@6qat/tcp-connection 0.2.7 → 0.2.9

package/dist/{tcp-connection.d.ts → src/tcp-connection.d.ts}

@@ -33,6 +33,9 @@ declare const ConnectionConfig_base: Context.TagClass<ConnectionConfig, "Connect
  */
 export declare class ConnectionConfig extends ConnectionConfig_base {
 }
-export declare const TcpStreamLive: () => Layer.Layer<TcpStream, TcpStreamError | import("effect/Cause").UnknownException | import("effect/Cause").TimeoutException, ConnectionConfig>;
+/**
+ * Creates the TcpStream layer using Layer.scoped for proper resource management.
+ */
+export declare const TcpStreamLive: () => Layer.Layer<TcpStream, TcpStreamError | import("effect/Cause").TimeoutException, ConnectionConfig>;
 export declare const ConnectionConfigLive: (host: string, port: number, tickers: string[], magicToken: string, username: string, password: string) => Layer.Layer<ConnectionConfig, never, never>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@6qat/tcp-connection",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "TCP connection library with Effect.js integration",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -8,6 +8,7 @@
   "type": "module",
   "files": [
     "dist",
+    "src",
     "README.md"
   ],
   "exports": {
@@ -22,7 +23,7 @@
     "build:types": "bun tsc --emitDeclarationOnly --outDir dist",
     "build": "bun run build:main && bun run build:types",
     "prepublishOnly": "bun run build",
-    "test": "vitest run --passWithNoTests",
+    "test": "bunx --bun vitest run --passWithNoTests",
     "format": "biome format --write ./src",
     "lint": "biome lint ."
   },
