@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -1,270 +0,0 @@
-import { vg } from 'valgen';
-import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
-import { translate } from '../../i18n/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { SORT_FIELD_PATTERN } from '../constants.js';
-import { DataType } from './data-type.js';
-import { ApiField } from './field.js';
-/**
- * @class ComplexType
- */
-export class ComplexTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.ComplexType.Kind;
-        this.fields = new ResponsiveMap();
-        const own = this.own = {};
-        own.ctor = init.ctor;
-        if (init.base) {
-            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'MixinType'))
-                throw new TypeError('"base" argument must be one of ComplexType or MappedType or MixinType');
-            own.ctor = own.ctor || init.base.ctor;
-        }
-        own.additionalFields = init?.additionalFields;
-        own.embedded = init?.embedded;
-        own.fields = new ResponsiveMap();
-        this.kind = OpraSchema.ComplexType.Kind;
-        this.base = init?.base;
-        this.ctor = own.ctor || Object;
-        this.abstract = init.abstract;
-        this.additionalFields = own.additionalFields;
-        this.isEmbedded = this.isEmbedded || init.embedded;
-        if (this.base?.additionalFields === true && this.additionalFields !== true)
-            this.additionalFields = true;
-        else if (this.base?.additionalFields === 'error' && !this.additionalFields)
-            this.additionalFields = 'error';
-        if (this.base) {
-            if (this.base.fields)
-                for (const [k, el] of this.base.fields.entries()) {
-                    const field = new ApiField(this, el);
-                    this.fields.set(k, field);
-                }
-        }
-        if (init.fields) {
-            for (const [k, el] of Object.entries(init.fields)) {
-                const field = new ApiField(this, el);
-                this.own.fields.set(field.name, field);
-                this.fields.set(k, field);
-            }
-        }
-    }
-    findField(nameOrPath) {
-        let field;
-        if (nameOrPath.includes('.')) {
-            for (const [, f] of this.iteratePath(nameOrPath, true)) {
-                if (!f)
-                    return;
-                field = f;
-            }
-            return field;
-        }
-        return this.fields.get(nameOrPath);
-    }
-    getField(nameOrPath) {
-        let field;
-        if (nameOrPath.includes('.')) {
-            for (const [, f] of this.iteratePath(nameOrPath)) {
-                field = f;
-            }
-        }
-        else
-            field = this.fields.get(nameOrPath);
-        if (!field)
-            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
-        return field;
-    }
-    iteratePath(path, silent) {
-        const arr = path.split('.');
-        const len = arr.length;
-        let dataType = this;
-        let field;
-        let curPath = '';
-        let s;
-        let i = -1;
-        const ComplexType = Object.getPrototypeOf(this).constructor;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                if (i < len) {
-                    s = arr[i];
-                    if (dataType && !(dataType instanceof ComplexType)) {
-                        if (silent)
-                            return { done: true, value: [] };
-                        throw new TypeError(`"${curPath}" field is not a complex type and has no child fields`);
-                    }
-                    field = dataType?.fields.get(s);
-                    if (field) {
-                        curPath += (curPath ? '.' : '') + field.name;
-                        dataType = field.type;
-                    }
-                    else {
-                        curPath += (curPath ? '.' : '') + s;
-                        if (dataType && !dataType.additionalFields) {
-                            if (silent)
-                                return { done: true, value: [] };
-                            throw new Error(translate('error:UNKNOWN_FIELD', { field: curPath }));
-                        }
-                    }
-                }
-                return {
-                    done: i >= len,
-                    value: [field?.name || s, field, curPath]
-                };
-            }
-        };
-    }
-    normalizeFieldNames(fieldNames, allowSortSigns) {
-        const array = (Array.isArray(fieldNames) ? fieldNames : [fieldNames])
-            .map(s => {
-            let sign = '';
-            if (allowSortSigns) {
-                const m = SORT_FIELD_PATTERN.exec(s);
-                sign = (m && m[1]) || '';
-                s = (m && m[2]) || s;
-            }
-            let curPath = '';
-            for (const [, , p] of this.iteratePath(s)) {
-                curPath = p;
-            }
-            return sign + curPath;
-        }).flat();
-        return array.length ? array : undefined;
-    }
-    exportSchema(options) {
-        const out = super.exportSchema(options);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema(options)) : undefined,
-            abstract: this.abstract,
-            additionalFields: this.own.additionalFields instanceof DataType
-                ? (this.own.additionalFields.name
-                    ? this.own.additionalFields.name
-                    : this.own.additionalFields.exportSchema(options))
-                : this.own.additionalFields
-        }));
-        if (this.own.fields.size) {
-            const fields = out.fields = {};
-            for (const field of this.own.fields.values()) {
-                fields[field.name] = field.exportSchema(options);
-            }
-        }
-        return omitUndefined(out);
-    }
-    isTypeOf(t) {
-        return t === this.own?.ctor;
-    }
-    extendsFrom(t) {
-        const base = t instanceof DataType ? t : this.document.getDataType(t);
-        if (this.base) {
-            if (this.base === base)
-                return true;
-            return this.base.extendsFrom(base);
-        }
-        return false;
-    }
-    generateCodec(codec, options) {
-        const schema = this.generateCodecSchema(codec, options);
-        const additionalFields = this.additionalFields instanceof DataType
-            ? this.additionalFields.generateCodec(codec, {
-                operation: options?.operation,
-                caseSensitive: options?.caseSensitive,
-                partial: options?.partial
-            })
-            : this.additionalFields;
-        return vg.isObject(schema, {
-            ctor: this.ctor,
-            additionalFields,
-            name: this.name,
-            caseInSensitive: !options?.caseSensitive,
-            onFail: options?.onFail
-        });
-    }
-    generateCodecSchema(codec, options) {
-        const opts = {
-            ...options,
-            pick: (options?.pick || []).map(x => x.toLowerCase()),
-            omit: (options?.omit || []).map(x => x.toLowerCase()),
-            overwriteFields: options?.overwriteFields ? this._buildOverwriteFieldsTree(options.overwriteFields) : undefined,
-        };
-        return this._generateCodecSchema(codec, opts);
-    }
-    _generateCodecSchema(codec, options) {
-        const schema = {};
-        const overwriteFields = options?.overwriteFields;
-        const optionsPick = options?.pick || [];
-        const optionsOmit = options?.omit || [];
-        const fieldNames = [...this.fields.keys()];
-        // Add field name from overwriteFields which doesn't exist in this.fields
-        if (overwriteFields) {
-            for (const k of Object.keys(overwriteFields)) {
-                if (!this.fields.has(k))
-                    fieldNames.push(k);
-            }
-        }
-        // Process fields
-        for (const fieldName of fieldNames) {
-            const lowerName = fieldName.toLowerCase();
-            const overwriteFieldInit = overwriteFields?.[fieldName];
-            // If field omitted or not in pick list we ignore it unless overwriteField defined
-            if (!overwriteFieldInit &&
-                (optionsOmit.find(x => x === lowerName) ||
-                    (optionsPick.length && !optionsPick.find(x => x === lowerName || x.startsWith(lowerName + '.')))))
-                continue;
-            const subOptions = {
-                ...options,
-                pick: optionsPick
-                    .filter(x => x.startsWith(lowerName + '.'))
-                    .map(x => x.substring(x.indexOf('.') + 1)),
-                omit: optionsOmit
-                    .filter(x => x.startsWith(lowerName + '.'))
-                    .map(x => x.substring(x.indexOf('.') + 1)),
-                overwriteFields: overwriteFieldInit?.overrideFields
-            };
-            let f;
-            if (overwriteFieldInit) {
-                const field = this.fields.get(fieldName);
-                const init = { ...field, ...overwriteFieldInit, name: fieldName };
-                if (!(init.type instanceof DataType))
-                    init.type = this.document.getDataType(init.type || 'any');
-                f = new ApiField(this, init);
-            }
-            else
-                f = this.getField(fieldName);
-            schema[f.name] = f.generateCodec(codec, subOptions);
-        }
-        return schema;
-    }
-    _buildOverwriteFieldsTree(obj) {
-        const tree = {};
-        for (let k of Object.keys(obj)) {
-            const v = obj[k];
-            if (!k.includes('.')) {
-                // Fix field name
-                const field = this.fields.get(k);
-                if (field)
-                    k = field.name;
-                tree[k] = { ...tree[k], ...v };
-                continue;
-            }
-            const keyPath = k.split('.');
-            let subTree = tree;
-            while (keyPath.length) {
-                let j = keyPath.shift();
-                // Fix field name
-                const field = this.fields.get(j);
-                if (field)
-                    j = field.name;
-                const treeItem = subTree[j] = subTree[j] || {};
-                if (keyPath.length) {
-                    subTree = treeItem.overrideFields = treeItem.overrideFields || {};
-                }
-                else
-                    Object.assign(treeItem, v);
-            }
-        }
-        return tree;
-    }
-}

