@oox/socketio 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 lipingruan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/adapter.js

@@ -0,0 +1,48 @@
+import * as SocketIOClient from 'socket.io-client';
+import * as oox from 'oox';
+import { OOXEvent, genWebSocketURL } from './utils.js';
+import { randomUUID } from 'node:crypto';
+import { SampleKeepAliveConnectionAdapter } from 'oox/samples';
+export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter {
+    name = 'socketio';
+    OOXEvent = OOXEvent;
+    newConnection(identify) {
+        const { id, name } = oox.config;
+        const headers = {
+            'x-caller': name,
+            'x-caller-id': id,
+        };
+        let mURL;
+        const connectionData = {
+            name: 'anonymous',
+            id: randomUUID(),
+            adapter: this.name,
+            ip: '',
+            token: ''
+        };
+        if ('string' === typeof identify) {
+            mURL = genWebSocketURL(identify);
+        }
+        else if (identify instanceof URL) {
+            mURL = identify;
+        }
+        else if (identify.url) {
+            // KeepAliveConnectionData
+            Object.assign(connectionData, identify);
+            mURL = new URL(identify.url);
+            if (identify.token) {
+                headers['x-token'] = identify.token;
+            }
+        }
+        else {
+            throw new Error('identify must be string, URL, or KeepAliveConnectionData');
+        }
+        const socket = SocketIOClient.io(mURL.origin, {
+            extraHeaders: headers,
+            path: mURL.pathname,
+            autoConnect: false,
+        });
+        const connection = new oox.KeepAliveConnection(this, socket, connectionData);
+        return connection;
+    }
+}

package/index.js

@@ -0,0 +1,23 @@
+import * as PATH from 'node:path';
+import * as oox from 'oox';
+import SocketINServer from './server.js';
+export default class SocketIOModule extends SocketINServer {
+    async serve() {
+        await this.stop();
+        const _http = oox.modules.builtins.http;
+        const httpConfig = _http.getConfig(), config = this.getConfig();
+        let isShareServer = false;
+        // 都没设置端口
+        isShareServer = !httpConfig.port && !config.port;
+        // 都设置相同端口
+        isShareServer ||= httpConfig.port === config.port;
+        // http 模块未被禁用
+        isShareServer &&= httpConfig.enabled;
+        if (isShareServer) {
+            config.path = PATH.posix.join(httpConfig.path, config.path);
+            this.server = _http.server;
+            this.config.ssl = _http.config.ssl;
+        }
+        await super.serve();
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@oox/socketio",
+    "version": "1.0.0",
+    "description": "OOX SocketIO Module",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    },
+    "main": "index.js",
+    "types": "./types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./index.js",
+            "require": "./index.js",
+            "types": "./types/index.d.ts"
+        }
+    },
+    "keywords": [
+        "oox",
+        "socketio",
+        "module",
+        "websocket"
+    ],
+    "author": "lipingruan",
+    "email": "hello@ruanmail.com",
+    "homepage": "https://gitee.com/lipingruan/oox/tree/main/packages/oox-socketio",
+    "license": "MIT",
+    "type": "module",
+    "dependencies": {
+        "socket.io": "^4.8.3",
+        "socket.io-client": "^4.8.3"
+    }
+}

package/server.js

