@opra/common 1.20.0 → 1.22.0

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

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpApiFactory = void 0;
-const objects_1 = require("@jsopen/objects");
-const index_js_1 = require("../../helpers/index.js");
-const constants_js_1 = require("../constants.js");
-const http_api_js_1 = require("../http/http-api.js");
-const http_controller_js_1 = require("../http/http-controller.js");
-const http_media_type_js_1 = require("../http/http-media-type.js");
-const http_multipart_field_js_1 = require("../http/http-multipart-field.js");
-const http_operation_js_1 = require("../http/http-operation.js");
-const http_operation_response_js_1 = require("../http/http-operation-response.js");
-const http_parameter_js_1 = require("../http/http-parameter.js");
-const http_request_body_js_1 = require("../http/http-request-body.js");
-const data_type_factory_js_1 = require("./data-type.factory.js");
-/**
- * @class HttpApiFactory
- */
-class HttpApiFactory {
-    /**
-     * Generates HttpApi
-     * @param context
-     * @param init
-     */
-    static async createApi(context, init) {
-        const api = new http_api_js_1.HttpApi(init);
-        if (init.controllers) {
-            await context.enterAsync('.controllers', async () => {
-                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);
-                }
-            });
-        }
-    }
-    static async _resolveControllerMetadata(context, parent, thunk) {
-        if (typeof thunk === 'function' && !(0, objects_1.isConstructor)(thunk)) {
-            thunk =
-                parent instanceof http_controller_js_1.HttpController ? thunk(parent.instance) : 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.HTTP_CONTROLLER_METADATA, thunk);
-            if (!metadata)
-                return context.addError(`Class "${thunk.name}" doesn't have a valid HttpController metadata`);
-            ctor = thunk;
-        }
-        else {
-            // If thunk is an instance of a class decorated with HttpController()
-            ctor = Object.getPrototypeOf(thunk).constructor;
-            metadata = Reflect.getMetadata(constants_js_1.HTTP_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 HttpController()`);
-        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,
-            instance,
-            ctor,
-        });
-        if (metadata.types) {
-            await context.enterAsync('.types', async () => {
-                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, controller, metadata.types);
-            });
-        }
-        if (metadata.parameters) {
-            await context.enterAsync('.parameters', async () => {
-                let i = 0;
-                for (const v of metadata.parameters) {
-                    await context.enterAsync(`[${i++}]`, async () => {
-                        const prmArgs = { ...v };
-                        await context.enterAsync('.type', async () => {
-                            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);
-                    });
-                }
-            });
-        }
-        if (metadata.operations) {
-            await context.enterAsync('.operations', async () => {
-                for (const [k, v] of Object.entries(metadata.operations)) {
-                    await context.enterAsync(`[${k}]`, async () => {
-                        const operation = new http_operation_js_1.HttpOperation(controller, {
-                            name: k,
-                            method: 'GET',
-                        });
-                        await this._initHttpOperation(context, operation, v);
-                        controller.operations.set(k, operation);
-                    });
-                }
-            });
-        }
-        if (metadata.controllers) {
-            await context.enterAsync('.controllers', async () => {
-                await this._createControllers(context, controller, metadata.controllers);
-            });
-        }
-        return controller;
-    }
-    /**
-     * Initializes HttpOperation
-     * @param context
-     * @param operation
-     * @param metadata
-     * @protected
-     */
-    static async _initHttpOperation(context, operation, metadata) {
-        const initArgs = {
-            ...metadata,
-            name: operation.name,
-            types: undefined,
-        };
-        http_operation_js_1.HttpOperation.apply(operation, [operation.owner, initArgs]);
-        if (metadata.types) {
-            await context.enterAsync('.types', async () => {
-                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, operation, metadata.types);
-            });
-        }
-        if (metadata.parameters) {
-            await context.enterAsync('.parameters', async () => {
-                let i = 0;
-                for (const v of metadata.parameters) {
-                    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 http_parameter_js_1.HttpParameter(operation, prmArgs);
-                        operation.parameters.push(prm);
-                    });
-                }
-            });
-        }
-        if (metadata.responses) {
-            await context.enterAsync('.responses', async () => {
-                let i = 0;
-                for (const v of metadata.responses) {
-                    await context.enterAsync(`[${i++}]`, async () => {
-                        const response = new http_operation_response_js_1.HttpOperationResponse(operation, {
-                            statusCode: v.statusCode,
-                        });
-                        await this._initHttpOperationResponse(context, response, v);
-                        operation.responses.push(response);
-                    });
-                }
-            });
-        }
-        if (metadata.requestBody) {
-            await context.enterAsync('.requestBody', async () => {
-                const requestBody = new http_request_body_js_1.HttpRequestBody(operation);
-                await this._initHttpRequestBody(context, requestBody, metadata.requestBody);
-                operation.requestBody = requestBody;
-            });
-        }
-        return operation;
-    }
-    /**
-     * Initializes HttpMediaType
-     * @param context
-     * @param target
-     * @param metadata
-     * @protected
-     */
-    static async _initHttpMediaType(context, target, metadata) {
-        http_media_type_js_1.HttpMediaType.call(target, target.owner, {
-            ...metadata,
-            type: undefined,
-            multipartFields: undefined,
-        });
-        if (metadata.type) {
-            await context.enterAsync('.type', async () => {
-                target.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, target, metadata.type);
-            });
-        }
-        if (metadata.multipartFields) {
-            await context.enterAsync('.multipartFields', async () => {
-                for (let i = 0; i < metadata.multipartFields.length; i++) {
-                    await context.enterAsync(`[${i}]`, async () => {
-                        const src = metadata.multipartFields[i];
-                        const field = new http_multipart_field_js_1.HttpMultipartField(target, {
-                            fieldName: src.fieldName,
-                            fieldType: src.fieldType,
-                        });
-                        await this._initHttpMediaType(context, field, src);
-                        target.multipartFields.push(field);
-                    });
-                }
-            });
-        }
-    }
-    /**
-     * Initializes HttpOperationResponse
-     * @param context
-     * @param target
-     * @param metadata
-     * @protected
-     */
-    static async _initHttpOperationResponse(context, target, metadata) {
-        await this._initHttpMediaType(context, target, metadata);
-        target.partial = metadata.partial;
-        if (metadata.parameters) {
-            await context.enterAsync('.parameters', async () => {
-                let i = 0;
-                for (const v of metadata.parameters) {
-                    await context.enterAsync(`[${i++}]`, async () => {
-                        const prmArgs = { ...v };
-                        await context.enterAsync('.type', async () => {
-                            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);
-                    });
-                }
-            });
-        }
-    }
-    /**
-     * Initializes HttpRequestBody
-     * @param context
-     * @param target
-     * @param metadata
-     * @protected
-     */
-    static async _initHttpRequestBody(context, target, metadata) {
-        target.description = metadata.description;
-        target.required = metadata.required;
-        target.maxContentSize = metadata.maxContentSize;
-        target.immediateFetch = metadata.immediateFetch;
-        target.partial = metadata.partial;
-        target.allowPatchOperators = metadata.allowPatchOperators;
-        target.keepKeyFields = metadata.keepKeyFields;
-        if (metadata.content) {
-            await context.enterAsync('.content', async () => {
-                for (let i = 0; i < metadata.content.length; i++) {
-                    await context.enterAsync(`[${i}]`, async () => {
-                        const src = metadata.content[i];
-                        const field = new http_media_type_js_1.HttpMediaType(target, String(i));
-                        await this._initHttpMediaType(context, field, src);
-                        target.content.push(field);
-                    });
-                }
-            });
-        }
-    }
-}
-exports.HttpApiFactory = HttpApiFactory;

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

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 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 MQApiFactory
- */
-class MQApiFactory {
-    /**
-     * Generates MQApi
-     * @param context
-     * @param init
-     */
-    static async createApi(context, init) {
-        const api = new mq_api_js_1.MQApi(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.MQ_CONTROLLER_METADATA, thunk);
-            if (!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 MQController()
-            ctor = Object.getPrototypeOf(thunk).constructor;
-            metadata = Reflect.getMetadata(constants_js_1.MQ_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 MQController()`);
-        name = name || metadata.name;
-        if (!name)
-            throw new TypeError(`Controller name required`);
-        const controller = new mq_controller_js_1.MQController(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 mq_header_js_1.MQHeader(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 mq_operation_js_1.MQOperation(controller, {
-                            ...operationMeta,
-                            name: operationName,
-                            types: undefined,
-                            type: undefined,
-                            keyType: undefined,
-                        });
-                        await this._initMQOperation(context, operation, operationMeta);
-                        controller.operations.set(operation.name, operation);
-                    });
-                }
-            });
-        }
-        return controller;
-    }
-    /**
-     * Initializes MQOperation
-     * @param context
-     * @param operation
-     * @param metadata
-     * @protected
-     */
-    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);
-            });
-        }
-        operation.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, metadata.type);
-        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 mq_header_js_1.MQHeader(operation, prmArgs);
-                        operation.headers.push(prm);
-                    });
-                }
-            });
-        }
-        if (metadata.response) {
-            await context.enterAsync('.response', async () => {
-                const response = new mq_operation_response_js_1.MQOperationResponse(operation, {
-                    ...metadata.response,
-                    type: undefined,
-                    keyType: undefined,
-                });
-                await this._initMQOperationResponse(context, response, metadata.response);
-                operation.response = response;
-            });
-        }
-    }
-    /**
-     * Initializes MQOperationResponse
-     * @param context
-     * @param response
-     * @param metadata
-     * @protected
-     */
-    static async _initMQOperationResponse(context, response, metadata) {
-        response.type = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, response, metadata.type);
-        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 mq_header_js_1.MQHeader(response, prmArgs);
-                        response.headers.push(prm);
-                    });
-                }
-            });
-        }
-    }
-}
-exports.MQApiFactory = MQApiFactory;

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

