@hla4ts/transport 0.1.0 → 0.1.1

package/src/tls-transport.ts

@@ -1,193 +1,193 @@
-/**
- * TLS Transport Implementation
- *
- * Provides a TLS-encrypted TCP connection for the Federate Protocol.
- * Uses Bun's built-in TLS support.
- */
-
-import { connect, type Socket, type SocketHandler, type TLSOptions } from "bun";
-import { FrameDecoder } from "./frame-decoder.ts";
-import { Ports, Protocol } from "./constants.ts";
-import type {
-  Transport,
-  TransportEvents,
-  TlsOptions,
-  ReceivedMessage,
-} from "./transport.ts";
-
-/**
- * TLS Transport for Federate Protocol
- *
- * @example
- * ```ts
- * const transport = new TlsTransport({
- *   host: 'localhost',
- *   port: 15165,
- * });
- *
- * transport.setEventHandlers({
- *   onMessage: (msg) => console.log('Received:', msg.header.messageType),
- *   onClose: () => console.log('Disconnected'),
- *   onError: (err) => console.error('Error:', err),
- * });
- *
- * await transport.connect();
- * await transport.send(someData);
- * await transport.disconnect();
- * ```
- */
-export class TlsTransport implements Transport {
-  private readonly options: Required<
-    Pick<TlsOptions, "host" | "port" | "connectionTimeout" | "noDelay">
-  > &
-    Omit<TlsOptions, "host" | "port" | "connectionTimeout" | "noDelay">;
-
-  private socket: Socket<{ decoder: FrameDecoder }> | null = null;
-  private events: TransportEvents = {};
-  private decoder: FrameDecoder;
-  private connected = false;
-
-  constructor(options: TlsOptions) {
-    this.options = {
-      host: options.host,
-      port: options.port ?? Ports.TLS,
-      connectionTimeout: options.connectionTimeout ?? 10000,
-      noDelay: options.noDelay ?? true,
-      ca: options.ca,
-      cert: options.cert,
-      key: options.key,
-      rejectUnauthorized: options.rejectUnauthorized ?? true,
-      serverName: options.serverName,
-    };
-
-    this.decoder = new FrameDecoder();
-    this.decoder.onMessage = (msg) => this.handleMessage(msg);
-    this.decoder.onError = (err) => this.handleError(err);
-  }
-
-  async connect(): Promise<void> {
-    if (this.socket) {
-      throw new Error("Already connected");
-    }
-
-    const decoder = this.decoder;
-    const transport = this;
-
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error(`Connection timeout after ${this.options.connectionTimeout}ms`));
-      }, this.options.connectionTimeout);
-
-      const socketHandler: SocketHandler<{ decoder: FrameDecoder }> = {
-        data(_socket, data) {
-          decoder.push(new Uint8Array(data));
-        },
-        open(_socket) {
-          clearTimeout(timeoutId);
-          transport.connected = true;
-          resolve();
-        },
-        close(_socket) {
-          transport.connected = false;
-          transport.socket = null;
-          transport.events.onClose?.(false);
-        },
-        error(_socket, error) {
-          clearTimeout(timeoutId);
-          transport.connected = false;
-          const err = error instanceof Error ? error : new Error(String(error));
-          transport.events.onError?.(err);
-          reject(err);
-        },
-        connectError(_socket, error) {
-          clearTimeout(timeoutId);
-          const err = error instanceof Error ? error : new Error(String(error));
-          reject(err);
-        },
-      };
-
-      // Build TLS options
-      const tlsConfig: TLSOptions = {
-        rejectUnauthorized: this.options.rejectUnauthorized,
-      };
-
-      // Add optional TLS settings
-      if (this.options.ca) {
-        tlsConfig.ca = Bun.file(this.options.ca);
-      }
-      if (this.options.cert) {
-        tlsConfig.cert = Bun.file(this.options.cert);
-      }
-      if (this.options.key) {
-        tlsConfig.key = Bun.file(this.options.key);
-      }
-      if (this.options.serverName) {
-        tlsConfig.serverName = this.options.serverName;
-      }
-
-      connect({
-        hostname: this.options.host,
-        port: this.options.port,
-        socket: socketHandler,
-        data: { decoder },
-        tls: tlsConfig,
-      })
-        .then((socket) => {
-          this.socket = socket;
-        })
-        .catch(reject);
-    });
-  }
-
-  async disconnect(): Promise<void> {
-    if (this.socket) {
-      this.socket.end();
-      this.socket = null;
-      this.connected = false;
-      this.decoder.reset();
-    }
-  }
-
-  isConnected(): boolean {
-    return this.connected && this.socket !== null;
-  }
-
-  async send(data: Uint8Array): Promise<void> {
-    if (!this.socket || !this.connected) {
-      throw new Error("Not connected");
-    }
-
-    const written = this.socket.write(data);
-    if (written < data.length) {
-      // Bun's socket.write returns the number of bytes written
-      // If not all bytes were written, we need to wait for drain
-      // For simplicity, we'll throw an error here
-      // In production, you'd want to buffer and retry
-      throw new Error(
-        `Failed to write all data: wrote ${written} of ${data.length} bytes`
-      );
-    }
-  }
-
-  setEventHandlers(handlers: TransportEvents): void {
-    this.events = handlers;
-  }
-
-  getProtocolName(): string {
-    return Protocol.TLS;
-  }
-
-  getRemoteAddress(): string | null {
-    return this.socket
-      ? `${this.options.host}:${this.options.port}`
-      : null;
-  }
-
-  private handleMessage(message: ReceivedMessage): void {
-    this.events.onMessage?.(message);
-  }
-
-  private handleError(error: Error): void {
-    this.events.onError?.(error);
-  }
-}
+/**
+ * TLS Transport Implementation
+ *
+ * Provides a TLS-encrypted TCP connection for the Federate Protocol.
+ * Uses Bun's built-in TLS support.
+ */
+
+import { connect, type Socket, type SocketHandler, type TLSOptions } from "bun";
+import { FrameDecoder } from "./frame-decoder.ts";
+import { Ports, Protocol } from "./constants.ts";
+import type {
+  Transport,
+  TransportEvents,
+  TlsOptions,
+  ReceivedMessage,
+} from "./transport.ts";
+
+/**
+ * TLS Transport for Federate Protocol
+ *
+ * @example
+ * ```ts
+ * const transport = new TlsTransport({
+ *   host: 'localhost',
+ *   port: 15165,
+ * });
+ *
+ * transport.setEventHandlers({
+ *   onMessage: (msg) => console.log('Received:', msg.header.messageType),
+ *   onClose: () => console.log('Disconnected'),
+ *   onError: (err) => console.error('Error:', err),
+ * });
+ *
+ * await transport.connect();
+ * await transport.send(someData);
+ * await transport.disconnect();
+ * ```
+ */
+export class TlsTransport implements Transport {
+  private readonly options: Required<
+    Pick<TlsOptions, "host" | "port" | "connectionTimeout" | "noDelay">
+  > &
+    Omit<TlsOptions, "host" | "port" | "connectionTimeout" | "noDelay">;
+
+  private socket: Socket<{ decoder: FrameDecoder }> | null = null;
+  private events: TransportEvents = {};
+  private decoder: FrameDecoder;
+  private connected = false;
+
+  constructor(options: TlsOptions) {
+    this.options = {
+      host: options.host,
+      port: options.port ?? Ports.TLS,
+      connectionTimeout: options.connectionTimeout ?? 10000,
+      noDelay: options.noDelay ?? true,
+      ca: options.ca,
+      cert: options.cert,
+      key: options.key,
+      rejectUnauthorized: options.rejectUnauthorized ?? true,
+      serverName: options.serverName,
+    };
+
+    this.decoder = new FrameDecoder();
+    this.decoder.onMessage = (msg) => this.handleMessage(msg);
+    this.decoder.onError = (err) => this.handleError(err);
+  }
+
+  async connect(): Promise<void> {
+    if (this.socket) {
+      throw new Error("Already connected");
+    }
+
+    const decoder = this.decoder;
+    const transport = this;
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Connection timeout after ${this.options.connectionTimeout}ms`));
+      }, this.options.connectionTimeout);
+
+      const socketHandler: SocketHandler<{ decoder: FrameDecoder }> = {
+        data(_socket, data) {
+          decoder.push(new Uint8Array(data));
+        },
+        open(_socket) {
+          clearTimeout(timeoutId);
+          transport.connected = true;
+          resolve();
+        },
+        close(_socket) {
+          transport.connected = false;
+          transport.socket = null;
+          transport.events.onClose?.(false);
+        },
+        error(_socket, error) {
+          clearTimeout(timeoutId);
+          transport.connected = false;
+          const err = error instanceof Error ? error : new Error(String(error));
+          transport.events.onError?.(err);
+          reject(err);
+        },
+        connectError(_socket, error) {
+          clearTimeout(timeoutId);
+          const err = error instanceof Error ? error : new Error(String(error));
+          reject(err);
+        },
+      };
+
+      // Build TLS options
+      const tlsConfig: TLSOptions = {
+        rejectUnauthorized: this.options.rejectUnauthorized,
+      };
+
+      // Add optional TLS settings
+      if (this.options.ca) {
+        tlsConfig.ca = Bun.file(this.options.ca);
+      }
+      if (this.options.cert) {
+        tlsConfig.cert = Bun.file(this.options.cert);
+      }
+      if (this.options.key) {
+        tlsConfig.key = Bun.file(this.options.key);
+      }
+      if (this.options.serverName) {
+        tlsConfig.serverName = this.options.serverName;
+      }
+
+      connect({
+        hostname: this.options.host,
+        port: this.options.port,
+        socket: socketHandler,
+        data: { decoder },
+        tls: tlsConfig,
+      })
+        .then((socket) => {
+          this.socket = socket;
+        })
+        .catch(reject);
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+      this.connected = false;
+      this.decoder.reset();
+    }
+  }
+
+  isConnected(): boolean {
+    return this.connected && this.socket !== null;
+  }
+
+  async send(data: Uint8Array): Promise<void> {
+    if (!this.socket || !this.connected) {
+      throw new Error("Not connected");
+    }
+
+    const written = this.socket.write(data);
+    if (written < data.length) {
+      // Bun's socket.write returns the number of bytes written
+      // If not all bytes were written, we need to wait for drain
+      // For simplicity, we'll throw an error here
+      // In production, you'd want to buffer and retry
+      throw new Error(
+        `Failed to write all data: wrote ${written} of ${data.length} bytes`
+      );
+    }
+  }
+
+  setEventHandlers(handlers: TransportEvents): void {
+    this.events = handlers;
+  }
+
+  getProtocolName(): string {
+    return Protocol.TLS;
+  }
+
+  getRemoteAddress(): string | null {
+    return this.socket
+      ? `${this.options.host}:${this.options.port}`
+      : null;
+  }
+
+  private handleMessage(message: ReceivedMessage): void {
+    this.events.onMessage?.(message);
+  }
+
+  private handleError(error: Error): void {
+    this.events.onError?.(error);
+  }
+}

package/src/transport.ts

@@ -1,99 +1,99 @@
-/**
- * Transport Interface
- *
- * Defines the contract for Federate Protocol transports (TCP, TLS, WebSocket).
- */
-
-import type { MessageHeader } from "./message-header.ts";
-
-/**
- * Transport connection options
- */
-export interface TransportOptions {
-  /** Server hostname or IP address */
-  host: string;
-  /** Server port (defaults to Ports.TCP for TCP, Ports.TLS for TLS) */
-  port?: number;
-  /** Connection timeout in milliseconds */
-  connectionTimeout?: number;
-  /** Enable TCP_NODELAY (disable Nagle's algorithm) */
-  noDelay?: boolean;
-}
-
-/**
- * TLS-specific options
- */
-export interface TlsOptions extends TransportOptions {
-  /** Path to CA certificate file (for server verification) */
-  ca?: string;
-  /** Path to client certificate file (for mutual TLS) */
-  cert?: string;
-  /** Path to client private key file (for mutual TLS) */
-  key?: string;
-  /** Skip server certificate verification (INSECURE - for testing only) */
-  rejectUnauthorized?: boolean;
-  /** Server name for SNI */
-  serverName?: string;
-}
-
-/**
- * Received message with header and payload
- */
-export interface ReceivedMessage {
-  header: MessageHeader;
-  payload: Uint8Array;
-}
-
-/**
- * Transport event handlers
- */
-export interface TransportEvents {
-  /** Called when a complete message is received */
-  onMessage?: (message: ReceivedMessage) => void;
-  /** Called when the connection is closed */
-  onClose?: (hadError: boolean) => void;
-  /** Called when an error occurs */
-  onError?: (error: Error) => void;
-}
-
-/**
- * Transport interface for Federate Protocol communication
- */
-export interface Transport {
-  /**
-   * Connect to the server
-   * @throws Error if connection fails
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Disconnect from the server
-   */
-  disconnect(): Promise<void>;
-
-  /**
-   * Check if the transport is connected
-   */
-  isConnected(): boolean;
-
-  /**
-   * Send raw bytes to the server
-   * @param data The data to send
-   */
-  send(data: Uint8Array): Promise<void>;
-
-  /**
-   * Set event handlers
-   */
-  setEventHandlers(handlers: TransportEvents): void;
-
-  /**
-   * Get the protocol name (tcp, tls, websocket, websocketsecure)
-   */
-  getProtocolName(): string;
-
-  /**
-   * Get the remote address
-   */
-  getRemoteAddress(): string | null;
-}
+/**
+ * Transport Interface
+ *
+ * Defines the contract for Federate Protocol transports (TCP, TLS, WebSocket).
+ */
+
+import type { MessageHeader } from "./message-header.ts";
+
+/**
+ * Transport connection options
+ */
+export interface TransportOptions {
+  /** Server hostname or IP address */
+  host: string;
+  /** Server port (defaults to Ports.TCP for TCP, Ports.TLS for TLS) */
+  port?: number;
+  /** Connection timeout in milliseconds */
+  connectionTimeout?: number;
+  /** Enable TCP_NODELAY (disable Nagle's algorithm) */
+  noDelay?: boolean;
+}
+
+/**
+ * TLS-specific options
+ */
+export interface TlsOptions extends TransportOptions {
+  /** Path to CA certificate file (for server verification) */
+  ca?: string;
+  /** Path to client certificate file (for mutual TLS) */
+  cert?: string;
+  /** Path to client private key file (for mutual TLS) */
+  key?: string;
+  /** Skip server certificate verification (INSECURE - for testing only) */
+  rejectUnauthorized?: boolean;
+  /** Server name for SNI */
+  serverName?: string;
+}
+
+/**
+ * Received message with header and payload
+ */
+export interface ReceivedMessage {
+  header: MessageHeader;
+  payload: Uint8Array;
+}
+
+/**
+ * Transport event handlers
+ */
+export interface TransportEvents {
+  /** Called when a complete message is received */
+  onMessage?: (message: ReceivedMessage) => void;
+  /** Called when the connection is closed */
+  onClose?: (hadError: boolean) => void;
+  /** Called when an error occurs */
+  onError?: (error: Error) => void;
+}
+
+/**
+ * Transport interface for Federate Protocol communication
+ */
+export interface Transport {
+  /**
+   * Connect to the server
+   * @throws Error if connection fails
+   */
+  connect(): Promise<void>;
+
+  /**
+   * Disconnect from the server
+   */
+  disconnect(): Promise<void>;
+
+  /**
+   * Check if the transport is connected
+   */
+  isConnected(): boolean;
+
+  /**
+   * Send raw bytes to the server
+   * @param data The data to send
+   */
+  send(data: Uint8Array): Promise<void>;
+
+  /**
+   * Set event handlers
+   */
+  setEventHandlers(handlers: TransportEvents): void;
+
+  /**
+   * Get the protocol name (tcp, tls, websocket, websocketsecure)
+   */
+  getProtocolName(): string;
+
+  /**
+   * Get the remote address
+   */
+  getRemoteAddress(): string | null;
+}