@opra/common 0.33.13 → 1.0.0-alpha.10

package/esm/document/common/data-type-map.js

@@ -0,0 +1,62 @@
+var _a, _b;
+import { ResponsiveMap } from '../../helpers/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { DataType } from '../data-type/data-type.js';
+const kMap = Symbol.for('kMap');
+const kCtorMap = Symbol.for('kCtorMap');
+/**
+ * @class DataTypeMap
+ */
+export class DataTypeMap {
+    constructor() {
+        this[_a] = new ResponsiveMap();
+        this[_b] = new WeakMap();
+    }
+    get size() {
+        return this[kMap].size;
+    }
+    forEach(callbackFn, thisArg) {
+        this[kMap].forEach(callbackFn, thisArg);
+    }
+    get(nameOrCtor) {
+        let name = typeof nameOrCtor === 'string' ? nameOrCtor : this[kCtorMap].get(nameOrCtor);
+        if (!name && typeof nameOrCtor === 'function') {
+            const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
+            name = metadata?.name;
+        }
+        if (!name && typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[DATATYPE_METADATA];
+            name = metadata?.name;
+        }
+        return name ? this[kMap].get(name) : undefined;
+    }
+    set(name, dataType) {
+        this[kMap].set(name, dataType);
+        if (dataType.ctor)
+            this[kCtorMap].set(dataType.ctor, name);
+        else if (dataType.instance)
+            this[kCtorMap].set(dataType.instance, name);
+    }
+    has(nameOrCtor) {
+        if (nameOrCtor instanceof DataType)
+            return !!nameOrCtor.name && this[kMap].has(nameOrCtor.name);
+        const name = typeof nameOrCtor === 'string' ? nameOrCtor : this[kCtorMap].get(nameOrCtor);
+        return name ? this[kMap].has(name) : false;
+    }
+    keys() {
+        return this[kMap].keys();
+    }
+    values() {
+        return this[kMap].values();
+    }
+    entries() {
+        return this[kMap].entries();
+    }
+    sort(compareFn) {
+        this[kMap].sort(compareFn);
+        return this;
+    }
+    [(_a = kMap, _b = kCtorMap, Symbol.iterator)]() {
+        return this[kMap][Symbol.iterator]();
+    }
+}

package/esm/document/common/document-element.js

@@ -0,0 +1,29 @@
+import { asMutable } from 'ts-gems';
+import { DocumentNode } from './document-node.js';
+/**
+ *
+ * @constructor DocumentElement
+ */
+export const DocumentElement = function (owner) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    const _this = asMutable(this);
+    Object.defineProperty(_this, 'node', {
+        value: new DocumentNode(this, owner?.node),
+        enumerable: false,
+        writable: true,
+    });
+    if (owner) {
+        Object.defineProperty(_this, 'owner', {
+            value: owner,
+            enumerable: false,
+            writable: true,
+        });
+    }
+};
+/**
+ * @class DocumentElement
+ */
+class DocumentElementClass {
+}
+DocumentElement.prototype = DocumentElementClass.prototype;

package/esm/document/common/document-init-context.js

@@ -0,0 +1,65 @@
+import { OpraDocumentError } from './opra-document-error.js';
+export class DocumentInitContext {
+    constructor(options) {
+        this.path = '';
+        this.error = new OpraDocumentError();
+        this.showErrorDetails = true;
+        this.maxErrors = options?.maxErrors || 0;
+        this.error.message = '';
+    }
+    addError(error) {
+        if (!this.error.details.length) {
+            if (error instanceof Error)
+                this.error.stack = error.stack;
+            else {
+                const e = new Error();
+                Error.captureStackTrace(e, this.addError);
+                this.error.stack = e.stack;
+            }
+        }
+        // @ts-ignore
+        this.error.add({
+            message: typeof error === 'string' ? error : error.message,
+            path: this.path,
+            ...(typeof error === 'object' ? error : undefined),
+        });
+        if (this.error.details.length >= this.maxErrors)
+            throw this.error;
+    }
+    enter(path, fn) {
+        const oldPath = this.path;
+        this.path = this.path + path;
+        try {
+            return fn();
+        }
+        catch (e) {
+            if (e !== this.error) {
+                this.addError(e);
+            }
+        }
+        finally {
+            this.path = oldPath;
+        }
+    }
+    async enterAsync(path, fn) {
+        const oldPath = this.path;
+        this.path = this.path + path;
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (e !== this.error)
+                this.addError(e);
+        }
+        finally {
+            this.path = oldPath;
+        }
+    }
+    extend(args) {
+        const out = {
+            ...args,
+        };
+        Object.setPrototypeOf(out, this);
+        return out;
+    }
+}

