@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumTypeClass = void 0;
-const valgen_1 = require("valgen");
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-const data_type_js_1 = require("./data-type.js");
-class EnumTypeClass extends data_type_js_1.DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = index_js_2.OpraSchema.EnumType.Kind;
-        this.enumObject = init.enumObject;
-        this.base = init.base;
-        this.ownValues = { ...init.values };
-        this.values = { ...this.base?.values, ...this.ownValues };
-        this.decode = valgen_1.vg.isEnum(Object.keys(this.values));
-        this.encode = valgen_1.vg.isEnum(Object.keys(this.values));
-    }
-    isTypeOf(t) {
-        return t[constants_js_1.DATATYPE_METADATA] &&
-            t[constants_js_1.DATATYPE_METADATA] === this.enumObject?.[constants_js_1.DATATYPE_METADATA];
-    }
-    exportSchema() {
-        const out = super.exportSchema();
-        out.values = {};
-        Object.entries(this.values).forEach(([k, i]) => {
-            out.values[k] = (0, index_js_1.omitUndefined)({ key: i.key, description: i.description });
-        });
-        return out;
-    }
-    generateCodec(codec) {
-        if (codec === 'encode')
-            return this.encode;
-        else
-            return this.decode;
-    }
-}
-exports.EnumTypeClass = EnumTypeClass;

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

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldClass = void 0;
-const valgen_1 = require("valgen");
-const index_js_1 = require("../../helpers/index.js");
-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 (0, index_js_1.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 valgen_1.isUndefined;
-        if (options?.operation === 'write' && this.readonly)
-            return valgen_1.isUndefined;
-        let fn = this.type.generateCodec(codec, {
-            ...options,
-            designType: this.designType,
-            partial: options?.partial && (this.partialUpdate || !this.isArray)
-        });
-        if (this.pattern)
-            fn = valgen_1.vg.allOf(fn, valgen_1.vg.isRegExp(this.pattern));
-        if (this.isArray)
-            fn = valgen_1.vg.isArray(fn);
-        return !options?.partial && this.required ? valgen_1.vg.required(fn) : valgen_1.vg.optional(fn);
-    }
-}
-exports.FieldClass = FieldClass;

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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiField = void 0;
-const tslib_1 = require("tslib");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const constants_js_1 = require("../constants.js");
-const field_class_js_1 = require("./field-class.js");
-const field_decorator_js_1 = require("./field-decorator.js");
-/**
- * @class ApiField
- * @decorator ApiField
- */
-exports.ApiField = function (...args) {
-    // Decorator
-    if (!this) {
-        const [options] = args;
-        return exports.ApiField[constants_js_1.DECORATOR](options);
-    }
-    // Constructor
-    const [owner, init] = args;
-    (0, putil_merge_1.default)(this, new field_class_js_1.FieldClass(owner, init), { descriptor: true });
-};
-exports.ApiField.prototype = field_class_js_1.FieldClass.prototype;
-Object.assign(exports.ApiField, field_decorator_js_1.FieldDecorator);
-exports.ApiField[constants_js_1.DECORATOR] = field_decorator_js_1.FieldDecorator;

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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIsInheritedPredicateFn = exports.MappedTypeClass = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const complex_type_class_js_1 = require("./complex-type-class.js");
-class MappedTypeClass extends complex_type_class_js_1.ComplexTypeClass {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = index_js_2.OpraSchema.MappedType.Kind;
-        const own = this.own;
-        own.pick = init.pick;
-        own.omit = init.omit;
-        own.partial = init.partial;
-        this.kind = index_js_2.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, (0, index_js_1.omitUndefined)({
-            pick: this.own.pick,
-            omit: this.own.omit,
-            partial: this.own.partial
-        }));
-        return out;
-    }
-}
-exports.MappedTypeClass = MappedTypeClass;
-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;
-    };
-}
-exports.getIsInheritedPredicateFn = getIsInheritedPredicateFn;

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

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MixinTypeClass = void 0;
-const index_js_1 = require("../../schema/index.js");
-const complex_type_js_1 = require("./complex-type.js");
-const mapped_type_js_1 = require("./mapped-type.js");
-class MixinTypeClass extends complex_type_js_1.ComplexType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = index_js_1.OpraSchema.MixinType.Kind;
-        const own = this.own;
-        own.types = [];
-        const MixinType = Object.getPrototypeOf(this).constructor;
-        for (const base of init.types) {
-            if (!(base instanceof complex_type_js_1.ComplexType || base instanceof MixinType || base instanceof mapped_type_js_1.MappedType))
-                throw new TypeError(`${index_js_1.OpraSchema.MixinType.Kind} shall contain ${index_js_1.OpraSchema.ComplexType.Kind}, ` +
-                    `${index_js_1.OpraSchema.MixinType.Kind} of ${index_js_1.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;
-    }
-}
-exports.MixinTypeClass = MixinTypeClass;

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleTypeClass = void 0;
-const valgen_1 = require("valgen");
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const data_type_js_1 = require("./data-type.js");
-/**
- * @class SimpleType
- */
-class SimpleTypeClass extends data_type_js_1.DataType {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = index_js_2.OpraSchema.SimpleType.Kind;
-        this.base = init.base;
-        this.decode = init.decoder || init.base?.decode || valgen_1.isAny;
-        this.encode = init.encoder || init.base?.encode || valgen_1.isAny;
-    }
-    exportSchema(options) {
-        // noinspection UnnecessaryLocalVariableJS
-        const out = super.exportSchema(options);
-        Object.assign(out, (0, index_js_1.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;
-    }
-}
-exports.SimpleTypeClass = SimpleTypeClass;

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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleTypeDecorator = void 0;
-const tslib_1 = require("tslib");
-const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
-const index_js_1 = require("../../schema/index.js");
-const constants_js_1 = require("../constants.js");
-function SimpleTypeDecorator(options) {
-    return function (target) {
-        let name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
-        name = name.charAt(0).toLowerCase() + name.substring(1);
-        const metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target) || {};
-        metadata.kind = index_js_1.OpraSchema.SimpleType.Kind;
-        metadata.name = name;
-        if (options)
-            Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name']));
-        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, target);
-    };
-}
-exports.SimpleTypeDecorator = SimpleTypeDecorator;

package/cjs/document/document-base.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentBase = void 0;
-const index_js_1 = require("../helpers/index.js");
-const index_js_2 = require("../schema/index.js");
-class DocumentBase {
-    constructor() {
-        this.info = {
-            version: '',
-            title: ''
-        };
-    }
-    /**
-     * Export as OPRA schema definition object
-     */
-    exportSchema() {
-        return (0, index_js_1.omitUndefined)({
-            version: index_js_2.OpraSchema.SpecVersion,
-            url: this.url,
-            info: (0, index_js_1.cloneObject)(this.info, true)
-        });
-    }
-}
-exports.DocumentBase = DocumentBase;

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

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiDocumentFactory = void 0;
-const index_js_1 = require("../../helpers/index.js");
-const index_js_2 = require("../../schema/index.js");
-const api_document_js_1 = require("../api-document.js");
-const constants_js_1 = require("../constants.js");
-const complex_type_js_1 = require("../data-type/complex-type.js");
-const enum_type_js_1 = require("../data-type/enum-type.js");
-const collection_js_1 = require("../resource/collection.js");
-const container_js_1 = require("../resource/container.js");
-const singleton_js_1 = require("../resource/singleton.js");
-const storage_js_1 = require("../resource/storage.js");
-const type_document_factory_js_1 = require("./type-document-factory.js");
-/**
- * @class ApiDocumentFactory
- */
-class ApiDocumentFactory extends type_document_factory_js_1.TypeDocumentFactory {
-    constructor() {
-        super(...arguments);
-        this.resourceQueue = new index_js_1.ResponsiveMap();
-    }
-    /**
-     * Creates ApiDocument instance from given schema object
-     * @param init
-     */
-    static async createDocument(init) {
-        const factory = new ApiDocumentFactory();
-        const document = factory.document = new api_document_js_1.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 api_document_js_1.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 = (0, enum_type_js_1.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 (0, index_js_1.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(constants_js_1.RESOURCE_METADATA, ctor) &&
-                index_js_2.OpraSchema.isResource(thunk) && typeof thunk.controller === 'object') {
-                ctor = Object.getPrototypeOf(thunk.controller).constructor;
-                metadata = thunk;
-                instance = thunk.controller;
-            }
-        }
-        metadata = metadata || Reflect.getMetadata(constants_js_1.RESOURCE_METADATA, ctor);
-        if (!metadata && index_js_2.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 = (0, enum_type_js_1.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 = (0, enum_type_js_1.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 = (0, enum_type_js_1.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 = (0, index_js_1.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 complex_type_js_1.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_js_1.Collection(container, initArguments);
-        if (initArguments.kind === 'Singleton')
-            return new singleton_js_1.Singleton(container, initArguments);
-        if (initArguments.kind === 'Storage')
-            return new storage_js_1.Storage(container, initArguments);
-        if (initArguments.kind === 'Container') {
-            const newContainer = new container_js_1.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}`);
-    }
-}
-exports.ApiDocumentFactory = ApiDocumentFactory;