@@ -0,0 +1,207 @@
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { Server } from 'socket.io';
+import * as oox from 'oox';
+import { Module } from 'oox';
+import SocketIOAdapter from './adapter.js';
+import { OOXEvent } from './utils.js';
+import { randomUUID } from 'node:crypto';
+export class SocketIOConfig {
+    enabled = true;
+    // listen port
+    port = 0;
+    // service path
+    path = '/socket.io';
+    // browser cross origin
+    origin = '';
+    // https options
+    ssl = {
+        // enable https
+        enabled: false,
+        // ssl certificate path
+        cert: '',
+        // ssl private key path
+        key: '',
+        // ssl ca path
+        ca: ''
+    };
+}
+export default class SocketIOServer extends Module {
+    name = 'socketio';
+    config = new SocketIOConfig;
+    /**
+     * means this.server created by myself<SocketIOServer>
+     */
+    #isSelfServer = false;
+    server = null;
+    socketServer = null;
+    adapter = new SocketIOAdapter();
+    constructor() {
+        super();
+        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
+    }
+    getURL() {
+        const { host } = oox.config;
+        const { port, path } = this.config;
+        const protocol = this.config.ssl.enabled ? 'wss:' : 'ws:';
+        return new URL(`${protocol}//${host}:${port}${path}`);
+    }
+    setConfig(config) {
+        Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    // 对外提供服务的URL
+    get serviceURL() {
+        return this.getURL();
+    }
+    async serve() {
+        await this.stop();
+        const { port, ssl } = this.config;
+        const isSelfServer = this.#isSelfServer = this.server ? true : false;
+        let server = null;
+        if (isSelfServer) {
+            if (!this.server)
+                throw new Error('HTTP Server is not created');
+            server = this.server;
+        }
+        else {
+            if (ssl.enabled) {
+                const fs = await import('node:fs');
+                const options = {
+                    key: ssl.key ? fs.readFileSync(ssl.key) : undefined,
+                    cert: ssl.cert ? fs.readFileSync(ssl.cert) : undefined,
+                    ca: ssl.ca ? fs.readFileSync(ssl.ca) : undefined
+                };
+                if (!options.key || !options.cert) {
+                    throw new Error('HTTPS enabled but missing key or cert');
+                }
+                server = https.createServer(options, (_request, response) => response.end('No HTTP Gateway'));
+            }
+            else {
+                server = http.createServer((_request, response) => response.end('No HTTP Gateway'));
+            }
+        }
+        this.server = server;
+        if (!server.listening)
+            server.listen(port);
+        const address = server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read socket.io server port');
+        this.config.port = address.port;
+        this.createSocketIOServer();
+    }
+    async stop() {
+        const { server, socketServer } = this;
+        if (socketServer)
+            await new Promise((resolve, reject) => socketServer.close(error => error ? reject(error) : resolve()));
+        if (this.#isSelfServer)
+            await new Promise((resolve, reject) => server?.close(error => error ? reject(error) : resolve()));
+    }
+    genSocketIOServerOptions() {
+        const options = {
+            /**
+             * name of the path to capture
+             * @default "/socket.io"
+             */
+            path: this.config.path,
+            /**
+             * how many ms before a client without namespace is closed
+             * @default 45000
+             */
+            connectTimeout: 5000,
+            /**
+             * how many ms without a pong packet to consider the connection closed
+             * @default 5000
+             */
+            pingTimeout: 2000,
+            /**
+             * how many ms before sending a new ping packet
+             * @default 25000
+             */
+            pingInterval: 10000,
+            /**
+             * how many bytes or characters a message can be, before closing the session (to avoid DoS).
+             * @default 1e5 (100 KB)
+             */
+            maxHttpBufferSize: 1e5
+        };
+        const { origin } = this.config;
+        if (origin)
+            options.cors = { origin };
+        return options;
+    }
+    createSocketIOServer() {
+        const { server } = this;
+        if (!server)
+            throw new Error('HTTP Server is not created');
+        const socketServer = this.socketServer = new Server(server, {
+            ...this.genSocketIOServerOptions(),
+        });
+        socketServer.on('connection', async (socket) => {
+            try {
+                this.serverOnSocketConnection(socket);
+            }
+            catch (error) {
+                console.error(error);
+                socket.send(error.message).disconnect(true);
+            }
+        });
+    }
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket) {
+        const headers = socket.handshake.headers;
+        const callerId = String(headers['x-caller-id'] || randomUUID());
+        // client ip or caller service ip
+        const ip = String(headers['x-real-ip'] || socket.handshake.address);
+        // service name
+        const caller = String(headers['x-caller'] || 'anonymous');
+        const token = String(headers['x-token'] || '');
+        // check token
+        const { allow, reason } = oox.checkAllow(ip, caller, token);
+        if (!allow) {
+            socket.send(reason).disconnect(true);
+            return;
+        }
+        const connection = new oox.KeepAliveConnection(this.adapter, socket, {
+            ip,
+            name: caller,
+            id: callerId,
+            token,
+        });
+        oox.addKeepAliveConnection(connection);
+        this.bindServerConnectionEvents(connection);
+        socket.emit(OOXEvent.READY, {
+            id: oox.config.id,
+            name: oox.config.name
+        });
+        connection.enabled = true;
+        this.adapter.bindCall(connection);
+    }
+    /**
+     * 绑定服务器连接事件
+     * @param connection
+     */
+    bindServerConnectionEvents(connection) {
+        const socket = connection.nativeConnection;
+        socket.on(OOXEvent.REGISTRY_SYNC_CONNECTIONS, async (fn) => {
+            if ('function' !== typeof fn)
+                return;
+            oox.registry.onSyncConnections(connection, {}, fn);
+        });
+        socket.on('disconnecting', (reason) => {
+            socket.removeAllListeners();
+            oox.removeKeepAliveConnection(connection);
+            connection.emit('disconnect');
+        });
+    }
+}

package/socket.js

@@ -0,0 +1 @@
+export {};

package/types/adapter.d.ts

@@ -0,0 +1,19 @@
+import * as oox from 'oox';
+import { Socket } from './socket.js';
+import { SampleKeepAliveConnectionAdapter } from 'oox/samples';
+export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter<Socket> {
+    name: string;
+    OOXEvent: {
+        CONNECT: string;
+        DISCONNECT: string;
+        ERROR: string;
+        CALL: string;
+        READY: string;
+        ENABLED: string;
+        DISABLED: string;
+        REGISTRY_SYNC_CONNECTIONS: string;
+        REGISTRY_SUBSCRIBE: string;
+        REGISTRY_NOTIFY: string;
+    };
+    newConnection(identify: string | URL | oox.KeepAliveConnectionData): oox.KeepAliveConnection<Socket>;
+}

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import SocketINServer from './server.js';
+export default class SocketIOModule extends SocketINServer {
+    serve(): Promise<void>;
+}

package/types/server.d.ts

@@ -0,0 +1,45 @@
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { Server, ServerOptions } from 'socket.io';
+import * as oox from 'oox';
+import { Module, ModuleConfig } from 'oox';
+import { Socket } from './socket.js';
+import SocketIOAdapter from './adapter.js';
+export declare class SocketIOConfig implements ModuleConfig {
+    enabled: boolean;
+    port: number;
+    path: string;
+    origin: string | string[];
+    ssl: {
+        enabled: boolean;
+        cert: string;
+        key: string;
+        ca: string;
+    };
+}
+export default class SocketIOServer extends Module {
+    #private;
+    name: string;
+    config: SocketIOConfig;
+    server: http.Server | https.Server | null;
+    socketServer: Server | null;
+    adapter: SocketIOAdapter;
+    constructor();
+    getURL(): URL;
+    setConfig(config: SocketIOConfig): void;
+    getConfig(): SocketIOConfig;
+    get serviceURL(): URL;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+    genSocketIOServerOptions(): Partial<ServerOptions>;
+    createSocketIOServer(): void;
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket: Socket<'server'>): void;
+    /**
+     * 绑定服务器连接事件
+     * @param connection
+     */
+    bindServerConnectionEvents(connection: oox.KeepAliveConnection<Socket<'server'>>): void;
+}

