@opra/socketio 1.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+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/README.md

@@ -0,0 +1,3 @@
+# @opra/socketio
+
+Opra SocketIO package.

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// export * from './constants.js';
+tslib_1.__exportStar(require("./socketio-adapter.js"), exports);
+tslib_1.__exportStar(require("./socketio-context.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/socketio-adapter.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketioAdapter = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@opra/common");
+const core_1 = require("@opra/core");
+const socketio = tslib_1.__importStar(require("socket.io"));
+const socketio_context_js_1 = require("./socketio-context.js");
+/**
+ *
+ * @class SocketioAdapter
+ */
+class SocketioAdapter extends core_1.PlatformAdapter {
+    constructor(document, options) {
+        super(options);
+        this._controllerInstances = new Map();
+        this._eventsRegByName = new Map();
+        this._eventsRegByPattern = [];
+        this.transform = 'ws';
+        this.platform = SocketioAdapter.PlatformName;
+        this._document = document;
+        if (!(this.document.api instanceof common_1.WSApi)) {
+            throw new TypeError(`The document doesn't expose a WS Api`);
+        }
+        this.interceptors = [...(options?.interceptors || [])];
+        this._scope = options?.scope;
+        this.server = new socketio.Server();
+        this.server.on('error', error => {
+            this.emit('error', error, undefined, this);
+        });
+        this.server.on('connection', (socket) => {
+            this._initSocket(socket);
+            this.emit('connection', socket, this);
+        });
+        for (const contDef of this.api.controllers.values()) {
+            for (const oprDef of contDef.operations.values()) {
+                const fn = contDef.instance[oprDef.name];
+                if (typeof fn !== 'function')
+                    continue;
+                const reg = {
+                    event: oprDef.event,
+                    contDef,
+                    oprDef,
+                    handler: fn,
+                    decoders: [],
+                };
+                if (typeof reg.event === 'string')
+                    this._eventsRegByName.set(reg.event, reg);
+                else
+                    this._eventsRegByPattern.push(reg);
+                /** Generate decoders */
+                if (oprDef.arguments?.length) {
+                    for (const dt of oprDef.arguments) {
+                        reg.decoders.push(dt.generateCodec('decode', {
+                            scope: this.scope,
+                            ignoreReadonlyFields: true,
+                        }));
+                    }
+                }
+                /** Generate response encoder */
+                if (oprDef.response) {
+                    reg.encoder = oprDef.response.generateCodec('encode', {
+                        scope: this.scope,
+                        ignoreWriteonlyFields: true,
+                    });
+                }
+            }
+        }
+    }
+    get api() {
+        return this.document.getWsApi();
+    }
+    get scope() {
+        return this._scope;
+    }
+    close() {
+        return this.server.close();
+    }
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     */
+    listen(srv, opts) {
+        if (this.server.httpServer?.listening)
+            throw new Error('Server is already listening');
+        if (opts?.path)
+            this.server.path(opts?.path);
+        this.server.listen(srv, opts);
+        return this;
+    }
+    _initSocket(socket) {
+        socket.on('close', () => {
+            this.emit('close', socket, this);
+        });
+        socket.on('error', error => {
+            this.emit('error', error, socket, this);
+        });
+        socket.onAny((event, ...args) => {
+            const callback = args.length > 0 ? args[args.length - 1] : null;
+            const reg = this._eventsRegByName.get(event) ||
+                this._eventsRegByPattern.find(r => r.event.test(event));
+            if (!reg) {
+                if (callback)
+                    callback(new Error(`Unknown event "${event}"`));
+                return;
+            }
+            const parameters = callback ? args.slice(0, -1) : args;
+            Promise.resolve().then(async () => {
+                const ctx = new socketio_context_js_1.SocketioContext({
+                    __adapter: this,
+                    __contDef: reg.contDef,
+                    __oprDef: reg.oprDef,
+                    __controller: reg.contDef.instance,
+                    __handler: reg.handler,
+                    socket,
+                    event,
+                    parameters,
+                });
+                try {
+                    let x = await reg.handler.apply(reg.contDef.instance, [
+                        ctx,
+                        ...parameters,
+                    ]);
+                    if (reg.encoder)
+                        x = reg.encoder(x);
+                    if (x != null && typeof x !== 'string')
+                        x = JSON.stringify(x);
+                    callback(x);
+                }
+                catch (err) {
+                    const error = new common_1.OpraException(err);
+                    callback(error);
+                }
+            });
+        });
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+}
+exports.SocketioAdapter = SocketioAdapter;
+SocketioAdapter.PlatformName = 'socketio';

package/cjs/socketio-context.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketioContext = void 0;
+const core_1 = require("@opra/core");
+/**
+ * Provides the context for handling messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+class SocketioContext extends core_1.ExecutionContext {
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init) {
+        super({
+            ...init,
+            __docNode: init.__oprDef?.node ||
+                init.__contDef?.node ||
+                init.__adapter.document.node,
+            transport: 'ws',
+            platform: 'socketio',
+        });
+        this.parameters = [];
+        this.socket = init.socket;
+        this.event = init.event;
+        this.parameters = init.parameters || [];
+        if (init.__contDef)
+            this.__contDef = init.__contDef;
+        if (init.__controller)
+            this.__controller = init.__controller;
+        if (init.__oprDef)
+            this.__oprDef = init.__oprDef;
+        if (init.__handler)
+            this.__handler = init.__handler;
+    }
+    get server() {
+        return this.__adapter.server;
+    }
+}
+exports.SocketioContext = SocketioContext;

package/esm/index.js

@@ -0,0 +1,3 @@
+// export * from './constants.js';
+export * from './socketio-adapter.js';
+export * from './socketio-context.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/socketio-adapter.js

@@ -0,0 +1,141 @@
+import { OpraException, WSApi, } from '@opra/common';
+import { PlatformAdapter } from '@opra/core';
+import * as socketio from 'socket.io';
+import { SocketioContext } from './socketio-context.js';
+/**
+ *
+ * @class SocketioAdapter
+ */
+export class SocketioAdapter extends PlatformAdapter {
+    constructor(document, options) {
+        super(options);
+        this._controllerInstances = new Map();
+        this._eventsRegByName = new Map();
+        this._eventsRegByPattern = [];
+        this.transform = 'ws';
+        this.platform = SocketioAdapter.PlatformName;
+        this._document = document;
+        if (!(this.document.api instanceof WSApi)) {
+            throw new TypeError(`The document doesn't expose a WS Api`);
+        }
+        this.interceptors = [...(options?.interceptors || [])];
+        this._scope = options?.scope;
+        this.server = new socketio.Server();
+        this.server.on('error', error => {
+            this.emit('error', error, undefined, this);
+        });
+        this.server.on('connection', (socket) => {
+            this._initSocket(socket);
+            this.emit('connection', socket, this);
+        });
+        for (const contDef of this.api.controllers.values()) {
+            for (const oprDef of contDef.operations.values()) {
+                const fn = contDef.instance[oprDef.name];
+                if (typeof fn !== 'function')
+                    continue;
+                const reg = {
+                    event: oprDef.event,
+                    contDef,
+                    oprDef,
+                    handler: fn,
+                    decoders: [],
+                };
+                if (typeof reg.event === 'string')
+                    this._eventsRegByName.set(reg.event, reg);
+                else
+                    this._eventsRegByPattern.push(reg);
+                /** Generate decoders */
+                if (oprDef.arguments?.length) {
+                    for (const dt of oprDef.arguments) {
+                        reg.decoders.push(dt.generateCodec('decode', {
+                            scope: this.scope,
+                            ignoreReadonlyFields: true,
+                        }));
+                    }
+                }
+                /** Generate response encoder */
+                if (oprDef.response) {
+                    reg.encoder = oprDef.response.generateCodec('encode', {
+                        scope: this.scope,
+                        ignoreWriteonlyFields: true,
+                    });
+                }
+            }
+        }
+    }
+    get api() {
+        return this.document.getWsApi();
+    }
+    get scope() {
+        return this._scope;
+    }
+    close() {
+        return this.server.close();
+    }
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     */
+    listen(srv, opts) {
+        if (this.server.httpServer?.listening)
+            throw new Error('Server is already listening');
+        if (opts?.path)
+            this.server.path(opts?.path);
+        this.server.listen(srv, opts);
+        return this;
+    }
+    _initSocket(socket) {
+        socket.on('close', () => {
+            this.emit('close', socket, this);
+        });
+        socket.on('error', error => {
+            this.emit('error', error, socket, this);
+        });
+        socket.onAny((event, ...args) => {
+            const callback = args.length > 0 ? args[args.length - 1] : null;
+            const reg = this._eventsRegByName.get(event) ||
+                this._eventsRegByPattern.find(r => r.event.test(event));
+            if (!reg) {
+                if (callback)
+                    callback(new Error(`Unknown event "${event}"`));
+                return;
+            }
+            const parameters = callback ? args.slice(0, -1) : args;
+            Promise.resolve().then(async () => {
+                const ctx = new SocketioContext({
+                    __adapter: this,
+                    __contDef: reg.contDef,
+                    __oprDef: reg.oprDef,
+                    __controller: reg.contDef.instance,
+                    __handler: reg.handler,
+                    socket,
+                    event,
+                    parameters,
+                });
+                try {
+                    let x = await reg.handler.apply(reg.contDef.instance, [
+                        ctx,
+                        ...parameters,
+                    ]);
+                    if (reg.encoder)
+                        x = reg.encoder(x);
+                    if (x != null && typeof x !== 'string')
+                        x = JSON.stringify(x);
+                    callback(x);
+                }
+                catch (err) {
+                    const error = new OpraException(err);
+                    callback(error);
+                }
+            });
+        });
+    }
+    getControllerInstance(controllerPath) {
+        const controller = this.api.findController(controllerPath);
+        return controller && this._controllerInstances.get(controller);
+    }
+}
+SocketioAdapter.PlatformName = 'socketio';

package/esm/socketio-context.js

@@ -0,0 +1,36 @@
+import { ExecutionContext } from '@opra/core';
+/**
+ * Provides the context for handling messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+export class SocketioContext extends ExecutionContext {
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init) {
+        super({
+            ...init,
+            __docNode: init.__oprDef?.node ||
+                init.__contDef?.node ||
+                init.__adapter.document.node,
+            transport: 'ws',
+            platform: 'socketio',
+        });
+        this.parameters = [];
+        this.socket = init.socket;
+        this.event = init.event;
+        this.parameters = init.parameters || [];
+        if (init.__contDef)
+            this.__contDef = init.__contDef;
+        if (init.__controller)
+            this.__controller = init.__controller;
+        if (init.__oprDef)
+            this.__oprDef = init.__oprDef;
+        if (init.__handler)
+            this.__handler = init.__handler;
+    }
+    get server() {
+        return this.__adapter.server;
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@opra/socketio",
+  "version": "1.20.0",
+  "description": "Opra Socket.IO adapter",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^2.0.2",
+    "@browsery/type-is": "^2.0.1",
+    "content-type": "^1.0.5",
+    "iconv-lite": "^0.7.0",
+    "node-events-async": "^1.2.0",
+    "tslib": "^2.8.1",
+    "valgen": "^5.18.2"
+  },
+  "peerDependencies": {
+    "@opra/common": "^1.20.0",
+    "@opra/core": "^1.20.0",
+    "socket.io": ">=4.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/panates/opra.git",
+    "directory": "packages/socketio"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "socketio",
+    "websocket",
+    "ws"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/index.d.cts

@@ -0,0 +1,2 @@
+export * from './socketio-adapter.js';
+export * from './socketio-context.js';

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './socketio-adapter.js';
+export * from './socketio-context.js';

package/types/socketio-adapter.d.ts

@@ -0,0 +1,83 @@
+import { ApiDocument, OpraSchema, WSApi, WSController, WSOperation } from '@opra/common';
+import { PlatformAdapter } from '@opra/core';
+import type * as http from 'http';
+import type * as http2 from 'http2';
+import type * as https from 'https';
+import * as socketio from 'socket.io';
+import { SocketioContext } from './socketio-context.js';
+type TServerInstance = http.Server | https.Server | http2.Http2SecureServer | http2.Http2Server;
+/**
+ *
+ * @class SocketioAdapter
+ */
+export declare class SocketioAdapter extends PlatformAdapter<SocketioAdapter.Events> {
+    static readonly PlatformName = "socketio";
+    protected _controllerInstances: Map<WSController, any>;
+    protected _eventsRegByName: Map<string, MessageHandlerReg>;
+    protected _eventsRegByPattern: MessageHandlerReg[];
+    protected _scope?: string;
+    readonly transform: OpraSchema.Transport;
+    readonly platform = "socketio";
+    readonly interceptors: (SocketioAdapter.InterceptorFunction | SocketioAdapter.IWSInterceptor)[];
+    readonly server: socketio.Server;
+    /**
+     *
+     * @constructor
+     */
+    constructor(document: ApiDocument, options?: SocketioAdapter.Options);
+    get api(): WSApi;
+    get scope(): string | undefined;
+    close(): Promise<void>;
+    /**
+     * Attaches socket.io to a server or port.
+     *
+     * @param srv - server or port
+     * @param opts - options passed to engine.io
+     * @return self
+     */
+    listen(srv: TServerInstance | number, opts?: Partial<socketio.ServerOptions>): this;
+    protected _initSocket(socket: socketio.Socket): void;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+}
+/**
+ * @namespace SocketioAdapter
+ */
+export declare namespace SocketioAdapter {
+    type NextCallback = () => Promise<any>;
+    interface Options extends PlatformAdapter.Options {
+        interceptors?: (InterceptorFunction | IWSInterceptor)[];
+        scope?: string;
+    }
+    /**
+     * @type InterceptorFunction
+     */
+    type InterceptorFunction = IWSInterceptor['intercept'];
+    /**
+     * @interface IWSInterceptor
+     */
+    type IWSInterceptor = {
+        intercept(context: SocketioContext, next: NextCallback): Promise<any>;
+    };
+    interface Events {
+        error: [
+            error: Error,
+            socket: socketio.Socket | undefined,
+            _this: SocketioAdapter
+        ];
+        connection: [socket: socketio.Socket, _this: SocketioAdapter];
+        close: [socket: socketio.Socket, _this: SocketioAdapter];
+        execute: [context: SocketioContext];
+    }
+}
+/**
+ * @interface
+ */
+interface MessageHandlerReg {
+    event: string | RegExp;
+    handler: Function;
+    contDef: WSController;
+    oprDef: WSOperation;
+    decoders: ((data: any) => any)[];
+    encoder?: (data: any) => any;
+}
+export {};

package/types/socketio-context.d.ts

@@ -0,0 +1,37 @@
+import { WSController, WSOperation } from '@opra/common';
+import { ExecutionContext } from '@opra/core';
+import type { AsyncEventEmitter } from 'node-events-async';
+import * as socketio from 'socket.io';
+import type { SocketioAdapter } from './socketio-adapter.js';
+/**
+ * Provides the context for handling messages.
+ * It extends the ExecutionContext and implements the AsyncEventEmitter.
+ */
+export declare class SocketioContext extends ExecutionContext implements AsyncEventEmitter {
+    readonly __contDef: WSController;
+    readonly __oprDef: WSOperation;
+    readonly __controller: any;
+    readonly __handler?: Function;
+    readonly __adapter: SocketioAdapter;
+    readonly socket: socketio.Socket;
+    readonly event: string;
+    readonly parameters: any[];
+    /**
+     * Constructor
+     * @param init the context options
+     */
+    constructor(init: SocketioContext.Initiator);
+    get server(): socketio.Server;
+}
+export declare namespace SocketioContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'transport' | 'platform' | '__docNode'> {
+        __adapter: SocketioAdapter;
+        __contDef?: WSController;
+        __oprDef?: WSOperation;
+        __controller?: any;
+        __handler?: Function;
+        socket: socketio.Socket;
+        event: string;
+        parameters?: any[];
+    }
+}