@opra/common 0.33.12 → 1.0.0-alpha.1

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

@@ -0,0 +1,142 @@
+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, c);
+                        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) {
+        paramName = paramName.toLowerCase();
+        for (const prm of this.parameters) {
+            if ((!location || location === prm.location) &&
+                ((prm.name instanceof RegExp && prm.name.test(paramName)) ||
+                    (typeof prm.name === 'string' && prm.name.toLowerCase() === paramName)))
+                return prm;
+        }
+        if (this.node.parent && this.node.parent.element instanceof HttpController)
+            return this.node.parent.element.findParameter(paramName, location);
+    }
+    /**
+     *
+     */
+    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 [name, v] of this.operations.entries()) {
+                out.operations[name] = v.toJSON();
+            }
+        }
+        if (this.controllers.size) {
+            out.controllers = {};
+            for (const [name, v] of this.controllers.entries()) {
+                out.controllers[name] = v.toJSON();
+            }
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const [name, v] of this.types.entries()) {
+                out.types[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,65 @@
+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,38 @@
+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;
+    }
+}

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

@@ -0,0 +1,90 @@
+import { asMutable } from 'ts-gems';
+import { cloneObject, omitUndefined } 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 { HttpOperationDecoratorFactory } from '../decorators/http-operation.decorator.js';
+/**
+ *  HttpOperation
+ */
+export const HttpOperation = function (...args) {
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        const decoratorChain = [];
+        return HttpOperation[DECORATOR].call(undefined, decoratorChain, options);
+    }
+    // Constructor
+    const [resource, initArgs] = args;
+    DocumentElement.call(this, resource);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid operation name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.parameters = [];
+    _this.responses = [];
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.name = initArgs.name;
+    _this.path = initArgs.path;
+    _this.method = initArgs.method || 'GET';
+    _this.description = initArgs.description;
+    _this.composition = initArgs.composition;
+    _this.compositionOptions = initArgs.compositionOptions ? cloneObject(initArgs.compositionOptions) : undefined;
+};
+/**
+ * @class HttpOperation
+ */
+class HttpOperationClass extends DocumentElement {
+    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 out = omitUndefined({
+            kind: OpraSchema.HttpOperation.Kind,
+            description: this.description,
+            method: this.method,
+            composition: this.composition,
+            requestBody: this.requestBody?.toJSON(),
+        });
+        if (this.parameters.length) {
+            out.parameters = [];
+            for (const prm of this.parameters) {
+                out.parameters.push(prm.toJSON());
+            }
+        }
+        if (this.responses.length)
+            out.responses = this.responses.map(r => r.toJSON());
+        return out;
+    }
+}
+HttpOperation.prototype = HttpOperationClass.prototype;
+HttpOperation[DECORATOR] = HttpOperationDecoratorFactory;
+HttpOperation.GET = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'GET' });
+};
+HttpOperation.DELETE = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'DELETE' });
+};
+HttpOperation.HEAD = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'HEAD' });
+};
+HttpOperation.OPTIONS = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'OPTIONS' });
+};
+HttpOperation.PATCH = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'PATCH' });
+};
+HttpOperation.POST = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'POST' });
+};
+HttpOperation.PUT = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'PUT' });
+};
+HttpOperation.SEARCH = function (options) {
+    return HttpOperationDecoratorFactory([], { ...options, method: 'SEARCH' });
+};

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

@@ -0,0 +1,41 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { Value } from '../common/value.js';
+import { parseRegExp } from '../utils/parse-regexp.util.js';
+export const HttpParameter = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    Value.call(this, owner, initArgs);
+    const _this = asMutable(this);
+    if (initArgs.name) {
+        _this.name =
+            initArgs.name instanceof RegExp
+                ? initArgs.name
+                : initArgs.name.startsWith('/')
+                    ? parseRegExp(initArgs.name, {
+                        includeFlags: 'i',
+                        excludeFlags: 'm',
+                    })
+                    : initArgs.name;
+    }
+    _this.location = initArgs.location;
+    _this.deprecated = initArgs.deprecated;
+    _this.required = initArgs.required;
+    _this.arraySeparator = initArgs.arraySeparator;
+};
+/**
+ * @class HttpParameter
+ */
+class HttpParameterClass extends Value {
+    toJSON() {
+        return omitUndefined({
+            ...super.toJSON(),
+            name: this.name,
+            location: this.location,
+            arraySeparator: this.arraySeparator,
+            required: this.required,
+            deprecated: this.deprecated,
+        });
+    }
+}
+HttpParameter.prototype = HttpParameterClass.prototype;

