@6qat/tcp-connection 0.2.6 → 0.2.8

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)),
+  );