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

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

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcApiFactory = void 0;
+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 data_type_factory_js_1 = require("./data-type.factory.js");
+/**
+ * @class RpcApiFactory
+ */
+class RpcApiFactory {
+    /**
+     * Generates RpcApi
+     * @param context
+     * @param init
+     */
+    static async createApi(context, init) {
+        const api = new rpc_api_js_1.RpcApi(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, index_js_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.RPC_CONTROLLER_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid RpcController metadata`);
+            ctor = thunk;
+        }
+        else {
+            // If thunk is an instance of a class decorated with RpcController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(constants_js_1.RPC_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 RpcController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new rpc_controller_js_1.RpcController(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.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    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');
+                        });
+                        const prm = new rpc_header_js_1.RpcHeader(controller, prmArgs);
+                        controller.headers.push(prm);
+                    });
+                }
+            });
+        }
+        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 rpc_operation_js_1.RpcOperation(controller, {
+                            ...operationMeta,
+                            name: operationName,
+                            types: undefined,
+                            payloadType: undefined,
+                            keyType: undefined,
+                        });
+                        await this._initRpcOperation(context, operation, operationMeta);
+                        controller.operations.set(operation.name, operation);
+                    });
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes RpcOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initRpcOperation(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);
+        if (metadata.keyType) {
+            operation.keyType = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, metadata.keyType);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        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);
+                        operation.headers.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.response) {
+            await context.enterAsync('.response', async () => {
+                const response = new rpc_operation_response_js_1.RpcOperationResponse(operation, {
+                    ...metadata.response,
+                    payloadType: undefined,
+                    keyType: undefined,
+                });
+                await this._initRpcOperationResponse(context, response, metadata.response);
+                operation.response = response;
+            });
+        }
+    }
+    /**
+     * Initializes RpcOperationResponse
+     * @param context
+     * @param response
+     * @param metadata
+     * @protected
+     */
+    static async _initRpcOperationResponse(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);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        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);
+                        response.headers.push(prm);
+                    });
+                }
+            });
+        }
+    }
+}
+exports.RpcApiFactory = RpcApiFactory;

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

@@ -8,12 +8,13 @@ const http_controller_js_1 = require("./http-controller.js");
  * @class HttpApi
  */
 class HttpApi extends api_base_js_1.ApiBase {
-    constructor(owner) {
-        super(owner);
+    constructor(init) {
+        super(init);
         // noinspection JSUnusedGlobalSymbols
         this._controllerReverseMap = new WeakMap();
-        this.protocol = 'http';
+        this.transport = 'http';
         this.controllers = new index_js_1.ResponsiveMap();
+        this.url = init.url;
     }
     findController(arg0) {
         return http_controller_js_1.HttpController.prototype.findController.call(this, arg0);
@@ -26,7 +27,7 @@ class HttpApi extends api_base_js_1.ApiBase {
         const schema = super.toJSON();
         const out = {
             ...schema,
-            protocol: this.protocol,
+            transport: this.transport,
             url: this.url,
             controllers: {},
         };

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

@@ -36,6 +36,8 @@ exports.HttpController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -155,3 +157,17 @@ class HttpControllerClass extends document_element_js_1.DocumentElement {
 exports.HttpController.prototype = HttpControllerClass.prototype;
 Object.assign(exports.HttpController, http_controller_decorator_js_1.HttpControllerDecoratorFactory);
 exports.HttpController[constants_js_1.DECORATOR] = http_controller_decorator_js_1.HttpControllerDecoratorFactory;
+exports.HttpController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+exports.HttpController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

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

@@ -78,6 +78,12 @@ class HttpOperationClass extends document_element_js_1.DocumentElement {
             composition: this.composition,
             requestBody: this.requestBody?.toJSON(),
         });
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
         if (this.parameters.length) {
             out.parameters = [];
             for (const prm of this.parameters) {

package/cjs/document/index.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classes = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
+const RpcControllerDecorator_ = tslib_1.__importStar(require("./decorators/rpc-controller.decorator.js"));
+const RpcOperationDecorator_ = tslib_1.__importStar(require("./decorators/rpc-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);
@@ -37,8 +39,14 @@ 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);
 var classes;
 (function (classes) {
     classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
+    classes.RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
+    classes.RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
 })(classes || (exports.classes = classes = {}));

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcApi = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const api_base_js_1 = require("../common/api-base.js");
+/**
+ * @class RpcApi
+ */
+class RpcApi extends api_base_js_1.ApiBase {
+    constructor(init) {
+        super(init);
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.transport = 'rpc';
+        this.controllers = new index_js_1.ResponsiveMap();
+        this.platform = init.platform;
+    }
+    findController(arg0) {
+        if (typeof arg0 === 'function') {
+            /** Check for cached mapping */
+            const controller = this._controllerReverseMap.get(arg0);
+            if (controller != null)
+                return controller;
+            /** Lookup for ctor in all controllers */
+            for (const c of this.controllers.values()) {
+                if (c.ctor === arg0) {
+                    this._controllerReverseMap.set(arg0, c);
+                    return c;
+                }
+            }
+            this._controllerReverseMap.set(arg0, null);
+            return;
+        }
+        return this.controllers.get(arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            transport: this.transport,
+            platform: this.platform,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}
+exports.RpcApi = RpcApi;

package/cjs/document/rpc/rpc-controller.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcController = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+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 rpc_controller_decorator_js_1 = require("../decorators/rpc-controller.decorator.js");
+const inspect_util_js_1 = require("../utils/inspect.util.js");
+/**
+ * RpcController
+ */
+exports.RpcController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        return exports.RpcController[constants_js_1.DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs] = args;
+    document_element_js_1.DocumentElement.call(this, owner);
+    if (!constants_js_1.CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid resource name (${initArgs.name})`);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.OpraSchema.RpcController.Kind;
+    _this.types = _this.node[constants_js_1.kDataTypeMap] = new data_type_map_js_1.DataTypeMap();
+    _this.operations = new index_js_1.ResponsiveMap();
+    _this.headers = [];
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
+};
+/**
+ *
+ * @class RpcController
+ */
+class RpcControllerClass extends document_element_js_1.DocumentElement {
+    findHeader(paramName, location) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+        if (this.node.parent && this.node.parent.element instanceof exports.RpcController) {
+            return this.node.parent.element.findHeader(paramName, location);
+        }
+    }
+    /**
+     *
+     */
+    toString() {
+        return `[RpcController ${this.name}]`;
+    }
+    /**
+     *
+     */
+    toJSON() {
+        const out = (0, index_js_1.omitUndefined)({
+            kind: this.kind,
+            description: this.description,
+        });
+        if (this.operations.size) {
+            out.operations = {};
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
+            }
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow}RpcController${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+}
+exports.RpcController.prototype = RpcControllerClass.prototype;
+Object.assign(exports.RpcController, rpc_controller_decorator_js_1.RpcControllerDecoratorFactory);
+exports.RpcController[constants_js_1.DECORATOR] = rpc_controller_decorator_js_1.RpcControllerDecoratorFactory;
+exports.RpcController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+exports.RpcController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(constants_js_1.RPC_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/cjs/document/rpc/rpc-header.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcHeader = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const value_js_1 = require("../common/value.js");
+const parse_regexp_util_js_1 = require("../utils/parse-regexp.util.js");
+exports.RpcHeader = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    value_js_1.Value.call(this, owner, initArgs);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    if (initArgs.name) {
+        _this.name =
+            initArgs.name instanceof RegExp
+                ? initArgs.name
+                : initArgs.name.startsWith('/')
+                    ? (0, parse_regexp_util_js_1.parseRegExp)(initArgs.name, {
+                        includeFlags: 'i',
+                        excludeFlags: 'm',
+                    })
+                    : initArgs.name;
+    }
+    _this.deprecated = initArgs.deprecated;
+    _this.required = initArgs.required;
+};
+/**
+ * @class RpcHeader
+ */
+class RpcHeaderClass extends value_js_1.Value {
+    toJSON() {
+        return (0, index_js_1.omitUndefined)({
+            ...super.toJSON(),
+            name: this.name,
+            required: this.required,
+            deprecated: this.deprecated,
+        });
+    }
+}
+exports.RpcHeader.prototype = RpcHeaderClass.prototype;

package/cjs/document/rpc/rpc-operation-response.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcOperationResponse = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const document_element_js_1 = require("../common/document-element.js");
+const data_type_js_1 = require("../data-type/data-type.js");
+/**
+ * @class RpcOperationResponse
+ */
+class RpcOperationResponse extends document_element_js_1.DocumentElement {
+    constructor(owner, initArgs) {
+        super(owner);
+        this.headers = [];
+        this.channel = initArgs?.channel;
+        this.description = initArgs?.description;
+        if (initArgs?.payloadType) {
+            this.payloadType =
+                initArgs?.payloadType instanceof data_type_js_1.DataType
+                    ? initArgs.payloadType
+                    : this.owner.node.getDataType(initArgs.payloadType);
+        }
+        else
+            this.payloadType = this.owner.node.getDataType('any');
+        if (initArgs?.keyType) {
+            this.keyType =
+                initArgs?.keyType instanceof data_type_js_1.DataType ? initArgs.keyType : this.owner.node.getDataType(initArgs.keyType);
+        }
+    }
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = (0, index_js_1.omitUndefined)({
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}
+exports.RpcOperationResponse = RpcOperationResponse;

package/cjs/document/rpc/rpc-operation.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcOperation = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+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 rpc_operation_decorator_js_1 = require("../decorators/rpc-operation.decorator.js");
+/**
+ *  RpcOperation
+ */
+exports.RpcOperation = function (...args) {
+    // Decorator
+    if (!this) {
+        const [payloadType, options] = args;
+        const decoratorChain = [];
+        return exports.RpcOperation[constants_js_1.DECORATOR].call(undefined, decoratorChain, payloadType, options);
+    }
+    // Constructor
+    const [resource, initArgs] = args;
+    document_element_js_1.DocumentElement.call(this, resource);
+    if (!constants_js_1.CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid operation name (${initArgs.name})`);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.headers = [];
+    _this.types = _this.node[constants_js_1.kDataTypeMap] = new data_type_map_js_1.DataTypeMap();
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.channel = initArgs.channel;
+    if (initArgs?.payloadType) {
+        _this.payloadType =
+            initArgs?.payloadType instanceof data_type_js_1.DataType
+                ? initArgs.payloadType
+                : _this.owner.node.getDataType(initArgs.payloadType);
+    }
+    if (initArgs?.keyType) {
+        _this.keyType =
+            initArgs?.keyType instanceof data_type_js_1.DataType ? initArgs.keyType : _this.owner.node.getDataType(initArgs.keyType);
+    }
+};
+/**
+ * @class RpcOperation
+ */
+class RpcOperationClass extends document_element_js_1.DocumentElement {
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = (0, index_js_1.omitUndefined)({
+            kind: index_js_2.OpraSchema.RpcOperation.Kind,
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+            response: this.response?.toJSON(),
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}
+exports.RpcOperation.prototype = RpcOperationClass.prototype;
+exports.RpcOperation[constants_js_1.DECORATOR] = rpc_operation_decorator_js_1.RpcOperationDecoratorFactory;

package/cjs/enums/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./http-headers-codes.enum.js"), exports);
+tslib_1.__exportStar(require("./http-status-codes.enum.js"), exports);
+tslib_1.__exportStar(require("./http-status-messages.js"), exports);
+tslib_1.__exportStar(require("./mime-types.enum.js"), exports);

package/cjs/exception/http-errors/forbidden.error.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForbiddenError = void 0;
-const index_js_1 = require("../../http/index.js");
+const index_js_1 = require("../../enums/index.js");
 const index_js_2 = require("../../i18n/index.js");
 const opra_http_error_js_1 = require("../opra-http-error.js");
 /**

package/cjs/exception/http-errors/resource-not.available.error.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceNotAvailableError = void 0;
-const index_js_1 = require("../../http/index.js");
+const index_js_1 = require("../../enums/index.js");
 const index_js_2 = require("../../i18n/index.js");
 const opra_http_error_js_1 = require("../opra-http-error.js");
 /**