@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApiFactory = void 0;
+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 document
+     * @param init
+     */
+    static async createApi(context, document, init) {
+        const api = new http_api_js_1.HttpApi(document);
+        api.description = init.description;
+        api.url = init.url;
+        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 = 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()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new http_controller_js_1.HttpController(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.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 () => {
+                            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 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 () => {
+                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);
+                            }
+                        });
+                    }
+                }
+            });
+        }
+        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 () => {
+                            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');
+                        });
+                        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.enter('.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 () => {
+                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');
+            });
+        }
+        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 () => {
+                            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');
+                        });
+                        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;
+        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/http/decorators/http-controller.decorator.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpControllerDecoratorFactory = void 0;
+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 = /^(.*)(Collection|Singleton|Resource|Controller)$/;
+function HttpControllerDecoratorFactory(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.HTTP_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.HTTP_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.HttpController.Kind,
+            name,
+            path: name,
+            ...(0, lodash_omit_1.default)(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
+        }, { deep: true });
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata);
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
+    };
+    /**
+     *
+     */
+    decorator.Cookie = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'cookie',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'cookie' };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.Header = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'header',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'header' };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.QueryParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'query',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'query' };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.PathParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'path',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'path' };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    return decorator;
+}
+exports.HttpControllerDecoratorFactory = HttpControllerDecoratorFactory;