@opra/common 0.25.5 → 0.26.0

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

@@ -12,7 +12,8 @@ export class DataType {
         this.description = init?.description;
         this.isAnonymous = !this.name;
     }
-    exportSchema() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    exportSchema(options) {
         return omitUndefined({
             kind: this.kind,
             description: this.description

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

@@ -6,22 +6,25 @@ 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.ownMeanings = init.meanings || {};
+        this.ownValues = { ...init.values };
         this.values = { ...this.base?.values, ...this.ownValues };
-        this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
-        this.decode = vg.isEnum(Object.values(this.values));
-        this.encode = vg.isEnum(Object.values(this.values));
+        this.decode = vg.isEnum(Object.keys(this.values));
+        this.encode = vg.isEnum(Object.keys(this.values));
     }
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            values: this.ownValues,
-            meanings: this.ownMeanings
-        }));
+        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/enum-type.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
-import omit from 'lodash.omit';
 import merge from 'putil-merge';
+import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
 import { EnumTypeClass } from './enum-type-class.js';
@@ -11,20 +11,34 @@ export const EnumType = function (...args) {
     // Injector
     if (!this) {
         const [enumSource, options] = args;
-        const values = Array.isArray(enumSource)
-            ? enumSource.reduce((obj, v) => {
-                obj[v] = v;
-                return obj;
-            }, {})
-            : enumSource;
+        let values = {};
+        if (Array.isArray(enumSource)) {
+            values = {};
+            enumSource.forEach(k => {
+                const description = options?.meanings?.[k];
+                values[k] = omitUndefined({ description });
+            });
+        }
+        else {
+            Object.keys(enumSource).forEach(k => {
+                const description = options?.meanings?.[k];
+                values[enumSource[k]] = omitUndefined({ key: k, description });
+            });
+        }
         const metadata = {
             kind: OpraSchema.EnumType.Kind,
-            values
+            values,
+            base: options?.base,
+            name: options?.name,
+            description: options?.description
         };
-        if (options)
-            Object.assign(metadata, omit(options, ['kind', 'values']));
-        Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
-        return values;
+        Object.defineProperty(enumSource, DATATYPE_METADATA, {
+            value: metadata,
+            enumerable: false,
+            configurable: true,
+            writable: true
+        });
+        return metadata;
     }
     // Constructor
     const [document, init] = args;

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

@@ -1,10 +1,11 @@
+import * as vg from 'valgen';
 import { omitUndefined } from '../../helpers/index.js';
 export class FieldClass {
     constructor(owner, init) {
         this.owner = owner;
-        this.name = init.name;
         this.origin = init.origin || owner;
         this.type = init.type;
+        this.name = init.name;
         this.description = init.description;
         this.isArray = init.isArray;
         this.default = init.default;
@@ -14,9 +15,9 @@ export class FieldClass {
         this.deprecated = init.deprecated;
         this.examples = init.examples;
     }
-    exportSchema() {
+    exportSchema(options) {
         return omitUndefined({
-            type: this.type.name ? this.type.name : this.type.exportSchema(),
+            type: this.type.name ? this.type.name : this.type.exportSchema(options),
             description: this.description,
             isArray: this.isArray,
             default: this.default,
@@ -27,4 +28,20 @@ export class FieldClass {
             examples: this.examples
         });
     }
+    getDecoder() {
+        if (!this._decoder)
+            this._decoder = this.generateCodec('decode');
+        return this._decoder;
+    }
+    getEncoder() {
+        if (!this._encoder)
+            this._encoder = this.generateCodec('encode');
+        return this._encoder;
+    }
+    generateCodec(codec, options) {
+        let fn = this.type.generateCodec(codec, options);
+        if (this.isArray)
+            fn = vg.isArray(fn);
+        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+    }
 }

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

@@ -1,7 +1,6 @@
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-import { EnumType } from './enum-type.js';
 export function FieldDecorator(options) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
@@ -12,30 +11,12 @@ export function FieldDecorator(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         const elemMeta = metadata.fields[propertyKey] = {
             ...options,
-            enum: undefined,
             designType
         };
         if (designType === Array) {
             elemMeta.isArray = true;
             delete elemMeta.designType;
         }
-        if (options?.enum) {
-            elemMeta.type = undefined;
-            if (Array.isArray(options.enum)) {
-                const enumObj = options.enum.reduce((o, v) => {
-                    o[v] = v;
-                    return o;
-                }, {});
-                EnumType(enumObj);
-                elemMeta.enum = enumObj;
-            }
-            else {
-                const m = Reflect.getOwnMetadata(DATATYPE_METADATA, options?.enum);
-                if (!OpraSchema.isEnumType(m))
-                    throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
-                elemMeta.enum = options.enum;
-            }
-        }
         Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
     };
 }

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

@@ -1,7 +1,7 @@
-import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
-import { DataType } from './data-type.js';
-export class MappedTypeClass extends DataType {
+import { ComplexTypeClass } from './complex-type-class.js';
+export class MappedTypeClass extends ComplexTypeClass {
     constructor(document, init) {
         super(document, init);
         this.kind = OpraSchema.MappedType.Kind;
@@ -9,21 +9,19 @@ export class MappedTypeClass extends DataType {
         own.pick = init.pick;
         own.omit = init.omit;
         this.kind = OpraSchema.MappedType.Kind;
-        this.type = init.type;
         this.pick = own.pick;
         this.omit = own.omit;
-        this.fields = new ResponsiveMap();
-        this.additionalFields = this.type.additionalFields;
         const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
-        for (const [elemName, elem] of this.type.fields.entries()) {
-            if (isInheritedPredicate(elemName))
-                this.fields.set(elemName, elem);
+        for (const fieldName of this.fields.keys()) {
+            if (!isInheritedPredicate(fieldName)) {
+                this.fields.delete(fieldName);
+            }
         }
     }
+    // @ts-ignore
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
+        const out = super.exportSchema();
         Object.assign(out, omitUndefined({
-            type: this.type.name ? this.type.name : this.type.exportSchema(),
             pick: this.own.pick,
             omit: this.own.omit,
         }));

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

@@ -43,7 +43,7 @@ export const MappedType = function (...args) {
         throw new TypeError(`Class "${mappedSource}" is not a ${OpraSchema.ComplexType.Kind}`);
     const metadata = {
         kind: 'MappedType',
-        type: mappedSource
+        base: mappedSource
     };
     if (options.pick)
         metadata.pick = options.pick;

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

@@ -1,4 +1,5 @@
 import * as vg from 'valgen';
+import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DataType } from './data-type.js';
 /**
@@ -12,13 +13,21 @@ export class SimpleTypeClass extends DataType {
         this.decode = init.decoder || init.base?.decode || vg.isAny();
         this.encode = init.encoder || init.base?.encode || vg.isAny();
     }
-    exportSchema() {
+    exportSchema(options) {
         // noinspection UnnecessaryLocalVariableJS
-        const out = super.exportSchema();
-        // Object.assign(out, omitUndefined({
-        //   base: this.base ?
-        //       (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-        // }));
+        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.js

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import merge from 'putil-merge';
 import { DECORATOR } from '../constants.js';
-import { SimpleTypeDecorator } from '../decorators/simple-type.decorator.js';
+import { SimpleTypeDecorator } from './simple-type.decorator.js';
 import { SimpleTypeClass } from './simple-type-class.js';
 /**
  * @class SimpleType

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

@@ -1,13 +1,10 @@
-import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ComplexType } from './complex-type.js';
-import { DataType } from './data-type.js';
 import { MappedType } from './mapped-type.js';
-export class UnionTypeClass extends DataType {
+export class UnionTypeClass extends ComplexType {
     constructor(document, init) {
         super(document, init);
         this.kind = OpraSchema.UnionType.Kind;
-        this.fields = new ResponsiveMap();
         const own = this.own;
         own.types = [];
         const UnionType = Object.getPrototypeOf(this).constructor;
@@ -16,17 +13,22 @@ export class UnionTypeClass extends DataType {
                 throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
                     `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
             own.types.push(base);
-            if (base.additionalFields)
-                this.additionalFields = base.additionalFields;
+            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();
-        Object.assign(out, omitUndefined({
-            types: this.own.types.map(t => t.name ? t.name : t.exportSchema())
-        }));
+        out.types = this.own.types.map(t => t.name ? t.name : t.exportSchema());
         return out;
     }
 }

package/esm/document/document-base.js

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,227 @@
+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 [kA, oA] of Object.entries(source)) {
+                /* istanbul ignore next */
+                if (!oA)
+                    continue;
+                let parameters;
+                if (oA.parameters) {
+                    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')
+                        };
+                    }
+                }
+                output[kA] = { ...oA[kA], parameters };
+            }
+            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)) {
+                let parameters;
+                if (oA.parameters) {
+                    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')
+                        };
+                    }
+                }
+                output[kA] = { ...oA, parameters };
+            }
+            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}`);
+    }
+}