package/esm/document/common/document-node.js

@@ -0,0 +1,120 @@
+import { OpraSchema } from '../../schema/index.js';
+import { DATATYPE_METADATA, kDataTypeMap, kTypeNSMap } from '../constants.js';
+/**
+ * @class DocumentNode
+ */
+export class DocumentNode {
+    constructor(element, parent) {
+        this.element = element;
+        this.parent = parent;
+    }
+    getDocument() {
+        if (this._document)
+            return this._document;
+        if (this.element[kTypeNSMap])
+            return this.element;
+        if (this.parent)
+            return (this._document = this.parent.getDocument());
+        // istanbul ignore next
+        throw new Error('ApiDocument not found in document tree');
+    }
+    hasDataType(nameOrCtor) {
+        const result = this[kDataTypeMap]?.has(nameOrCtor);
+        if (result)
+            return result;
+        return this.parent ? this.parent.hasDataType(nameOrCtor) : false;
+    }
+    findDataType(nameOrCtor) {
+        const result = this[kDataTypeMap]?.get(nameOrCtor);
+        if (result)
+            return result;
+        return this.parent ? this.parent.findDataType(nameOrCtor) : undefined;
+    }
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor) {
+        const dt = this.findDataType(nameOrCtor);
+        if (dt)
+            return dt;
+        let name = '';
+        if (typeof nameOrCtor === 'function') {
+            const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
+            name = metadata.name;
+        }
+        else if (typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[DATATYPE_METADATA];
+            name = metadata?.name;
+        }
+        if (typeof nameOrCtor === 'string')
+            name = nameOrCtor;
+        throw new TypeError(`Unknown data type` + (name ? ' (' + name + ')' : ''));
+    }
+    getDataTypeNameWithNs(dataType) {
+        if (!dataType.name)
+            return;
+        const ns = this.getDocument().getDataTypeNs(dataType);
+        return ns ? ns + ':' + dataType.name : dataType.name;
+    }
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a ComplexType
+     * @param nameOrCtor
+     */
+    getComplexType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.ComplexType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name}" is not a ComplexType`);
+    }
+    /**
+     * Returns SimpleType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a SimpleType
+     * @param nameOrCtor
+     */
+    getSimpleType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.SimpleType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a SimpleType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a EnumType
+     * @param nameOrCtor
+     */
+    getEnumType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.EnumType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a EnumType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MappedType
+     * @param nameOrCtor
+     */
+    getMappedType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.MappedType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MappedType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MixinType
+     * @param nameOrCtor
+     */
+    getMixinType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.MixinType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
+    }
+}

package/esm/document/common/opra-document-error.js

@@ -0,0 +1,11 @@
+import { OpraException } from '../../exception/opra-exception.js';
+export class OpraDocumentError extends OpraException {
+    constructor() {
+        super('');
+        this.details = [];
+    }
+    add(detail) {
+        this.details.push(detail);
+        return this;
+    }
+}

package/esm/document/common/value.js

@@ -0,0 +1,30 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from './document-element.js';
+export const Value = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    DocumentElement.call(this, owner);
+    // if (args.name && !PARAMETER_NAME_PATTERN.test(args.name))
+    //   throw new TypeError(`"${args.name}" is not a valid parameter name`);
+    const _this = asMutable(this);
+    _this.description = initArgs.description;
+    _this.type = initArgs.type;
+    _this.examples = initArgs.examples;
+    _this.isArray = initArgs.isArray;
+};
+/**
+ * @class Value
+ */
+class ValueClass extends DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return omitUndefined({
+            type: this.type ? (typeName ? typeName : this.type.toJSON()) : 'any',
+            description: this.description,
+            isArray: this.isArray,
+            examples: this.examples,
+        });
+    }
+}
+Value.prototype = ValueClass.prototype;

package/esm/document/constants.js

