@socket-mesh/server 17.3.6 → 18.0.0

package/action.d.ts

@@ -5,8 +5,8 @@ import { AuthState, AuthToken, SignedAuthToken } from "@socket-mesh/auth";
 import { IncomingMessage } from 'http';
 import { DataPacket } from "@socket-mesh/simple-broker";
 import { ChannelOptions } from "@socket-mesh/channel";
-import { Request } from "@socket-mesh/request";
-import { ServerSocket } from "./serversocket";
+import { ServerSocket } from "./serversocket.js";
+import { HandshakeRequest } from "./request.js";
 export declare enum ActionType {
     HANDSHAKE_WS = "handshakeWS",
     HANDSHAKE_SC = "handshakeSC",
@@ -32,11 +32,12 @@ export declare abstract class Action<T, U extends ActionType = ActionType> {
     private _resolve;
     private _reject;
     constructor(type: U);
-    allow(packet?: ActionResult<T>): void;
-    block(error: Error): void;
+    allow: (packet?: ActionResult<T>) => void;
+    block: (error: Error) => void;
 }
-export type MiddlewareAction<T> = ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T> | ActionPublishOut<T> | ActionSubscribe<T> | ActionHandshakeSC<T> | ActionHandshakeWS | ActionAuthenticate<T> | ActionMessage<T>;
-export type InboundAction<T> = ActionAuthenticate<T> | ActionTransmit<T> | ActionInvoke<T> | ActionPublishIn<T> | ActionSubscribe<T>;
+export type MiddlewareAction = ActionTransmit | ActionInvoke | ActionPublishIn | ActionPublishOut | ActionSubscribe | ActionHandshakeSC | ActionHandshakeWS | ActionAuthenticate | ActionMessage;
+export type InboundAction = ActionAuthenticate | ActionTransmit | ActionInvoke | ActionPublishIn | ActionSubscribe;
+export type HandshakeAction = ActionHandshakeSC | ActionHandshakeWS;
 export declare class ActionHandshakeWS extends Action<undefined, ActionType.HANDSHAKE_WS> {
     constructor(request: IncomingMessage);
     request: IncomingMessage;
@@ -52,58 +53,54 @@ export type AuthInfo = {
     authToken: AuthToken;
     authState: AuthState;
 };
-export declare class ActionHandshakeSC<T> extends Action<AuthInfo, ActionType.HANDSHAKE_SC> {
-    constructor(socket: ServerSocket<T>, request: Request<{
-        authToken: string;
-    }>, data: AuthInfo);
-    request: Request<{
-        authToken: string;
-    }>;
-    socket: ServerSocket<T>;
+export declare class ActionHandshakeSC extends Action<AuthInfo, ActionType.HANDSHAKE_SC> {
+    constructor(socket: ServerSocket, request: HandshakeRequest, data: AuthInfo);
+    request: HandshakeRequest;
+    socket: ServerSocket;
     data: AuthInfo;
 }
-export declare class ActionMessage<T> extends Action<string | ArrayBuffer | Buffer[], ActionType.MESSAGE> {
-    constructor(socket: ServerSocket<T>, data: string | ArrayBuffer | Buffer[]);
-    socket: ServerSocket<T>;
+export declare class ActionMessage extends Action<string | ArrayBuffer | Buffer[], ActionType.MESSAGE> {
+    constructor(socket: ServerSocket, data: string | ArrayBuffer | Buffer[]);
+    socket: ServerSocket;
     data: string | ArrayBuffer | Buffer[];
 }
-export declare class ActionTransmit<T> extends Action<T, ActionType.TRANSMIT> {
-    constructor(socket: ServerSocket<T>, receiver: string, packet: DataPacket<T>);
-    socket: ServerSocket<T>;
+export declare class ActionTransmit extends Action<any, ActionType.TRANSMIT> {
+    constructor(socket: ServerSocket, receiver: string, packet: DataPacket<any>);
+    socket: ServerSocket;
     authTokenExpiredError?: AuthTokenExpiredError;
     receiver: string;
-    data?: DataPacket<T>;
+    data?: DataPacket<any>;
 }
-export declare class ActionInvoke<T> extends Action<T, ActionType.INVOKE> {
-    constructor(socket: ServerSocket<T>, procedure: string, packet?: DataPacket<T>);
-    socket: ServerSocket<T>;
+export declare class ActionInvoke extends Action<any, ActionType.INVOKE> {
+    constructor(socket: ServerSocket, procedure: string, packet?: DataPacket<any>);
+    socket: ServerSocket;
     authTokenExpiredError?: AuthTokenExpiredError;
     procedure: string;
-    data?: DataPacket<T>;
+    data?: DataPacket<any>;
 }
-export declare class ActionSubscribe<T> extends Action<ChannelOptions, ActionType.SUBSCRIBE> {
-    constructor(socket: ServerSocket<T>, packet?: DataPacket<ChannelOptions>);
-    socket: ServerSocket<T>;
+export declare class ActionSubscribe extends Action<ChannelOptions, ActionType.SUBSCRIBE> {
+    constructor(socket: ServerSocket, packet?: DataPacket<ChannelOptions>);
+    socket: ServerSocket;
     authTokenExpiredError?: AuthTokenExpiredError;
-    channel?: string;
+    channel: string;
     data?: ChannelOptions;
 }
-export declare class ActionPublishIn<T> extends Action<T, ActionType.PUBLISH_IN> {
-    constructor(socket: ServerSocket<T>, packet?: Partial<DataPacket<T>>);
-    socket: ServerSocket<T>;
+export declare class ActionPublishIn extends Action<any, ActionType.PUBLISH_IN> {
+    constructor(socket: ServerSocket, packet: Partial<DataPacket<any>>);
+    socket: ServerSocket;
     authTokenExpiredError?: AuthTokenExpiredError;
-    channel?: string;
-    data?: T;
+    channel: string;
+    data?: any;
 }
-export declare class ActionPublishOut<T> extends Action<T, ActionType.PUBLISH_OUT> {
-    constructor(socket: ServerSocket<T>);
-    socket: ServerSocket<T>;
+export declare class ActionPublishOut extends Action<any, ActionType.PUBLISH_OUT> {
+    constructor(socket: ServerSocket);
+    socket: ServerSocket;
     channel?: string;
-    data?: T;
+    data?: any;
 }
-export declare class ActionAuthenticate<T> extends Action<undefined, ActionType.AUTHENTICATE> {
-    constructor(socket: ServerSocket<T>, authToken: AuthToken, signedAuthToken: SignedAuthToken);
-    socket: ServerSocket<T>;
+export declare class ActionAuthenticate extends Action<undefined, ActionType.AUTHENTICATE> {
+    constructor(socket: ServerSocket, authToken: AuthToken, signedAuthToken: SignedAuthToken);
+    socket: ServerSocket;
     authToken: AuthToken;
     signedAuthToken: string;
 }

package/action.js

@@ -13,6 +13,20 @@ export var ActionType;
 })(ActionType || (ActionType = {}));
 export class Action {
     constructor(type) {
+        this.allow = (packet) => {
+            if (this.outcome) {
+                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
+            }
+            this.outcome = 'allowed';
+            this._resolve(packet);
+        };
+        this.block = (error) => {
+            if (this.outcome) {
+                throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
+            }
+            this.outcome = 'blocked';
+            this._reject(error);
+        };
         this.type = type;
         this.outcome = null;
         this.promise = new Promise((resolve, reject) => {
@@ -20,20 +34,6 @@ export class Action {
             this._reject = reject;
         });
     }
-    allow(packet) {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot allow`);
-        }
-        this.outcome = 'allowed';
-        this._resolve(packet);
-    }
-    block(error) {
-        if (this.outcome) {
-            throw new InvalidActionError(`Action ${this.type} has already been ${this.outcome}; cannot block`);
-        }
-        this.outcome = 'blocked';
-        this._reject(error);
-    }
 }
 export class ActionHandshakeWS extends Action {
     constructor(request) {
@@ -80,20 +80,16 @@ export class ActionSubscribe extends Action {
     constructor(socket, packet) {
         super(ActionType.SUBSCRIBE);
         this.socket = socket;
-        if (packet) {
-            this.channel = packet.channel;
-            this.data = packet.data;
-        }
+        this.channel = packet.channel;
+        this.data = packet.data;
     }
 }
 export class ActionPublishIn extends Action {
     constructor(socket, packet) {
         super(ActionType.PUBLISH_IN);
         this.socket = socket;
-        if (packet) {
-            this.channel = packet.channel;
-            this.data = packet.data;
-        }
+        this.channel = packet.channel;
+        this.data = packet.data;
     }
 }
 export class ActionPublishOut extends Action {

package/auth-engine.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import jwt from 'jsonwebtoken';
+import { ServerSocket } from './serversocket.js';
+export interface AuthTokenOptions extends jwt.SignOptions {
+    rejectOnFailedDelivery?: boolean;
+}
+export interface VerifyOptions extends jwt.VerifyOptions {
+    socket: ServerSocket;
+}
+export declare class AuthEngine {
+    verifyToken(signedToken: string, key: jwt.Secret | jwt.GetPublicKeyOrSecret, options: VerifyOptions): Promise<jwt.JwtPayload>;
+    signToken(token: string | object | Buffer, key: jwt.Secret, options: jwt.SignOptions): Promise<string>;
+}

package/auth-engine.js

@@ -0,0 +1,32 @@
+import jwt from 'jsonwebtoken';
+import { InvalidArgumentsError } from '@socket-mesh/errors';
+export class AuthEngine {
+    verifyToken(signedToken, key, options) {
+        const jwtOptions = Object.assign({}, options || {});
+        if (typeof signedToken === 'string' || signedToken == null) {
+            return new Promise((resolve, reject) => {
+                const cb = (err, token) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve(token);
+                };
+                jwt.verify(signedToken || '', key, jwtOptions, cb);
+            });
+        }
+        return Promise.reject(new InvalidArgumentsError('Invalid token format - Token must be a string'));
+    }
+    signToken(token, key, options) {
+        const jwtOptions = Object.assign({}, options || {});
+        return new Promise((resolve, reject) => {
+            jwt.sign(token, key, jwtOptions, (err, signedToken) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(signedToken);
+            });
+        });
+    }
+}

package/events.d.ts

@@ -6,16 +6,16 @@ export type RawMessage = {
     message: string | ArrayBuffer | Buffer[];
 };
 export interface AuthStateChanged extends AuthStateChange {
-    authToken?: AuthToken | null;
+    authToken?: AuthToken;
 }
 export interface AuthTokenSigned {
     signedAuthToken: SignedAuthToken;
 }
 export interface Authenticated {
-    authToken?: AuthToken | null;
+    authToken: AuthToken;
 }
 export interface Deauthenticated {
-    oldAuthToken?: AuthToken | null;
+    oldAuthToken: AuthToken;
 }
 export interface BadAuthToken {
     authError: Error;

package/inbound-packet.d.ts

@@ -1,7 +1,7 @@
 import { SignedAuthToken } from "@socket-mesh/auth";
 import { ChannelOptions } from "@socket-mesh/channel";
 import { DataPacket } from "@socket-mesh/simple-broker";
-export type InboundPacket<T> = InboundHandshakePacket | InboundDataPacket<T> | InboundPublishPacket<T> | InboundSubscribePacket | InboundUnsubscribePacket | InboundAuthenticatePacket | InboundRemoveAuthTokenPacket;
+export type InboundPacket = InboundHandshakePacket | InboundDataPacket | InboundPublishPacket | InboundSubscribePacket | InboundUnsubscribePacket | InboundAuthenticatePacket | InboundRemoveAuthTokenPacket;
 export interface InboundHandshakePacket {
     event: '#handshake';
     cid: number;
@@ -19,10 +19,10 @@ export interface InboundUnsubscribePacket {
     cid?: number;
     data: string;
 }
-export interface InboundPublishPacket<T> {
+export interface InboundPublishPacket {
     event: '#publish';
     cid?: number;
-    data?: Partial<DataPacket<T>>;
+    data?: Partial<DataPacket<any>>;
 }
 export interface InboundAuthenticatePacket {
     event: '#authenticate';
@@ -33,16 +33,16 @@ export interface InboundRemoveAuthTokenPacket {
     event: '#removeAuthToken';
     data: undefined;
 }
-export interface InboundDataPacket<T> {
+export interface InboundDataPacket {
     event: string | null;
     rid: number | null;
     cid?: number | null;
-    data: DataPacket<T>;
+    data: DataPacket<any>;
     error: any;
 }
-export declare function isHandshakePacket<T>(packet: InboundPacket<T>): packet is InboundHandshakePacket;
-export declare function isSubscribePacket<T>(packet: InboundPacket<T>): packet is InboundSubscribePacket;
-export declare function isUnsubscribePacket<T>(packet: InboundPacket<T>): packet is InboundUnsubscribePacket;
-export declare function isPublishPacket<T>(packet: InboundPacket<T>): packet is InboundPublishPacket<T>;
-export declare function isAuthenticatePacket<T>(packet: InboundPacket<T>): packet is InboundAuthenticatePacket;
-export declare function isRemoveAuthTokenPacket<T>(packet: InboundPacket<T>): packet is InboundRemoveAuthTokenPacket;
+export declare function isHandshakePacket(packet: InboundPacket): packet is InboundHandshakePacket;
+export declare function isSubscribePacket(packet: InboundPacket): packet is InboundSubscribePacket;
+export declare function isUnsubscribePacket(packet: InboundPacket): packet is InboundUnsubscribePacket;
+export declare function isPublishPacket(packet: InboundPacket): packet is InboundPublishPacket;
+export declare function isAuthenticatePacket(packet: InboundPacket): packet is InboundAuthenticatePacket;
+export declare function isRemoveAuthTokenPacket(packet: InboundPacket): packet is InboundRemoveAuthTokenPacket;

package/index.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
 import http from "http";
-import { Server } from "./server";
-import { ServerOptions } from "./server-options";
-export { Server } from "./server";
-export { ServerSocket } from "./serversocket";
-export { ServerOptions } from "./server-options";
-export { MiddlewareType } from "./middleware-type";
+import { Server } from "./server.js";
+import { ServerOptions } from "./server-options.js";
+export { Server } from "./server.js";
+export { ServerSocket } from "./serversocket.js";
+export { ServerOptions } from "./server-options.js";
+export { MiddlewareType } from "./middleware-type.js";
 /**
  * Creates an http.Server exclusively used for WS upgrades.
  *
@@ -15,10 +15,10 @@ export { MiddlewareType } from "./middleware-type";
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function listen<T>(): Server<T>;
-export declare function listen<T>(port: number, fn: () => void): Server<T>;
-export declare function listen<T>(port: number, options: ServerOptions): Server<T>;
-export declare function listen<T>(port: number, options: ServerOptions, fn: () => void): Server<T>;
+export declare function listen(): Server;
+export declare function listen(port: number, fn: () => void): Server;
+export declare function listen(port: number, options: ServerOptions): Server;
+export declare function listen(port: number, options: ServerOptions, fn: () => void): Server;
 /**
  * Captures upgrade requests for a http.Server.
  *
@@ -27,4 +27,4 @@ export declare function listen<T>(port: number, options: ServerOptions, fn: () =
  * @return {AGServer} websocket cluster server
  * @api public
  */
-export declare function attach<T>(server: http.Server, options?: ServerOptions): Server<T>;
+export declare function attach(server: http.Server, options?: ServerOptions): Server;

package/index.js

@@ -1,8 +1,8 @@
 import http from "http";
-import { Server } from "./server";
-export { Server } from "./server";
-export { ServerSocket } from "./serversocket";
-export { MiddlewareType } from "./middleware-type";
+import { Server } from "./server.js";
+export { Server } from "./server.js";
+export { ServerSocket } from "./serversocket.js";
+export { MiddlewareType } from "./middleware-type.js";
 export function listen(port, options, fn) {
     if (typeof options === 'function') {
         fn = options;

package/middleware-stream.d.ts

@@ -1,7 +1,7 @@
 import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
-import { MiddlewareType } from "./middleware-type";
-import { Action } from "./action";
-export declare class MiddlewareStream<T> extends WritableConsumableStream<Action<T>> {
+import { MiddlewareType } from "./middleware-type.js";
+import { Action, ActionType } from "./action.js";
+export declare class MiddlewareStream<T extends Action<any, ActionType>> extends WritableConsumableStream<T> {
     readonly type: MiddlewareType;
     constructor(type: MiddlewareType);
 }

package/outbound-packet.d.ts

@@ -1,18 +1,18 @@
 import { DataPacket } from "@socket-mesh/simple-broker";
-export type OutboundPacket<T> = OutboundPublishPacket<T> | OutboundTransmitPacket<T> | OutboundInvokePacket<T>;
-export interface OutboundPublishPacket<T> {
+export type OutboundPacket = OutboundPublishPacket | OutboundTransmitPacket | OutboundInvokePacket;
+export interface OutboundPublishPacket {
     event: '#publish';
-    data: DataPacket<T>;
+    data: DataPacket<any>;
     options?: OutboundPacketOptions;
 }
-export interface OutboundTransmitPacket<T> {
+export interface OutboundTransmitPacket {
     event: string;
-    data: T;
+    data: any;
     options?: OutboundPacketOptions;
 }
-export interface OutboundInvokePacket<T> {
+export interface OutboundInvokePacket {
     event: string;
-    data: T;
+    data: any;
     options?: OutboundPacketOptions;
     resolve: (value: any) => void;
     reject: (err: Error) => void;
@@ -22,4 +22,4 @@ export interface OutboundPacketOptions {
     useCache?: boolean;
     stringifiedData?: string;
 }
-export declare function isPublishOutPacket<T>(packet: OutboundPacket<T>): packet is OutboundPublishPacket<T>;
+export declare function isPublishOutPacket(packet: OutboundPacket): packet is OutboundPublishPacket;

package/package.json

@@ -1,60 +1,58 @@
 {
-  "name": "@socket-mesh/server",
-  "version": "17.3.6",
-  "description": "Server module for SocketMesh",
-  "main": "index.js",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/socket-mesh/server.git"
-  },
-  "dependencies": {
-    "@socket-mesh/async-stream-emitter": "^4.2.4",
-		"@socket-mesh/consumable-stream": "3.2.0",
-    "@socket-mesh/auth": "^2.1.5",
-    "@socket-mesh/errors": "^3.0.4",
-    "@socket-mesh/formatter": "^4.0.3",
-    "@socket-mesh/request": "^2.0.3",
-    "@socket-mesh/server-auth": "^0.0.3",
-    "@socket-mesh/simple-broker": "^5.1.5",
-    "@socket-mesh/stream-demux": "^9.0.5",
-    "@socket-mesh/writable-consumable-stream": "^4.2.0",
-		"@socket-mesh/channel": "6.0.15",
-    "base64id": "^2.0.0",
-    "clone-deep": "^4.0.1",
-    "jsonwebtoken": "^9.0.0",
-    "ws": "^8.13.0"
-  },
-  "devDependencies": {
-    "@socket-mesh/local-storage": "^1.0.0",
-    "@types/base64id": "^2.0.0",
-    "@types/clone-deep": "^4.0.1",
-    "@types/jsonwebtoken": "^9.0.1",
-    "@types/ws": "^8.5.4",
-    "cross-env": "^7.0.3",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.0.5",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
-  },
-  "scripts": {
-    "build": "node ./scripts/build.mjs && tsc",
-    "deploy": "cd dist && npm publish --access public",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --config ./jest.config.ts"
-  },
-  "keywords": [
-    "websocket",
-    "realtime",
-    "socketcluster",
-    "socketmesh"
-  ],
-  "author": "Jonathan Gros-Dubois <grosjona@yahoo.com.au>",
-  "contributors": [
-    "Greg Kimmy",
-    {
-      "name": "Jonathan Gros-Dubois",
-      "email": "grosjona@yahoo.com.au"
-    }
-  ],
-  "license": "MIT"
+	"name": "@socket-mesh/server",
+	"version": "18.0.0",
+	"description": "Server module for SocketMesh",
+	"main": "index.js",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/socket-mesh/server.git"
+	},
+	"dependencies": {
+		"@socket-mesh/async-stream-emitter": "^7.0.2",
+		"@socket-mesh/consumable-stream": "3.2.1",
+		"@socket-mesh/auth": "^2.1.6",
+		"@socket-mesh/errors": "^3.0.8",
+		"@socket-mesh/formatter": "^4.0.5",
+		"@socket-mesh/request": "^2.0.9",
+		"@socket-mesh/simple-broker": "^6.0.0",
+		"@socket-mesh/stream-demux": "^10.0.1",
+		"@socket-mesh/writable-consumable-stream": "^4.2.9",
+		"@socket-mesh/channel": "6.0.25",
+		"base64id": "^2.0.0",
+		"clone-deep": "^4.0.1",
+		"jsonwebtoken": "^9.0.2",
+		"ws": "^8.14.2"
+	},
+	"devDependencies": {
+		"@socket-mesh/client": "^18.0.3",
+		"@socket-mesh/local-storage": "^1.0.2",
+		"@types/base64id": "^2.0.1",
+		"@types/clone-deep": "^4.0.3",
+		"@types/jsonwebtoken": "^9.0.4",
+		"@types/ws": "^8.5.8",
+		"cross-env": "^7.0.3",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.2.2"
+	},
+	"scripts": {
+		"build": "node ./scripts/build.mjs && tsc",
+		"deploy": "cd dist && npm publish --access public",
+		"test": "cross-env node --test --loader ts-node/esm test/test.ts"
+	},
+	"keywords": [
+		"websocket",
+		"realtime",
+		"socketcluster",
+		"socketmesh"
+	],
+	"author": "Jonathan Gros-Dubois <grosjona@yahoo.com.au>",
+	"contributors": [
+		"Greg Kimmy",
+		{
+			"name": "Jonathan Gros-Dubois",
+			"email": "grosjona@yahoo.com.au"
+		}
+	],
+	"license": "MIT"
 }

package/request.d.ts

@@ -1,26 +1,24 @@
-import { Request } from "@socket-mesh/request";
-import { RequestSocket } from "@socket-mesh/request/request";
-import { Connected } from "./events";
+import { Request, RequestSocket, RequestWithResponse } from "@socket-mesh/request";
+import { Connected } from "./events.js";
 import { DataPacket } from "@socket-mesh/simple-broker";
 import { ChannelOptions } from "@socket-mesh/channel";
-export type InboundRequest<T> = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest<T>;
+export type InboundRequest = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest | InvokeRequest<any, any>;
 export interface HandshakeData {
     authToken: string;
 }
-export declare class HandshakeRequest extends Request<HandshakeData, Connected> {
+export declare class HandshakeRequest extends RequestWithResponse<HandshakeData, Connected> {
     constructor(socket: RequestSocket, id: number, procedureName: '#handshake', data: HandshakeData);
 }
-export type SubscribeRequest = Request<Partial<DataPacket<ChannelOptions>>, void>;
-export type PublishRequest<T> = Request<Partial<DataPacket<T>>, void>;
-export declare class UnsubscribeRequest extends Request<string, void> {
+export type InvokeRequest<T, U> = RequestWithResponse<T, U>;
+export type SubscribeRequest = Request<Partial<DataPacket<ChannelOptions>>>;
+export type PublishRequest = Request<Partial<DataPacket<any>>>;
+export declare class UnsubscribeRequest extends Request<string> {
     constructor(socket: RequestSocket, id: number, procedureName: '#unsubscribe', data: string);
 }
 export interface AuthenticateData {
     isAuthenticated: boolean;
     authError: Error | null;
 }
-export declare class AuthenticateRequest extends Request<string, AuthenticateData> {
+export declare class AuthenticateRequest extends RequestWithResponse<string, AuthenticateData> {
     constructor(socket: RequestSocket, id: number, procedureName: '#authenticate', data: string);
 }
-export declare function isSubscribeRequest(request: Request<unknown>): request is SubscribeRequest;
-export declare function isPublishRequest<T>(request: Request<unknown>): request is PublishRequest<T>;

package/request.js

@@ -1,5 +1,5 @@
-import { Request } from "@socket-mesh/request";
-export class HandshakeRequest extends Request {
+import { Request, RequestWithResponse } from "@socket-mesh/request";
+export class HandshakeRequest extends RequestWithResponse {
     constructor(socket, id, procedureName, data) {
         super(socket, id, procedureName, data);
     }
@@ -9,14 +9,8 @@ export class UnsubscribeRequest extends Request {
         super(socket, id, procedureName, data);
     }
 }
-export class AuthenticateRequest extends Request {
+export class AuthenticateRequest extends RequestWithResponse {
     constructor(socket, id, procedureName, data) {
         super(socket, id, procedureName, data);
     }
 }
-export function isSubscribeRequest(request) {
-    return request.procedure === '#subscribe';
-}
-export function isPublishRequest(request) {
-    return request.procedure === '#publish';
-}

package/server-options.d.ts

@@ -3,7 +3,7 @@ import { CodecEngine } from "@socket-mesh/formatter";
 import ws from "ws";
 import jwt from "jsonwebtoken";
 import { Server as HttpServer } from 'http';
-import { AuthEngine } from "@socket-mesh/server-auth";
+import { AuthEngine } from "./auth-engine.js";
 export type ProtocolVersions = 1 | 2;
 export interface ServerOptions {
     httpServer?: HttpServer;
@@ -28,7 +28,7 @@ export interface ServerOptions {
     batchOnHandshake?: boolean;
     batchOnHandshakeDuration?: number;
     batchInterval?: number;
-    socketStreamCleanupMode?: 'kill' | 'close';
+    socketStreamCleanupMode?: 'kill' | 'close' | 'none';
     authVerifyAlgorithms?: jwt.Algorithm[];
     authEngine?: AuthEngine;
     codecEngine?: CodecEngine;