@socket-mesh/server 18.1.0 → 18.1.2

package/dist/server-event.d.ts

@@ -1,12 +1,12 @@
 import { IncomingMessage } from "http";
 import { ClientSocket } from "@socket-mesh/client";
 import { ServerSocket } from "./server-socket.js";
-import { AuthenticateEvent, BadAuthTokenEvent, ConnectEvent, CloseEvent as SCloseEvent, DisconnectEvent, ErrorEvent as SErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, UnexpectedResponseEvent, UpgradeEvent, ConnectingEvent, RemoveAuthTokenEvent, DeauthenticateEvent, AuthStateChangeEvent } from "@socket-mesh/core";
+import { AuthenticateEvent, BadAuthTokenEvent, ConnectEvent, CloseEvent as SCloseEvent, DisconnectEvent, ErrorEvent as SErrorEvent, MessageEvent, PingEvent, PongEvent, RequestEvent, ResponseEvent, ConnectingEvent, RemoveAuthTokenEvent, DeauthenticateEvent, AuthStateChangeEvent } from "@socket-mesh/core";
 import { ServerMap } from "./maps/server-map.js";
 import { ClientMapFromServer } from "./maps/client-map.js";
 import { SubscribeEvent, SubscribeFailEvent, SubscribeStateChangeEvent, UnsubscribeEvent } from "@socket-mesh/channels";
 import { SocketMapFromServer } from "./maps/socket-map.js";
-export type ServerEvent<T extends ServerMap> = ConnectionEvent<T> | CloseEvent | ErrorEvent | HeadersEvent | HandshakeEvent<T> | ListeningEvent | SocketAuthStateChangeEvent<T> | SocketAuthenticateEvent<T> | SocketBadAuthTokenEvent<T> | SocketCloseEvent<T> | SocketDeauthenticateEvent<T> | SocketErrorEvent<T> | SocketMessageEvent<T> | SocketConnectEvent<T> | SocketConnectingEvent<T> | SocketDisconnectEvent<T> | SocketPingEvent<T> | SocketPongEvent<T> | SocketRemoveAuthTokenEvent<T> | SocketRequestEvent<T> | SocketResponseEvent<T> | SocketUnexpectedResponseEvent<T> | SocketUpgradeEvent<T> | WarningEvent;
+export type ServerEvent<T extends ServerMap> = ConnectionEvent<T> | CloseEvent | ErrorEvent | HeadersEvent | HandshakeEvent<T> | ListeningEvent | SocketAuthStateChangeEvent<T> | SocketAuthenticateEvent<T> | SocketBadAuthTokenEvent<T> | SocketCloseEvent<T> | SocketDeauthenticateEvent<T> | SocketErrorEvent<T> | SocketMessageEvent<T> | SocketConnectEvent<T> | SocketConnectingEvent<T> | SocketDisconnectEvent<T> | SocketPingEvent<T> | SocketPongEvent<T> | SocketRemoveAuthTokenEvent<T> | SocketRequestEvent<T> | SocketResponseEvent<T> | WarningEvent;
 export interface ConnectionEvent<T extends ServerMap> {
     socket: ServerSocket<T>;
     upgradeReq: IncomingMessage;
@@ -50,5 +50,3 @@ export type SocketSubscribeEvent<T extends ServerMap> = SubscribeEvent & ServerS
 export type SocketSubscribeFailEvent<T extends ServerMap> = SubscribeFailEvent & ServerSocketEvent<T>;
 export type SocketSubscribeStateChangeEvent<T extends ServerMap> = SubscribeStateChangeEvent & ServerSocketEvent<T>;
 export type SocketUnsubscribeEvent<T extends ServerMap> = UnsubscribeEvent & ServerSocketEvent<T>;
-export type SocketUnexpectedResponseEvent<T extends ServerMap> = UnexpectedResponseEvent & ServerSocketEvent<T>;
-export type SocketUpgradeEvent<T extends ServerMap> = UpgradeEvent & ServerSocketEvent<T>;

package/dist/server-socket.d.ts

@@ -20,8 +20,9 @@ export declare class ServerSocket<T extends ServerMap> extends Socket<SocketMapF
     private _serverTransport;
     constructor(options: ServerSocketOptions<T>);
     deauthenticate(rejectOnFailedDelivery?: boolean): Promise<boolean>;
-    kickOut(channel: string, message: string): Promise<void[]>;
     get exchange(): Exchange<T['Channel']>;
+    kickOut(channel: string, message: string): Promise<void[]>;
+    ping(): Promise<void>;
     get service(): string;
     get type(): 'server';
 }

