add node:net module

src/node/internal/compatibility-flags.d.ts

@@ -31,3 +31,4 @@ export const workerdExperimental: boolean;
 export const durableObjectGetExisting: boolean;
 export const vectorizeQueryMetadataOptional: boolean;
 export const nodeJsZlib: boolean;
+export const nodeJsCompatNet: boolean;

src/node/internal/internal_errors.ts

@@ -609,6 +609,55 @@ export class DnsError extends NodeError {
   }
 }
 
+export class ERR_OPTION_NOT_IMPLEMENTED extends NodeError {
+  constructor(name: string | symbol) {
+    if (typeof name === 'symbol') {
+      name = (name as symbol).description!;
+    }
+    super(
+      'ERR_OPTION_NOT_IMPLEMENTED',
+      `The ${name} option is not implemented`
+    );
+  }
+}
+
+export class ERR_SOCKET_BAD_PORT extends NodeError {
+  constructor(name: string, port: any, allowZero: boolean) {
+    const operator = allowZero ? '>=' : '>';
+    super(
+      'ERR_SOCKET_BAD_PORT',
+      `${name} should be ${operator} 0 and < 65536. Received ${typeof port}.`
+    );
+  }
+}
+
+export class EPIPE extends NodeError {
+  constructor() {
+    super('EPIPE', 'This socket has been ended by the other party');
+  }
+}
+
+export class ERR_SOCKET_CLOSED_BEFORE_CONNECTION extends NodeError {
+  constructor() {
+    super(
+      'ERR_SOCKET_CLOSED_BEFORE_CONNETION',
+      'Socket closed before connection established'
+    );
+  }
+}
+
+export class ERR_SOCKET_CLOSED extends NodeError {
+  constructor() {
+    super('ERR_SOCKET_CLOSED', 'Socket is closed');
+  }
+}
+
+export class ERR_SOCKET_CONNECTING extends NodeError {
+  constructor() {
+    super('ERR_SOCKET_CONNECTING', 'Socket is already connecting');
+  }
+}
+
 export function aggregateTwoErrors(innerError: any, outerError: any) {
   if (innerError && outerError && innerError !== outerError) {
     if (Array.isArray(outerError.errors)) {

src/node/internal/sockets.d.ts

@@ -0,0 +1,25 @@
+import type { Buffer } from 'node-internal:internal_buffer';
+
+declare namespace sockets {
+  function connect(
+    input: string,
+    options: Record<string, unknown>
+  ): {
+    opened: Promise<void>;
+    closed: Promise<void>;
+    close(): Promise<void>;
+    readable: {
+      getReader(options: Record<string, string>): {
+        close(): Promise<void>;
+        read(value: unknown): Promise<{ value: Buffer; done: boolean }>;
+      };
+    };
+    writable: {
+      getWriter(): {
+        close(): Promise<void>;
+        write(data: string | ArrayBufferView): Promise<void>;
+      };
+    };
+  };
+}
+export default sockets;

src/node/internal/streams_duplex.d.ts

@@ -0,0 +1,7 @@
+export {
+  Duplex,
+  Writable,
+  WritableOptions,
+  Readable,
+  ReadableOptions,
+} from 'node:stream';

src/node/internal/validators.ts

@@ -30,11 +30,12 @@ import { normalizeEncoding } from 'node-internal:internal_utils';
 import {
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
+  ERR_SOCKET_BAD_PORT,
   ERR_OUT_OF_RANGE,
 } from 'node-internal:internal_errors';
 import { default as bufferUtil } from 'node-internal:buffer';
 
-// TODO(someday): Not current implementing parseFileMode, validatePort
+// TODO(someday): Not current implementing parseFileMode
 
 export function isInt32(value: unknown): value is number {
   // @ts-expect-error Due to value being unknown
@@ -301,6 +302,23 @@ export function checkRangesOrGetDefault(
   return number;
 }
 
+export function validatePort(
+  port: unknown,
+  name = 'Port',
+  allowZero = true
+): number {
+  if (
+    (typeof port !== 'number' && typeof port !== 'string') ||
+    (typeof port === 'string' && port.trim().length === 0) ||
+    +port !== +port >>> 0 ||
+    +port > 0xffff ||
+    (port === 0 && !allowZero)
+  ) {
+    throw new ERR_SOCKET_BAD_PORT(name, port, allowZero);
+  }
+  return +port | 0;
+}
+
 export default {
   isInt32,
   isUint32,
@@ -316,6 +334,7 @@ export default {
   validateOneOf,
   validateString,
   validateUint32,
+  validatePort,
 
   // Zlib specific
   checkFiniteNumber,