package/esm/document/data-type/enum-type-class.js

@@ -1,35 +0,0 @@
-import { vg } from 'valgen';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-import { DataType } from './data-type.js';
-export class EnumTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.EnumType.Kind;
-        this.enumObject = init.enumObject;
-        this.base = init.base;
-        this.ownValues = { ...init.values };
-        this.values = { ...this.base?.values, ...this.ownValues };
-        this.decode = vg.isEnum(Object.keys(this.values));
-        this.encode = vg.isEnum(Object.keys(this.values));
-    }
-    isTypeOf(t) {
-        return t[DATATYPE_METADATA] &&
-            t[DATATYPE_METADATA] === this.enumObject?.[DATATYPE_METADATA];
-    }
-    exportSchema() {
-        const out = super.exportSchema();
-        out.values = {};
-        Object.entries(this.values).forEach(([k, i]) => {
-            out.values[k] = omitUndefined({ key: i.key, description: i.description });
-        });
-        return out;
-    }
-    generateCodec(codec) {
-        if (codec === 'encode')
-            return this.encode;
-        else
-            return this.decode;
-    }
-}

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

@@ -1,63 +0,0 @@
-import { isUndefined, vg } from 'valgen';
-import { omitUndefined } from '../../helpers/index.js';
-export class FieldClass {
-    constructor(owner, init) {
-        this.owner = owner;
-        this.origin = init.origin || owner;
-        this.type = init.type;
-        this.designType = init.designType;
-        this.name = init.name;
-        this.description = init.description;
-        this.isArray = init.isArray;
-        this.default = init.default;
-        this.fixed = init.fixed;
-        this.required = init.required;
-        this.readonly = init.readonly;
-        this.writeonly = init.writeonly;
-        this.exclusive = init.exclusive;
-        this.translatable = init.translatable;
-        this.deprecated = init.deprecated;
-        this.examples = init.examples;
-        this.pattern = init.pattern ?
-            (init.pattern instanceof RegExp ? init.pattern : new RegExp(init.pattern)) : undefined;
-        this.partialUpdate = init.partialUpdate;
-    }
-    exportSchema(options) {
-        const isEmbedded = !this.type?.name ||
-            (this.type?.kind === 'ComplexType' && this.type.isEmbedded);
-        return omitUndefined({
-            type: this.type
-                ? (isEmbedded ? this.type.exportSchema(options) : this.type.name)
-                : undefined,
-            description: this.description,
-            isArray: this.isArray,
-            default: this.default,
-            fixed: this.fixed,
-            required: this.required,
-            readonly: this.readonly,
-            writeonly: this.writeonly,
-            exclusive: this.exclusive,
-            translatable: this.translatable,
-            deprecated: this.deprecated,
-            examples: this.examples,
-            pattern: this.pattern ? String(this.pattern) : undefined,
-            partialUpdate: this.partialUpdate,
-        });
-    }
-    generateCodec(codec, options) {
-        if (options?.operation === 'read' && this.writeonly)
-            return isUndefined;
-        if (options?.operation === 'write' && this.readonly)
-            return isUndefined;
-        let fn = this.type.generateCodec(codec, {
-            ...options,
-            designType: this.designType,
-            partial: options?.partial && (this.partialUpdate || !this.isArray)
-        });
-        if (this.pattern)
-            fn = vg.allOf(fn, vg.isRegExp(this.pattern));
-        if (this.isArray)
-            fn = vg.isArray(fn);
-        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
-    }
-}

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

