@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -0,0 +1,313 @@
+import { isConstructor, resolveThunk } from '../../helpers/index.js';
+import { HTTP_CONTROLLER_METADATA } from '../constants.js';
+import { HttpApi } from '../http/http-api.js';
+import { HttpController } from '../http/http-controller.js';
+import { HttpMediaType } from '../http/http-media-type.js';
+import { HttpMultipartField } from '../http/http-multipart-field.js';
+import { HttpOperation } from '../http/http-operation.js';
+import { HttpOperationResponse } from '../http/http-operation-response.js';
+import { HttpParameter } from '../http/http-parameter.js';
+import { HttpRequestBody } from '../http/http-request-body.js';
+import { DataTypeFactory } from './data-type.factory.js';
+/**
+ * @class HttpApiFactory
+ */
+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;
+        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' && !isConstructor(thunk)) {
+            thunk = parent instanceof HttpController ? thunk(parent.instance) : thunk();
+        }
+        thunk = await resolveThunk(thunk);
+        let ctor;
+        let metadata;
+        let instance;
+        // If thunk is a class
+        if (typeof thunk === 'function') {
+            metadata = Reflect.getMetadata(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(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 HttpController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await 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 DataTypeFactory.createDataType(context, controller, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = controller.node.getDataType('any');
+                        });
+                        const prm = new 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 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,
+        };
+        HttpOperation.apply(operation, [operation.owner, initArgs]);
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await 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 DataTypeFactory.createDataType(context, operation, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = operation.node.getDataType('any');
+                        });
+                        const prm = new 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 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 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) {
+        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 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 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 DataTypeFactory.createDataType(context, target, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = target.node.getDataType('any');
+                        });
+                        const prm = new 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 HttpMediaType(target, String(i));
+                        await this._initHttpMediaType(context, field, src);
+                        target.content.push(field);
+                    });
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+import { ResponsiveMap } from '../../helpers/index.js';
+import { ApiBase } from '../common/api-base.js';
+import { HttpController } from './http-controller.js';
+/**
+ * @class HttpApi
+ */
+export class HttpApi extends ApiBase {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.protocol = 'http';
+        this.controllers = new ResponsiveMap();
+    }
+    findController(arg0) {
+        return HttpController.prototype.findController.call(this, arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            protocol: this.protocol,
+            url: this.url,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}

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

@@ -0,0 +1,153 @@
+import nodePath from 'node:path';
+import { asMutable } from 'ts-gems';
+import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
+import { HttpControllerDecoratorFactory } from '../decorators/http-controller.decorator.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+/**
+ * HttpController
+ */
+export const HttpController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        return HttpController[DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs] = args;
+    DocumentElement.call(this, owner);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid resource name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.HttpController.Kind;
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.operations = new ResponsiveMap();
+    _this.controllers = new ResponsiveMap();
+    _this.parameters = [];
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.path = initArgs.path || initArgs.name;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+};
+/**
+ *
+ * @class HttpController
+ */
+class HttpControllerClass extends DocumentElement {
+    /**
+     * @property isRoot
+     */
+    get isRoot() {
+        return !(this.owner instanceof HttpController);
+    }
+    findController(arg0) {
+        if (typeof arg0 === 'function') {
+            /** Check for cached mapping */
+            let 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;
+                }
+                if (c.controllers.size) {
+                    controller = c.findController(arg0);
+                    if (controller) {
+                        this._controllerReverseMap.set(arg0, controller);
+                        return controller;
+                    }
+                }
+            }
+            this._controllerReverseMap.set(arg0, null);
+            return;
+        }
+        if (arg0.startsWith('/'))
+            arg0 = arg0.substring(1);
+        if (arg0.includes('/')) {
+            const a = arg0.split('/');
+            let r = this;
+            while (r && a.length > 0) {
+                r = r.controllers.get(a.shift());
+            }
+            return r;
+        }
+        return this.controllers.get(arg0);
+    }
+    findParameter(paramName, location) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.parameters) {
+            if (location && location !== prm.location)
+                continue;
+            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 HttpController) {
+            return this.node.parent.element.findParameter(paramName, location);
+        }
+    }
+    getFullUrl() {
+        return nodePath.posix.join(this.owner instanceof HttpController ? this.owner.getFullUrl() : '/', this.path);
+    }
+    /**
+     *
+     */
+    toString() {
+        return `[HttpController ${this.name}]`;
+    }
+    /**
+     *
+     */
+    toJSON() {
+        const out = omitUndefined({
+            kind: this.kind,
+            description: this.description,
+            path: this.path,
+        });
+        if (this.operations.size) {
+            out.operations = {};
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
+            }
+        }
+        if (this.controllers.size) {
+            out.controllers = {};
+            for (const v of this.controllers.values()) {
+                out.controllers[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.parameters.length) {
+            out.parameters = [];
+            for (const prm of this.parameters) {
+                out.parameters.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow}HttpController${colorFgMagenta + this.name + colorReset}]`;
+    }
+}
+HttpController.prototype = HttpControllerClass.prototype;
+Object.assign(HttpController, HttpControllerDecoratorFactory);
+HttpController[DECORATOR] = HttpControllerDecoratorFactory;

package/esm/document/http/http-media-type.js

@@ -0,0 +1,67 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+export const HttpMediaType = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    DocumentElement.call(this, owner);
+    const _this = asMutable(this);
+    if (initArgs.contentType) {
+        let arr = Array.isArray(initArgs.contentType) ? initArgs.contentType : [initArgs.contentType];
+        arr = arr.map(x => x.split(/\s*,\s*/)).flat();
+        _this.contentType = arr.length > 1 ? arr : arr[0];
+    }
+    _this.description = initArgs.description;
+    _this.contentEncoding = initArgs.contentEncoding;
+    _this.examples = initArgs.examples;
+    _this.multipartFields = [];
+    _this.maxFieldsSize = initArgs.maxFieldsSize;
+    _this.maxFields = initArgs.maxFields;
+    _this.maxFiles = initArgs.maxFiles;
+    _this.maxFileSize = initArgs.maxFileSize;
+    _this.maxTotalFileSize = initArgs.maxTotalFileSize;
+    _this.minFileSize = initArgs.minFileSize;
+    if (initArgs?.type) {
+        _this.type = initArgs?.type instanceof DataType ? initArgs.type : _this.owner.node.getDataType(initArgs.type);
+    }
+    _this.isArray = initArgs.isArray;
+};
+/**
+ * @class HttpMediaType
+ */
+class HttpMediaTypeClass extends DocumentElement {
+    findMultipartField(fieldName, fieldType) {
+        if (!this.multipartFields)
+            return;
+        for (const f of this.multipartFields) {
+            if ((!fieldType || fieldType === f.fieldType) &&
+                ((f.fieldName instanceof RegExp && f.fieldName.test(fieldName)) || f.fieldName === fieldName)) {
+                return f;
+            }
+        }
+    }
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        const out = omitUndefined({
+            description: this.description,
+            contentType: this.contentType,
+            contentEncoding: this.contentEncoding,
+            type: typeName ? typeName : this.type?.toJSON(),
+            isArray: this.isArray,
+            example: this.example,
+            examples: this.examples,
+            maxFields: this.maxFields,
+            maxFieldsSize: this.maxFieldsSize,
+            maxFiles: this.maxFiles,
+            maxFileSize: this.maxFileSize,
+            maxTotalFileSize: this.maxTotalFileSize,
+            minFileSize: this.minFileSize,
+        });
+        if (this.multipartFields?.length) {
+            out.multipartFields = this.multipartFields.map(x => x.toJSON());
+        }
+        return out;
+    }
+}
+HttpMediaType.prototype = HttpMediaTypeClass.prototype;

package/esm/document/http/http-multipart-field.js

@@ -0,0 +1,29 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { parseRegExp } from '../utils/parse-regexp.util.js';
+import { HttpMediaType } from './http-media-type.js';
+/**
+ *
+ * @class HttpMultipartField
+ */
+export class HttpMultipartField extends HttpMediaType {
+    constructor(owner, initArgs) {
+        super(owner, initArgs);
+        this.owner = owner;
+        this.fieldName =
+            initArgs.fieldName instanceof RegExp
+                ? initArgs.fieldName
+                : initArgs.fieldName.startsWith('/')
+                    ? parseRegExp(initArgs.fieldName)
+                    : initArgs.fieldName;
+        this.fieldType = initArgs.fieldType;
+        this.required = initArgs.required;
+    }
+    toJSON() {
+        return omitUndefined({
+            fieldName: this.fieldName,
+            fieldType: this.fieldType,
+            required: this.required,
+            ...super.toJSON(),
+        });
+    }
+}

package/esm/document/http/http-operation-response.js

@@ -0,0 +1,39 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { HttpMediaType } from './http-media-type.js';
+import { HttpStatusRange } from './http-status-range.js';
+/**
+ * @class HttpOperationResponse
+ */
+export class HttpOperationResponse extends HttpMediaType {
+    constructor(owner, init) {
+        super(owner, init);
+        this.owner = owner;
+        this.parameters = [];
+        this.statusCode = (Array.isArray(init.statusCode) ? init.statusCode : [init.statusCode]).map(x => typeof x === 'object' ? new HttpStatusRange(x.start, x.end) : new HttpStatusRange(x));
+        this.partial = init.partial;
+    }
+    findParameter(paramName, location) {
+        paramName = paramName.toLowerCase();
+        for (const prm of this.parameters) {
+            if ((!location || location === prm.location) &&
+                ((prm.name instanceof RegExp && prm.name.test(paramName)) || prm.name === paramName)) {
+                return prm;
+            }
+        }
+    }
+    toJSON() {
+        const statusCode = this.statusCode.map(x => x.toJSON());
+        const out = omitUndefined({
+            ...super.toJSON(),
+            statusCode: statusCode.length === 1 && typeof statusCode[0] === 'number' ? statusCode[0] : statusCode,
+            partial: this.partial,
+        });
+        if (this.parameters.length) {
+            out.parameters = [];
+            for (const prm of this.parameters) {
+                out.parameters.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}