@opra/common 0.33.13 → 1.0.0-alpha.1

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)
-        });
-    }
-}

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

@@ -1,258 +0,0 @@
-import { cloneObject, resolveThunk, ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { ApiDocument } from '../api-document.js';
-import { RESOURCE_METADATA } from '../constants.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { EnumType } from '../data-type/enum-type.js';
-import { Collection } from '../resource/collection.js';
-import { Container } from '../resource/container.js';
-import { Singleton } from '../resource/singleton.js';
-import { Storage } from '../resource/storage.js';
-import { TypeDocumentFactory } from './type-document-factory.js';
-/**
- * @class ApiDocumentFactory
- */
-export class ApiDocumentFactory extends TypeDocumentFactory {
-    constructor() {
-        super(...arguments);
-        this.resourceQueue = new ResponsiveMap();
-    }
-    /**
-     * Creates ApiDocument instance from given schema object
-     * @param init
-     */
-    static async createDocument(init) {
-        const factory = new ApiDocumentFactory();
-        const document = factory.document = new ApiDocument();
-        await factory.initDocument(init);
-        return document;
-    }
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static async createDocumentFromUrl(url) {
-        const factory = new ApiDocumentFactory();
-        const document = factory.document = new ApiDocument();
-        await factory.initDocumentFromUrl(url);
-        return document;
-    }
-    async initDocument(init) {
-        await super.initDocument(init);
-        const processContainer = async (container, containerInit) => {
-            if (!containerInit.resources)
-                return;
-            if (Array.isArray(containerInit.resources)) {
-                for (const thunk of containerInit.resources) {
-                    const initArguments = await this.importResourceInstance(thunk);
-                    container.resources.set(initArguments.name, await this.createResource(container, initArguments));
-                }
-            }
-            else
-                for (const [name, schema] of Object.entries(containerInit.resources)) {
-                    const initArguments = await this.importResourceSchema(name, schema);
-                    container.resources.set(initArguments.name, await this.createResource(container, initArguments));
-                }
-            container.resources.sort();
-        };
-        if (init.root) {
-            this.curPath.push('/root');
-            await processContainer(this.document.root, init.root);
-            this.curPath.pop();
-            this.document.invalidate();
-        }
-        return this.document;
-    }
-    async importResourceSchema(name, schema) {
-        const convertEndpoints = async (source) => {
-            if (!source)
-                return;
-            const output = {};
-            for (const [endpointName, endpointSchema] of Object.entries(source)) {
-                /* istanbul ignore next */
-                if (!endpointSchema)
-                    continue;
-                const outputEndpoint = output[endpointName] = { ...endpointSchema };
-                let parameters;
-                // Resolve lazy type
-                if (endpointSchema.returnType) {
-                    outputEndpoint.returnType = await this.importDataType(endpointSchema.returnType);
-                }
-                if (endpointSchema.parameters) {
-                    parameters = outputEndpoint.parameters = {};
-                    for (const [kP, oP] of Object.entries(endpointSchema.parameters)) {
-                        if (oP.enum) {
-                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
-                        }
-                        parameters[kP] = {
-                            ...oP,
-                            type: await this.importDataType(oP.type || 'any')
-                        };
-                    }
-                }
-            }
-            return output;
-        };
-        if (schema.kind === 'Collection') {
-            return {
-                ...schema,
-                kind: schema.kind,
-                name,
-                type: await this.importDataType(schema.type),
-                actions: await convertEndpoints(schema.actions),
-                operations: await convertEndpoints(schema.operations),
-            };
-        }
-        else if (schema.kind === 'Singleton') {
-            return {
-                ...schema,
-                kind: schema.kind,
-                name,
-                type: await this.importDataType(schema.type),
-                actions: await convertEndpoints(schema.actions),
-                operations: await convertEndpoints(schema.operations),
-            };
-        }
-        else if (schema.kind === 'Storage') {
-            return {
-                ...schema,
-                name,
-                actions: await convertEndpoints(schema.actions),
-                operations: await convertEndpoints(schema.operations),
-            };
-        }
-        else if (schema.kind === 'Container') {
-            const resources = [];
-            if (schema.resources) {
-                for (const [k, o] of Object.entries(schema.resources)) {
-                    const rinit = await this.importResourceSchema(k, o);
-                    resources.push(rinit);
-                }
-            }
-            return {
-                ...schema,
-                name,
-                resources,
-                actions: await convertEndpoints(schema.actions)
-            };
-        }
-        throw new TypeError(`Can not import resource schema (${schema.kind})`);
-    }
-    async importResourceInstance(thunk) {
-        thunk = await resolveThunk(thunk);
-        let ctor;
-        let metadata;
-        let instance;
-        if (typeof thunk === 'function') {
-            ctor = thunk;
-        }
-        else {
-            ctor = Object.getPrototypeOf(thunk).constructor;
-            instance = thunk;
-            if (!Reflect.hasMetadata(RESOURCE_METADATA, ctor) &&
-                OpraSchema.isResource(thunk) && typeof thunk.controller === 'object') {
-                ctor = Object.getPrototypeOf(thunk.controller).constructor;
-                metadata = thunk;
-                instance = thunk.controller;
-            }
-        }
-        metadata = metadata || Reflect.getMetadata(RESOURCE_METADATA, ctor);
-        if (!metadata && OpraSchema.isResource(metadata))
-            throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
-        const convertEndpoints = async (source) => {
-            if (!source)
-                return;
-            const output = {};
-            for (const [kA, oA] of Object.entries(source)) {
-                const o = output[kA] = { ...oA };
-                // Resolve lazy type
-                if (oA.returnType) {
-                    o.returnType = await this.importDataType(oA.returnType);
-                }
-                if (oA.parameters) {
-                    const parameters = o.parameters = {};
-                    for (const [kP, oP] of Object.entries(oA.parameters)) {
-                        if (oP.enum) {
-                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
-                        }
-                        parameters[kP] = {
-                            ...oP,
-                            type: await this.importDataType(oP.type || 'any')
-                        };
-                    }
-                }
-                if (oA.options?.inputOverwriteFields) {
-                    const inputOverwriteFields = {};
-                    for (const [kP, oP] of Object.entries(oA.options.inputOverwriteFields)) {
-                        if (oP.enum) {
-                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
-                        }
-                        inputOverwriteFields[kP] = { ...oP, };
-                        if (oP.type)
-                            inputOverwriteFields[kP].type = await this.importDataType(oP.type);
-                    }
-                    o.options.inputOverwriteFields = inputOverwriteFields;
-                }
-                if (oA.options?.outputOverwriteFields) {
-                    const outputOverwriteFields = {};
-                    for (const [kP, oP] of Object.entries(oA.options.outputOverwriteFields)) {
-                        if (oP.enum) {
-                            oP.type = EnumType(oP.enum, { name: kP + 'Enum' });
-                        }
-                        outputOverwriteFields[kP] = { ...oP };
-                        if (oP.type)
-                            outputOverwriteFields[kP].type = await this.importDataType(oP.type);
-                    }
-                    o.options.outputOverwriteFields = outputOverwriteFields;
-                }
-            }
-            return output;
-        };
-        // Clone metadata to prevent changing its contents
-        const initArguments = cloneObject(metadata);
-        initArguments.controller = instance;
-        initArguments.ctor = ctor;
-        if (initArguments.actions)
-            initArguments.actions = await convertEndpoints(initArguments.actions);
-        if (initArguments.kind === 'Collection' || initArguments.kind === 'Singleton') {
-            const dataType = await this.importDataType((metadata).type);
-            if (!dataType)
-                throw new TypeError(`Unable to determine data type of "${initArguments.name}" resource`);
-            if (!(dataType instanceof ComplexType))
-                throw new TypeError(`Data type of "${initArguments.name}" resource is not a ComplexType`);
-            initArguments.type = dataType;
-            if (initArguments.operations)
-                initArguments.operations = await convertEndpoints(initArguments.operations);
-        }
-        else if (initArguments.kind === 'Container') {
-            const oldResources = initArguments.resources;
-            if (Array.isArray(oldResources)) {
-                initArguments.resources = [];
-                for (const t of oldResources) {
-                    const rinit = await this.importResourceInstance(t);
-                    initArguments.resources.push(rinit);
-                }
-            }
-        }
-        return initArguments;
-    }
-    async createResource(container, initArguments) {
-        if (initArguments.kind === 'Collection')
-            return new Collection(container, initArguments);
-        if (initArguments.kind === 'Singleton')
-            return new Singleton(container, initArguments);
-        if (initArguments.kind === 'Storage')
-            return new Storage(container, initArguments);
-        if (initArguments.kind === 'Container') {
-            const newContainer = new Container(container, { ...initArguments, resources: undefined });
-            if (initArguments.resources) {
-                for (const r of initArguments.resources) {
-                    const res = await this.createResource(newContainer, r);
-                    newContainer.resources.set(res.name, res);
-                }
-            }
-            return newContainer;
-        }
-        else
-            throw new Error(`Unknown resource type ${initArguments.kind}`);
-    }
-}