@socket-mesh/server 18.0.6 → 18.1.1

package/events.d.ts

@@ -1,54 +0,0 @@
-/// <reference types="node" />
-import { AuthToken, SignedAuthToken, AuthStateChange } from "@socket-mesh/auth";
-import { ChannelOptions } from "@socket-mesh/channel";
-export type ServerSocketEvents = RawMessage | AuthStateChanged | AuthTokenSigned | Authenticated | Deauthenticated | BadAuthToken | Connected | Subscribed | Unsubscribed | ConnectAborted | Disconnected | Closed | ErrorOccurred | void;
-export type RawMessage = {
-    message: string | ArrayBuffer | Buffer[];
-};
-export interface AuthStateChanged extends AuthStateChange {
-    authToken?: AuthToken;
-}
-export interface AuthTokenSigned {
-    signedAuthToken: SignedAuthToken;
-}
-export interface Authenticated {
-    authToken: AuthToken;
-}
-export interface Deauthenticated {
-    oldAuthToken: AuthToken;
-}
-export interface BadAuthToken {
-    authError: Error;
-    signedAuthToken: string;
-}
-export interface Connected {
-    id: string;
-    pingTimeout: number;
-    authError?: Error;
-    isAuthenticated: boolean;
-}
-export interface Subscribed {
-    channel: string;
-    subscriptionOptions: ChannelOptions;
-}
-export interface Unsubscribed {
-    channel: string;
-}
-export interface ConnectAborted {
-    code: number;
-    reason: string;
-}
-export interface Disconnected {
-    code: number;
-    reason: string;
-}
-export interface Closed {
-    code: number;
-    reason: string;
-}
-export interface ErrorOccurred {
-    error: Error;
-}
-export interface WarningOccurred {
-    warning: Error;
-}

package/inbound-packet.d.ts

@@ -1,48 +0,0 @@
-import { SignedAuthToken } from "@socket-mesh/auth";
-import { ChannelOptions } from "@socket-mesh/channel";
-import { DataPacket } from "@socket-mesh/broker";
-export type InboundPacket = InboundHandshakePacket | InboundDataPacket | InboundPublishPacket | InboundSubscribePacket | InboundUnsubscribePacket | InboundAuthenticatePacket | InboundRemoveAuthTokenPacket;
-export interface InboundHandshakePacket {
-    event: '#handshake';
-    cid: number;
-    data: {
-        authToken: SignedAuthToken;
-    };
-}
-export interface InboundSubscribePacket {
-    event: '#subscribe';
-    cid: number;
-    data: DataPacket<ChannelOptions>;
-}
-export interface InboundUnsubscribePacket {
-    event: '#unsubscribe';
-    cid?: number;
-    data: string;
-}
-export interface InboundPublishPacket {
-    event: '#publish';
-    cid?: number;
-    data?: Partial<DataPacket<any>>;
-}
-export interface InboundAuthenticatePacket {
-    event: '#authenticate';
-    cid: number;
-    data: string;
-}
-export interface InboundRemoveAuthTokenPacket {
-    event: '#removeAuthToken';
-    data: undefined;
-}
-export interface InboundDataPacket {
-    event: string | null;
-    rid?: number | null;
-    cid?: number | null;
-    data: DataPacket<any>;
-    error?: any;
-}
-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/inbound-packet.js

@@ -1,18 +0,0 @@
-export function isHandshakePacket(packet) {
-    return packet.event === '#handshake';
-}
-export function isSubscribePacket(packet) {
-    return packet.event === '#subscribe';
-}
-export function isUnsubscribePacket(packet) {
-    return packet.event === '#unsubscribe';
-}
-export function isPublishPacket(packet) {
-    return packet.event === '#publish';
-}
-export function isAuthenticatePacket(packet) {
-    return packet.event === '#authenticate';
-}
-export function isRemoveAuthTokenPacket(packet) {
-    return packet.event === '#removeAuthToken';
-}

package/index.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="node" />
-import http from "http";
-import { Server } from "./server.js";
-import { ServerOptions } from "./server-options.js";
-export { Server } from "./server.js";
-export { ServerSocket } from "./serversocket.js";
-export { SocketState } from "./socket-state.js";
-export { ServerOptions } from "./server-options.js";
-export { MiddlewareType } from "./middleware-type.js";
-export * from "./action.js";
-/**
- * Creates an http.Server exclusively used for WS upgrades.
- *
- * @param {Number} port
- * @param {Function} callback
- * @param {Object} options
- * @return {AGServer} websocket cluster server
- * @api public
- */
-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.
- *
- * @param {http.Server} server
- * @param {Object} options
- * @return {AGServer} websocket cluster server
- * @api public
- */
-export declare function attach(server: http.Server, options?: ServerOptions): Server;

package/middleware-stream.d.ts

