@opra/common 1.0.0-beta.2 → 1.0.0-beta.3

package/cjs/document/api-document.js

@@ -9,6 +9,8 @@ const data_type_map_js_1 = require("./common/data-type-map.js");
 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 msg_api_js_1 = require("./msg/msg-api.js");
 /**
  *
  * @class ApiDocument
@@ -44,6 +46,18 @@ class ApiDocument extends document_element_js_1.DocumentElement {
                 return d;
         }
     }
+    get httpApi() {
+        if (!(this.api && this.api instanceof http_api_js_1.HttpApi)) {
+            throw new TypeError('The document do not contains HttpApi instance');
+        }
+        return this.api;
+    }
+    get msgApi() {
+        if (!(this.api && this.api instanceof msg_api_js_1.MsgApi)) {
+            throw new TypeError('The document do not contains MsgApi instance');
+        }
+        return this.api;
+    }
     toJSON() {
         return this.export();
     }

package/cjs/document/common/api-base.js

@@ -5,13 +5,15 @@ const index_js_1 = require("../../helpers/index.js");
 const constants_js_1 = require("../constants.js");
 const document_element_js_1 = require("./document-element.js");
 class ApiBase extends document_element_js_1.DocumentElement {
-    constructor(owner) {
-        super(owner);
+    constructor(init) {
+        super(init.owner);
         this.name = 'OpraApi';
+        this.name = init.name;
+        this.description = init.description;
     }
     toJSON() {
         return (0, index_js_1.omitUndefined)({
-            protocol: this.protocol,
+            transport: this.transport,
             name: this.name,
             description: this.description,
         });

package/cjs/document/common/document-node.js

@@ -50,8 +50,12 @@ class DocumentNode {
             const metadata = nameOrCtor[constants_js_1.DATATYPE_METADATA];
             name = metadata?.name;
         }
-        if (typeof nameOrCtor === 'string')
-            name = nameOrCtor;
+        if (!name) {
+            if (nameOrCtor && typeof nameOrCtor === 'string')
+                name = nameOrCtor;
+            else if (typeof nameOrCtor === 'function')
+                name = nameOrCtor.name;
+        }
         throw new TypeError(`Unknown data type` + (name ? ' (' + name + ')' : ''));
     }
     getDataTypeNameWithNs(dataType) {

package/cjs/document/constants.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.kTypeNSMap = exports.kCtorMap = exports.kDataTypeMap = exports.EXTRACT_TYPENAME_PATTERN = exports.CLASS_NAME_PATTERN = exports.NAMESPACE_PATTERN = exports.BUILTIN = exports.DECORATOR = exports.ENCODER = exports.DECODER = exports.HTTP_CONTROLLER_METADATA = exports.DATATYPE_METADATA = void 0;
+exports.kTypeNSMap = exports.kCtorMap = exports.kDataTypeMap = exports.EXTRACT_TYPENAME_PATTERN = exports.CLASS_NAME_PATTERN = exports.NAMESPACE_PATTERN = exports.BUILTIN = exports.DECORATOR = exports.ENCODER = exports.DECODER = exports.MSG_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.MSG_CONTROLLER_METADATA = Symbol('opra.msg-controller.metadata');
 exports.DECODER = Symbol.for('opra.type.decoder');
 exports.ENCODER = Symbol('opra.type.encoder');
 exports.DECORATOR = Symbol.for('DECORATOR');

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

@@ -31,7 +31,7 @@ function HttpControllerDecoratorFactory(options) {
         }, { deep: true });
         Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
         for (const fn of decoratorChain)
-            fn(metadata);
+            fn(metadata, target);
         Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
     };
     /**

package/cjs/document/decorators/http-operation-entity.decorator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../enums/index.js");
 const filter_rules_js_1 = require("../../filter/filter-rules.js");
-const index_js_1 = require("../../http/index.js");
 const constants_js_1 = require("../constants.js");
 const index_js_2 = require("../data-type/extended-types/index.js");
 const index_js_3 = require("../data-type/primitive-types/index.js");

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpOperationDecoratorFactory = HttpOperationDecoratorFactory;
 const tslib_1 = require("tslib");
 const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
-const index_js_1 = require("../../http/index.js");
+const index_js_1 = require("../../enums/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 function HttpOperationDecoratorFactory(decoratorChain, options) {
@@ -17,13 +17,13 @@ function HttpOperationDecoratorFactory(decoratorChain, options) {
             kind: index_js_2.OpraSchema.HttpOperation.Kind,
             ...(0, lodash_omit_1.default)(options, ['kind']),
         };
-        const resourceMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) ||
+        const controllerMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) ||
             {});
-        resourceMetadata.operations = resourceMetadata.operations || {};
-        resourceMetadata.operations[propertyKey] = operationMetadata;
+        controllerMetadata.operations = controllerMetadata.operations || {};
+        controllerMetadata.operations[propertyKey] = operationMetadata;
         for (const fn of decoratorChain)
             fn(operationMetadata);
-        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, resourceMetadata, target.constructor);
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, controllerMetadata, target.constructor);
     });
     /**
      *

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgControllerDecoratorFactory = MsgControllerDecoratorFactory;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
+function MsgControllerDecoratorFactory(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.MSG_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.MSG_CONTROLLER_METADATA, target);
+        if (oldMetadata)
+            (0, putil_merge_1.default)(metadata, oldMetadata, { deep: true });
+        (0, putil_merge_1.default)(metadata, {
+            kind: index_js_1.OpraSchema.MsgController.Kind,
+            name,
+            path: name,
+            ...(0, lodash_omit_1.default)(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
+        }, { deep: true });
+        Reflect.defineMetadata(constants_js_1.MSG_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata);
+        Reflect.defineMetadata(constants_js_1.MSG_CONTROLLER_METADATA, metadata, target);
+    };
+    /**
+     *
+     */
+    decorator.Header = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    type: arg1,
+                }
+                : { ...arg1, name };
+            meta.headers = meta.headers || [];
+            meta.headers.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    return decorator;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgOperationDecoratorFactory = MsgOperationDecoratorFactory;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const augmentationRegistry = [];
+function MsgOperationDecoratorFactory(decoratorChain, payloadType, options) {
+    let inResponse = false;
+    /**
+     *
+     */
+    const decorator = ((target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can not be decorated`);
+        const operationMetadata = {
+            kind: index_js_1.OpraSchema.MsgOperation.Kind,
+            channel: propertyKey,
+            ...(0, lodash_omit_1.default)(options, ['kind']),
+            payloadType,
+        };
+        const controllerMetadata = (Reflect.getOwnMetadata(constants_js_1.MSG_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.MSG_CONTROLLER_METADATA, controllerMetadata, target.constructor);
+    });
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.Header = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const headerMetadata = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    type: arg1,
+                }
+                : { ...arg1, name };
+            const subMeta = inResponse ? meta.response : meta;
+            if (subMeta.headers) {
+                subMeta.headers = subMeta.headers.filter(p => String(p.name) !== String(name));
+            }
+            else
+                subMeta.headers = [];
+            subMeta.headers.push(headerMetadata);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.Response = (_payloadType, _options) => {
+        decoratorChain.push((meta) => {
+            inResponse = true;
+            meta.response = {
+                ..._options,
+                payloadType: _payloadType,
+            };
+        });
+        return decorator;
+    };
+    augmentationRegistry.forEach(fn => fn(decorator, decoratorChain, payloadType, options));
+    return decorator;
+}
+MsgOperationDecoratorFactory.augment = function (fn) {
+    augmentationRegistry.push(fn);
+};

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

@@ -11,6 +11,7 @@ const index_js_3 = require("../data-type/extended-types/index.js");
 const index_js_4 = 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 msg_api_factory_js_1 = require("./msg-api.factory.js");
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + index_js_2.OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -111,13 +112,18 @@ class ApiDocumentFactory {
         }
         if (init.api) {
             await context.enterAsync(`.api`, async () => {
-                if (init.api.protocol === 'http') {
-                    const api = await http_api_factory_js_1.HttpApiFactory.createApi(context, document, init.api);
+                if (init.api && init.api.transport === 'http') {
+                    const api = await http_api_factory_js_1.HttpApiFactory.createApi(context, { ...init.api, owner: document });
+                    if (api)
+                        document.api = api;
+                }
+                else if (init.api && init.api.transport === 'msg') {
+                    const api = await msg_api_factory_js_1.MsgApiFactory.createApi(context, { ...init.api, owner: document });
                     if (api)
                         document.api = api;
                 }
                 else
-                    context.addError(`Unknown service protocol (${init.api.protocol})`);
+                    context.addError(`Unknown service transport (${init.api.transport})`);
             });
         }
         document.invalidate();

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

@@ -27,6 +27,26 @@ class DataTypeFactory {
             return this._createDataType(context, owner, initArgs);
         }
     }
+    static async resolveDataType(context, owner, v) {
+        if (v) {
+            const dt = owner.node.findDataType(v);
+            if (dt)
+                return dt;
+        }
+        if (typeof v === 'object' || typeof v === 'function') {
+            const dt = await DataTypeFactory.createDataType(context, owner, v);
+            if (dt)
+                return dt;
+        }
+        if (v) {
+            /** To throw not found error */
+            const dt = owner.node.getDataType(v);
+            /** istanbul ignore next */
+            if (dt)
+                return dt;
+        }
+        return owner.node.getDataType('any');
+    }
     /**
      *
      * @param context

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

@@ -19,35 +19,56 @@ class HttpApiFactory {
     /**
      * Generates HttpApi
      * @param context
-     * @param document
      * @param init
      */
-    static async createApi(context, document, init) {
-        const api = new http_api_js_1.HttpApi(document);
-        api.name = init.name;
-        api.description = init.description;
-        api.url = init.url;
+    static async createApi(context, init) {
+        const api = new http_api_js_1.HttpApi(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);
+                await this._createControllers(context, api, init.controllers);
+            });
+        }
+        return api;
+    }
+    static async _createControllers(context, parent, controllers) {
+        if (Array.isArray(controllers)) {
+            let i = 0;
+            for (const c of controllers) {
+                let r;
+                await context.enterAsync(`[${i++}]`, async () => {
+                    r = await this._resolveControllerMetadata(context, parent, c);
+                });
+                if (!r)
+                    continue;
+                await context.enterAsync(`[${r.metadata.name}]`, async () => {
+                    const controller = await this._createController(context, parent, r.metadata, r.instance, r.ctor);
+                    if (controller) {
+                        if (parent.controllers.get(controller.name))
+                            context.addError(`Duplicate controller name (${r.name})`);
+                        parent.controllers.set(controller.name, controller);
                     }
+                });
+            }
+            return;
+        }
+        for (const [k, c] of Object.entries(controllers)) {
+            await context.enterAsync(`[${k}]`, async () => {
+                const r = await this._resolveControllerMetadata(context, parent, c);
+                if (!r)
+                    return;
+                const controller = await this._createController(context, parent, {
+                    ...r.metadata,
+                    name: k,
+                }, r.instance, r.ctor);
+                if (controller) {
+                    if (parent.controllers.get(controller.name))
+                        context.addError(`Duplicate controller name (${k})`);
+                    parent.controllers.set(controller.name, controller);
                 }
             });
         }
-        return api;
     }
-    static async _createController(context, parent, thunk, name) {
+    static async _resolveControllerMetadata(context, parent, thunk) {
         if (typeof thunk === 'function' && !(0, index_js_1.isConstructor)(thunk)) {
             thunk = parent instanceof http_controller_js_1.HttpController ? thunk(parent.instance) : thunk();
         }
@@ -79,12 +100,13 @@ class HttpApiFactory {
         }
         if (!metadata)
             return context.addError(`Class "${ctor.name}" is not decorated with HttpController()`);
-        name = name || metadata.name;
-        if (!name)
+        return { metadata, instance, ctor };
+    }
+    static async _createController(context, parent, metadata, instance, ctor) {
+        if (!metadata.name)
             throw new TypeError(`Controller name required`);
         const controller = new http_controller_js_1.HttpController(parent, {
             ...metadata,
-            name,
             instance,
             ctor,
         });
@@ -100,13 +122,7 @@ class HttpApiFactory {
                     await context.enterAsync(`[${i++}]`, async () => {
                         const prmArgs = { ...v };
                         await context.enterAsync('.type', async () => {
-                            if (v.type)
-                                prmArgs.type = controller.node.findDataType(v.type);
-                            if (!prmArgs.type && typeof v.type === 'object') {
-                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, controller, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = controller.node.getDataType('any');
+                            prmArgs.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, controller, v.type);
                         });
                         const prm = new http_parameter_js_1.HttpParameter(controller, prmArgs);
                         controller.parameters.push(prm);
@@ -127,32 +143,7 @@ class HttpApiFactory {
         }
         if (metadata.controllers) {
             await context.enterAsync('.controllers', async () => {
-                if (Array.isArray(metadata.controllers)) {
-                    let k = 0;
-                    for (const v of metadata.controllers) {
-                        await context.enterAsync(`[${k}]`, async () => {
-                            const r = await this._createController(context, controller, v);
-                            if (r) {
-                                if (controller.controllers.get(r.name))
-                                    context.addError(`Duplicate controller name (${r.name})`);
-                                controller.controllers.set(r.name, r);
-                            }
-                        });
-                        k++;
-                    }
-                }
-                else {
-                    for (const [k, v] of Object.entries(metadata.controllers)) {
-                        await context.enterAsync(`[${k}]`, async () => {
-                            const r = await this._createController(context, controller, v, k);
-                            if (r) {
-                                if (controller.controllers.get(r.name))
-                                    context.addError(`Duplicate controller name (${r.name})`);
-                                controller.controllers.set(r.name, r);
-                            }
-                        });
-                    }
-                }
+                await this._createControllers(context, controller, metadata.controllers);
             });
         }
         return controller;
@@ -183,13 +174,7 @@ class HttpApiFactory {
                     await context.enterAsync(`[${i++}]`, async () => {
                         const prmArgs = { ...v };
                         await context.enterAsync('.type', async () => {
-                            if (v.type)
-                                prmArgs.type = operation.node.findDataType(v.type);
-                            if (!prmArgs.type && typeof v.type === 'object') {
-                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, operation, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = operation.node.getDataType('any');
+                            prmArgs.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, v.type);
                         });
                         const prm = new http_parameter_js_1.HttpParameter(operation, prmArgs);
                         operation.parameters.push(prm);
@@ -233,13 +218,7 @@ class HttpApiFactory {
         });
         if (metadata.type) {
             await context.enterAsync('.type', async () => {
-                if (metadata.type)
-                    target.type = target.node.findDataType(metadata.type);
-                if (!target.type && (typeof metadata.type === 'object' || typeof metadata.type === 'function')) {
-                    target.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, target, metadata.type);
-                }
-                if (!target.type)
-                    target.type = target.node.getDataType('any');
+                target.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, target, metadata.type);
             });
         }
         if (metadata.multipartFields) {
@@ -272,13 +251,7 @@ class HttpApiFactory {
                     await context.enterAsync(`[${i++}]`, async () => {
                         const prmArgs = { ...v };
                         await context.enterAsync('.type', async () => {
-                            if (v.type)
-                                prmArgs.type = target.node.findDataType(v.type);
-                            if (!prmArgs.type && typeof v.type === 'object') {
-                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, target, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = target.node.getDataType('any');
+                            prmArgs.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, target, v.type);
                         });
                         const prm = new http_parameter_js_1.HttpParameter(target, prmArgs);
                         target.parameters.push(prm);