@@ -1,145 +0,0 @@
-"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 argumentsMetadata = Reflect.getMetadata(constants_js_1.WS_PARAM_METADATA, ctor.prototype, operationName);
-                        let operationMeta = _operationMeta;
-                        if (argumentsMetadata) {
-                            operationMeta = {
-                                ...operationMeta,
-                                arguments: argumentsMetadata,
-                            };
-                        }
-                        const operation = new ws_operation_js_1.WSOperation(controller, {
-                            ...operationMeta,
-                            name: operationName,
-                            types: undefined,
-                            type: undefined,
-                            keyType: undefined,
-                            arguments: undefined,
-                        });
-                        await this._initWSOperation(context, operation, operationMeta);
-                        controller.operations.set(operationName, 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);
-            });
-        }
-        if (metadata.arguments?.length) {
-            await context.enterAsync('.arguments', async () => {
-                operation.arguments = [];
-                for (const x of metadata.arguments) {
-                    const t = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, x);
-                    operation.arguments?.push(t);
-                }
-            });
-        }
-        if (metadata.response) {
-            await context.enterAsync('.response', async () => {
-                operation.response = await data_type_factory_js_1.DataTypeFactory.resolveDataType(context, operation, metadata.response);
-            });
-        }
-    }
-}
-exports.WSApiFactory = WSApiFactory;

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpApi = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const api_base_js_1 = require("../common/api-base.js");
-const http_controller_js_1 = require("./http-controller.js");
-/**
- * @class HttpApi
- */
-class HttpApi extends api_base_js_1.ApiBase {
-    constructor(init) {
-        super(init);
-        // noinspection JSUnusedGlobalSymbols
-        this._controllerReverseMap = new WeakMap();
-        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);
-    }
-    findOperation(arg0, operationName) {
-        const controller = this.findController(arg0);
-        return controller?.operations.get(operationName);
-    }
-    toJSON(options) {
-        const schema = super.toJSON();
-        const out = {
-            ...schema,
-            transport: this.transport,
-            url: this.url,
-            controllers: {},
-        };
-        for (const v of this.controllers.values()) {
-            out.controllers[v.name] = v.toJSON(options);
-        }
-        return out;
-    }
-}
-exports.HttpApi = HttpApi;