@@ -42,7 +43,8 @@
   "devDependencies": {
     "@effect/language-service": "^0.63.2",
     "@types/bun": "^1.3.5",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
   },
   "publishConfig": {
     "access": "public"

package/src/examples.ts

@@ -0,0 +1,62 @@
+import { Effect, Fiber, Layer } from 'effect';
+import {
+  TcpStream,
+  TcpStreamLive,
+  ConnectionConfigLive,
+} from './tcp-connection.js';
+import { ping } from './utils.js';
+
+/**
+ * Example usage of ping function with real TCP stream
+ */
+export const pingExample = Effect.gen(function* () {
+  // Create TCP stream layer
+  const tcpStreamLayer = TcpStreamLive().pipe(
+    Layer.provide(ConnectionConfigLive('localhost', 8080, [], '', '', '')),
+  );
+
+  // Run the ping example with TCP stream
+  yield* Effect.gen(function* () {
+    const tcpStream = yield* TcpStream;
+
+    console.log('Connected to TCP server, starting ping loop...');
+
+    // Start ping loop using the real TCP send function (handle errors)
+    const pingFiber = yield* ping((data) =>
+      tcpStream
+        .send(data)
+        .pipe(
+          Effect.catchAll((error) =>
+            Effect.logError(`Send failed: ${error.message}`),
+          ),
+        ),
+    );
+
+    console.log('Ping loop started in background');
+
+    // Keep the main effect alive for 10 seconds to see pings
+    yield* Effect.sleep('10 seconds');
+
+    // Clean up: stop the ping loop
+    yield* Fiber.interrupt(pingFiber);
+
+    console.log('Ping loop stopped, closing connection...');
+
+    // Close the TCP connection
+    yield* tcpStream.close;
+
+    console.log('Connection closed');
+  }).pipe(
+    Effect.provide(tcpStreamLayer),
+    Effect.catchAll((error) =>
+      Effect.logError(
+        `Connection error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    ),
+  );
+});
+
+/**
+ * To run this example:
+ * Effect.runPromise(pingExample)
+ */

package/src/index.ts

@@ -0,0 +1,4 @@
+// Export everything from tcp-connection
+export * from './tcp-connection.js';
+// Export utilities
+export * from './utils.js';

package/src/tcp-connection-OLD.ts

@@ -0,0 +1,354 @@
+import type { Socket } from 'node:net';
+// src/tcp-stream.ts
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Queue,
+  Ref,
+  Runtime,
+  Schedule,
+  Stream,
+  pipe,
+} from 'effect';
+
+// Base error class with a more flexible tag system
+export class TcpConnectionError extends Data.TaggedError('TcpConnectionError') {
+  constructor(readonly errorType?: string) {
+    super();
+  }
+}
+
+export class TcpConnectionTimeoutError extends TcpConnectionError {
+  constructor(readonly message: string) {
+    super('ConnectionTimeout');
+  }
+}
+
+export class TcpConnectionWriteError extends TcpConnectionError {
+  constructor(readonly message: string) {
+    super('WriteError');
+  }
+}
+
+export class TcpConnectionCloseError extends TcpConnectionError {
+  constructor(readonly message: string) {
+    super('CloseError');
+  }
+}
+
+// Context Tag for Dependency Injection
+class TcpConnection extends Context.Tag('TcpConnection')<
+  TcpConnection,
+  TcpConnectionShape
+>() {}
+
+interface TcpConnectionShape {
+  readonly incoming: Stream.Stream<Uint8Array, TcpConnectionError>;
+  readonly send: (data: Uint8Array) => Effect.Effect<void, TcpConnectionError>;
+  readonly sendWithRetry: (
+    data: Uint8Array,
+  ) => Effect.Effect<void, TcpConnectionError>;
+}
+// Configuration (host/port)
+class TcpConfig extends Context.Tag('TcpConfig')<
+  TcpConfig,
+  {
+    host: string;
+    port: number;
+    bufferSize?: number;
+    runtimeEffect?: Effect.Effect<Runtime.Runtime<never>, never, never>;
+  }
+>() {}
+
+// State
+interface ConnectionState {
+  readonly socket: Socket; // Or TLS socket
+  readonly isOpen: boolean;
+}
+
+const TcpConnectionLive = Layer.scoped(
+  TcpConnection,
+  Effect.gen(function* () {
+    const {
+      host,
+      port,
+      bufferSize = 2048,
+      runtimeEffect = Effect.succeed(Runtime.defaultRuntime),
+    } = yield* TcpConfig;
+
+    const queue = yield* Queue.bounded<Uint8Array>(bufferSize);
+    const stateRef = yield* Ref.make<ConnectionState | null>(null);
+    const restartQueue = yield* Queue.unbounded<void>(); // Signal restarts
+
+    const runtime = yield* runtimeEffect;
+    const runPromise = <A, E>(effect: Effect.Effect<A, E, never>) =>
+      Runtime.runPromise(runtime)(effect);
+
+    const net = yield* Effect.promise(() => import('node:net'));
+
+    /**
+     * The close event triggers runPromise(handleClose), which sets stateRef to null and signals a restart. If a new connection is established before the previous one is fully cleaned up, you could have overlapping sockets or fibers.
+     */
+    // TODO: Improvement: Ensure that any socket cleanup is fully completed before a new socket is created. Consider using a mutex or a dedicated "connection management" fiber to serialize open/close/restart operations.
+    // When the socket closes, notify the restart queue
+    const handleClose = Effect.gen(function* () {
+      const currentState = yield* Ref.get(stateRef);
+      const socket = currentState?.socket;
+      if (socket && !socket.closed) {
+        // TODO: Check if its necessary to check if the socket is closed before end()
+        socket.removeAllListeners().end();
+        if (!socket.destroyed) {
+          socket.destroy();
+        }
+      }
+      yield* Ref.set(stateRef, null);
+      yield* Queue.offer(restartQueue, void 0); // Signal restart
+      yield* Effect.logDebug('Connection closed abruptly!!!');
+    });
+
+    const handleShutdown = Effect.gen(function* () {
+      yield* handleClose;
+      yield* Effect.logDebug('Finalizer: shutting down queues...');
+      yield* Queue.shutdown(queue);
+      yield* Queue.shutdown(restartQueue);
+      yield* Effect.logDebug('Finalizer: shutting down socket...');
+      const currentState = yield* Ref.get(stateRef);
+      const socket = currentState?.socket;
+      if (socket && !socket.closed) {
+        socket.removeAllListeners().end();
+        if (!socket.destroyed) {
+          socket.destroy();
+        }
+      }
+      yield* Effect.logDebug('Finalizer: done.');
+    });
+
+    const createSocket: () => Effect.Effect<
+      ConnectionState,
+      TcpConnectionError,
+      never
+    > = () => {
+      const effect: Effect.Effect<ConnectionState, TcpConnectionError, never> =
+        Effect.async((resume) => {
+          const socket = net.createConnection({ host, port });
+          socket.on('connect', () => {
+            // Handle incoming data
+            socket.on('data', (chunk: Buffer) => {
+              runPromise(Queue.offer(queue, new Uint8Array(chunk)));
+            });
+            socket.on('error', (err) => {
+              runPromise(Effect.fail(new TcpConnectionError(err.message)));
+            });
+            socket.on('close', () => {
+              runPromise(handleClose);
+            });
+            resume(Effect.succeed({ socket, isOpen: true }));
+          });
+          socket.on('error', (err) =>
+            resume(Effect.fail(new TcpConnectionError(err.message))),
+          );
+        });
+      return effect.pipe(
+        Effect.retry(
+          Schedule.exponential('1 second').pipe(
+            Schedule.compose(Schedule.recurUpTo(5)),
+          ),
+        ),
+        Effect.tap(() => Effect.logDebug('Connection established')),
+
+        Effect.tapErrorCause((cause) =>
+          Effect.logError('Connection failed', cause),
+        ),
+      );
+    };
+
+    // Create TCP socket
+    const initialState = yield* createSocket();
+
+    yield* Ref.set(stateRef, initialState);
+
+    // Restart logic
+    /**
+     * If multiple errors or closes happen in quick succession, you may queue multiple restarts.
+     */
+    // TODO: Debounce the restart calls
+    const restart: Effect.Effect<void, TcpConnectionError, never> = Effect.gen(
+      function* () {
+        yield* Effect.logDebug('Restarting connection');
+        const currentState = yield* Ref.get(stateRef);
+        if (currentState?.isOpen) return; // Already connected
+        yield* createSocket().pipe(
+          Effect.flatMap((state) => Ref.set(stateRef, state)),
+          Effect.retry(Schedule.fibonacci('5 seconds')),
+        );
+      },
+    );
+
+    // Add a mutex for state management
+    const stateMutex = yield* Effect.makeSemaphore(1);
+    // Wrap state updates
+    const withState = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      stateMutex.withPermits(1)(effect).pipe(Effect.withLogSpan('elapsed'));
+
+    const safeRestart = withState(restart);
+
+    const debouncedRestart = pipe(
+      safeRestart,
+      Effect.delay('3 seconds'),
+      // Effect.raceFirst(Effect.never), // Cancels previous restart if new one comes in
+      Effect.uninterruptible,
+    );
+
+    yield* pipe(
+      Stream.fromQueue(restartQueue, { shutdown: true }),
+      Stream.tap(() => Effect.logDebug('Queue restarted')),
+      Stream.tap(() => debouncedRestart),
+      Stream.runDrain,
+      Effect.onInterrupt(() =>
+        Effect.logDebug('Queue restart fiber interrupted'),
+      ),
+      Effect.forkDaemon,
+    );
+
+    const send = (data: Uint8Array) =>
+      Effect.gen(function* () {
+        const state = yield* Ref.get(stateRef);
+        if (!state?.isOpen) {
+          return yield* Effect.fail(new TcpConnectionCloseError('not_open'));
+        }
+        return yield* Effect.tryPromise({
+          try: () =>
+            new Promise((resolve, reject) => {
+              state.socket.write(data, (err) =>
+                err
+                  ? reject(new TcpConnectionWriteError(err.message))
+                  : resolve(void 0),
+              );
+            }),
+          catch: (error) => new TcpConnectionWriteError(error as string),
+        });
+      });
+
+    // Retry logic for send
+    const sendWithRetry = (data: Uint8Array) =>
+      send(data).pipe(
+        Effect.retry(
+          Schedule.exponential('100 millis', 2).pipe(
+            Schedule.compose(Schedule.recurUpTo(5)),
+          ),
+        ),
+        Effect.catchAll((error) => new TcpConnectionWriteError(error.message)),
+      );
+
+    // Cleanup on exit
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        yield* handleShutdown;
+      }),
+    );
+
+    return {
+      incoming: Stream.fromQueue(queue, { shutdown: true }),
+      send,
+      sendWithRetry,
+    };
+  }),
+);
+
+/*
+// Usage examples
+
+// Metrics
+const bytesReceived = Metric.counter('tcp.bytes_received');
+const bytesSent = Metric.counter('tcp.bytes_sent');
+
+const program = Effect.gen(function* () {
+  // Create a Ref to track the value
+  const bytesReceivedRef = yield* Ref.make(0);
+  const bytesSentRef = yield* Ref.make(0);
+
+  const printMetrics = Effect.gen(function* () {
+    const received = yield* Ref.get(bytesReceivedRef);
+    const sent = yield* Ref.get(bytesSentRef);
+    yield* Effect.logInfo(`Bytes received: ${received}`);
+    yield* Effect.logInfo(`Bytes sent: ${sent}`);
+  });
+
+  const client = yield* TcpConnection;
+
+  // yield* client.send('GET / HTTP/1.1\r\nHost: www.terra.com.br\r\n\r\n');
+  const data = new TextEncoder().encode(
+    'GET / HTTP/1.1\r\nHost: www.terra.com.br\r\n\r\n',
+  );
+
+  const send = (data: Uint8Array) =>
+    pipe(
+      Ref.update(bytesSentRef, (n) => n + data.length),
+      Effect.zipRight(Metric.incrementBy(bytesSent, data.length)),
+      Effect.flatMap(() => client.send(data)),
+    );
+
+  const _sendWithRetry = (data: Uint8Array) =>
+    pipe(
+      Ref.update(bytesSentRef, (n) => n + data.length),
+      Effect.zipRight(Metric.incrementBy(bytesSent, data.length)),
+      Effect.flatMap(() => client.sendWithRetry(data)),
+    );
+
+  // Initial send
+  yield* send(data).pipe(Effect.orElse(() => Effect.logError('deu ruim')));
+
+  // Incoming data handling
+  yield* pipe(
+    client.incoming,
+    Stream.tap((data) => Metric.incrementBy(bytesReceived, data.length)),
+    Stream.tap((data) => Ref.update(bytesReceivedRef, (n) => n + data.length)),
+    // Stream.tap((data) => Effect.logDebug(new TextDecoder().decode(data))),
+    Stream.tap((data) => Effect.logDebug(`Received: ${Buffer.from(data)}`)),
+    Stream.tap((chunks) => Effect.logDebug(`Received ${chunks.length} chunks`)),
+    Stream.catchAll((error) => {
+      if (error instanceof TcpConnectionCloseError) {
+        return Effect.log('Connection closed. Restarting...');
+      }
+      return Effect.fail(error);
+    }),
+    Stream.runDrain,
+    // Effect.forever,
+    Effect.fork, // Run in background
+  );
+
+  // Cleanup on exit
+  yield* Effect.addFinalizer(() =>
+    Effect.gen(function* () {
+      yield* Effect.logDebug('Program Finalizer');
+      yield* Effect.logDebug('Before printing stats');
+      yield* printMetrics;
+    }),
+  );
+
+  yield* Effect.never;
+}).pipe(Effect.catchAll((error) => Effect.logError(error)));
+
+const LoggerLive = Logger.minimumLogLevel(LogLevel.Debug);
+const TcpConfigLive = Layer.succeed(TcpConfig, {
+  host: 'www.terra.com.br',
+  port: 80,
+  bufferSize: 1024,
+  runtimeEffect: Effect.scoped(Layer.toRuntime(LoggerLive)),
+});
+*/
+
+// const runnable = Effect.gen(function* () {
+//   yield* Effect.scoped(
+//     Effect.provide(
+//       Effect.provide(Effect.provide(program, TcpConnectionLive), TcpConfigLive),
+//       LoggerLive,
+//     ),
+//   );
+// });
+
+// NodeRuntime.runMain(runnable);
+
+export { TcpConfig, TcpConnection, TcpConnectionLive };

package/src/tcp-connection.ts

@@ -0,0 +1,229 @@
+import {
+  Context,
+  Duration,
+  Effect,
+  Fiber,
+  Layer,
+  Queue,
+  Ref,
+  Stream,
+  Data,
+} from 'effect';
+
+// =========================================================================
+// Errors
+// =========================================================================
+export class TcpStreamError extends Data.TaggedError('TcpStreamError')<{
+  readonly message: string;
+}> {}
+
+// =========================================================================
+// TCP Connection with Write support
+// =========================================================================
+interface TcpStreamShape {
+  readonly stream: Stream.Stream<Uint8Array, TcpStreamError>;
+  readonly send: (data: Uint8Array) => Effect.Effect<void, TcpStreamError>;
+  readonly sendText: (data: string) => Effect.Effect<void, TcpStreamError>;
+  readonly close: Effect.Effect<void>;
+}
+
+export class TcpStream extends Context.Tag('TcpStream')<
+  TcpStream,
+  TcpStreamShape
+>() {}
+
+/**
+ * ConnectionConfigShape is an interface that defines the shape of the data
+ * needed to connect to the server.
+ */
+interface ConnectionConfigShape {
+  host: string;
+  port: number;
+  magicToken?: string;
+  username?: string;
+  password?: string;
+  tickers?: string[];
+}
+
+/**
+ * ConnectionConfig is a Context.Tag that provides the connection configuration.
+ */
+export class ConnectionConfig extends Context.Tag('ConnectionConfig')<
+  ConnectionConfig,
+  ConnectionConfigShape
+>() {}
+
+/**
+ * Creates the TcpStream layer using Layer.scoped for proper resource management.
+ */
+export const TcpStreamLive = () =>
+  Layer.scoped(
+    TcpStream,
+
+    Effect.gen(function* () {
+      const config = yield* ConnectionConfig;
+
+      const incomingQueue = yield* Queue.unbounded<Uint8Array>();
+      const outgoingQueue = yield* Queue.unbounded<Uint8Array>();
+      const writeErrorCount = yield* Ref.make(0);
+      const isClosing = yield* Ref.make(false);
+      const writerFiberRef = yield* Ref.make<Fiber.Fiber<
+        void,
+        TcpStreamError
+      > | null>(null);
+
+      // Connect to the server
+      const bunSocket = yield* Effect.tryPromise({
+        try: () =>
+          Bun.connect({
+            port: config.port,
+            hostname: config.host,
+            socket: {
+              data(_socket, data) {
+                // Use unsafeOffer for immediate queueing
+                Queue.unsafeOffer(incomingQueue, data);
+              },
+              error(_socket, error) {
+                Effect.runPromise(
+                  Ref.get(isClosing).pipe(
+                    Effect.flatMap((closing) =>
+                      closing ? Effect.void : shutdownEffect,
+                    ),
+                  ),
+                );
+              },
+              close(_socket) {
+                Effect.runPromise(
+                  Ref.get(isClosing).pipe(
+                    Effect.flatMap((closing) =>
+                      closing ? Effect.void : shutdownEffect,
+                    ),
+                  ),
+                );
+              },
+            },
+          }),
+        catch: (error) =>
+          new TcpStreamError({
+            message: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+          }),
+      }).pipe(
+        Effect.timeout(Duration.millis(3000)),
+        Effect.flatMap((maybeSocket) =>
+          maybeSocket
+            ? Effect.succeed(maybeSocket)
+            : Effect.fail(
+                new TcpStreamError({ message: 'Connection timeout' }),
+              ),
+        ),
+      );
+
+      // Define shutdown effect
+      const shutdownEffect = Effect.gen(function* () {
+        const alreadyClosing = yield* Ref.getAndSet(isClosing, true);
+        if (alreadyClosing) return;
+
+        yield* Effect.log('Closing TCP connection');
+        bunSocket.end();
+
+        // Allow socket events to propagate
+        yield* Effect.sleep(Duration.millis(10));
+
+        const fiber = yield* Ref.get(writerFiberRef);
+        if (fiber) {
+          yield* Fiber.interrupt(fiber);
+        }
+
+        yield* Queue.shutdown(incomingQueue);
+        yield* Queue.shutdown(outgoingQueue);
+      });
+
+      // Writer loop
+      const writerLoop = Effect.gen(function* () {
+        while (true) {
+          const isShutdown = yield* Queue.isShutdown(outgoingQueue);
+          if (isShutdown) break;
+
+          const data = yield* Queue.take(outgoingQueue);
+
+          yield* Effect.gen(function* () {
+            const bytesWritten = bunSocket.write(data);
+            if (bytesWritten !== data.length) {
+              return yield* Effect.fail(
+                new TcpStreamError({ message: 'Partial write' }),
+              );
+            }
+            yield* Ref.set(writeErrorCount, 0);
+          }).pipe(
+            Effect.catchAll((error) =>
+              Effect.gen(function* () {
+                const currentErrors = yield* Ref.updateAndGet(
+                  writeErrorCount,
+                  (n) => n + 1,
+                );
+                if (currentErrors > 3) {
+                  return yield* Effect.fail(
+                    new TcpStreamError({
+                      message: `Write failed after ${currentErrors} attempts: ${error}`,
+                    }),
+                  );
+                }
+                yield* Effect.sleep(Duration.millis(100));
+                yield* Queue.offer(outgoingQueue, data);
+              }),
+            ),
+          );
+        }
+      });
+
+      const writerFiber = yield* Effect.fork(writerLoop);
+      yield* Ref.set(writerFiberRef, writerFiber);
+
+      // Register finalizer
+      yield* Effect.addFinalizer(() => shutdownEffect);
+
+      const safeOffer = (queue: Queue.Queue<Uint8Array>, data: Uint8Array) =>
+        Effect.gen(function* () {
+          const isShutdown = yield* Queue.isShutdown(queue);
+          if (isShutdown) {
+            return yield* Effect.fail(
+              new TcpStreamError({ message: 'Queue is shutdown' }),
+            );
+          }
+          yield* Queue.offer(queue, data);
+        }).pipe(
+          Effect.mapError((e) =>
+            e instanceof TcpStreamError
+              ? e
+              : new TcpStreamError({ message: String(e) }),
+          ),
+        );
+
+      return TcpStream.of({
+        stream: Stream.fromQueue(incomingQueue).pipe(
+          Stream.mapError((e) => new TcpStreamError({ message: String(e) })),
+        ),
+        send: (data: Uint8Array) => safeOffer(outgoingQueue, data),
+        sendText: (data: string) =>
+          safeOffer(outgoingQueue, new TextEncoder().encode(data)),
+        close: shutdownEffect,
+      });
+    }),
+  );
+
+export const ConnectionConfigLive = (
+  host: string,
+  port: number,
+  tickers: string[],
+  magicToken: string,
+  username: string,
+  password: string,
+) =>
+  Layer.succeed(ConnectionConfig, {
+    host,
+    port,
+    magicToken,
+    username,
+    password,
+    tickers,
+  });