package/types/socket.d.ts

@@ -0,0 +1,8 @@
+import { Socket as ServerSocket } from 'socket.io';
+import { Socket as ClientSocket } from 'socket.io-client';
+export type SocketMap = {
+    [key: string]: ServerSocket | ClientSocket;
+    server: ServerSocket;
+    client: ClientSocket;
+};
+export type Socket<T extends keyof SocketMap = keyof SocketMap> = SocketMap[T];

package/types/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const OOXEvent: {
+    CONNECT: string;
+    DISCONNECT: string;
+    ERROR: string;
+    CALL: string;
+    READY: string;
+    ENABLED: string;
+    DISABLED: string;
+    REGISTRY_SYNC_CONNECTIONS: string;
+    REGISTRY_SUBSCRIBE: string;
+    REGISTRY_NOTIFY: string;
+};
+export declare function isWebSocketURL(url: string | URL): boolean;
+export declare function genWebSocketURL(url: string): URL;

package/utils.js

@@ -0,0 +1,44 @@
+export const OOXEvent = {
+    CONNECT: 'connect',
+    DISCONNECT: 'disconnect',
+    ERROR: 'error',
+    CALL: 'call',
+    READY: 'oox:ready',
+    ENABLED: 'oox:enabled',
+    DISABLED: 'oox:disabled',
+    REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+    REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+    REGISTRY_NOTIFY: 'oox:registry:notify',
+};
+export function isWebSocketURL(url) {
+    if ('string' === typeof url) {
+        return /^wss?:\/\/.+$/.test(url);
+    }
+    else {
+        return url.protocol === 'ws:' || url.protocol === 'wss:';
+    }
+}
+export function genWebSocketURL(url) {
+    // :6000
+    if (url.startsWith(':'))
+        url = 'ws://localhost' + url;
+    // 127.0.0.1:6000
+    if (!/^\w+?:\/.+$/.test(url))
+        url = 'ws://' + url;
+    const urlObject = new URL(url);
+    // :8000 => :8000/socket.io
+    const notSetPath = !urlObject.pathname || (urlObject.pathname === '/'
+        && !url.endsWith('/')
+        && !urlObject.search
+        && !urlObject.hash);
+    if (notSetPath) {
+        urlObject.pathname = '/socket.io';
+    }
+    if (urlObject.protocol !== 'wss:') {
+        if (urlObject.port === '443')
+            urlObject.protocol = 'wss:';
+        else
+            urlObject.protocol = 'ws:';
+    }
+    return urlObject;
+}