@6qat/tcp-connection 0.2.8 → 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.8",
+  "version": "0.2.9",
   "description": "TCP connection library with Effect.js integration",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -23,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 ."
   },
@@ -43,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/tcp-connection.ts

@@ -7,7 +7,6 @@ import {
   Queue,
   Ref,
   Stream,
-  pipe,
   Data,
 } from 'effect';
 
@@ -54,141 +53,160 @@ export class ConnectionConfig extends Context.Tag('ConnectionConfig')<
   ConnectionConfigShape
 >() {}
 
+/**
+ * Creates the TcpStream layer using Layer.scoped for proper resource management.
+ */
 export const TcpStreamLive = () =>
-  /**
-   * Layer.effect() binds an Effect to a Context.Tag and returns
-   * a Layer.
-   */
-  Layer.effect(
+  Layer.scoped(
     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);
+      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' }),
+              ),
+        ),
+      );
 
-      // Safely shut down once
-      const performShutdown = Effect.gen(function* () {
+      // 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));
 
-        // Interrupt writer fiber before shutting down queues
-        // TODO: isn't the writing fiber already interrupted when sutting down the Queue?
-        yield* Fiber.interrupt(writerFiber);
+        const fiber = yield* Ref.get(writerFiberRef);
+        if (fiber) {
+          yield* Fiber.interrupt(fiber);
+        }
 
-        yield* Effect.all([
-          Queue.shutdown(incomingQueue),
-          Queue.shutdown(outgoingQueue),
-        ]);
+        yield* Queue.shutdown(incomingQueue);
+        yield* 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)),
-                    );
-                  },
-                }),
-              ),
+      // 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);
+              }),
             ),
-        }),
-        Effect.fork,
-      );
-
-      // Cleanup procedure
-      const close = Effect.gen(function* () {
-        yield* Effect.void;
-        yield* performShutdown;
+          );
+        }
       });
 
-      // returns TCPStream implementation
+      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) })),
-          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) })),
-          ),
-
+        send: (data: Uint8Array) => safeOffer(outgoingQueue, data),
         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,
+          safeOffer(outgoingQueue, new TextEncoder().encode(data)),
+        close: shutdownEffect,
       });
     }),
   );
@@ -201,16 +219,11 @@ export const ConnectionConfigLive = (
   username: string,
   password: string,
 ) =>
-  Layer.scoped(
-    ConnectionConfig,
-    Effect.succeed({
-      host,
-      port,
-      magicToken,
-      username,
-      password,
-      tickers,
-    }),
-  );
-
-// Redundant export removed
+  Layer.succeed(ConnectionConfig, {
+    host,
+    port,
+    magicToken,
+    username,
+    password,
+    tickers,
+  });

package/dist/lab-effect/src/log-level.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/m-cedro/src/tcp-stream.d.ts

@@ -1,31 +0,0 @@
-import { Context, Effect, Layer, Stream } from 'effect';
-interface TcpStreamShape {
-    readonly stream: Stream.Stream<Uint8Array, Error>;
-    readonly send: (data: Uint8Array) => Effect.Effect<void>;
-    readonly sendText: (data: string) => Effect.Effect<void>;
-    readonly close: Effect.Effect<void>;
-}
-declare const TcpStream_base: Context.TagClass<TcpStream, "TcpStream", TcpStreamShape>;
-declare class TcpStream extends TcpStream_base {
-}
-/**
- * ConnectionConfigShape is an interface that defines the shape of the data
- * needed to connect to the Cedro server.
- */
-interface ConnectionConfigShape {
-    host: string;
-    port: number;
-    magicToken?: string;
-    username?: string;
-    password?: string;
-    tickers?: string[];
-}
-declare const ConnectionConfig_base: Context.TagClass<ConnectionConfig, "ConnectionConfig", ConnectionConfigShape>;
-/**
- * ConnectionConfig is a Context.Tag that provides the connection configuration.
- */
-declare class ConnectionConfig extends ConnectionConfig_base {
-}
-declare const TcpStreamLive: () => Layer.Layer<TcpStream, Error, ConnectionConfig>;
-declare const ConnectionConfigLive: (host: string, port: number, tickers: string[], magicToken: string, username: string, password: string) => Layer.Layer<ConnectionConfig, never, never>;
-export { ConnectionConfig, ConnectionConfigLive, TcpStream, TcpStreamLive };

package/dist/tcp-connection/src/index.d.ts

@@ -1 +0,0 @@
-export * from './tcp-stream';

package/dist/tcp-connection/src/tcp-connection.d.ts