@@ -1,7 +0,0 @@
-import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
-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/middleware-stream.js

@@ -1,8 +0,0 @@
-import { WritableConsumableStream } from "@socket-mesh/writable-consumable-stream";
-export class MiddlewareStream extends WritableConsumableStream {
-    type;
-    constructor(type) {
-        super();
-        this.type = type;
-    }
-}

package/middleware-type.d.ts

@@ -1,6 +0,0 @@
-export declare enum MiddlewareType {
-    MIDDLEWARE_HANDSHAKE = "handshake",
-    MIDDLEWARE_INBOUND_RAW = "inboundRaw",
-    MIDDLEWARE_INBOUND = "inbound",
-    MIDDLEWARE_OUTBOUND = "outbound"
-}

package/middleware-type.js

@@ -1,7 +0,0 @@
-export var MiddlewareType;
-(function (MiddlewareType) {
-    MiddlewareType["MIDDLEWARE_HANDSHAKE"] = "handshake";
-    MiddlewareType["MIDDLEWARE_INBOUND_RAW"] = "inboundRaw";
-    MiddlewareType["MIDDLEWARE_INBOUND"] = "inbound";
-    MiddlewareType["MIDDLEWARE_OUTBOUND"] = "outbound";
-})(MiddlewareType || (MiddlewareType = {}));

package/outbound-packet.d.ts

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

package/outbound-packet.js

@@ -1,3 +0,0 @@
-export function isPublishOutPacket(packet) {
-    return packet.event === '#publish';
-}

package/remote-procedure.d.ts

