@6qat/tcp-connection 0.2.4 → 0.2.7

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

@@ -0,0 +1,31 @@
+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

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

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

@@ -0,0 +1,38 @@
+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-connection.test.d.ts

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

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

@@ -0,0 +1,38 @@
+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-connection/src/utils.d.ts

@@ -0,0 +1,3 @@
+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>;

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

@@ -0,0 +1,38 @@
+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.d.ts

@@ -1,33 +1,38 @@
-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";
+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 TcpConnectionError extends TcpConnectionError_base {
-    readonly errorType?: string | undefined;
-    constructor(errorType?: string | undefined);
-}
-export declare class BunError extends TcpConnectionError {
+export declare class TcpStreamError extends TcpStreamError_base<{
     readonly message: string;
-    readonly errorType = "BunError";
-    constructor(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 {
 }
-export interface TcpStreamConfig {
-    readonly host: string;
-    readonly port: number;
-    readonly bufferSize?: number;
-    readonly connectTimeout?: Duration.DurationInput;
+/**
+ * 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[];
 }
-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>;
+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/tcp-stream.d.ts

@@ -1,12 +1,38 @@
-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>;
+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>;
 }
-export declare const createTcpConnection: (options: {
+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;
-    timeout?: Duration.Duration;
-}) => Effect.Effect<TcpConnection, Error>;
+    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

@@ -0,0 +1,3 @@
+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>;

package/package.json

@@ -1,32 +1,49 @@
 {
   "name": "@6qat/tcp-connection",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "description": "TCP connection library with Effect.js integration",
   "module": "dist/index.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "files": ["dist", "README.md"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
-    "build:main": "bun build --minify-syntax --minify-whitespace ./src/index.ts --outdir ./dist --target node --format esm",
+    "build:main": "bun build --minify-syntax --minify-whitespace ./src/index.ts --outdir ./dist --target bun --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",
+    "test": "vitest run --passWithNoTests",
     "format": "biome format --write ./src",
     "lint": "biome lint ."
   },
-  "keywords": ["tcp", "connection", "effect", "bun"],
+  "keywords": [
+    "tcp",
+    "connection",
+    "effect",
+    "bun"
+  ],
   "author": "Your Name",
   "license": "MIT",
   "dependencies": {
-    "effect": "^3.14.21"
+    "@effect/platform-bun": "^0.87.0",
+    "@effect/platform-node": "^0.104.0",
+    "effect": "3.19.14"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.11",
-    "typescript": "^5.8.3"
+    "@effect/language-service": "^0.63.2",
+    "@types/bun": "^1.3.5",
+    "typescript": "^5.9.3"
   },
-  "peerDependencies": {},
   "publishConfig": {
     "access": "public"
   }