@socket-mesh/core 1.0.3 → 2.0.0

package/dist/socket.d.ts

@@ -1,38 +1,43 @@
-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, MethodMap, PrivateMethodMap, PublicMethodMap, ServiceMap } 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 { Plugin } from "./plugins/plugin.js";
-export type StreamCleanupMode = 'kill' | 'close' | 'none';
-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>> {
+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 { FunctionReturnType, PrivateMethodMap, PublicMethodMap, ServiceMap, ServiceMethodName, ServiceName } from './maps/method-map.js';
+import { AnyPlugin } from './plugins/plugin.js';
+import { LooseHandlerMap } from './request-handler.js';
+import { AuthenticateEvent, AuthStateChangeEvent, BadAuthTokenEvent, CloseEvent, ConnectEvent, ConnectingEvent, DeauthenticateEvent, DisconnectEvent, ErrorEvent, MessageEvent, PingEvent, PongEvent, RemoveAuthTokenEvent, RequestEvent, ResponseEvent, SocketEvent, TypedRequestEvent, TypedResponseEvent } from './socket-event.js';
+import { BaseSocketTransport, CallIdGenerator, InvokeMethodOptions, InvokeServiceOptions } from './socket-transport.js';
+export interface BaseSocketOptions<TState extends object = {}> {
     ackTimeoutMs?: number;
     callIdGenerator?: CallIdGenerator;
     codecEngine?: CodecEngine;
-    handlers?: HandlerMap<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>;
+    handlers?: LooseHandlerMap;
     isPingTimeoutDisabled?: boolean;
-    plugins?: Plugin<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>[];
-    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<TIncoming, TService>) => boolean;
+    plugins?: AnyPlugin[];
     state?: Partial<TState>;
     streamCleanupMode?: StreamCleanupMode;
 }