package/esm/document/http/http-request-body.js

@@ -0,0 +1,21 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+/**
+ * @class HttpRequestBody
+ */
+export class HttpRequestBody extends DocumentElement {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+        this.content = [];
+    }
+    toJSON() {
+        return omitUndefined({
+            description: this.description,
+            required: this.required,
+            maxContentSize: this.maxContentSize,
+            content: this.content.length ? this.content.map(x => x.toJSON()) : [],
+            partial: this.partial,
+        });
+    }
+}

package/esm/document/http/http-status-range.js

@@ -0,0 +1,37 @@
+const STATUS_RANGE_PATTERN = /^([1-6]\d{2})(?:-([1-6]\d{2}))?$/;
+/**
+ * @class HttpStatusRange
+ */
+export class HttpStatusRange {
+    constructor(arg0, arg1) {
+        this.start = 0;
+        this.end = 0;
+        if (arg0 && typeof arg0 === 'object') {
+            this.start = arg0.start || 0;
+            this.end = arg0.end || 0;
+        }
+        if (typeof arg0 === 'number') {
+            this.start = arg0;
+            this.end = arg1 || this.start;
+        }
+        if (typeof arg0 === 'string') {
+            const m = STATUS_RANGE_PATTERN.exec(arg0);
+            if (!m)
+                throw new TypeError(`"${arg0}" is not a valid Status Code range`);
+            this.start = parseInt(m[1], 10);
+            this.end = m[2] ? parseInt(m[2], 10) : this.start;
+        }
+    }
+    get distance() {
+        return this.end - this.start;
+    }
+    toString() {
+        if (this.start === this.end)
+            return String(this.start);
+        else
+            return String(this.start) + '-' + String(this.end);
+    }
+    toJSON() {
+        return !this.end || this.start === this.end ? this.start : { start: this.start, end: this.end };
+    }
+}

package/esm/document/index.js

@@ -1,28 +1,40 @@
 import 'reflect-metadata';
-export * from './constants.js';
+import * as DataTypeFactory_ from './factory/data-type.factory.js';
+import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
-export * from './type-document.js';
-export * from './factory/type-document-factory.js';
-export * from './factory/api-document-factory.js';
-export * from './data-type/data-type.js';
+export * from './constants.js';
+export * from './common/api-base.js';
+export * from './common/data-type-map.js';
+export * from './common/document-element.js';
+export * from './common/document-init-context.js';
+export * from './common/document-node.js';
+export * from './common/opra-document-error.js';
 export * from './data-type/complex-type.js';
-export * from './data-type/field.js';
+export * from './data-type/data-type.js';
 export * from './data-type/enum-type.js';
+export * from './data-type/api-field.js';
 export * from './data-type/mapped-type.js';
-export * from './data-type/simple-type.js';
 export * from './data-type/mixin-type.js';
-export * from './resource/action.js';
-export * from './resource/collection.js';
-export * from './resource/container.js';
-export * from './resource/crud-resource.js';
-export * from './resource/endpoint.js';
-export * from './resource/crud-operation.js';
-export * from './resource/parameter.js';
-export * from './resource/resource.js';
-export * from './resource/singleton.js';
-export * from './resource/storage.js';
-export * from './resource/enums/metadata-mode.enum.js';
-export * from './resource/types/operation-result.type.js';
-export * from './interfaces/collection.interface.js';
-export * from './interfaces/singleton.interface.js';
-export * from './interfaces/storage.interface.js';
+export * from './data-type/omit-type.js';
+export * from './data-type/partial-type.js';
+export * from './data-type/pick-type.js';
+export * from './data-type/required-type.js';
+export * from './data-type/simple-type.js';
+export * from './data-type/primitive-types/index.js';
+export * from './data-type/extended-types/index.js';
+export * from './decorators/http-operation-entity.decorator.js';
+export * from './factory/api-document.factory.js';
+export * from './http/http-api.js';
+export * from './http/http-media-type.js';
+export * from './http/http-multipart-field.js';
+export * from './http/http-operation.js';
+export * from './http/http-operation-response.js';
+export * from './http/http-parameter.js';
+export * from './http/http-request-body.js';
+export * from './http/http-controller.js';
+export * from './http/http-status-range.js';
+export var classes;
+(function (classes) {
+    classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
+    classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
+})(classes || (classes = {}));

