@opra/common 1.19.4 → 1.19.7

package/cjs/document/api-document.js

@@ -11,7 +11,8 @@ const document_element_js_1 = require("./common/document-element.js");
 const constants_js_1 = require("./constants.js");
 const data_type_js_1 = require("./data-type/data-type.js");
 const http_api_js_1 = require("./http/http-api.js");
-const rpc_api_js_1 = require("./rpc/rpc-api.js");
+const mq_api_js_1 = require("./mq/mq-api.js");
+const ws_api_js_1 = require("./ws/ws-api.js");
 /**
  *
  * @class ApiDocument
@@ -55,9 +56,15 @@ class ApiDocument extends document_element_js_1.DocumentElement {
         }
         return this.api;
     }
-    get rpcApi() {
-        if (!(this.api && this.api instanceof rpc_api_js_1.RpcApi)) {
-            throw new TypeError('The document do not contains RpcApi instance');
+    get mqApi() {
+        if (!(this.api && this.api instanceof mq_api_js_1.MQApi)) {
+            throw new TypeError('The document do not contains MQApi instance');
+        }
+        return this.api;
+    }
+    get wsApi() {
+        if (!(this.api && this.api instanceof ws_api_js_1.WSApi)) {
+            throw new TypeError('The document do not contains WSApi instance');
         }
         return this.api;
     }

package/cjs/document/constants.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kTypeNSMap = exports.kCtorMap = exports.kDataTypeMap = exports.CLASS_NAME_PATTERN = exports.NAMESPACE_PATTERN = exports.BUILTIN = exports.DECORATOR = exports.ENCODER = exports.DECODER = exports.RPC_CONTROLLER_METADATA = exports.HTTP_CONTROLLER_METADATA = exports.DATATYPE_METADATA = void 0;
+exports.kTypeNSMap = exports.kCtorMap = exports.kDataTypeMap = exports.CLASS_NAME_PATTERN = exports.NAMESPACE_PATTERN = exports.BUILTIN = exports.DECORATOR = exports.ENCODER = exports.DECODER = exports.RPC_CONTROLLER_METADATA = exports.WS_CONTROLLER_METADATA = exports.MQ_CONTROLLER_METADATA = exports.HTTP_CONTROLLER_METADATA = exports.DATATYPE_METADATA = void 0;
 exports.DATATYPE_METADATA = Symbol.for('opra.type.metadata');
 exports.HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
+exports.MQ_CONTROLLER_METADATA = Symbol('opra.mq-controller.metadata');
+exports.WS_CONTROLLER_METADATA = Symbol('opra.ws-controller.metadata');
 exports.RPC_CONTROLLER_METADATA = Symbol('opra.rpc-controller.metadata');
 exports.DECODER = Symbol.for('opra.type.decoder');
 exports.ENCODER = Symbol('opra.type.encoder');

package/cjs/document/data-type/enum-type.js

@@ -90,6 +90,8 @@ function EnumTypeFactory(enumSource, ...args) {
         }
         attributes = {};
         enumSource.forEach(k => {
+            if (!isNaN(Number(k)))
+                return;
             const description = options?.meanings?.[k];
             attributes[k] = (0, objects_1.omitUndefined)({ description });
         });
@@ -101,6 +103,8 @@ function EnumTypeFactory(enumSource, ...args) {
             out = { ...base, ...enumSource };
         }
         Object.keys(enumSource).forEach(k => {
+            if (!isNaN(Number(k)))
+                return;
             const description = options?.meanings?.[k];
             attributes[enumSource[k]] = (0, objects_1.omitUndefined)({ alias: k, description });
         });

package/cjs/document/decorators/{rpc-controller.decorator.js → mq-controller.decorator.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcControllerDecoratorFactory = RpcControllerDecoratorFactory;
+exports.MQControllerDecoratorFactory = MQControllerDecoratorFactory;
 const objects_1 = require("@jsopen/objects");
 const index_js_1 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
 const augmentationRegistry = [];
-function RpcControllerDecoratorFactory(options) {
+function MQControllerDecoratorFactory(options) {
     const decoratorChain = [];
     /**
      *
@@ -16,22 +16,22 @@ function RpcControllerDecoratorFactory(options) {
         if (!name)
             name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
         const metadata = {};
-        const baseMetadata = Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        const baseMetadata = Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, Object.getPrototypeOf(target));
         if (baseMetadata)
             (0, objects_1.merge)(metadata, baseMetadata, { deep: true });
-        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target);
+        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, target);
         if (oldMetadata)
             (0, objects_1.merge)(metadata, oldMetadata, { deep: true });
         (0, objects_1.merge)(metadata, {
             ...options,
-            kind: index_js_1.OpraSchema.RpcController.Kind,
+            kind: index_js_1.OpraSchema.MQController.Kind,
             name,
             path: name,
         }, { deep: true });
-        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, metadata, target);
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, metadata, target);
         for (const fn of decoratorChain)
             fn(metadata, target);
-        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, metadata, target);
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, metadata, target);
     };
     /**
      *
@@ -62,6 +62,6 @@ function RpcControllerDecoratorFactory(options) {
     augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, options));
     return decorator;
 }
-RpcControllerDecoratorFactory.augment = function (fn) {
+MQControllerDecoratorFactory.augment = function (fn) {
     augmentationRegistry.push(fn);
 };

package/cjs/document/decorators/{rpc-operation.decorator.js → mq-operation.decorator.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcOperationDecoratorFactory = RpcOperationDecoratorFactory;
+exports.MQOperationDecoratorFactory = MQOperationDecoratorFactory;
 const objects_1 = require("@jsopen/objects");
 const index_js_1 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 const augmentationRegistry = [];
-function RpcOperationDecoratorFactory(decoratorChain, payloadType, options) {
+function MQOperationDecoratorFactory(decoratorChain, payloadType, options) {
     let inResponse = false;
     /**
      *
@@ -14,17 +14,17 @@ function RpcOperationDecoratorFactory(decoratorChain, payloadType, options) {
         if (typeof propertyKey !== 'string')
             throw new TypeError(`Symbol properties can not be decorated`);
         const operationMetadata = {
-            kind: index_js_1.OpraSchema.RpcOperation.Kind,
+            kind: index_js_1.OpraSchema.MQOperation.Kind,
             channel: propertyKey,
             payloadType,
             ...(0, objects_1.omit)(options, ['kind', 'payloadType']),
         };
-        const controllerMetadata = (Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor) || {});
+        const controllerMetadata = (Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, target.constructor) || {});
         controllerMetadata.operations = controllerMetadata.operations || {};
         controllerMetadata.operations[propertyKey] = operationMetadata;
         for (const fn of decoratorChain)
             fn(operationMetadata, target, propertyKey);
-        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, controllerMetadata, target.constructor);
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, controllerMetadata, target.constructor);
     });
     /**
      *
@@ -73,6 +73,6 @@ function RpcOperationDecoratorFactory(decoratorChain, payloadType, options) {
     augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
     return decorator;
 }
-RpcOperationDecoratorFactory.augment = function (fn) {
+MQOperationDecoratorFactory.augment = function (fn) {
     augmentationRegistry.push(fn);
 };

package/cjs/document/decorators/ws-controller.decorator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSControllerDecoratorFactory = WSControllerDecoratorFactory;
+const objects_1 = require("@jsopen/objects");
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
+const augmentationRegistry = [];
+function WSControllerDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target) {
+        let name = options?.name;
+        if (!name)
+            name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
+        const metadata = {};
+        const baseMetadata = Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            (0, objects_1.merge)(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, target);
+        if (oldMetadata)
+            (0, objects_1.merge)(metadata, oldMetadata, { deep: true });
+        (0, objects_1.merge)(metadata, {
+            ...options,
+            kind: index_js_1.OpraSchema.WSController.Kind,
+            name,
+            path: name,
+        }, { deep: true });
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata, target);
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, metadata, target);
+    };
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, options));
+    return decorator;
+}
+WSControllerDecoratorFactory.augment = function (fn) {
+    augmentationRegistry.push(fn);
+};

package/cjs/document/decorators/ws-operation.decorator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSOperationDecoratorFactory = WSOperationDecoratorFactory;
+const objects_1 = require("@jsopen/objects");
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const augmentationRegistry = [];
+function WSOperationDecoratorFactory(decoratorChain, payloadType, options) {
+    /**
+     *
+     */
+    const decorator = ((target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can not be decorated`);
+        const operationMetadata = {
+            kind: index_js_1.OpraSchema.WSOperation.Kind,
+            channel: propertyKey,
+            payloadType,
+            ...(0, objects_1.omit)(options, ['kind', 'payloadType']),
+        };
+        const controllerMetadata = (Reflect.getOwnMetadata(constants_js_1.MQ_CONTROLLER_METADATA, target.constructor) || {});
+        controllerMetadata.operations = controllerMetadata.operations || {};
+        controllerMetadata.operations[propertyKey] = operationMetadata;
+        for (const fn of decoratorChain)
+            fn(operationMetadata, target, propertyKey);
+        Reflect.defineMetadata(constants_js_1.MQ_CONTROLLER_METADATA, controllerMetadata, target.constructor);
+    });
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
+    return decorator;
+}
+WSOperationDecoratorFactory.augment = function (fn) {
+    augmentationRegistry.push(fn);
+};

package/cjs/document/factory/api-document.factory.js

@@ -12,7 +12,7 @@ const extendedTypes = tslib_1.__importStar(require("../data-type/extended-types/
 const primitiveTypes = tslib_1.__importStar(require("../data-type/primitive-types/index.js"));
 const data_type_factory_js_1 = require("./data-type.factory.js");
 const http_api_factory_js_1 = require("./http-api.factory.js");
-const rpc_api_factory_js_1 = require("./rpc-api.factory.js");
+const mq_api_factory_js_1 = require("./mq-api.factory.js");
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + index_js_2.OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -123,8 +123,8 @@ class ApiDocumentFactory {
                     if (api)
                         document.api = api;
                 }
-                else if (init.api && init.api.transport === 'rpc') {
-                    const api = await rpc_api_factory_js_1.RpcApiFactory.createApi(context, {
+                else if (init.api && init.api.transport === 'mq') {
+                    const api = await mq_api_factory_js_1.MQApiFactory.createApi(context, {
                         ...init.api,
                         owner: document,
                     });

package/cjs/document/factory/{rpc-api.factory.js → mq-api.factory.js}

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcApiFactory = void 0;
+exports.MQApiFactory = void 0;
 const objects_1 = require("@jsopen/objects");
 const index_js_1 = require("../../helpers/index.js");
 const constants_js_1 = require("../constants.js");
-const rpc_api_js_1 = require("../rpc/rpc-api.js");
-const rpc_controller_js_1 = require("../rpc/rpc-controller.js");
-const rpc_header_js_1 = require("../rpc/rpc-header.js");
-const rpc_operation_js_1 = require("../rpc/rpc-operation.js");
-const rpc_operation_response_js_1 = require("../rpc/rpc-operation-response.js");
+const mq_api_js_1 = require("../mq/mq-api.js");
+const mq_controller_js_1 = require("../mq/mq-controller.js");
+const mq_header_js_1 = require("../mq/mq-header.js");
+const mq_operation_js_1 = require("../mq/mq-operation.js");
+const mq_operation_response_js_1 = require("../mq/mq-operation-response.js");
 const data_type_factory_js_1 = require("./data-type.factory.js");
 /**
- * @class RpcApiFactory
+ * @class MQApiFactory
  */
-class RpcApiFactory {
+class MQApiFactory {
     /**
-     * Generates RpcApi
+     * Generates MQApi
      * @param context
      * @param init
      */
     static async createApi(context, init) {
-        const api = new rpc_api_js_1.RpcApi(init);
+        const api = new mq_api_js_1.MQApi(init);
         if (init.controllers) {
             await context.enterAsync('.controllers', async () => {
                 if (Array.isArray(init.controllers)) {
@@ -51,15 +51,15 @@ class RpcApiFactory {
         let instance;
         // If thunk is a class
         if (typeof thunk === 'function') {
-            metadata = Reflect.getMetadata(constants_js_1.RPC_CONTROLLER_METADATA, thunk);
+            metadata = Reflect.getMetadata(constants_js_1.MQ_CONTROLLER_METADATA, thunk);
             if (!metadata)
-                return context.addError(`Class "${thunk.name}" doesn't have a valid RpcController metadata`);
+                return context.addError(`Class "${thunk.name}" doesn't have a valid MQController metadata`);
             ctor = thunk;
         }
         else {
-            // If thunk is an instance of a class decorated with RpcController()
+            // If thunk is an instance of a class decorated with MQController()
             ctor = Object.getPrototypeOf(thunk).constructor;
-            metadata = Reflect.getMetadata(constants_js_1.RPC_CONTROLLER_METADATA, ctor);
+            metadata = Reflect.getMetadata(constants_js_1.MQ_CONTROLLER_METADATA, ctor);
             if (metadata)
                 instance = thunk;
             else {
@@ -72,11 +72,11 @@ class RpcApiFactory {
             }
         }
         if (!metadata)
-            return context.addError(`Class "${ctor.name}" is not decorated with RpcController()`);
+            return context.addError(`Class "${ctor.name}" is not decorated with MQController()`);
         name = name || metadata.name;
         if (!name)
             throw new TypeError(`Controller name required`);
-        const controller = new rpc_controller_js_1.RpcController(parent, {
+        const controller = new mq_controller_js_1.MQController(parent, {
             ...metadata,
             name,
             instance,
@@ -102,7 +102,7 @@ class RpcApiFactory {
                             if (!prmArgs.type)
                                 prmArgs.type = controller.node.getDataType('any');
                         });
-                        const prm = new rpc_header_js_1.RpcHeader(controller, prmArgs);
+                        const prm = new mq_header_js_1.MQHeader(controller, prmArgs);
                         controller.headers.push(prm);
                     });
                 }
@@ -112,14 +112,14 @@ class RpcApiFactory {
             await context.enterAsync('.operations', async () => {
                 for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
                     await context.enterAsync(`[${operationName}]`, async () => {
-                        const operation = new rpc_operation_js_1.RpcOperation(controller, {
+                        const operation = new mq_operation_js_1.MQOperation(controller, {
                             ...operationMeta,
                             name: operationName,
                             types: undefined,
                             payloadType: undefined,
                             keyType: undefined,
                         });
-                        await this._initRpcOperation(context, operation, operationMeta);
+                        await this._initMQOperation(context, operation, operationMeta);
                         controller.operations.set(operation.name, operation);
                     });
                 }
@@ -128,13 +128,13 @@ class RpcApiFactory {
         return controller;
     }
     /**
-     * Initializes RpcOperation
+     * Initializes MQOperation
      * @param context
      * @param operation
      * @param metadata
      * @protected
      */
-    static async _initRpcOperation(context, operation, metadata) {
+    static async _initMQOperation(context, operation, metadata) {
         if (metadata.types) {
             await context.enterAsync('.types', async () => {
                 await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, operation, metadata.types);
@@ -153,7 +153,7 @@ class RpcApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, v.type);
                         });
-                        const prm = new rpc_header_js_1.RpcHeader(operation, prmArgs);
+                        const prm = new mq_header_js_1.MQHeader(operation, prmArgs);
                         operation.headers.push(prm);
                     });
                 }
@@ -161,24 +161,24 @@ class RpcApiFactory {
         }
         if (metadata.response) {
             await context.enterAsync('.response', async () => {
-                const response = new rpc_operation_response_js_1.RpcOperationResponse(operation, {
+                const response = new mq_operation_response_js_1.MQOperationResponse(operation, {
                     ...metadata.response,
                     payloadType: undefined,
                     keyType: undefined,
                 });
-                await this._initRpcOperationResponse(context, response, metadata.response);
+                await this._initMQOperationResponse(context, response, metadata.response);
                 operation.response = response;
             });
         }
     }
     /**
-     * Initializes RpcOperationResponse
+     * Initializes MQOperationResponse
      * @param context
      * @param response
      * @param metadata
      * @protected
      */
-    static async _initRpcOperationResponse(context, response, metadata) {
+    static async _initMQOperationResponse(context, response, metadata) {
         response.payloadType = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, response, metadata.payloadType);
         if (metadata.keyType) {
             response.keyType = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, response, metadata.keyType);
@@ -192,7 +192,7 @@ class RpcApiFactory {
                         await context.enterAsync('.type', async () => {
                             prmArgs.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, response, v.type);
                         });
-                        const prm = new rpc_header_js_1.RpcHeader(response, prmArgs);
+                        const prm = new mq_header_js_1.MQHeader(response, prmArgs);
                         response.headers.push(prm);
                     });
                 }
@@ -200,4 +200,4 @@ class RpcApiFactory {
         }
     }
 }
-exports.RpcApiFactory = RpcApiFactory;
+exports.MQApiFactory = MQApiFactory;

package/cjs/document/factory/ws-api.factory.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WSApiFactory = void 0;
+const objects_1 = require("@jsopen/objects");
+const index_js_1 = require("../../helpers/index.js");
+const constants_js_1 = require("../constants.js");
+const ws_api_js_1 = require("../ws/ws-api.js");
+const ws_controller_js_1 = require("../ws/ws-controller.js");
+const ws_operation_js_1 = require("../ws/ws-operation.js");
+const data_type_factory_js_1 = require("./data-type.factory.js");
+/**
+ * @class WSApiFactory
+ */
+class WSApiFactory {
+    /**
+     * Generates MQApi
+     * @param context
+     * @param init
+     */
+    static async createApi(context, init) {
+        const api = new ws_api_js_1.WSApi(init);
+        if (init.controllers) {
+            await context.enterAsync('.controllers', async () => {
+                if (Array.isArray(init.controllers)) {
+                    for (const c of init.controllers) {
+                        const controller = await this._createController(context, api, c);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+                else {
+                    for (const [k, v] of Object.entries(init.controllers)) {
+                        const controller = await this._createController(context, api, v, k);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+            });
+        }
+        return api;
+    }
+    static async _createController(context, parent, thunk, name) {
+        if (typeof thunk === 'function' && !(0, objects_1.isConstructor)(thunk)) {
+            thunk = thunk();
+        }
+        thunk = await (0, index_js_1.resolveThunk)(thunk);
+        let ctor;
+        let metadata;
+        let instance;
+        // If thunk is a class
+        if (typeof thunk === 'function') {
+            metadata = Reflect.getMetadata(constants_js_1.WS_CONTROLLER_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid WSController metadata`);
+            ctor = thunk;
+        }
+        else {
+            // If thunk is an instance of a class decorated with WSController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(constants_js_1.WS_CONTROLLER_METADATA, ctor);
+            if (metadata)
+                instance = thunk;
+            else {
+                // If thunk is a DecoratorMetadata or InitArguments
+                metadata = thunk;
+                if (thunk.instance === 'object') {
+                    instance = thunk.instance;
+                    ctor = Object.getPrototypeOf(instance).constructor;
+                }
+            }
+        }
+        if (!metadata)
+            return context.addError(`Class "${ctor.name}" is not decorated with WSController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new ws_controller_js_1.WSController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, controller, metadata.types);
+            });
+        }
+        if (metadata.operations) {
+            await context.enterAsync('.operations', async () => {
+                for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
+                    await context.enterAsync(`[${operationName}]`, async () => {
+                        const operation = new ws_operation_js_1.WSOperation(controller, {
+                            ...operationMeta,
+                            name: operationName,
+                            types: undefined,
+                            payloadType: undefined,
+                            keyType: undefined,
+                        });
+                        await this._initWSOperation(context, operation, operationMeta);
+                        controller.operations.set(operation.name, operation);
+                    });
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes WSOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initWSOperation(context, operation, metadata) {
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, operation, metadata.types);
+            });
+        }
+        operation.payloadType = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, metadata.payloadType);
+    }
+}
+exports.WSApiFactory = WSApiFactory;

package/cjs/document/index.js

@@ -12,8 +12,10 @@ require("./decorators/http-operation-entity-get.decorator.js");
 require("./decorators/http-operation-entity-replace.decorator.js");
 require("./decorators/http-operation-entity-update.decorator.js");
 require("./decorators/http-operation-entity-update-many.decorator.js");
-const RpcControllerDecorator_ = tslib_1.__importStar(require("./decorators/rpc-controller.decorator.js"));
-const RpcOperationDecorator_ = tslib_1.__importStar(require("./decorators/rpc-operation.decorator.js"));
+const MQControllerDecorator_ = tslib_1.__importStar(require("./decorators/mq-controller.decorator.js"));
+const MQOperationDecorator_ = tslib_1.__importStar(require("./decorators/mq-operation.decorator.js"));
+const WSControllerDecorator_ = tslib_1.__importStar(require("./decorators/ws-controller.decorator.js"));
+const WSOperationDecorator_ = tslib_1.__importStar(require("./decorators/ws-operation.decorator.js"));
 const DataTypeFactory_ = tslib_1.__importStar(require("./factory/data-type.factory.js"));
 const HttpApiFactory_ = tslib_1.__importStar(require("./factory/http-api.factory.js"));
 tslib_1.__exportStar(require("./api-document.js"), exports);
@@ -48,14 +50,19 @@ tslib_1.__exportStar(require("./http/http-operation-response.js"), exports);
 tslib_1.__exportStar(require("./http/http-parameter.js"), exports);
 tslib_1.__exportStar(require("./http/http-request-body.js"), exports);
 tslib_1.__exportStar(require("./http/http-status-range.js"), exports);
-tslib_1.__exportStar(require("./rpc/rpc-api.js"), exports);
-tslib_1.__exportStar(require("./rpc/rpc-controller.js"), exports);
-tslib_1.__exportStar(require("./rpc/rpc-header.js"), exports);
-tslib_1.__exportStar(require("./rpc/rpc-operation.js"), exports);
+tslib_1.__exportStar(require("./mq/mq-api.js"), exports);
+tslib_1.__exportStar(require("./mq/mq-controller.js"), exports);
+tslib_1.__exportStar(require("./mq/mq-header.js"), exports);
+tslib_1.__exportStar(require("./mq/mq-operation.js"), exports);
+tslib_1.__exportStar(require("./ws/ws-api.js"), exports);
+tslib_1.__exportStar(require("./ws/ws-controller.js"), exports);
+tslib_1.__exportStar(require("./ws/ws-operation.js"), exports);
 var classes;
 (function (classes) {
     classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
-    classes.RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
-    classes.RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
+    classes.MQOperationDecoratorFactory = MQOperationDecorator_.MQOperationDecoratorFactory;
+    classes.MQControllerDecoratorFactory = MQControllerDecorator_.MQControllerDecoratorFactory;
+    classes.WSOperationDecoratorFactory = WSOperationDecorator_.WSOperationDecoratorFactory;
+    classes.WSControllerDecoratorFactory = WSControllerDecorator_.WSControllerDecoratorFactory;
 })(classes || (exports.classes = classes = {}));

package/cjs/document/{rpc/rpc-api.js → mq/mq-api.js}

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcApi = void 0;
+exports.MQApi = void 0;
 const index_js_1 = require("../../helpers/index.js");
 const api_base_js_1 = require("../common/api-base.js");
 /**
- * @class RpcApi
+ * @class MQApi
  */
-class RpcApi extends api_base_js_1.ApiBase {
+class MQApi extends api_base_js_1.ApiBase {
     constructor(init) {
         super(init);
         // noinspection JSUnusedGlobalSymbols
         this._controllerReverseMap = new WeakMap();
-        this.transport = 'rpc';
+        this.transport = 'mq';
         this.controllers = new index_js_1.ResponsiveMap();
         this.platform = init.platform;
     }
@@ -51,4 +51,4 @@ class RpcApi extends api_base_js_1.ApiBase {
         return out;
     }
 }
-exports.RpcApi = RpcApi;
+exports.MQApi = MQApi;