@6qat/tcp-connection 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@6qat/tcp-connection",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "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": {

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,216 @@
+import {
+  Context,
+  Duration,
+  Effect,
+  Fiber,
+  Layer,
+  Queue,
+  Ref,
+  Stream,
+  pipe,
+  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
+>() {}
+
+export const TcpStreamLive = () =>
+  /**
+   * Layer.effect() binds an Effect to a Context.Tag and returns
+   * a Layer.
+   */
+  Layer.effect(
+    TcpStream,
+
+    Effect.gen(function* () {
+      const config = yield* ConnectionConfig;
+
+      // Create queues for incoming and outgoing data
+      const incomingQueue = yield* Queue.unbounded<Uint8Array>();
+      const outgoingQueue = yield* Queue.unbounded<Uint8Array>();
+
+      // Track error count
+      const writeErrorCount = yield* Ref.make(0);
+
+      // Use refs for coordinated cleanup
+      const isClosing = yield* Ref.make(false);
+
+      // Safely shut down once
+      const performShutdown = 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));
+
+        // Interrupt writer fiber before shutting down queues
+        // TODO: isn't the writing fiber already interrupted when sutting down the Queue?
+        yield* Fiber.interrupt(writerFiber);
+
+        yield* Effect.all([
+          Queue.shutdown(incomingQueue),
+          Queue.shutdown(outgoingQueue),
+        ]);
+      });
+
+      // Create deferred for connection cleanup
+      const bunSocket = yield* Effect.tryPromise(() =>
+        Bun.connect({
+          port: config.port,
+          hostname: config.host,
+          socket: {
+            data(_socket, data) {
+              Queue.unsafeOffer(incomingQueue, data);
+            },
+            error(_socket, _error) {
+              //Queue.unsafeOffer(incomingQueue, error)
+              Effect.runPromise(performShutdown);
+            },
+            close(_socket) {
+              Effect.runPromise(performShutdown);
+            },
+          },
+        }),
+      ).pipe(
+        Effect.timeout(Duration.millis(3000)),
+        Effect.flatMap((maybeSocket) =>
+          maybeSocket
+            ? Effect.succeed(maybeSocket)
+            : Effect.fail(
+                new TcpStreamError({ message: 'Connection timeout' }),
+              ),
+        ),
+      );
+
+      // Fiber for writing outgoing data
+      const writerFiber = yield* pipe(
+        Effect.iterate(undefined, {
+          while: () => true,
+          body: () =>
+            pipe(
+              Queue.take(outgoingQueue),
+              Effect.flatMap((data) =>
+                Effect.try({
+                  try: () => {
+                    const bytesWritten = bunSocket.write(data);
+                    if (bytesWritten !== data.length) {
+                      throw new Error('Partial write');
+                    }
+                    // Reset error count on success
+                    Effect.runSync(Ref.set(writeErrorCount, 0));
+                  },
+                  catch: (error) => {
+                    const currentErrors = Effect.runSync(
+                      Ref.updateAndGet(writeErrorCount, (n) => n + 1),
+                    );
+                    if (currentErrors > 3) {
+                      // Too many errors, close the socket
+                      return Effect.fail(
+                        new TcpStreamError({
+                          message: `Write failed after ${currentErrors} attempts: ${error}`,
+                        }),
+                      );
+                    }
+                    // Retry with the same data after a delay
+                    return Effect.sleep(Duration.millis(100)).pipe(
+                      Effect.flatMap(() => Queue.offer(outgoingQueue, data)),
+                    );
+                  },
+                }),
+              ),
+            ),
+        }),
+        Effect.fork,
+      );
+
+      // Cleanup procedure
+      const close = Effect.gen(function* () {
+        yield* Effect.void;
+        yield* performShutdown;
+      });
+
+      // returns TCPStream implementation
+      return TcpStream.of({
+        stream: Stream.fromQueue(incomingQueue).pipe(
+          Stream.mapError((e) => new TcpStreamError({ message: String(e) })),
+          Stream.ensuring(close),
+        ),
+        // TODO: yield* Queue.isShutdown(queue) and only offer if false.
+        send: (data: Uint8Array) =>
+          Queue.offer(outgoingQueue, data).pipe(
+            Effect.mapError((e) => new TcpStreamError({ message: String(e) })),
+          ),
+
+        sendText: (data: string) =>
+          // TODO: yield* Queue.isShutdown(queue) and only offer if false.
+          Queue.offer(outgoingQueue, new TextEncoder().encode(data)).pipe(
+            Effect.mapError((e) => new TcpStreamError({ message: String(e) })),
+          ),
+        close,
+      });
+    }),
+  );
+
+export const ConnectionConfigLive = (
+  host: string,
+  port: number,
+  tickers: string[],
+  magicToken: string,
+  username: string,
+  password: string,
+) =>
+  Layer.scoped(
+    ConnectionConfig,
+    Effect.succeed({
+      host,
+      port,
+      magicToken,
+      username,
+      password,
+      tickers,
+    }),
+  );
+
+// Redundant export removed

package/src/utils.ts

@@ -0,0 +1,36 @@
+import { Effect, pipe, Schedule } from 'effect';
+
+// Send "ping" every second
+export const ping = (
+  send: (data: Uint8Array) => Effect.Effect<void, never, never>,
+) =>
+  pipe(
+    Effect.repeat(
+      pipe(
+        Effect.flatMap(
+          Effect.sync(() => Buffer.from('ping')),
+          (data) =>
+            send(data).pipe(
+              Effect.catchAll((error) => Effect.logError(error)),
+              // Effect.zipRight(printMetrics), // <-- Add this line
+            ),
+        ),
+      ),
+      Schedule.spaced('2 seconds'),
+    ),
+    Effect.fork,
+  );
+
+// Retry logic for send
+export const sendWithRetry = (
+  send: (data: Uint8Array) => Effect.Effect<void, never, never>,
+  data: Uint8Array,
+) =>
+  send(data).pipe(
+    Effect.retry(
+      Schedule.exponential('100 millis', 2).pipe(
+        Schedule.compose(Schedule.recurUpTo(5)),
+      ),
+    ),
+    Effect.catchAll((error) => Effect.logError(error)),
+  );