@@ -1,6 +1,12 @@
-export const DATATYPE_METADATA = Symbol('DATATYPE_METADATA');
-export const RESOURCE_METADATA = Symbol('RESOURCE_METADATA');
-export const DECORATOR = Symbol('DECORATOR');
-export const NAMESPACE_PATTERN = /([a-z$_]\w+)(?::.+)?/i;
-export const TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
-export const SORT_FIELD_PATTERN = /^([+-])?([a-z$_][\w.]+)$/;
+export const DATATYPE_METADATA = Symbol.for('opra.type.metadata');
+export const HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
+export const DECODER = Symbol.for('opra.type.decoder');
+export const ENCODER = Symbol('opra.type.encoder');
+export const DECORATOR = Symbol.for('DECORATOR');
+export const BUILTIN = Symbol.for('BUILTIN');
+export const NAMESPACE_PATTERN = /([a-z$_]\w+):(.+)/i;
+export const CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
+export const EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
+export const kDataTypeMap = Symbol.for('kDataTypeMap');
+export const kCtorMap = Symbol.for('kCtorMap');
+export const kTypeNSMap = Symbol.for('kTypeNSMap');

package/esm/document/data-type/api-field.js

@@ -0,0 +1,66 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DECORATOR } from '../constants.js';
+import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+/**
+ * @constructor ApiField
+ * @decorator ApiField
+ */
+export const ApiField = function (...args) {
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        return ApiField[DECORATOR](options);
+    }
+    // Constructor
+    const [owner, initArgs] = args;
+    DocumentElement.call(this, owner);
+    const _this = asMutable(this);
+    _this.name = initArgs.name;
+    const origin = initArgs.origin || owner;
+    /* istanbul ignore next */
+    if (!(origin instanceof ComplexTypeBase)) {
+        throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
+    }
+    _this.origin = origin;
+    _this.type = initArgs.type || owner.node.getDataType('any');
+    _this.description = initArgs.description;
+    _this.isArray = initArgs.isArray;
+    _this.default = initArgs.default;
+    _this.fixed = initArgs.fixed;
+    _this.required = initArgs.required;
+    _this.exclusive = initArgs.exclusive;
+    _this.translatable = initArgs.translatable;
+    _this.deprecated = initArgs.deprecated;
+    _this.readonly = initArgs.readonly;
+    _this.writeonly = initArgs.writeonly;
+    _this.examples = initArgs.examples;
+};
+/**
+ *
+ * @class ApiField
+ */
+class ApiFieldClass extends DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return omitUndefined({
+            type: typeName ? typeName : this.type?.toJSON(),
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            fixed: this.fixed,
+            required: this.required,
+            exclusive: this.exclusive,
+            translatable: this.translatable,
+            deprecated: this.deprecated,
+            readonly: this.readonly,
+            writeonly: this.writeonly,
+            examples: this.examples,
+        });
+    }
+}
+ApiField.prototype = ApiFieldClass.prototype;
+Object.assign(ApiField, ApiFieldDecorator);
+ApiField[DECORATOR] = ApiFieldDecorator;

package/esm/document/data-type/complex-type-base.js