@@ -1,38 +0,0 @@
-import { Context, Effect, Layer, Runtime, Stream } from 'effect';
-declare const TcpConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "TcpConnectionError";
-} & Readonly<A>;
-export declare class TcpConnectionError extends TcpConnectionError_base {
-    readonly errorType?: string | undefined;
-    constructor(errorType?: string | undefined);
-}
-export declare class TcpConnectionTimeoutError extends TcpConnectionError {
-    readonly message: string;
-    constructor(message: string);
-}
-export declare class TcpConnectionWriteError extends TcpConnectionError {
-    readonly message: string;
-    constructor(message: string);
-}
-export declare class TcpConnectionCloseError extends TcpConnectionError {
-    readonly message: string;
-    constructor(message: string);
-}
-declare const TcpConnection_base: Context.TagClass<TcpConnection, "TcpConnection", TcpConnectionShape>;
-declare class TcpConnection extends TcpConnection_base {
-}
-interface TcpConnectionShape {
-    readonly incoming: Stream.Stream<Uint8Array, TcpConnectionError>;
-    readonly send: (data: Uint8Array) => Effect.Effect<void, TcpConnectionError>;
-    readonly sendWithRetry: (data: Uint8Array) => Effect.Effect<void, TcpConnectionError>;
-}
-declare const TcpConfig_base: Context.TagClass<TcpConfig, "TcpConfig", {
-    host: string;
-    port: number;
-    bufferSize?: number;
-    runtimeEffect?: Effect.Effect<Runtime.Runtime<never>, never, never>;
-}>;
-declare class TcpConfig extends TcpConfig_base {
-}
-declare const TcpConnectionLive: Layer.Layer<TcpConnection, TcpConnectionError, TcpConfig>;
-export { TcpConfig, TcpConnection, TcpConnectionLive };

package/dist/tcp-connection/src/tcp-stream.d.ts

@@ -1,38 +0,0 @@
-import { Context, Effect, Layer, Stream } from 'effect';
-declare const TcpStreamError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "TcpStreamError";
-} & Readonly<A>;
-export declare class TcpStreamError extends TcpStreamError_base<{
-    readonly message: string;
-}> {
-}
-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>;
-}
-declare const TcpStream_base: Context.TagClass<TcpStream, "TcpStream", TcpStreamShape>;
-declare class TcpStream extends TcpStream_base {
-}
-/**
- * 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[];
-}
-declare const ConnectionConfig_base: Context.TagClass<ConnectionConfig, "ConnectionConfig", ConnectionConfigShape>;
-/**
- * ConnectionConfig is a Context.Tag that provides the connection configuration.
- */
-declare class ConnectionConfig extends ConnectionConfig_base {
-}
-declare const TcpStreamLive: () => Layer.Layer<TcpStream, import("effect/Cause").UnknownException | import("effect/Cause").TimeoutException | TcpStreamError, ConnectionConfig>;
-declare const ConnectionConfigLive: (host: string, port: number, tickers: string[], magicToken: string, username: string, password: string) => Layer.Layer<ConnectionConfig, never, never>;
-export { ConnectionConfig, ConnectionConfigLive, TcpStream, TcpStreamLive };

package/dist/tcp-stream.d.ts

@@ -1,38 +0,0 @@
-import { Context, Effect, Layer, Stream } from 'effect';
-declare const TcpStreamError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "TcpStreamError";
-} & Readonly<A>;
-export declare class TcpStreamError extends TcpStreamError_base<{
-    readonly message: string;
-}> {
-}
-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>;
-}
-declare const TcpStream_base: Context.TagClass<TcpStream, "TcpStream", TcpStreamShape>;
-export declare class TcpStream extends TcpStream_base {
-}
-/**
- * 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[];
-}
-declare const ConnectionConfig_base: Context.TagClass<ConnectionConfig, "ConnectionConfig", ConnectionConfigShape>;
-/**
- * ConnectionConfig is a Context.Tag that provides the connection configuration.
- */
-export declare class ConnectionConfig extends ConnectionConfig_base {
-}
-export declare const TcpStreamLive: () => Layer.Layer<TcpStream, TcpStreamError | import("effect/Cause").UnknownException | 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/dist/utils.d.ts

@@ -1,3 +0,0 @@
-import { Effect } from 'effect';
-export declare const ping: (send: (data: Uint8Array) => Effect.Effect<void, never, never>) => Effect.Effect<import("effect/Fiber").RuntimeFiber<number, never>, never, never>;
-export declare const sendWithRetry: (send: (data: Uint8Array) => Effect.Effect<void, never, never>, data: Uint8Array) => Effect.Effect<void, never, never>;