package/dist/server-socket.js

@@ -28,6 +28,9 @@ export class ServerSocket extends Socket {
             }
         }
     }
+    get exchange() {
+        return this.server.exchange;
+    }
     kickOut(channel, message) {
         const channels = channel ? [channel] : Object.keys(this.state.channelSubscriptions);
         return Promise.all(channels.map((channelName) => {
@@ -35,8 +38,8 @@ export class ServerSocket extends Socket {
             return this._serverTransport.unsubscribe(channelName);
         }));
     }
-    get exchange() {
-        return this.server.exchange;
+    ping() {
+        return this._serverTransport.ping();
     }
     get service() {
         return this._serverTransport.service;

package/dist/server-transport.d.ts

@@ -3,9 +3,9 @@ import { ServerSocket, ServerSocketOptions } from "./server-socket.js";
 import { AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { SocketMapFromServer } from "./maps/socket-map.js";
 import { AuthTokenOptions } from "@socket-mesh/auth-engine";
-import { RawData } from "ws";
-import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest } from "@socket-mesh/core";
-import { ClientRequest, IncomingMessage } from "http";
+import { Data } from "ws";
+import { AnyPacket, AnyResponse, SocketStatus, SocketTransport, InvokeMethodRequest, InvokeServiceRequest, TransmitMethodRequest, TransmitServiceRequest, InboundMessage } from "@socket-mesh/core";
+import { IncomingMessage } from "http";
 import { ServerPlugin } from "./plugin/server-plugin.js";
 import { PublishOptions } from "@socket-mesh/channels";
 export declare class ServerTransport<T extends ServerMap> extends SocketTransport<SocketMapFromServer<T>> {
@@ -14,20 +14,18 @@ export declare class ServerTransport<T extends ServerMap> extends SocketTranspor
     readonly request: IncomingMessage;
     constructor(options: ServerSocketOptions<T>);
     changeToUnauthenticatedState(): Promise<boolean>;
-    protected decode(data: string | RawData): AnyPacket<SocketMapFromServer<T>> | AnyPacket<SocketMapFromServer<T>>[] | AnyResponse<SocketMapFromServer<T>> | AnyResponse<SocketMapFromServer<T>>[] | null;
+    protected handleInboudMessage({ packet, timestamp }: InboundMessage<SocketMapFromServer<T>>): Promise<void>;
     protected onClose(code: number, reason?: string | Buffer): 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: RawData, isBinary: boolean): void;
-    protected onPing(data: Buffer): void;
-    protected onPong(data: Buffer): void;
+    protected onMessage(data: Data, isBinary: boolean): void;
+    protected onPingPong(): void;
     protected onPublish(options: PublishOptions): Promise<void>;
     protected onRequest(packet: AnyPacket<SocketMapFromServer<T>>, timestamp: Date, pluginError?: Error): Promise<boolean>;
     protected onResponse(response: AnyResponse<SocketMapFromServer<T>>): void;
     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 onUpgrade(request: IncomingMessage): void;
-    protected onUnexpectedResponse(request: ClientRequest, response: IncomingMessage): void;
+    ping(): Promise<void>;
     setAuthorization(authToken: AuthToken, options?: AuthTokenOptions): Promise<boolean>;
     setAuthorization(signedAuthToken: SignedAuthToken, authToken?: AuthToken): Promise<boolean>;
     setReadyStatus(pingTimeoutMs: number, authError?: Error): void;

package/dist/server-transport.js

@@ -24,13 +24,12 @@ export class ServerTransport extends SocketTransport {
         }
         return false;
     }
-    decode(data) {
-        const packet = super.decode(data);
+    handleInboudMessage({ packet, timestamp }) {
         if ((packet === null || typeof packet !== 'object') && this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
-            return null;
+            return;
         }
-        return packet;
+        return super.handleInboudMessage({ packet, timestamp });
     }
     onClose(code, reason) {
         const status = this.status;
@@ -91,18 +90,25 @@ export class ServerTransport extends SocketTransport {
         this.socket.server.emit('socketMessage', { socket: this.socket, data, isBinary });
         super.onMessage(data, isBinary);
     }
-    onPing(data) {
+    /*
+        protected override onPing(data: Buffer): void {
+            if (this.socket.server.strictHandshake && this.status === 'connecting') {
+                this.disconnect(4009);
+                return;
+            }
+    
+            super.onPing(data);
+            this.socket.server.emit('socketPing', { socket: this.socket, data });
+        }
+    */
+    onPingPong() {
         if (this.socket.server.strictHandshake && this.status === 'connecting') {
             this.disconnect(4009);
             return;
         }
-        super.onPing(data);
-        this.socket.server.emit('socketPing', { socket: this.socket, data });
-    }
-    onPong(data) {
         this.resetPingTimeout(this.socket.server.isPingTimeoutDisabled ? false : this.socket.server.pingTimeoutMs, 4001);
-        super.onPong(data);
-        this.socket.server.emit('socketPong', { socket: this.socket, data });
+        this.socket.emit('pong', {});
+        this.socket.server.emit('socketPong', { socket: this.socket });
     }
     async onPublish(options) {
         let data = options.data;
@@ -144,13 +150,8 @@ export class ServerTransport extends SocketTransport {
             abortRequest(request, err);
         });
     }
-    onUpgrade(request) {
-        super.onUpgrade(request);
-        this.socket.server.emit('socketUpgrade', { socket: this.socket, request });
-    }
-    onUnexpectedResponse(request, response) {
-        super.onUnexpectedResponse(request, response);
-        this.socket.server.emit('socketUnexpectedResponse', { socket: this.socket, request, response });
+    ping() {
+        return this.send('');
     }
     async setAuthorization(authToken, options) {
         const wasAuthenticated = !!this.signedAuthToken;

package/dist/server.d.ts

@@ -1,16 +1,14 @@
 import { ServerSocket } from "./server-socket.js";
 import { Server as HttpServer } from 'http';
 import { CodecEngine } from "@socket-mesh/formatter";
-import { ClientSocket } from "@socket-mesh/client";
 import { StreamCleanupMode } from "@socket-mesh/core";
 import { AuthEngine } from "@socket-mesh/auth-engine";
 import { ServerPlugin } from "./plugin/server-plugin.js";
-import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnexpectedResponseEvent, SocketUnsubscribeEvent, SocketUpgradeEvent, WarningEvent } from "./server-event.js";
+import { CloseEvent, ConnectionEvent, ErrorEvent, HandshakeEvent, HeadersEvent, ListeningEvent, ServerEvent, SocketAuthenticateEvent, SocketAuthStateChangeEvent, SocketBadAuthTokenEvent, SocketCloseEvent, SocketConnectEvent, SocketConnectingEvent, SocketDeauthenticateEvent, SocketDisconnectEvent, SocketErrorEvent, SocketMessageEvent, SocketPingEvent, SocketPongEvent, SocketRemoveAuthTokenEvent, SocketRequestEvent, SocketResponseEvent, SocketSubscribeEvent, SocketSubscribeFailEvent, SocketSubscribeStateChangeEvent, SocketUnsubscribeEvent, WarningEvent } from "./server-event.js";
 import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
 import { DemuxedConsumableStream, StreamEvent } from "@socket-mesh/stream-demux";
 import { ServerOptions } from "./server-options.js";
 import { ServerMap } from "./maps/server-map.js";
-import { ClientMapFromServer } from "./maps/client-map.js";
 import { Broker } from "./broker/broker.js";
 import { Exchange } from "./broker/exchange.js";
 export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<ServerEvent<T>> {
@@ -31,12 +29,12 @@ export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<Serv
     readonly auth: AuthEngine;
     readonly brokerEngine: Broker<T['Channel']>;
     readonly clients: {
-        [id: string]: ClientSocket<ClientMapFromServer<T>> | ServerSocket<T>;
+        [id: string]: ServerSocket<T>;
     };
     clientCount: number;
     readonly codecEngine: CodecEngine;
     readonly pendingClients: {
-        [id: string]: ClientSocket<ClientMapFromServer<T>> | ServerSocket<T>;
+        [id: string]: ServerSocket<T>;
     };
     pendingClientCount: number;
     readonly socketStreamCleanupMode: StreamCleanupMode;
@@ -87,8 +85,6 @@ export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<Serv
     emit(event: 'socketSubscribeRequest', data: SocketSubscribeEvent<T>): void;
     emit(event: 'socketSubscribeStateChange', data: SocketSubscribeStateChangeEvent<T>): void;
     emit(event: 'socketUnsubscribe', data: SocketUnsubscribeEvent<T>): void;
-    emit(event: 'socketUnexpectedResponse', data: SocketUnexpectedResponseEvent<T>): void;
-    emit(event: 'socketUpgrade', data: SocketUpgradeEvent<T>): void;
     emit(event: "warning", data: WarningEvent): void;
     listen(): DemuxedConsumableStream<StreamEvent<ServerEvent<T>>>;
     listen(event: "close"): DemuxedConsumableStream<CloseEvent>;
@@ -119,7 +115,5 @@ export declare class Server<T extends ServerMap> extends AsyncStreamEmitter<Serv
     listen(event: 'socketSubscribeRequest'): DemuxedConsumableStream<SocketSubscribeEvent<T>>;
     listen(event: 'socketSubscribeStateChange'): DemuxedConsumableStream<SocketSubscribeStateChangeEvent<T>>;
     listen(event: 'socketUnsubscribe'): DemuxedConsumableStream<SocketUnsubscribeEvent<T>>;
-    listen(event: 'socketUnexpectedResponse'): DemuxedConsumableStream<SocketUnexpectedResponseEvent<T>>;
-    listen(event: 'socketUpgrade'): DemuxedConsumableStream<SocketUpgradeEvent<T>>;
     listen(event: "warning"): DemuxedConsumableStream<WarningEvent>;
 }

package/dist/server.js

@@ -79,18 +79,33 @@ export class Server extends AsyncStreamEmitter {
         this.plugins.push(...plugin);
     }
     bind(socket) {
-        if (socket.type === 'client') {
-            (async () => {
-                for await (let event of socket.listen()) {
-                    this.emit(`socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}`, Object.assign({ socket }, event.value));
-                }
-            })();
-            (async () => {
-                for await (let event of socket.channels.listen()) {
-                    this.emit(`socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}`, Object.assign({ socket }, event.value));
+        /*
+                if (socket.type === 'client') {
+                    (async () => {
+                        for await (let event of socket.listen()) {
+                            this.emit(
+                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                                Object.assign(
+                                    { socket },
+                                    event.value
+                                )
+                            );
+                        }
+                    })();
+            
+                    (async () => {
+                        for await (let event of socket.channels.listen()) {
+                            this.emit(
+                                `socket${event.stream[0].toUpperCase()}${event.stream.substring(1)}` as any,
+                                Object.assign(
+                                    { socket },
+                                    event.value
+                                )
+                            );
+                        }
+                    })();
                 }
-            })();
-        }
+        */
         (async () => {
             for await (let {} of socket.listen('connect')) {
                 if (this.pendingClients[socket.id]) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@socket-mesh/server",
 	"description": "A TCP socket pair for easily transmitting full messages without worrying about request size limits.",
-	"version": "18.1.0",
+	"version": "18.1.2",
   "type": "module",
   "main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -14,6 +14,13 @@
     "deploy": "npm run build && node ../../scripts/publish.mjs",
 		"test": "cross-env node --test --import=./run-test.js test/server-test.ts"
 	},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/socket-mesh/client-server.git"
+  },
+  "bugs": {
+		"url": "https://github.com/socket-mesh/client-server/labels/server"
+  },	
 	"devDependencies": {
 		"@socket-mesh/local-storage": "^1.0.2",
 		"@types/base64id": "^2.0.2",
@@ -24,7 +31,7 @@
 		"@socket-mesh/async-stream-emitter": "^7.1.2",
 		"@socket-mesh/auth": "^2.2.0",
 		"@socket-mesh/auth-engine": "^1.0.0",
-		"@socket-mesh/client": "^18.1.0",
+		"@socket-mesh/client": "^18.1.3",
 		"@socket-mesh/errors": "^3.2.0",
 		"@socket-mesh/formatter": "^4.1.0",
 		"base64id": "^2.0.0",