@socket-mesh/core 1.0.0 → 1.0.2

package/dist/socket-event.d.ts

@@ -1,10 +1,9 @@
 import ws from "isomorphic-ws";
-import { ClientRequest, IncomingMessage } from "http";
 import { MethodPacket, ServicePacket } from "./packet.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { AnyResponse } from "./response.js";
 import { SocketMap } from "./maps/socket-map.js";
-export type SocketEvent<T extends SocketMap> = AuthStateChangeEvent | RemoveAuthTokenEvent | AuthenticateEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RequestEvent<T> | ResponseEvent<T> | UnexpectedResponseEvent | UpgradeEvent;
+export type SocketEvent<T extends SocketMap> = AuthStateChangeEvent | RemoveAuthTokenEvent | AuthenticateEvent | BadAuthTokenEvent | CloseEvent | ConnectEvent | ConnectingEvent | DeauthenticateEvent | DisconnectEvent | ErrorEvent | MessageEvent | PingEvent | PongEvent | RequestEvent<T> | ResponseEvent<T>;
 export type AuthStateChangeEvent = AuthenticatedChangeEvent | DeauthenticatedChangeEvent;
 export interface AuthenticatedChangeEvent {
     isAuthenticated: true;
@@ -53,10 +52,8 @@ export interface MessageEvent {
     isBinary: boolean;
 }
 export interface PingEvent {
-    data: Buffer;
 }
 export interface PongEvent {
-    data: Buffer;
 }
 export interface RemoveAuthTokenEvent {
     oldAuthToken: SignedAuthToken;
@@ -67,10 +64,3 @@ export interface RequestEvent<T extends SocketMap> {
 export interface ResponseEvent<T extends SocketMap> {
     response: AnyResponse<T>;
 }
-export interface UnexpectedResponseEvent {
-    request: ClientRequest;
-    response: IncomingMessage;
-}
-export interface UpgradeEvent {
-    request: IncomingMessage;
-}

package/dist/socket-transport.d.ts

@@ -3,7 +3,6 @@ import ws from "isomorphic-ws";
 import { Plugin } from "./plugins/plugin.js";
 import { AnyRequest, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest } from "./request.js";
 import { AnyPacket } from "./packet.js";
-import { ClientRequest, IncomingMessage } from "http";
 import { FunctionReturnType, MethodMap, ServiceMap } from "./maps/method-map.js";
 import { AnyResponse } from "./response.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
@@ -19,6 +18,10 @@ export interface InvokeServiceOptions<TServiceMap extends ServiceMap, TService e
     method: TMethod;
     ackTimeoutMs?: number | false;
 }
+export interface InboundMessage<T extends SocketMap> {
+    timestamp: Date;
+    packet: (AnyPacket<T> | AnyResponse<T>) | (AnyPacket<T> | AnyResponse<T>)[];
+}
 export declare class SocketTransport<T extends SocketMap> {
     private _socket;
     private _webSocket;
@@ -48,22 +51,21 @@ export declare class SocketTransport<T extends SocketMap> {
     getBackpressure(): number;
     getInboundBackpressure(): number;
     getOutboundBackpressure(): number;
-    private handleInboudMessage;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage<T>): Promise<void>;
     protected onClose(code: number, reason?: Buffer | string): void;
     protected onDisconnect(status: SocketStatus, code: number, reason?: string): void;
     onError(error: Error): void;
     protected onInvoke<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing'], TPrivateMethod extends keyof T['PrivateOutgoing']>(request: InvokeMethodRequest<T["Outgoing"], TMethod> | InvokeMethodRequest<T["PrivateOutgoing"], TPrivateMethod> | InvokeServiceRequest<T["Service"], TService, TServiceMethod>): void;
-    protected onMessage(data: ws.RawData, isBinary: boolean): void;
+    protected onMessage(data: ws.Data, isBinary: boolean): void;
     protected onOpen(): void;
-    protected onPing(data: Buffer): void;
-    protected onPong(data: Buffer): void;
+    protected onPingPong(): void;
     protected onRequest(packet: AnyPacket<T>, timestamp: Date, pluginError?: Error): Promise<boolean>;
     protected onResponse(response: AnyResponse<T>, pluginError?: Error): void;
+    private onSocketClose;
+    private onSocketError;
+    private onSocketMessage;
     protected onTransmit<TService extends keyof T['Service'], TServiceMethod extends keyof T['Service'][TService], TMethod extends keyof T['Outgoing']>(request: TransmitMethodRequest<T['Outgoing'], TMethod> | TransmitServiceRequest<T['Service'], TService, TServiceMethod>): void;
-    protected onUnexpectedResponse(request: ClientRequest, response: IncomingMessage): void;
     protected onUnhandledRequest(packet: AnyPacket<T>): boolean;
-    protected onUpgrade(request: IncomingMessage): void;
-    ping(): Promise<void>;
     protected resetPingTimeout(timeoutMs: number | false, code: number): void;
     send(data: Buffer | string): Promise<void>;
     protected sendRequest(requests: (AnyRequest<T>)[]): void;

package/dist/socket-transport.js

@@ -82,8 +82,7 @@ export class SocketTransport {
     getOutboundBackpressure() {
         return this._outboundPreparedMessageCount - this._outboundSentMessageCount;
     }
-    async handleInboudMessage({ data, timestamp }) {
-        let packet = this.decode(data);
+    async handleInboudMessage({ packet, timestamp }) {
         if (packet === null) {
             return;
         }
@@ -157,8 +156,13 @@ export class SocketTransport {
         this.sendRequest([request]);
     }
     onMessage(data, isBinary) {
+        data = isBinary ? data : data.toString();
+        if (data === '') {
+            this.onPingPong();
+            return;
+        }
         const timestamp = new Date();
-        let p = Promise.resolve(isBinary ? data : data.toString());
+        let p = Promise.resolve(data);
         let resolve;
         let reject;
         const promise = new Promise((res, rej) => {
@@ -175,8 +179,9 @@ export class SocketTransport {
             }
         }
         p.then(data => {
+            const packet = this.decode(data);
             this._socket.emit('message', { data, isBinary });
-            return this.handleInboudMessage({ data, timestamp });
+            return this.handleInboudMessage({ packet, timestamp });
         })
             .then(resolve)
             .catch(err => {
@@ -196,12 +201,7 @@ export class SocketTransport {
             }
         }
     }
-    onPing(data) {
-        this._socket.emit('ping', { data });
-    }
-    onPong(data) {
-        this._socket.emit('pong', { data });
-    }
+    onPingPong() { }
     async onRequest(packet, timestamp, pluginError) {
         this._socket.emit('request', { request: packet });
         const timeoutAt = typeof packet.ackTimeoutMs === 'number' ? new Date(timestamp.valueOf() + packet.ackTimeoutMs) : null;
@@ -273,33 +273,24 @@ export class SocketTransport {
             this._socket.emit('response', { response });
         }
     }
+    onSocketClose(event) {
+        this.onClose(event.code, event.reason);
+    }
+    onSocketError(event) {
+        this.onError(event.error);
+    }
+    onSocketMessage(event) {
+        this.onMessage(event.data, false);
+    }
     onTransmit(request) {
         this.sendRequest([request]);
     }
-    onUnexpectedResponse(request, response) {
-        this._socket.emit('unexpectedResponse', { request, response });
-    }
     onUnhandledRequest(packet) {
         if (this._onUnhandledRequest) {
             return this._onUnhandledRequest(this, packet);
         }
         return false;
     }
-    onUpgrade(request) {
-        this._socket.emit('upgrade', { request });
-    }
-    ping() {
-        return new Promise((resolve, reject) => {
-            this.webSocket.ping(undefined, undefined, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
     resetPingTimeout(timeoutMs, code) {
         if (this._pingTimeoutRef) {
             clearTimeout(this._pingTimeoutRef);
@@ -385,18 +376,24 @@ export class SocketTransport {
             const { promise, ...rest } = req;
             return rest;
         });
-        this._webSocket.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode), (err) => {
+        let sendErr;
+        this.send(this.codecEngine.encode(encode.length === 1 ? encode[0] : encode)).catch(err => {
+            sendErr = err;
+        }).then(() => {
+            const errCode = sendErr?.code;
             for (const req of requests) {
-                if (err?.code === 'ECONNRESET') {
-                    err = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
+                if (errCode === 'ECONNRESET') {
+                    sendErr = new BadConnectionError(`Socket ${'callback' in req ? 'invoke' : 'transmit'} ${String(req.method)} event was aborted due to a bad connection`, 'connectAbort');
                 }
                 if (req.sentCallback) {
-                    req.sentCallback(err);
+                    req.sentCallback(sendErr);
                 }
-                if (err && 'callback' in req) {
-                    req.callback(err);
+                if (sendErr && 'callback' in req) {
+                    req.callback(sendErr);
                 }
             }
+        }).catch(err => {
+            this.onError(err);
         });
     }
     sendResponse(index, responses) {
@@ -441,10 +438,8 @@ export class SocketTransport {
         }
         //timeoutId?: NodeJS.Timeout;
         //callback: (err: Error, result?: U) => void | null
-        this._webSocket.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses), (err) => {
-            if (err) {
-                this.onError(err);
-            }
+        this.send(this.codecEngine.encode(responses.length === 1 ? responses[0] : responses)).catch(err => {
+            this.onError(err);
         });
     }
     async setAuthorization(signedAuthToken, authToken) {
@@ -639,33 +634,21 @@ export class SocketTransport {
     }
     set webSocket(value) {
         if (this._webSocket) {
-            this._webSocket.off('open', this.onOpen);
-            this._webSocket.off('close', this.onClose);
-            this._webSocket.off('error', this.onError);
-            this._webSocket.off('upgrade', this.onUpgrade);
-            this._webSocket.off('message', this.onMessage);
-            this._webSocket.off('ping', this.onPing);
-            this._webSocket.off('pong', this.onPong);
-            this._webSocket.off('unexpectedResponse', this.onUnexpectedResponse);
+            this._webSocket.onclose = null;
+            this._webSocket.onerror = null;
+            this._webSocket.onmessage = null;
+            this._webSocket.onopen = null;
+            delete this.onSocketClose;
+            delete this.onSocketError;
+            delete this.onSocketMessage;
             delete this.onOpen;
-            delete this.onClose;
-            delete this.onError;
-            delete this.onUpgrade;
-            delete this.onMessage;
-            delete this.onPing;
-            delete this.onPong;
-            delete this.onUnexpectedResponse;
         }
         this._webSocket = value;
         if (value) {
-            this._webSocket.on('open', this.onOpen = this.onOpen.bind(this));
-            this._webSocket.on('close', this.onClose = this.onClose.bind(this));
-            this._webSocket.on('error', this.onError = this.onError.bind(this));
-            this._webSocket.on('upgrade', this.onUpgrade = this.onUpgrade.bind(this));
-            this._webSocket.on('message', this.onMessage = this.onMessage.bind(this));
-            this._webSocket.on('ping', this.onPing = this.onPing.bind(this));
-            this._webSocket.on('pong', this.onPong = this.onPong.bind(this));
-            this._webSocket.on('unexpectedResponse', this.onUnexpectedResponse = this.onUnexpectedResponse.bind(this));
+            this._webSocket.onclose = this.onSocketClose = this.onSocketClose.bind(this);
+            this._webSocket.onopen = this.onOpen = this.onOpen.bind(this);
+            this._webSocket.onerror = this.onSocketError = this.onSocketError.bind(this);
+            this._webSocket.onmessage = this.onSocketMessage = this.onSocketMessage.bind(this);
         }
     }
 }

package/dist/socket.d.ts

@@ -1,7 +1,7 @@
 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 { 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";
@@ -51,8 +51,6 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     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>;
@@ -71,10 +69,7 @@ export declare class Socket<T extends SocketMap> extends AsyncStreamEmitter<Sock
     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>;

package/dist/socket.js

@@ -36,9 +36,6 @@ export class Socket extends AsyncStreamEmitter {
     listen(event) {
         return super.listen(event);
     }
-    ping() {
-        return this._transport.ping();
-    }
     get status() {
         return this._transport.status;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socket-mesh/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Core module for SocketMesh Server",
   "type": "module",
   "main": "dist/index.js",
@@ -21,10 +21,10 @@
 	"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"
+    "url": "git+https://github.com/socket-mesh/client-server.git"
   },
   "bugs": {
-		"url": "https://github.com/socket-mesh/auth/issues"
+		"url": "https://github.com/socket-mesh/client-server/labels/core"
   },
 	"devDependencies": {
 		"@types/base64id": "^2.0.2",