@hla4ts/transport 0.1.0 → 0.1.1

package/src/tcp-transport.ts

@@ -1,154 +1,154 @@
-/**
- * TCP Transport Implementation
- *
- * Provides a plain TCP connection for the Federate Protocol.
- * Note: This is unencrypted and should only be used for local development/testing.
- */
-
-import { connect, type Socket, type SocketHandler } from "bun";
-import { FrameDecoder } from "./frame-decoder.ts";
-import { Ports, Protocol } from "./constants.ts";
-import type {
-  Transport,
-  TransportEvents,
-  TransportOptions,
-  ReceivedMessage,
-} from "./transport.ts";
-
-/**
- * Plain TCP Transport for Federate Protocol
- *
- * ⚠️ WARNING: This transport is unencrypted. Use TlsTransport for production.
- *
- * @example
- * ```ts
- * const transport = new TcpTransport({
- *   host: 'localhost',
- *   port: 15164,
- * });
- *
- * await transport.connect();
- * ```
- */
-export class TcpTransport implements Transport {
-  private readonly options: Required<TransportOptions>;
-  private socket: Socket<{ decoder: FrameDecoder }> | null = null;
-  private events: TransportEvents = {};
-  private decoder: FrameDecoder;
-  private connected = false;
-
-  constructor(options: TransportOptions) {
-    this.options = {
-      host: options.host,
-      port: options.port ?? Ports.TCP,
-      connectionTimeout: options.connectionTimeout ?? 10000,
-      noDelay: options.noDelay ?? true,
-    };
-
-    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);
-        },
-      };
-
-      connect({
-        hostname: this.options.host,
-        port: this.options.port,
-        socket: socketHandler,
-        data: { decoder },
-      })
-        .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) {
-      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.TCP;
-  }
-
-  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);
-  }
-}
+/**
+ * TCP Transport Implementation
+ *
+ * Provides a plain TCP connection for the Federate Protocol.
+ * Note: This is unencrypted and should only be used for local development/testing.
+ */
+
+import { connect, type Socket, type SocketHandler } from "bun";
+import { FrameDecoder } from "./frame-decoder.ts";
+import { Ports, Protocol } from "./constants.ts";
+import type {
+  Transport,
+  TransportEvents,
+  TransportOptions,
+  ReceivedMessage,
+} from "./transport.ts";
+
+/**
+ * Plain TCP Transport for Federate Protocol
+ *
+ * ⚠️ WARNING: This transport is unencrypted. Use TlsTransport for production.
+ *
+ * @example
+ * ```ts
+ * const transport = new TcpTransport({
+ *   host: 'localhost',
+ *   port: 15164,
+ * });
+ *
+ * await transport.connect();
+ * ```
+ */
+export class TcpTransport implements Transport {
+  private readonly options: Required<TransportOptions>;
+  private socket: Socket<{ decoder: FrameDecoder }> | null = null;
+  private events: TransportEvents = {};
+  private decoder: FrameDecoder;
+  private connected = false;
+
+  constructor(options: TransportOptions) {
+    this.options = {
+      host: options.host,
+      port: options.port ?? Ports.TCP,
+      connectionTimeout: options.connectionTimeout ?? 10000,
+      noDelay: options.noDelay ?? true,
+    };
+
+    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);
+        },
+      };
+
+      connect({
+        hostname: this.options.host,
+        port: this.options.port,
+        socket: socketHandler,
+        data: { decoder },
+      })
+        .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) {
+      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.TCP;
+  }
+
+  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);
+  }
+}