@socket-mesh/core 1.0.0

package/dist/socket.d.ts

@@ -0,0 +1,86 @@
+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, UnexpectedResponseEvent, UpgradeEvent, 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>> {
+    ackTimeoutMs?: number;
+    callIdGenerator?: CallIdGenerator;
+    codecEngine?: CodecEngine;
+    handlers?: HandlerMap<T>;
+    isPingTimeoutDisabled?: boolean;
+    plugins?: Plugin<T>[];
+    onUnhandledRequest?: (socket: TSocket, packet: AnyPacket<T>) => boolean;
+    state?: T['State'];
+    streamCleanupMode?: StreamCleanupMode;
+}
+export type SocketStatus = 'connecting' | 'ready' | 'closing' | 'closed';
+export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<SocketEvent<T>> {
+    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;
+    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;
+    emit(event: 'close', data: CloseEvent): void;
+    emit(event: 'connect', data: ConnectEvent): void;
+    emit(event: 'connectAbort', data: DisconnectEvent): void;
+    emit(event: 'connecting', data: ConnectingEvent): void;
+    emit(event: 'deauthenticate', data: DeauthenticateEvent): void;
+    emit(event: 'disconnect', data: DisconnectEvent): void;
+    emit(event: 'end'): void;
+    emit(event: 'error', data: ErrorEvent): void;
+    emit(event: 'message', data: MessageEvent): void;
+    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;
+    emit(event: 'unexpectedResponse', data: UnexpectedResponseEvent): void;
+    emit(event: 'upgrade', data: UpgradeEvent): void;
+    listen(): DemuxedConsumableStream<StreamEvent<SocketEvent<T>>>;
+    listen(event: 'authStateChange'): DemuxedConsumableStream<AuthStateChangeEvent>;
+    listen(event: 'authenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'badAuthToken'): DemuxedConsumableStream<BadAuthTokenEvent>;
+    listen(event: 'close'): DemuxedConsumableStream<CloseEvent>;
+    listen(event: 'connect'): DemuxedConsumableStream<ConnectEvent>;
+    listen(event: 'connectAbort'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'connecting'): DemuxedConsumableStream<ConnectingEvent>;
+    listen(event: 'deauthenticate'): DemuxedConsumableStream<AuthenticateEvent>;
+    listen(event: 'disconnect'): DemuxedConsumableStream<DisconnectEvent>;
+    listen(event: 'end'): DemuxedConsumableStream<void>;
+    listen(event: 'error'): DemuxedConsumableStream<ErrorEvent>;
+    listen(event: 'message'): DemuxedConsumableStream<MessageEvent>;
+    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(event: 'unexpectedResponse'): DemuxedConsumableStream<UnexpectedResponseEvent>;
+    listen(event: 'upgrade'): DemuxedConsumableStream<UpgradeEvent>;
+    listen<U extends SocketEvent<T>, V = U>(event: string): DemuxedConsumableStream<V>;
+    ping(): Promise<void>;
+    get status(): SocketStatus;
+    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

@@ -0,0 +1,54 @@
+import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
+export class Socket extends AsyncStreamEmitter {
+    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);
+    }
+    getBackpressure() {
+        return Math.max(this._transport.getBackpressure(), this.getListenerBackpressure());
+    }
+    getInboundBackpressure() {
+        return this._transport.getInboundBackpressure();
+    }
+    getOutboundBackpressure() {
+        return this._transport.getOutboundBackpressure();
+    }
+    emit(event, data) {
+        super.emit(event, data);
+    }
+    listen(event) {
+        return super.listen(event);
+    }
+    ping() {
+        return this._transport.ping();
+    }
+    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];
+    }
+}

package/dist/utils.d.ts

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

package/dist/utils.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@socket-mesh/core",
+  "version": "1.0.0",
+  "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",
+	"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/auth.git"
+  },
+  "bugs": {
+		"url": "https://github.com/socket-mesh/auth/issues"
+  },
+	"devDependencies": {
+		"@types/base64id": "^2.0.2",
+		"@types/ws": "^8.5.11"
+	},
+	"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"
+	}
+}