@@ -1,13 +0,0 @@
-import { DemuxedConsumableStream, StreamDemux, StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-import { AuthenticateRequest, HandshakeRequest, InboundRequest, InvokeRequest, PublishRequest, SubscribeRequest, UnsubscribeRequest } from "./request.js";
-import { Request } from "@socket-mesh/request";
-export declare class RemoteProcedure extends StreamDemuxWrapper<InboundRequest> {
-    constructor(stream: StreamDemux<InboundRequest>);
-    listen(name: '#handshake'): DemuxedConsumableStream<HandshakeRequest>;
-    listen(name: '#authenticate'): DemuxedConsumableStream<AuthenticateRequest>;
-    listen(name: '#subscribe'): DemuxedConsumableStream<SubscribeRequest>;
-    listen(name: '#unsubscribe'): DemuxedConsumableStream<UnsubscribeRequest>;
-    listen(name: '#publish'): DemuxedConsumableStream<PublishRequest>;
-    listen<U>(name: string): DemuxedConsumableStream<Request<U>>;
-    listen<U, V>(name: string): DemuxedConsumableStream<InvokeRequest<U, V>>;
-}

package/remote-procedure.js

@@ -1,9 +0,0 @@
-import { StreamDemuxWrapper } from "@socket-mesh/stream-demux";
-export class RemoteProcedure extends StreamDemuxWrapper {
-    constructor(stream) {
-        super(stream);
-    }
-    listen(name) {
-        return super.listen(name);
-    }
-}

package/request.d.ts

@@ -1,24 +0,0 @@
-import { Request, RequestSocket, RequestWithResponse } from "@socket-mesh/request";
-import { Connected } from "./events.js";
-import { DataPacket } from "@socket-mesh/broker";
-import { ChannelOptions } from "@socket-mesh/channel";
-export type InboundRequest = HandshakeRequest | SubscribeRequest | UnsubscribeRequest | AuthenticateRequest | PublishRequest | InvokeRequest<any, any>;
-export interface HandshakeData {
-    authToken: string;
-}
-export declare class HandshakeRequest extends RequestWithResponse<HandshakeData, Connected> {
-    constructor(socket: RequestSocket, id: number, procedureName: '#handshake', data: HandshakeData);
-}
-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 RequestWithResponse<string, AuthenticateData> {
-    constructor(socket: RequestSocket, id: number, procedureName: '#authenticate', data: string);
-}

package/request.js

@@ -1,16 +0,0 @@
-import { Request, RequestWithResponse } from "@socket-mesh/request";
-export class HandshakeRequest extends RequestWithResponse {
-    constructor(socket, id, procedureName, data) {
-        super(socket, id, procedureName, data);
-    }
-}
-export class UnsubscribeRequest extends Request {
-    constructor(socket, id, procedureName, data) {
-        super(socket, id, procedureName, data);
-    }
-}
-export class AuthenticateRequest extends RequestWithResponse {
-    constructor(socket, id, procedureName, data) {
-        super(socket, id, procedureName, data);
-    }
-}

package/server-options.d.ts

@@ -1,38 +0,0 @@
-/// <reference types="node" />
-import { CodecEngine } from "@socket-mesh/formatter";
-import ws from "ws";
-import jwt from "jsonwebtoken";
-import { Server as HttpServer } from 'http';
-import { AuthEngine } from "./auth-engine.js";
-export type ProtocolVersions = 1 | 2;
-export interface ServerOptions {
-    httpServer?: HttpServer;
-    wsEngineServerOptions?: ws.ServerOptions;
-    authKey?: jwt.Secret;
-    perMessageDeflate?: boolean | ws.PerMessageDeflateOptions;
-    authPrivateKey?: jwt.Secret;
-    authPublicKey?: jwt.Secret;
-    authDefaultExpiry?: number;
-    authAlgorithm?: jwt.Algorithm;
-    protocolVersion?: ProtocolVersions;
-    handshakeTimeout?: number;
-    ackTimeout?: number;
-    origins?: string;
-    socketChannelLimit?: number;
-    pingInterval?: number;
-    pingTimeout?: number;
-    pingTimeoutDisabled?: boolean;
-    middlewareEmitFailures?: boolean;
-    path?: string;
-    allowClientPublish?: boolean;
-    batchOnHandshake?: boolean;
-    batchOnHandshakeDuration?: number;
-    batchInterval?: number;
-    socketStreamCleanupMode?: 'kill' | 'close' | 'none';
-    authVerifyAlgorithms?: jwt.Algorithm[];
-    authEngine?: AuthEngine;
-    codecEngine?: CodecEngine;
-    cloneData?: boolean;
-    strictHandshake?: boolean;
-    [additionalOptions: string]: any;
-}

package/server.d.ts

@@ -1,113 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { AuthEngine } from "./auth-engine.js";
-import { CodecEngine } from "@socket-mesh/formatter";
-import { Broker, Packet } from "@socket-mesh/broker";
-import { AsyncStreamEmitter } from "@socket-mesh/async-stream-emitter";
-import { MiddlewareType } from "./middleware-type.js";
-import { MiddlewareStream } from "./middleware-stream.js";
-import { ActionAuthenticate, ActionHandshakeSC, ActionHandshakeWS, ActionMessage, ActionPublishOut, ActionResult, ActionSubscribe, AuthInfo, HandshakeAction, InboundAction, MiddlewareAction } from "./action.js";
-import { ProtocolVersions, ServerOptions } from "./server-options.js";
-import { PerMessageDeflateOptions, WebSocketServer } from 'ws';
-import jwt from "jsonwebtoken";
-import { Server as HttpServer } from 'http';
-import { ServerSocket } from "./serversocket.js";
-import { ChannelOptions, Client } from "@socket-mesh/channel";
-import { AuthStateChanged, Authenticated, BadAuthToken, Closed, ConnectAborted, Connected, Deauthenticated, Disconnected, ErrorOccurred, ServerSocketEvents, Subscribed, Unsubscribed, WarningOccurred } from "./events.js";
-import { DemuxedConsumableStream } from "@socket-mesh/stream-demux";
-export type ServerEvent<T extends ServerSocketEvents | {}> = {
-    socket: ServerSocket;
-} & T;
-type ServerEvents = ServerEvent<Connected> | ServerEvent<ConnectAborted> | ServerEvent<Disconnected> | ServerEvent<Closed> | {} | ServerEvent<BadAuthToken> | ServerEvent<Authenticated> | ServerEvent<AuthStateChanged> | ServerEvent<Deauthenticated> | ServerEvent<{}> | ErrorOccurred | WarningOccurred | ServerEvent<Subscribed> | ServerEvent<Unsubscribed>;
-export declare class Server extends AsyncStreamEmitter<ServerEvents> {
-    allowClientPublish: boolean;
-    auth: AuthEngine;
-    clientsCount: number;
-    codec: CodecEngine;
-    defaultVerificationOptions: jwt.VerifyOptions;
-    defaultSignatureOptions: jwt.SignOptions;
-    isReady: boolean;
-    httpServer: HttpServer;
-    middlewareEmitFailures: boolean;
-    pendingClientsCount: number;
-    ackTimeout: number;
-    handshakeTimeout: number;
-    options: ServerOptions;
-    path: string;
-    perMessageDeflate?: boolean | PerMessageDeflateOptions;
-    pingInterval: number;
-    pingTimeout: number;
-    pingTimeoutDisabled: boolean;
-    protocolVersion: ProtocolVersions;
-    origins: string;
-    signatureKey: jwt.Secret;
-    strictHandshake: boolean;
-    socketChannelLimit?: number;
-    verificationKey: jwt.Secret;
-    readonly clients: {
-        [id: string]: ServerSocket;
-    };
-    readonly pendingClients: {
-        [id: string]: ServerSocket;
-    };
-    readonly brokerEngine: Broker<any>;
-    readonly exchange: Client<Packet<any>>;
-    readonly wsServer: WebSocketServer;
-    private readonly _allowAllOrigins;
-    private readonly _path;
-    private readonly _middleware;
-    constructor(options: ServerOptions);
-    setAuthEngine(authEngine: AuthEngine): void;
-    setCodecEngine(codecEngine: CodecEngine): void;
-    emitError(error: Error): void;
-    emitWarning(warning: Error): void;
-    private _handleServerError;
-    private _handleSocketConnection;
-    emit(eventName: 'connection', data: ServerEvent<Connected>): void;
-    emit(eventName: 'connectionAbort', data: ServerEvent<ConnectAborted>): void;
-    emit(eventName: 'disconnection', data: ServerEvent<Disconnected>): void;
-    emit(eventName: 'closure', data: ServerEvent<Closed>): void;
-    emit(eventName: 'ready', data: {}): void;
-    emit(eventName: 'authentication', data: ServerEvent<Authenticated>): void;
-    emit(eventName: 'badSocketAuthToken', data: ServerEvent<BadAuthToken>): void;
-    emit(eventName: 'error', data: ErrorOccurred): void;
-    emit(eventName: 'handshake', data: ServerEvent<{}>): void;
-    emit(eventName: 'warning', data: WarningOccurred): void;
-    emit(eventName: 'subscription', data: ServerEvent<Subscribed>): void;
-    emit(eventName: 'unsubscription', data: ServerEvent<Unsubscribed>): void;
-    emit(eventName: 'authenticationStateChange', data: ServerEvent<AuthStateChanged>): void;
-    emit(eventName: 'deauthentication', data: ServerEvent<Deauthenticated>): void;
-    listen(eventName: 'connection'): DemuxedConsumableStream<ServerEvent<Connected>>;
-    listen(eventName: 'connectionAbort'): DemuxedConsumableStream<ServerEvent<ConnectAborted>>;
-    listen(eventName: 'disconnection'): DemuxedConsumableStream<ServerEvent<Disconnected>>;
-    listen(eventName: 'closure'): DemuxedConsumableStream<ServerEvent<Closed>>;
-    listen(eventName: 'ready'): DemuxedConsumableStream<{}>;
-    listen(eventName: 'authentication'): DemuxedConsumableStream<ServerEvent<Authenticated>>;
-    listen(eventName: 'badSocketAuthToken'): DemuxedConsumableStream<ServerEvent<BadAuthToken>>;
-    listen(eventName: 'error'): DemuxedConsumableStream<ErrorOccurred>;
-    listen(eventName: 'handshake'): DemuxedConsumableStream<ServerEvent<{}>>;
-    listen(eventName: 'warning'): DemuxedConsumableStream<WarningOccurred>;
-    listen(eventName: 'subscription'): DemuxedConsumableStream<ServerEvent<Subscribed>>;
-    listen(eventName: 'unsubscription'): DemuxedConsumableStream<ServerEvent<Unsubscribed>>;
-    listen(eventName: 'authenticationStateChange'): DemuxedConsumableStream<ServerEvent<AuthStateChanged>>;
-    listen(eventName: 'deauthentication'): DemuxedConsumableStream<ServerEvent<Deauthenticated>>;
-    close(keepSocketsOpen?: boolean): Promise<void>;
-    getPath(): string;
-    generateId(): string;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_HANDSHAKE, middleware: (stream: MiddlewareStream<HandshakeAction>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND_RAW, middleware: (stream: MiddlewareStream<ActionMessage>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_INBOUND, middleware: (stream: MiddlewareStream<InboundAction>) => void): void;
-    setMiddleware(type: MiddlewareType.MIDDLEWARE_OUTBOUND, middleware: (stream: MiddlewareStream<ActionPublishOut>) => void): void;
-    removeMiddleware(type: MiddlewareType): void;
-    hasMiddleware(type: MiddlewareType): boolean;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<InboundAction>, action: InboundAction, socket?: ServerSocket): Promise<ActionResult<any>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionAuthenticate>, action: ActionAuthenticate, socket?: ServerSocket): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionPublishOut>, action: ActionPublishOut, socket?: ServerSocket): Promise<ActionResult<any>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionSubscribe>, action: ActionSubscribe, socket?: ServerSocket): Promise<ActionResult<ChannelOptions>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeWS>, action: ActionHandshakeWS, socket?: ServerSocket): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionHandshakeSC>, action: ActionHandshakeSC, socket?: ServerSocket): Promise<ActionResult<void>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<ActionMessage>, action: ActionMessage, socket?: ServerSocket): Promise<ActionResult<string | ArrayBuffer | Buffer[]>>;
-    _processMiddlewareAction(middlewareStream: MiddlewareStream<MiddlewareAction>, action: MiddlewareAction, socket?: ServerSocket): Promise<ActionResult<any | ChannelOptions | AuthInfo | string | ArrayBuffer | Buffer[] | void>>;
-    private _verifyHandshake;
-}
-export {};