@socket-mesh/core 1.0.2 → 1.0.4

package/dist/socket.d.ts

@@ -1,39 +1,33 @@
-import { CodecEngine } from "@socket-mesh/formatter";
-import { AnyPacket } from "./packet.js";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { SocketEvent, AuthenticateEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, AuthStateChangeEvent, RemoveAuthTokenEvent, ConnectingEvent, DeauthenticateEvent } from "./socket-event.js";
-import { FunctionReturnType } from "./maps/method-map.js";
-import { HandlerMap } from "./maps/handler-map.js";
-import { CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions, SocketTransport } from "./socket-transport.js";
-import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
-import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
-import { SocketMap } from "./maps/socket-map.js";
-import { Plugin } from "./plugins/plugin.js";
-export type StreamCleanupMode = 'kill' | 'close' | 'none';
-export interface SocketOptions<T extends SocketMap, TSocket extends Socket<T> = Socket<T>> {
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+import { AuthToken, SignedAuthToken } from '@socket-mesh/auth';
+import { CodecEngine } from '@socket-mesh/formatter';
+import { DemuxedConsumableStream, StreamEvent } from '@socket-mesh/stream-demux';
+import { HandlerMap } from './maps/handler-map.js';
+import { FunctionReturnType, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from './maps/method-map.js';
+import { AnyPacket } from './packet.js';
+import { Plugin } from './plugins/plugin.js';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, SocketEvent } from './socket-event.js';
+import { CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions, SocketTransport } from './socket-transport.js';
+export interface SocketOptions<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object, TSocket extends Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState> = Socket<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>> {
     ackTimeoutMs?: number;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handlers?: HandlerMap<T>;
+    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
     isPingTimeoutDisabled?: boolean;
-    plugins?: Plugin<T>[];
-    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<T>) => boolean;
-    state?: T['State'];
+    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<TIncoming, TService>) => boolean;
+    plugins?: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
+    state?: Partial<TState>;
     streamCleanupMode?: StreamCleanupMode;
 }
