@opra/common 0.33.13 → 1.0.0-alpha.2

package/cjs/document/api-document.js

@@ -1,36 +1,125 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiDocument = void 0;
-const container_js_1 = require("./resource/container.js");
-const type_document_js_1 = require("./type-document.js");
-class ApiDocument extends type_document_js_1.TypeDocument {
+const index_js_1 = require("../helpers/index.js");
+const index_js_2 = require("../schema/index.js");
+const data_type_map_js_1 = require("./common/data-type-map.js");
+const document_element_js_1 = require("./common/document-element.js");
+const constants_js_1 = require("./constants.js");
+const data_type_js_1 = require("./data-type/data-type.js");
+/**
+ *
+ * @class ApiDocument
+ */
+class ApiDocument extends document_element_js_1.DocumentElement {
     constructor() {
-        super(...arguments);
-        this.root = new container_js_1.Container(this, { name: '' });
+        super(null);
+        this[_a] = new WeakMap();
+        this.references = new index_js_1.ResponsiveMap();
+        this.types = new data_type_map_js_1.DataTypeMap();
+        this.node[constants_js_1.kDataTypeMap] = this.types;
+        this.node.findDataType = this._findDataType.bind(this);
     }
-    getResource(path, silent) {
-        return this.root.getResource(path, silent);
-    }
-    getContainer(path, silent) {
-        return this.root.getContainer(path, silent);
-    }
-    getCollection(path, silent) {
-        return this.root.getCollection(path, silent);
-    }
-    getSingleton(path, silent) {
-        return this.root.getSingleton(path, silent);
+    /**
+     * Returns NS of datatype. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataTypeNs(nameOrCtor) {
+        const dt = nameOrCtor instanceof data_type_js_1.DataType ? this._findDataType(nameOrCtor.name || '') : this._findDataType(nameOrCtor);
+        if (dt)
+            return this[constants_js_1.kTypeNSMap].get(dt);
     }
-    getStorage(path, silent) {
-        return this.root.getStorage(path, silent);
+    toJSON() {
+        return this.export();
     }
     /**
      * Export as Opra schema definition object
      */
-    exportSchema(options) {
-        const schema = super.exportSchema(options);
-        schema.root = this.root.exportSchema(options);
-        delete schema.root.kind;
-        return schema;
+    export(options) {
+        const out = (0, index_js_1.omitUndefined)({
+            spec: index_js_2.OpraSchema.SpecVersion,
+            url: this.url,
+            info: (0, index_js_1.cloneObject)(this.info, true),
+            // api: this.api ? this.api.toJSON() : undefined,
+        });
+        if (this.references.size) {
+            let i = 0;
+            const references = {};
+            for (const [ns, doc] of this.references.entries()) {
+                if (doc[constants_js_1.BUILTIN])
+                    continue;
+                if (options?.references === 'external-url') {
+                    if (doc.url)
+                        references[ns] = doc.url;
+                    else
+                        references[ns] = `/$schema?ns=${ns}`;
+                }
+                else if (options?.references === 'relative-url')
+                    references[ns] = `/$schema?ns=${ns}`;
+                else
+                    references[ns] = doc.export(options);
+                i++;
+            }
+            if (i)
+                out.references = references;
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
+        if (this.api)
+            out.api = this.api.toJSON();
+        return out;
+    }
+    _findDataType(nameOrCtor, visitedRefs) {
+        let result = this.types.get(nameOrCtor);
+        if (result || !this.references.size)
+            return result;
+        // Lookup for references
+        if (typeof nameOrCtor === 'string') {
+            // If given string has namespace pattern (ns:type_name)
+            const m = constants_js_1.NAMESPACE_PATTERN.exec(nameOrCtor);
+            if (m) {
+                const ns = m[1];
+                if (ns) {
+                    const ref = this.references.get(ns);
+                    if (!ref)
+                        return;
+                    visitedRefs = visitedRefs || new WeakMap();
+                    visitedRefs.set(this, true);
+                    visitedRefs.set(ref, true);
+                    return ref._findDataType(m[2], visitedRefs);
+                }
+                nameOrCtor = m[2];
+            }
+        }
+        // if not found, search in references (from last to first)
+        visitedRefs = visitedRefs || new WeakMap();
+        visitedRefs.set(this, true);
+        const references = Array.from(this.references.keys()).reverse();
+        /** First step, lookup for own types */
+        for (const refNs of references) {
+            const ref = this.references.get(refNs);
+            result = ref?.types.get(nameOrCtor);
+            if (result) {
+                this[constants_js_1.kTypeNSMap].set(result, ref?.[constants_js_1.BUILTIN] ? '' : refNs);
+                return result;
+            }
+        }
+        /** If not found lookup for child references */
+        for (const refNs of references) {
+            const ref = this.references.get(refNs);
+            visitedRefs.set(ref, true);
+            result = ref._findDataType(nameOrCtor, visitedRefs);
+            if (result) {
+                this[constants_js_1.kTypeNSMap].set(result, ref?.[constants_js_1.BUILTIN] ? '' : refNs);
+                return result;
+            }
+        }
     }
 }
 exports.ApiDocument = ApiDocument;
+_a = constants_js_1.kTypeNSMap;

package/cjs/document/common/api-base.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiBase = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const constants_js_1 = require("../constants.js");
+const document_element_js_1 = require("./document-element.js");
+class ApiBase extends document_element_js_1.DocumentElement {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+    }
+    toJSON() {
+        return (0, index_js_1.omitUndefined)({
+            protocol: this.protocol,
+            name: this.name,
+            description: this.description,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _initialize(init, context) {
+        if (!constants_js_1.CLASS_NAME_PATTERN.test(init.name))
+            throw new TypeError(`Invalid api name (${init.name})`);
+        this.name = init.name;
+        this.description = init?.description;
+    }
+}
+exports.ApiBase = ApiBase;

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

@@ -0,0 +1,66 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTypeMap = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const constants_js_1 = require("../constants.js");
+const data_type_js_1 = require("../data-type/data-type.js");
+const kMap = Symbol.for('kMap');
+const kCtorMap = Symbol.for('kCtorMap');
+/**
+ * @class DataTypeMap
+ */
+class DataTypeMap {
+    constructor() {
+        this[_a] = new index_js_1.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) {
+            const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, nameOrCtor);
+            name = metadata?.name;
+        }
+        if (!name && typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[constants_js_1.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 data_type_js_1.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]();
+    }
+}
+exports.DataTypeMap = DataTypeMap;

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

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

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentInitContext = void 0;
+const opra_document_error_js_1 = require("./opra-document-error.js");
+class DocumentInitContext {
+    constructor(options) {
+        this.path = '';
+        this.error = new opra_document_error_js_1.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;
+    }
+}
+exports.DocumentInitContext = DocumentInitContext;

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentNode = void 0;
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+/**
+ * @class DocumentNode
+ */
+class DocumentNode {
+    constructor(element, parent) {
+        this.element = element;
+        this.parent = parent;
+    }
+    getDocument() {
+        if (this._document)
+            return this._document;
+        if (this.element[constants_js_1.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[constants_js_1.kDataTypeMap]?.has(nameOrCtor);
+        if (result)
+            return result;
+        return this.parent ? this.parent.hasDataType(nameOrCtor) : false;
+    }
+    findDataType(nameOrCtor) {
+        const result = this[constants_js_1.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(constants_js_1.DATATYPE_METADATA, nameOrCtor);
+            name = metadata.name;
+        }
+        else if (typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[constants_js_1.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 === index_js_1.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 === index_js_1.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 === index_js_1.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 === index_js_1.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 === index_js_1.OpraSchema.MixinType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
+    }
+}
+exports.DocumentNode = DocumentNode;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraDocumentError = void 0;
+const opra_exception_js_1 = require("../../exception/opra-exception.js");
+class OpraDocumentError extends opra_exception_js_1.OpraException {
+    constructor() {
+        super('');
+        this.details = [];
+    }
+    add(detail) {
+        this.details.push(detail);
+        return this;
+    }
+}
+exports.OpraDocumentError = OpraDocumentError;

package/cjs/document/common/value.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const document_element_js_1 = require("./document-element.js");
+exports.Value = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    document_element_js_1.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 = (0, ts_gems_1.asMutable)(this);
+    _this.description = initArgs.description;
+    _this.type = initArgs.type;
+    _this.examples = initArgs.examples;
+    _this.isArray = initArgs.isArray;
+};
+/**
+ * @class Value
+ */
+class ValueClass extends document_element_js_1.DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return (0, index_js_1.omitUndefined)({
+            type: this.type ? (typeName ? typeName : this.type.toJSON()) : 'any',
+            description: this.description,
+            isArray: this.isArray,
+            examples: this.examples,
+        });
+    }
+}
+exports.Value.prototype = ValueClass.prototype;

package/cjs/document/constants.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SORT_FIELD_PATTERN = exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.DECORATOR = exports.RESOURCE_METADATA = exports.DATATYPE_METADATA = void 0;
-exports.DATATYPE_METADATA = Symbol('DATATYPE_METADATA');
-exports.RESOURCE_METADATA = Symbol('RESOURCE_METADATA');
-exports.DECORATOR = Symbol('DECORATOR');
-exports.NAMESPACE_PATTERN = /([a-z$_]\w+)(?::.+)?/i;
-exports.TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
-exports.SORT_FIELD_PATTERN = /^([+-])?([a-z$_][\w.]+)$/;
+exports.kTypeNSMap = exports.kCtorMap = exports.kDataTypeMap = exports.EXTRACT_TYPENAME_PATTERN = exports.CLASS_NAME_PATTERN = exports.NAMESPACE_PATTERN = exports.BUILTIN = exports.DECORATOR = exports.ENCODER = exports.DECODER = exports.HTTP_CONTROLLER_METADATA = exports.DATATYPE_METADATA = void 0;
+exports.DATATYPE_METADATA = Symbol.for('opra.type.metadata');
+exports.HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
+exports.DECODER = Symbol.for('opra.type.decoder');
+exports.ENCODER = Symbol('opra.type.encoder');
+exports.DECORATOR = Symbol.for('DECORATOR');
+exports.BUILTIN = Symbol.for('BUILTIN');
+exports.NAMESPACE_PATTERN = /([a-z$_]\w+)(:.+)/i;
+exports.CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
+exports.EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
+exports.kDataTypeMap = Symbol.for('kDataTypeMap');
+exports.kCtorMap = Symbol.for('kCtorMap');
+exports.kTypeNSMap = Symbol.for('kTypeNSMap');

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiField = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const document_element_js_1 = require("../common/document-element.js");
+const constants_js_1 = require("../constants.js");
+const api_field_decorator_js_1 = require("../decorators/api-field-decorator.js");
+const complex_type_base_js_1 = require("./complex-type-base.js");
+/**
+ * @constructor ApiField
+ * @decorator ApiField
+ */
+exports.ApiField = function (...args) {
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        return exports.ApiField[constants_js_1.DECORATOR](options);
+    }
+    // Constructor
+    const [owner, initArgs] = args;
+    document_element_js_1.DocumentElement.call(this, owner);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.name = initArgs.name;
+    const origin = initArgs.origin || owner;
+    /* istanbul ignore next */
+    if (!(origin instanceof complex_type_base_js_1.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.examples = initArgs.examples;
+};
+/**
+ *
+ * @class ApiField
+ */
+class ApiFieldClass extends document_element_js_1.DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return (0, index_js_1.omitUndefined)({
+            type: this.type ? (typeName ? typeName : this.type?.toJSON()) : undefined,
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            fixed: this.fixed,
+            required: this.required,
+            exclusive: this.exclusive,
+            translatable: this.translatable,
+            deprecated: this.deprecated,
+            examples: this.examples,
+        });
+    }
+}
+exports.ApiField.prototype = ApiFieldClass.prototype;
+Object.assign(exports.ApiField, api_field_decorator_js_1.ApiFieldDecorator);
+exports.ApiField[constants_js_1.DECORATOR] = api_field_decorator_js_1.ApiFieldDecorator;