@6qat/tcp-connection 0.2.1 → 0.2.3

package/dist/tcp-connection.d.ts

@@ -0,0 +1,33 @@
+import { Effect, Stream, Duration } from 'effect';
+import type { TimeoutException } from 'effect/Cause';
+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 BunError extends TcpConnectionError {
+    readonly message: string;
+    readonly errorType = "BunError";
+    constructor(message: string);
+}
+export interface TcpStreamConfig {
+    readonly host: string;
+    readonly port: number;
+    readonly bufferSize?: number;
+    readonly connectTimeout?: Duration.DurationInput;
+}
+export declare class TcpStream {
+    private readonly incomingQueue;
+    private readonly outgoingQueue;
+    private readonly performShutdown;
+    private constructor();
+    static connect(config: TcpStreamConfig): Effect.Effect<TcpStream, TcpConnectionError | TimeoutException>;
+    get incomingStream(): Stream.Stream<Uint8Array, TcpConnectionError>;
+    write(data: Uint8Array): Effect.Effect<boolean, TcpConnectionError>;
+    writeText(data: string): Effect.Effect<boolean, TcpConnectionError>;
+    close(): Effect.Effect<void>;
+    static managedStream(config: TcpStreamConfig): Stream.Stream<Uint8Array, TcpConnectionError | TimeoutException>;
+}
+export {};

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

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

package/dist/tcp-stream.d.ts

@@ -1,5 +1,5 @@
-import { Effect, Stream, Duration } from "effect";
-interface TcpConnection {
+import { Effect, Stream, Duration } from 'effect';
+export interface TcpConnection {
     readonly stream: Stream.Stream<Uint8Array, Error>;
     readonly send: (data: Uint8Array) => Effect.Effect<void>;
     readonly sendText: (data: string) => Effect.Effect<void>;
@@ -10,4 +10,3 @@ export declare const createTcpConnection: (options: {
     port: number;
     timeout?: Duration.Duration;
 }) => Effect.Effect<TcpConnection, Error>;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@6qat/tcp-connection",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "TCP connection library with Effect.js integration",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -8,19 +8,23 @@
   "type": "module",
   "files": ["dist", "README.md"],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build:main": "bun build --minify-syntax --minify-whitespace ./src/index.ts --outdir ./dist --target node --format esm",
+    "build:types": "bun tsc --emitDeclarationOnly --outDir dist",
+    "build": "bun run build:main && bun run build:types",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "format": "biome format --write ./src",
+    "lint": "biome lint ."
   },
   "keywords": ["tcp", "connection", "effect", "bun"],
   "author": "Your Name",
   "license": "MIT",
   "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5"
+    "@types/bun": "^1.2.11",
+    "typescript": "^5.8.3"
   },
   "peerDependencies": {
-    "effect": "^2.0.0"
+    "effect": "^3.14.21"
   },
   "publishConfig": {
     "access": "public"

package/dist/tcp-stream.js

@@ -1,82 +0,0 @@
-import { Effect, Stream, Queue, pipe, Fiber, Duration, Ref } from "effect";
-export const createTcpConnection = (options) => {
-    return Effect.scoped(Effect.gen(function* () {
-        // Create queues for incoming and outgoing data
-        const incomingQueue = yield* Queue.unbounded();
-        const outgoingQueue = yield* Queue.unbounded();
-        // 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;
-            bunSocket.end();
-            // Allow socket events to propagate
-            yield* Effect.sleep(Duration.millis(10));
-            // Interrupt writer fiber before shutting down queues
-            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: options.port,
-            hostname: options.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(options.timeout ?? Duration.millis(3000)), Effect.flatMap((maybeSocket) => maybeSocket
-            ? Effect.succeed(maybeSocket)
-            : Effect.fail(new Error("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
-                        Effect.runSync(performShutdown);
-                        return Effect.fail(new Error(`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* () {
-            console.log("Closing connection");
-            yield* performShutdown;
-        });
-        // returns TCPConnection
-        return {
-            stream: Stream.fromQueue(incomingQueue).pipe(Stream.ensuring(close)),
-            send: (data) => Queue.offer(outgoingQueue, data),
-            sendText: (data) => Queue.offer(outgoingQueue, new TextEncoder().encode(data)),
-            close,
-        };
-    }));
-};