-export type SocketStatus = 'connecting' | 'ready' | 'closing' | 'closed';
-export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<SocketEvent<T>> {
+export type SocketStatus = 'closed' | 'closing' | 'connecting' | 'ready';
+export type StreamCleanupMode = 'close' | 'kill' | 'none';
+export declare class Socket<TIncoming extends MethodMap, TOutgoing extends PublicMethodMap, TPrivateOutgoing extends PrivateMethodMap, TService extends ServiceMap, TState extends object> extends AsyncStreamEmitter<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService> | undefined> {
     private readonly _transport;
-    readonly state: Partial<T['State']>;
-    protected constructor(transport: SocketTransport<T>, options?: SocketOptions<T>);
-    get id(): string;
-    get authToken(): AuthToken;
-    get signedAuthToken(): SignedAuthToken;
+    readonly state: Partial<TState>;
+    protected constructor(transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
+    get authToken(): AuthToken | null;
     deauthenticate(): Promise<boolean>;
     disconnect(code?: number, reason?: string): void;
-    getBackpressure(): number;
-    getInboundBackpressure(): number;
-    getOutboundBackpressure(): number;
     emit(event: 'authStateChange', data: AuthStateChangeEvent): void;
     emit(event: 'authenticate', data: AuthenticateEvent): void;
     emit(event: 'badAuthToken', data: BadAuthTokenEvent): void;
@@ -49,9 +43,17 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     emit(event: 'ping', data: PingEvent): void;
     emit(event: 'pong', data: PongEvent): void;
     emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
-    emit(event: 'request', data: RequestEvent<T>): void;
-    emit(event: 'response', data: ResponseEvent<T>): void;
-    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<T>>>;
+    emit(event: 'request', data: RequestEvent<TIncoming, TService>): void;
+    emit(event: 'response', data: ResponseEvent<TOutgoing, TPrivateOutgoing, TService>): void;
+    getBackpressure(): number;
+    getInboundBackpressure(): number;
+    getOutboundBackpressure(): number;
+    get id(): null | string;
+    invoke<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TMethod extends keyof TOutgoing>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>>>;
     listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
     listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
     listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
@@ -67,15 +69,12 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
     listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
     listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
-    listen(event: 'request'): DemuxedConsumableStream<RequestEvent<T>>;
-    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent<T>>;
-    listen<U extends SocketEvent<T>, V = U>(event: string): DemuxedConsumableStream<V>;
+    listen(event: 'request'): DemuxedConsumableStream<RequestEvent<TIncoming, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent<TOutgoing, TPrivateOutgoing, TService>>;
+    listen<U extends SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>, V = U>(event: string): DemuxedConsumableStream<V>;
+    get signedAuthToken(): null | SignedAuthToken;
     get status(): SocketStatus;
+    transmit<TMethod extends keyof TOutgoing>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends keyof TService, TMethod extends keyof TService[TServiceName]>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
     get url(): string;
-    transmit<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<void>;
-    transmit<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<void>;
-    invoke<TMethod extends keyof T['Outgoing']>(method: TMethod, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<FunctionReturnType<T['Outgoing'][TMethod]>>;
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: [TService, TMethod, (number | false)?], arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<FunctionReturnType<T['Service'][TService][TMethod]>>;
-    invoke<TService extends keyof T['Service'], TMethod extends keyof T['Service'][TService]>(options: InvokeServiceOptions<T['Service'], TService, TMethod>, arg?: Parameters<T['Service'][TService][TMethod]>[0]): Promise<FunctionReturnType<T['Service'][TService][TMethod]>>;
-    invoke<TMethod extends keyof T['Outgoing']>(options: InvokeMethodOptions<T['Outgoing'], TMethod>, arg?: Parameters<T['Outgoing'][TMethod]>[0]): Promise<FunctionReturnType<T['Outgoing'][TMethod]>>;
 }

package/dist/socket.js

@@ -1,28 +1,30 @@
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
 export class Socket extends AsyncStreamEmitter {
+    _transport;
+    state;
     constructor(transport, options) {
         super();
         this.state = options?.state || {};
         transport.socket = this;
         this._transport = transport;
     }
-    get id() {
-        return this._transport.id;
-    }
     get authToken() {
         return this._transport.authToken;
     }
-    get signedAuthToken() {
-        return this._transport.signedAuthToken;
-    }
     deauthenticate() {
         return this._transport.changeToUnauthenticatedState();
     }
     disconnect(code = 1000, reason) {
         this._transport.disconnect(code, reason);
     }
+    emit(event, data) {
+        super.emit(event, data);
+    }
     getBackpressure() {
-        return Math.max(this._transport.getBackpressure(), this.getListenerBackpressure());
+        return Math.max(this._transport.getBackpressure(), this.getListenerBackpressure()
+        // this.receiver.getBackpressure(),
+        // this.procedure.getBackpressure()
+        );
     }
     getInboundBackpressure() {
         return this._transport.getInboundBackpressure();
@@ -30,22 +32,25 @@ export class Socket extends AsyncStreamEmitter {
     getOutboundBackpressure() {
         return this._transport.getOutboundBackpressure();
     }
-    emit(event, data) {
-        super.emit(event, data);
+    get id() {
+        return this._transport.id;
+    }
+    invoke(methodOptions, arg) {
+        return this._transport.invoke(methodOptions, arg)[0];
     }
     listen(event) {
-        return super.listen(event);
+        return super.listen(event ?? '');
+    }
+    get signedAuthToken() {
+        return this._transport.signedAuthToken;
     }
     get status() {
         return this._transport.status;
     }
-    get url() {
-        return this._transport.url;
-    }
     transmit(serviceAndMethod, arg) {
         return this._transport.transmit(serviceAndMethod, arg);
     }
-    invoke(methodOptions, arg) {
-        return this._transport.invoke(methodOptions, arg)[0];
+    get url() {
+        return this._transport.url;
     }
 }

package/dist/utils.d.ts

@@ -1,2 +1,2 @@
-export declare function wait(duration: number): Promise<void>;
 export declare function toArray<T>(arr: T | T[]): T[];
+export declare function wait(duration: number): Promise<void>;

package/dist/utils.js

@@ -1,3 +1,6 @@
+export function toArray(arr) {
+    return Array.isArray(arr) ? arr : [arr];
+}
 export function wait(duration) {
     return new Promise((resolve) => {
         setTimeout(() => {
@@ -5,6 +8,3 @@ export function wait(duration) {
         }, duration);
     });
 }
-export function toArray(arr) {
-    return Array.isArray(arr) ? arr : [arr];
-}

package/package.json

@@ -1,42 +1,45 @@
 {
-  "name": "@socket-mesh/core",
-  "version": "1.0.2",
-  "description": "Core module for SocketMesh Server",
-  "type": "module",
-  "main": "dist/index.js",
+	"name": "@socket-mesh/core",
+	"version": "1.0.4",
+	"description": "Core module for SocketMesh Server",
+	"type": "module",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": ["./dist"],
-  "scripts": {
-    "build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
-    "deploy": "npm run build && node ../../scripts/publish.mjs",
-    "test": "cross-env node --test --loader ts-node/esm test/index.spec.ts"
-  },
-  "keywords": [
-    "auth",
-    "jwt",
-    "socketMesh"
-  ],
-  "author": "Greg Kimmy",
+	"scripts": {
+		"build": "node ../../scripts/build.mjs && tsc --project tsconfig.build.json",
+		"deploy": "node ../../scripts/publish.mjs",
+		"lint": "eslint . --c ../../eslint.config.mjs",
+		"lint:fix": "eslint . --c ../../eslint.config.mjs --fix",
+		"test": "tsx --tsconfig ./tsconfig.build.json --test ./src/**/*.{spec,test}.ts ./test/**/*.{spec,test}.ts"
+	},
+	"keywords": [
+		"auth",
+		"jwt",
+		"socketMesh"
+	],
+	"author": "Greg Kimmy",
 	"license": "MIT",
 	"homepage": "https://github.com/socket-mesh/main/tree/main/packages/core#README.md",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/socket-mesh/client-server.git"
-  },
-  "bugs": {
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/socket-mesh/client-server.git"
+	},
+	"bugs": {
 		"url": "https://github.com/socket-mesh/client-server/labels/core"
-  },
+	},
 	"devDependencies": {
-		"@types/base64id": "^2.0.2",
-		"@types/ws": "^8.5.11"
+		"@socket-mesh/typescript-config": "workspace:^",
+		"@types/base64id": "catalog:base64id",
+		"@types/ws": "catalog:ws"
 	},
 	"dependencies": {
-		"@socket-mesh/async-stream-emitter": "^7.1.2",
-		"@socket-mesh/auth": "^2.2.0",
-		"@socket-mesh/errors": "^3.2.0",
-		"@socket-mesh/formatter": "^4.1.0",
-		"@socket-mesh/stream-demux": "^10.1.5",
-		"isomorphic-ws": "^5.0.0",
-		"ws": "^8.18.0"
+		"@socket-mesh/async-stream-emitter": "workspace:^",
+		"@socket-mesh/auth": "workspace:^",
+		"@socket-mesh/errors": "workspace:^",
+		"@socket-mesh/formatter": "workspace:^",
+		"@socket-mesh/stream-demux": "workspace:^",
+		"isomorphic-ws": "catalog:ws",
+		"ws": "catalog:ws"
 	}
 }

package/dist/maps/socket-map.d.ts

@@ -1,15 +0,0 @@
-import { MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } from "./method-map.js";
-export interface SocketMap {
-    Incoming: MethodMap;
-    Service: ServiceMap;
-    Outgoing: PublicMethodMap;
-    PrivateOutgoing: PrivateMethodMap;
-    State: object;
-}
-export interface EmptySocketMap {
-    Incoming: {};
-    Service: {};
-    Outgoing: {};
-    PrivateOutgoing: {};
-    State: {};
-}

package/dist/maps/socket-map.js

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