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

package/cjs/schema/msg/msg-controller.interface.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgController = void 0;
+/**
+ *
+ * @namespace MsgController
+ */
+var MsgController;
+(function (MsgController) {
+    MsgController.Kind = 'MsgController';
+})(MsgController || (exports.MsgController = MsgController = {}));

package/cjs/schema/msg/msg-header.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/msg/msg-operation.interface.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgOperation = void 0;
+var MsgOperation;
+(function (MsgOperation) {
+    MsgOperation.Kind = 'MsgOperation';
+})(MsgOperation || (exports.MsgOperation = MsgOperation = {}));

package/cjs/schema/opra-schema.js

@@ -19,6 +19,9 @@ tslib_1.__exportStar(require("./http/http-operation-response.interface.js"), exp
 tslib_1.__exportStar(require("./http/http-parameter.interface.js"), exports);
 tslib_1.__exportStar(require("./http/http-request-body.interface.js"), exports);
 tslib_1.__exportStar(require("./http/http-status-range.interface.js"), exports);
+tslib_1.__exportStar(require("./msg/msg-controller.interface.js"), exports);
+tslib_1.__exportStar(require("./msg/msg-header.interface.js"), exports);
+tslib_1.__exportStar(require("./msg/msg-operation.interface.js"), exports);
 tslib_1.__exportStar(require("./type-guards.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./value.interface.js"), exports);

package/esm/document/api-document.js

@@ -6,6 +6,8 @@ import { DataTypeMap } from './common/data-type-map.js';
 import { DocumentElement } from './common/document-element.js';
 import { BUILTIN, kDataTypeMap, kTypeNSMap, NAMESPACE_PATTERN } from './constants.js';
 import { DataType } from './data-type/data-type.js';
+import { HttpApi } from './http/http-api.js';
+import { MsgApi } from './msg/msg-api.js';
 /**
  *
  * @class ApiDocument
@@ -41,6 +43,18 @@ export class ApiDocument extends DocumentElement {
                 return d;
         }
     }
+    get httpApi() {
+        if (!(this.api && this.api instanceof HttpApi)) {
+            throw new TypeError('The document do not contains HttpApi instance');
+        }
+        return this.api;
+    }
+    get msgApi() {
+        if (!(this.api && this.api instanceof MsgApi)) {
+            throw new TypeError('The document do not contains MsgApi instance');
+        }
+        return this.api;
+    }
     toJSON() {
         return this.export();
     }

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

@@ -2,13 +2,15 @@ import { omitUndefined } from '../../helpers/index.js';
 import { CLASS_NAME_PATTERN } from '../constants.js';
 import { DocumentElement } from './document-element.js';
 export class ApiBase extends DocumentElement {
-    constructor(owner) {
-        super(owner);
+    constructor(init) {
+        super(init.owner);
         this.name = 'OpraApi';
+        this.name = init.name;
+        this.description = init.description;
     }
     toJSON() {
         return omitUndefined({
-            protocol: this.protocol,
+            transport: this.transport,
             name: this.name,
             description: this.description,
         });

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

@@ -47,8 +47,12 @@ export class DocumentNode {
             const metadata = nameOrCtor[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/esm/document/constants.js

@@ -1,5 +1,6 @@
 export const DATATYPE_METADATA = Symbol.for('opra.type.metadata');
 export const HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
+export const MSG_CONTROLLER_METADATA = Symbol('opra.msg-controller.metadata');
 export const DECODER = Symbol.for('opra.type.decoder');
 export const ENCODER = Symbol('opra.type.encoder');
 export const DECORATOR = Symbol.for('DECORATOR');

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

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

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

@@ -1,5 +1,5 @@
+import { HttpStatusCode, MimeTypes } from '../../enums/index.js';
 import { FilterRules } from '../../filter/filter-rules.js';
-import { HttpStatusCode, MimeTypes } from '../../http/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
 import { FieldPathType, FilterType } from '../data-type/extended-types/index.js';
 import { IntegerType } from '../data-type/primitive-types/index.js';

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

@@ -1,5 +1,5 @@
 import omit from 'lodash.omit';
-import { MimeTypes } from '../../http/index.js';
+import { MimeTypes } from '../../enums/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { HTTP_CONTROLLER_METADATA } from '../constants.js';
 export function HttpOperationDecoratorFactory(decoratorChain, options) {
@@ -13,13 +13,13 @@ export function HttpOperationDecoratorFactory(decoratorChain, options) {
             kind: OpraSchema.HttpOperation.Kind,
             ...omit(options, ['kind']),
         };
-        const resourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) ||
+        const controllerMetadata = (Reflect.getOwnMetadata(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(HTTP_CONTROLLER_METADATA, resourceMetadata, target.constructor);
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, controllerMetadata, target.constructor);
     });
     /**
      *

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

@@ -0,0 +1,60 @@
+import omit from 'lodash.omit';
+import merge from 'putil-merge';
+import { OpraSchema } from '../../schema/index.js';
+import { MSG_CONTROLLER_METADATA } from '../constants.js';
+const CLASS_NAME_PATTERN = /^(.*)(Controller)$/;
+export 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(MSG_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            merge(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target);
+        if (oldMetadata)
+            merge(metadata, oldMetadata, { deep: true });
+        merge(metadata, {
+            kind: OpraSchema.MsgController.Kind,
+            name,
+            path: name,
+            ...omit(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
+        }, { deep: true });
+        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata);
+        Reflect.defineMetadata(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/esm/document/decorators/msg-operation.decorator.js

@@ -0,0 +1,76 @@
+import omit from 'lodash.omit';
+import { OpraSchema } from '../../schema/index.js';
+import { MSG_CONTROLLER_METADATA } from '../constants.js';
+const augmentationRegistry = [];
+export 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: OpraSchema.MsgOperation.Kind,
+            channel: propertyKey,
+            ...omit(options, ['kind']),
+            payloadType,
+        };
+        const controllerMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) ||
+            {});
+        controllerMetadata.operations = controllerMetadata.operations || {};
+        controllerMetadata.operations[propertyKey] = operationMetadata;
+        for (const fn of decoratorChain)
+            fn(operationMetadata, target, propertyKey);
+        Reflect.defineMetadata(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/esm/document/factory/api-document.factory.js

@@ -8,6 +8,7 @@ import { Base64Type, DateStringType, DateTimeStringType, DateTimeType, DateType,
 import { AnyType, BigintType, BooleanType, IntegerType, NullType, NumberType, ObjectType, StringType, } from '../data-type/primitive-types/index.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
+import { MsgApiFactory } from './msg-api.factory.js';
 const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
 /**
  * @class ApiDocumentFactory
@@ -108,13 +109,18 @@ export class ApiDocumentFactory {
         }
         if (init.api) {
             await context.enterAsync(`.api`, async () => {
-                if (init.api.protocol === 'http') {
-                    const api = await HttpApiFactory.createApi(context, document, init.api);
+                if (init.api && init.api.transport === 'http') {
+                    const api = await HttpApiFactory.createApi(context, { ...init.api, owner: document });
+                    if (api)
+                        document.api = api;
+                }
+                else if (init.api && init.api.transport === 'msg') {
+                    const api = await 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/esm/document/factory/data-type.factory.js

@@ -24,6 +24,26 @@ export 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/esm/document/factory/http-api.factory.js

@@ -16,35 +16,56 @@ export class HttpApiFactory {
     /**
      * Generates HttpApi
      * @param context
-     * @param document
      * @param init
      */
-    static async createApi(context, document, init) {
-        const api = new HttpApi(document);
-        api.name = init.name;
-        api.description = init.description;
-        api.url = init.url;
+    static async createApi(context, init) {
+        const api = new 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' && !isConstructor(thunk)) {
             thunk = parent instanceof HttpController ? thunk(parent.instance) : thunk();
         }
@@ -76,12 +97,13 @@ export 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 HttpController(parent, {
             ...metadata,
-            name,
             instance,
             ctor,
         });
@@ -97,13 +119,7 @@ export 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 DataTypeFactory.createDataType(context, controller, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = controller.node.getDataType('any');
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, controller, v.type);
                         });
                         const prm = new HttpParameter(controller, prmArgs);
                         controller.parameters.push(prm);
@@ -124,32 +140,7 @@ export 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;
@@ -180,13 +171,7 @@ export 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 DataTypeFactory.createDataType(context, operation, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = operation.node.getDataType('any');
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, operation, v.type);
                         });
                         const prm = new HttpParameter(operation, prmArgs);
                         operation.parameters.push(prm);
@@ -230,13 +215,7 @@ export 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 DataTypeFactory.createDataType(context, target, metadata.type);
-                }
-                if (!target.type)
-                    target.type = target.node.getDataType('any');
+                target.type = await DataTypeFactory.resolveDataType(context, target, metadata.type);
             });
         }
         if (metadata.multipartFields) {
@@ -269,13 +248,7 @@ export 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 DataTypeFactory.createDataType(context, target, v.type);
-                            }
-                            if (!prmArgs.type)
-                                prmArgs.type = target.node.getDataType('any');
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, target, v.type);
                         });
                         const prm = new HttpParameter(target, prmArgs);
                         target.parameters.push(prm);