@@ -0,0 +1,185 @@
+import { asMutable } from 'ts-gems';
+import { validator, vg } from 'valgen';
+import { parseFieldsProjection, ResponsiveMap } from '../../helpers/index.js';
+import { translate } from '../../i18n/index.js';
+import { DataType } from './data-type.js';
+export const FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
+/**
+ *
+ * @constructor
+ */
+export const ComplexTypeBase = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // Constructor
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.fields = new ResponsiveMap();
+};
+/**
+ *
+ */
+class ComplexTypeBaseClass extends DataType {
+    /**
+     *
+     */
+    findField(nameOrPath) {
+        if (nameOrPath.includes('.')) {
+            const fieldPath = this.parseFieldPath(nameOrPath);
+            const lastItem = fieldPath.pop();
+            return lastItem?.field;
+        }
+        return this.fields.get(nameOrPath);
+    }
+    /**
+     *
+     */
+    getField(nameOrPath) {
+        const field = this.findField(nameOrPath);
+        if (!field)
+            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        return field;
+    }
+    /**
+     *
+     */
+    parseFieldPath(fieldPath, options) {
+        let dataType = this;
+        let field;
+        const arr = fieldPath.split('.');
+        const len = arr.length;
+        const out = [];
+        const objectType = this.owner.node.getDataType('object');
+        const allowSigns = options?.allowSigns;
+        const getStrPath = () => out.map(x => x.fieldName).join('.');
+        for (let i = 0; i < len; i++) {
+            const item = {
+                fieldName: arr[i],
+                dataType: objectType,
+            };
+            out.push(item);
+            const m = FIELD_PATH_PATTERN.exec(arr[i]);
+            if (!m)
+                throw new TypeError(`Invalid field name (${getStrPath()})`);
+            if (m[1]) {
+                if ((i === 0 && allowSigns === 'first') || allowSigns === 'each')
+                    item.sign = m[1];
+                item.fieldName = m[2];
+            }
+            if (dataType) {
+                if (dataType instanceof ComplexTypeBase) {
+                    field = dataType.fields.get(item.fieldName);
+                    if (field) {
+                        item.fieldName = field.name;
+                        item.field = field;
+                        item.dataType = field.type;
+                        dataType = field.type;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === true) {
+                        item.additionalField = true;
+                        item.dataType = objectType;
+                        dataType = undefined;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === 'type' && dataType.additionalFields?.[1] instanceof DataType) {
+                        item.additionalField = true;
+                        item.dataType = dataType.additionalFields[1];
+                        dataType = dataType.additionalFields[1];
+                        continue;
+                    }
+                    throw new Error(`Unknown field (${out.map(x => x.fieldName).join('.')})`);
+                }
+                throw new TypeError(`"${out.map(x => x.fieldName).join('.')}" field is not a complex type and has no child fields`);
+            }
+            item.additionalField = true;
+            item.dataType = objectType;
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath, options) {
+        return this.parseFieldPath(fieldPath, options)
+            .map(x => (x.sign || '') + x.fieldName)
+            .join('.');
+    }
+    /**
+     *
+     */
+    generateCodec(codec, options) {
+        const projection = Array.isArray(options?.projection)
+            ? parseFieldsProjection(options.projection)
+            : options?.projection;
+        const schema = this._generateSchema(codec, { ...options, projection, currentPath: '' });
+        let additionalFields;
+        if (this.additionalFields instanceof DataType) {
+            additionalFields = this.additionalFields.generateCodec(codec, options);
+        }
+        else if (typeof this.additionalFields === 'boolean')
+            additionalFields = this.additionalFields;
+        else if (Array.isArray(this.additionalFields)) {
+            if (this.additionalFields.length < 2)
+                additionalFields = 'error';
+            else {
+                const message = additionalFields[1];
+                additionalFields = validator((input, context, _this) => context.fail(_this, message, input));
+            }
+        }
+        return vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields,
+            name: this.name,
+            coerce: true,
+            caseInSensitive: options?.caseInSensitive,
+            onFail: options?.onFail,
+        });
+    }
+    _generateSchema(codec, context) {
+        const schema = {};
+        const { currentPath, projection } = context;
+        const pickList = !!(projection && Object.values(projection).find(p => !p.sign));
+        // Process fields
+        let fieldName;
+        for (const field of this.fields.values()) {
+            if ((context.ignoreReadonlyFields && field.readonly) || (context.ignoreWriteonlyFields && field.writeonly)) {
+                schema[field.name] = vg.isUndefined({ coerce: true });
+                continue;
+            }
+            fieldName = field.name;
+            let p;
+            if (projection !== '*') {
+                p = projection?.[fieldName.toLowerCase()];
+                if (
+                /** Ignore if field is omitted */
+                p?.sign === '-' ||
+                    /** Ignore if default fields ignored and field is not in projection */
+                    (pickList && !p) ||
+                    /** Ignore if default fields enabled and fields is exclusive */
+                    (!pickList && field.exclusive && !p)) {
+                    schema[field.name] = vg.isUndefined({ coerce: true });
+                    continue;
+                }
+            }
+            const fn = this._generateFieldCodec(codec, field, {
+                ...context,
+                partial: context.partial === 'deep' ? context.partial : undefined,
+                projection: projection !== '*' ? projection : p?.projection,
+                currentPath: currentPath + (currentPath ? '.' : '') + fieldName,
+            });
+            schema[fieldName] = context.partial || !field.required ? vg.optional(fn) : vg.required(fn);
+        }
+        return schema;
+    }
+    _generateFieldCodec(codec, field, context) {
+        let fn = field.type.generateCodec(codec, context);
+        if (field.fixed)
+            fn = vg.isEnum([field.fixed]);
+        if (field.isArray)
+            fn = vg.isArray(fn);
+        return fn;
+    }
+}
+ComplexTypeBase.prototype = ComplexTypeBaseClass.prototype;