@@ -1,21 +0,0 @@
-import merge from 'putil-merge';
-import { DECORATOR } from '../constants.js';
-import { FieldClass } from './field-class.js';
-import { FieldDecorator } from './field-decorator.js';
-/**
- * @class ApiField
- * @decorator ApiField
- */
-export const ApiField = function (...args) {
-    // Decorator
-    if (!this) {
-        const [options] = args;
-        return ApiField[DECORATOR](options);
-    }
-    // Constructor
-    const [owner, init] = args;
-    merge(this, new FieldClass(owner, init), { descriptor: true });
-};
-ApiField.prototype = FieldClass.prototype;
-Object.assign(ApiField, FieldDecorator);
-ApiField[DECORATOR] = FieldDecorator;

package/esm/document/data-type/mapped-type-class.js

@@ -1,48 +0,0 @@
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { ComplexTypeClass } from './complex-type-class.js';
-export class MappedTypeClass extends ComplexTypeClass {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.MappedType.Kind;
-        const own = this.own;
-        own.pick = init.pick;
-        own.omit = init.omit;
-        own.partial = init.partial;
-        this.kind = OpraSchema.MappedType.Kind;
-        this.pick = own.pick;
-        this.omit = own.omit;
-        this.partial = own.partial;
-        const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
-        for (const fieldName of this.fields.keys()) {
-            if (!isInheritedPredicate(fieldName)) {
-                this.fields.delete(fieldName);
-            }
-            if (this.partial === true || (Array.isArray(this.partial) && this.partial.includes(fieldName))) {
-                const f = this.fields.get(fieldName);
-                if (f)
-                    f.required = false;
-            }
-        }
-    }
-    exportSchema() {
-        const out = super.exportSchema();
-        Object.assign(out, omitUndefined({
-            pick: this.own.pick,
-            omit: this.own.omit,
-            partial: this.own.partial
-        }));
-        return out;
-    }
-}
-export function getIsInheritedPredicateFn(pick, omit) {
-    const pickKeys = pick?.map(x => String(x).toLowerCase());
-    const omitKeys = omit?.map(x => String(x).toLowerCase());
-    return (propertyName) => {
-        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
-            return false;
-        if (pickKeys)
-            return pickKeys.includes(propertyName.toLowerCase());
-        return true;
-    };
-}