package/esm/document/utils/inspect.util.js

@@ -1,4 +1,4 @@
 export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-export const colorReset = "\x1b[0m";
-export const colorFgYellow = "\x1b[33m";
-export const colorFgMagenta = "\x1b[35m";
+export const colorReset = '\x1b[0m';
+export const colorFgYellow = '\x1b[33m';
+export const colorFgMagenta = '\x1b[35m';

package/esm/document/utils/parse-regexp.util.js

@@ -0,0 +1,18 @@
+export function parseRegExp(str, options) {
+    const i = str.lastIndexOf('/');
+    if (str.startsWith('/') && i) {
+        const s = str.substring(1, i);
+        let flags = str.substring(i + 1);
+        if (options?.includeFlags) {
+            for (const f of options?.includeFlags)
+                if (!flags.includes(f))
+                    flags += f;
+        }
+        if (options?.excludeFlags) {
+            for (const f of options?.excludeFlags)
+                flags.replace(f, '');
+        }
+        return new RegExp(s, flags);
+    }
+    throw new TypeError(`"${str}" is not a valid RegExp string`);
+}

package/esm/exception/http-errors/bad-request.error.js

@@ -1,11 +1,11 @@
 import { translate } from '../../i18n/index.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 400 Bad Request
  * The server cannot or will not process the request due to something that is perceived to be a client error
  * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
  */
-export class BadRequestError extends OpraException {
+export class BadRequestError extends OpraHttpError {
     constructor() {
         super(...arguments);
         this.status = 400;
@@ -14,7 +14,7 @@ export class BadRequestError extends OpraException {
         super.init({
             message: translate('error:BAD_REQUEST', 'Bad request'),
             code: 'BAD_REQUEST',
-            ...issue
+            ...issue,
         });
     }
 }

package/esm/exception/http-errors/conflict.error.js

@@ -1,10 +1,10 @@
 import { translate } from '../../i18n/index.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 409 Conflict
  * This response is sent when a request conflicts with the current state of the server.
  */
-export class ConflictError extends OpraException {
+export class ConflictError extends OpraHttpError {
     constructor() {
         super(...arguments);
         this.status = 409;
@@ -13,7 +13,7 @@ export class ConflictError extends OpraException {
         super.init({
             message: translate('error:CONFLICT', 'Conflict'),
             code: 'CONFLICT',
-            ...issue
+            ...issue,
         });
     }
 }

package/esm/exception/http-errors/failed-dependency.error.js

@@ -1,10 +1,10 @@
 import { translate } from '../../i18n/index.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 424 Failed Dependency
  * The request failed due to failure of a previous request.
  */
-export class FailedDependencyError extends OpraException {
+export class FailedDependencyError extends OpraHttpError {
     constructor() {
         super(...arguments);
         this.status = 424;
@@ -13,7 +13,7 @@ export class FailedDependencyError extends OpraException {
         super.init({
             message: translate('error:FAILED_DEPENDENCY', 'The request failed due to failure of a previous request'),
             code: 'FAILED_DEPENDENCY',
-            ...issue
+            ...issue,
         });
     }
 }

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

@@ -1,13 +1,13 @@
 import { HttpStatusCode } from '../../http/index.js';
 import { translate } from '../../i18n/index.js';
-import { OpraException } from '../opra-exception.js';
+import { OpraHttpError } from '../opra-http-error.js';
 /**
  * 403 Forbidden
  * The client does not have access rights to the content; that is, it is unauthorized,
  * so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
  * the client's identity is known to the server.
  */
-export class ForbiddenError extends OpraException {
+export class ForbiddenError extends OpraHttpError {
     constructor() {
         super(...arguments);
         this.status = HttpStatusCode.FORBIDDEN;
@@ -16,7 +16,7 @@ export class ForbiddenError extends OpraException {
         super.init({
             message: translate('error:FORBIDDEN', 'You are not authorized to perform this action'),
             code: 'FORBIDDEN',
-            ...issue
+            ...issue,
         });
     }
 }