-export type SocketStatus = 'connecting' | 'ready' | 'closing' | 'closed';
-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>> {
+export type Socket<TIncoming extends PublicMethodMap = {}, TOutgoing extends PublicMethodMap = {}, TState extends object = {}, TService extends ServiceMap = {}, TPrivateIncoming extends PrivateMethodMap = {}, TPrivateOutgoing extends PrivateMethodMap = {}> = Omit<BaseSocket<TState>, 'invoke' | 'listen' | 'transmit'> & {
+    invoke<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TMethod extends keyof TOutgoing & string>(options: InvokeMethodOptions<TOutgoing, TMethod>, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TOutgoing[TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod, (false | number)?], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: InvokeServiceOptions<TService, TServiceName, TMethod>, arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<FunctionReturnType<TService[TServiceName][TMethod]>>;
+    invoke<TMethod extends keyof TPrivateOutgoing & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<FunctionReturnType<TPrivateOutgoing[TMethod]>>;
+    listen(event: 'request'): DemuxedConsumableStream<TypedRequestEvent<TIncoming & TPrivateIncoming, TService>>;
+    listen(event: 'response'): DemuxedConsumableStream<TypedResponseEvent<TOutgoing, TPrivateOutgoing, TService>>;
+    transmit<TMethod extends keyof TOutgoing & string>(method: TMethod, arg?: Parameters<TOutgoing[TMethod]>[0]): Promise<void>;
+    transmit<TServiceName extends ServiceName<TService>, TMethod extends ServiceMethodName<TService, TServiceName>>(options: [TServiceName, TMethod], arg?: Parameters<TService[TServiceName][TMethod]>[0]): Promise<void>;
+    transmit<TMethod extends keyof TPrivateOutgoing & string>(method: TMethod, arg?: Parameters<TPrivateOutgoing[TMethod]>[0]): Promise<void>;
+};
+export type SocketStatus = 'closed' | 'closing' | 'connecting' | 'ready';
+export type StreamCleanupMode = 'close' | 'kill' | 'none';
+export declare class BaseSocket<TState extends object = {}> extends AsyncStreamEmitter<SocketEvent | undefined> {
     private readonly _transport;
     readonly state: Partial<TState>;
-    protected constructor(transport: SocketTransport<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>, options?: SocketOptions<TIncoming, TOutgoing, TPrivateOutgoing, TService, TState>);
-    get id(): string;
-    get authToken(): AuthToken;
-    get signedAuthToken(): SignedAuthToken;
+    protected constructor(transport: BaseSocketTransport<TState>, options?: BaseSocketOptions<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;
@@ -48,9 +53,14 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     emit(event: 'ping', data: PingEvent): void;
     emit(event: 'pong', data: PongEvent): void;
     emit(event: 'removeAuthToken', data: RemoveAuthTokenEvent): void;
-    emit(event: 'request', data: RequestEvent<TIncoming, TService>): void;
-    emit(event: 'response', data: ResponseEvent<TOutgoing, TPrivateOutgoing, TService>): void;
-    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<TIncoming, TOutgoing, TPrivateOutgoing, TService>>>;
+    emit(event: 'request', data: RequestEvent): void;
+    emit(event: 'response', data: ResponseEvent): void;
+    getBackpressure(): number;
+    getInboundBackpressure(): number;
+    getOutboundBackpressure(): number;
+    get id(): null | string;
+    invoke(methodOptions: [string, string, (false | number)?] | InvokeMethodOptions | InvokeServiceOptions | string, arg?: unknown): Promise<unknown>;
+    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent>>;
     listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
     listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
     listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
@@ -58,7 +68,7 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     listen(event: 'connect'): DemuxedConsumableStream<ConnectEvent>;
     listen(event: 'connectAbort'): DemuxedConsumableStream<DisconnectEvent>;
     listen(event: 'connecting'): DemuxedConsumableStream<ConnectingEvent>;
-    listen(event: 'deauthenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'deauthenticate'): DemuxedConsumableStream<DeauthenticateEvent>;
     listen(event: 'disconnect'): DemuxedConsumableStream<DisconnectEvent>;
     listen(event: 'end'): DemuxedConsumableStream<void>;
     listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
@@ -66,15 +76,11 @@ export declare class Socket<TIncoming extends MethodMap, TOutgoing extends Publi
     listen(event: 'ping'): DemuxedConsumableStream<PingEvent>;
     listen(event: 'pong'): DemuxedConsumableStream<PongEvent>;
     listen(event: 'removeAuthToken'): DemuxedConsumableStream<RemoveAuthTokenEvent>;
-    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>;
+    listen(event: 'request'): DemuxedConsumableStream<RequestEvent>;
+    listen(event: 'response'): DemuxedConsumableStream<ResponseEvent>;
+    listen<U extends SocketEvent, V = U>(event: string): DemuxedConsumableStream<V>;
+    get signedAuthToken(): null | SignedAuthToken;
     get status(): SocketStatus;
+    transmit(serviceAndMethod: [string, string] | string, arg?: unknown): Promise<void>;
     get url(): string;
-    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>;
-    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, (number | false)?], 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]>>;
 }

package/dist/socket.js

@@ -1,28 +1,30 @@
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-export class Socket extends AsyncStreamEmitter {
+import { AsyncStreamEmitter } from '@socket-mesh/async-stream-emitter';
+export class BaseSocket 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,3 @@
-export declare function wait(duration: number): Promise<void>;
 export declare function toArray<T>(arr: T | T[]): T[];
+export declare function toError(err: unknown): Error;
+export declare function wait(duration: number): Promise<void>;

package/dist/utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@socket-mesh/core",
-	"version": "1.0.3",
+	"version": "2.0.0",
 	"description": "Core module for SocketMesh Server",
 	"type": "module",
 	"main": "dist/index.js",
@@ -8,8 +8,10 @@
 	"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"
+		"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",
@@ -27,16 +29,17 @@
 		"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"
 	}
 }