package/esm/document/data-type/mixin-type-class.js

@@ -1,34 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { ComplexType } from './complex-type.js';
-import { MappedType } from './mapped-type.js';
-export class MixinTypeClass extends ComplexType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.MixinType.Kind;
-        const own = this.own;
-        own.types = [];
-        const MixinType = Object.getPrototypeOf(this).constructor;
-        for (const base of init.types) {
-            if (!(base instanceof ComplexType || base instanceof MixinType || base instanceof MappedType))
-                throw new TypeError(`${OpraSchema.MixinType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
-                    `${OpraSchema.MixinType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
-            own.types.push(base);
-            if (base.additionalFields === true && this.additionalFields !== true) {
-                // @ts-ignore
-                this.additionalFields = true;
-            }
-            else if (base.additionalFields === 'error' && !this.additionalFields) {
-                // @ts-ignore
-                this.additionalFields = 'error';
-            }
-            this.fields.setAll(base.fields);
-        }
-        this.types = [...own.types];
-    }
-    // @ts-ignore
-    exportSchema() {
-        const out = super.exportSchema();
-        out.types = this.own.types.map(t => t.name ? t.name : t.exportSchema());
-        return out;
-    }
-}

package/esm/document/data-type/simple-type-class.js

@@ -1,33 +0,0 @@
-import { isAny } from 'valgen';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from './data-type.js';
-/**
- * @class SimpleType
- */
-export class SimpleTypeClass extends DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.SimpleType.Kind;
-        this.base = init.base;
-        this.decode = init.decoder || init.base?.decode || isAny;
-        this.encode = init.encoder || init.base?.encode || isAny;
-    }
-    exportSchema(options) {
-        // noinspection UnnecessaryLocalVariableJS
-        const out = super.exportSchema(options);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema(options)) : undefined,
-            decode: !options?.webSafe ? this.decode : undefined,
-            encode: !options?.webSafe ? this.encode : undefined
-        }));
-        return out;
-    }
-    generateCodec(codec) {
-        if (codec === 'encode')
-            return this.encode;
-        else
-            return this.decode;
-    }
-}

package/esm/document/data-type/simple-type.decorator.js

@@ -1,15 +0,0 @@
-import omit from 'lodash.omit';
-import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA, TYPENAME_PATTERN } from '../constants.js';
-export function SimpleTypeDecorator(options) {
-    return function (target) {
-        let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-        name = name.charAt(0).toLowerCase() + name.substring(1);
-        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
-        metadata.kind = OpraSchema.SimpleType.Kind;
-        metadata.name = name;
-        if (options)
-            Object.assign(metadata, omit(options, ['kind', 'name']));
-        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
-    };
-}

package/esm/document/document-base.js

@@ -1,20 +0,0 @@
-import { cloneObject, omitUndefined } from '../helpers/index.js';
-import { OpraSchema } from '../schema/index.js';
-export class DocumentBase {
-    constructor() {
-        this.info = {
-            version: '',
-            title: ''
-        };
-    }
-    /**
-     * Export as OPRA schema definition object
-     */
-    exportSchema() {
-        return omitUndefined({
-            version: OpraSchema.SpecVersion,
-            url: this.url,
-            info: cloneObject(this.info, true)
-        });
-    }
-}