@opra/common 0.25.4 → 0.26.0

package/cjs/document/type-document.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeDocument = void 0;
+const index_js_1 = require("../exception/index.js");
+const index_js_2 = require("../helpers/index.js");
+const index_js_3 = require("../schema/index.js");
+const constants_js_1 = require("./constants.js");
+const complex_type_js_1 = require("./data-type/complex-type.js");
+const document_base_js_1 = require("./document-base.js");
+class TypeDocument extends document_base_js_1.DocumentBase {
+    constructor() {
+        super();
+        this._designCtorMap = new Map();
+        this._typeCache = new index_js_2.ResponsiveMap();
+        this._typesCacheByCtor = new Map();
+        this.references = new index_js_2.ResponsiveMap();
+        this.types = new index_js_2.ResponsiveMap();
+        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+        this._designCtorMap.set(String, 'string');
+        this._designCtorMap.set(Number, 'number');
+        this._designCtorMap.set(Boolean, 'boolean');
+        this._designCtorMap.set(Object, 'any');
+        this._designCtorMap.set(Date, 'timestamp');
+        this._designCtorMap.set(BigIntConstructor, 'bigint');
+        this._designCtorMap.set(ArrayBuffer, 'base64');
+        this._designCtorMap.set(SharedArrayBuffer, 'base64');
+        this._designCtorMap.set(BufferConstructor, 'base64');
+    }
+    /**
+     *
+     */
+    getDataType(arg0, silent) {
+        // Convert design ctor to type name (String -> 'string')
+        if (typeof arg0 === 'function') {
+            const x = this._designCtorMap.get(arg0);
+            if (x)
+                arg0 = x;
+        }
+        let dataType;
+        let name;
+        // Determine name
+        if (typeof arg0 === 'function') {
+            const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, arg0);
+            name = metadata?.name || arg0.name;
+        }
+        else if (typeof arg0 === 'function') {
+            const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, arg0);
+            name = metadata?.name;
+        }
+        else
+            name = String(arg0);
+        // Try to get instance from cache
+        const t = typeof arg0 === 'string'
+            ? this._typeCache.get(arg0)
+            : this._typesCacheByCtor.get(arg0);
+        if (t)
+            return t;
+        // If cached as null, it means "not found"
+        if (t === null) {
+            if (silent)
+                return;
+            throw new Error(`Data type "${name}" does not exists`);
+        }
+        if (typeof arg0 === 'string' && arg0) {
+            const m = constants_js_1.NAMESPACE_PATTERN.exec(arg0);
+            if (!m)
+                throw new TypeError(`Invalid data type name "${name}"`);
+            // If given string has namespace pattern (ns:type_name)
+            if (m[2]) {
+                const ref = this.references.get(m[1]);
+                if (!ref) {
+                    if (silent)
+                        return;
+                    throw new Error(`No referenced document found for given namespace "${m[1]}"`);
+                }
+                dataType = ref.getDataType(m[2], silent);
+            }
+            else {
+                // Get instance from own types
+                dataType = this.types.get(arg0);
+                // if not found, search in references (from last to first)
+                if (!dataType) {
+                    const references = Array.from(this.references.values()).reverse();
+                    for (const ref of references) {
+                        dataType = ref.getDataType(name, true);
+                        if (dataType)
+                            break;
+                    }
+                }
+            }
+            if (dataType) {
+                this._typeCache.set(arg0, dataType);
+                return dataType;
+            }
+            if (!silent)
+                throw new index_js_1.NotFoundError(`Data type "${arg0}" does not exists`);
+            return;
+        }
+        if (typeof arg0 === 'function') {
+            const types = Array.from(this.types.values()).reverse();
+            for (const dt of types) {
+                if (dt instanceof complex_type_js_1.ComplexType && dt.isTypeOf(arg0)) {
+                    dataType = dt;
+                    break;
+                }
+            }
+            // if not found, search in references (from last to first)
+            if (!dataType) {
+                const references = Array.from(this.references.values()).reverse();
+                for (const ref of references) {
+                    dataType = ref.getDataType(arg0, true);
+                    if (dataType)
+                        break;
+                }
+            }
+            if (dataType)
+                this._typesCacheByCtor.set(arg0, dataType);
+            if (dataType)
+                return dataType;
+            if (!silent)
+                throw new Error(`No data type mapping found for class "${name}"`);
+            return;
+        }
+        if (typeof arg0 === 'object') {
+            const metadata = arg0[constants_js_1.DATATYPE_METADATA];
+            if (metadata && metadata.name) {
+                dataType = this.getDataType(metadata.name, true);
+                if (dataType)
+                    return dataType;
+                if (!silent)
+                    throw new Error(`No data type mapping found for class "${name}"`);
+            }
+        }
+        /* istanbul ignore next */
+        if (!silent)
+            throw new TypeError('Invalid argument');
+    }
+    getComplexType(nameOrCtor, silent) {
+        if (nameOrCtor === Object)
+            nameOrCtor = 'object';
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+    }
+    getSimpleType(nameOrCtor, silent) {
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+    }
+    getEnumType(nameOrCtor, silent) {
+        const t = this.getDataType(nameOrCtor);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.EnumType.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a EnumType`);
+    }
+    /**
+     * Export as Opra schema definition object
+     */
+    exportSchema(options) {
+        const schema = super.exportSchema();
+        if (this.references.size) {
+            const references = {};
+            let i = 0;
+            for (const [ns, r] of this.references.entries()) {
+                if (ns.toLowerCase() === 'opra')
+                    continue;
+                references[ns] = r.url ? r.url : r.exportSchema(options);
+                i++;
+            }
+            if (i)
+                schema.references = references;
+        }
+        if (this.types.size) {
+            const types = schema.types = {};
+            for (const [name, r] of this.types.entries()) {
+                types[name] = r.exportSchema(options);
+            }
+        }
+        return schema;
+    }
+    invalidate() {
+        this._typeCache.clear();
+        this._typesCacheByCtor.clear();
+    }
+}
+exports.TypeDocument = TypeDocument;

package/cjs/exception/http-errors/internal-server.error.js

@@ -16,6 +16,7 @@ class InternalServerError extends opra_exception_js_1.OpraException {
         super.init({
             message: (0, index_js_1.translate)('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
             code: 'INTERNAL_SERVER_ERROR',
+            severity: 'fatal',
             ...issue
         });
     }

package/cjs/exception/opra-exception.js

@@ -25,7 +25,7 @@ class OpraException extends Error {
             this.initString(issue);
         else if (issue instanceof Error)
             this.initError(issue);
-        else if (issue && typeof issue === 'object')
+        else
             this.init(issue);
         this.message = this.message || this.constructor.name;
     }
@@ -47,25 +47,31 @@ class OpraException extends Error {
         }, true);
     }
     init(issue) {
-        this.message = issue.message || this.constructor.name;
-        this.severity = issue.severity || 'error';
-        this.system = issue.system;
-        this.code = issue.code;
-        this.details = issue.details;
+        this.message = issue?.message || this.constructor.name;
+        this.severity = issue?.severity || 'error';
+        if (issue) {
+            this.system = issue.system;
+            this.code = issue.code;
+            this.details = issue.details;
+        }
     }
     initString(issue) {
-        this.message = String(issue || '') || this.constructor.name;
-        this.severity = 'error';
-        this.code = this.constructor.name;
+        this.init({
+            message: String(issue || '') || this.constructor.name,
+            severity: 'error',
+            code: this.constructor.name
+        });
     }
     initError(issue) {
         if (typeof issue.status === 'number')
             this.status = issue.status;
         else if (typeof issue.getStatus === 'function')
             this.status = issue.getStatus();
-        this.message = issue.message;
-        this.severity = issue.severity || 'error';
-        this.code = issue.code || (issue.constructor.name);
+        this.init({
+            message: issue.message,
+            severity: issue.severity || 'error',
+            code: issue.code || (issue.constructor.name)
+        });
     }
 }
 exports.OpraException = OpraException;

package/cjs/exception/wrap-exception.js

@@ -4,6 +4,7 @@ exports.wrapException = void 0;
 const bad_request_error_js_1 = require("./http-errors/bad-request.error.js");
 const failed_dependency_error_js_1 = require("./http-errors/failed-dependency.error.js");
 const forbidden_error_js_1 = require("./http-errors/forbidden.error.js");
+const internal_server_error_js_1 = require("./http-errors/internal-server.error.js");
 const method_not_allowed_error_js_1 = require("./http-errors/method-not-allowed.error.js");
 const not_acceptable_error_js_1 = require("./http-errors/not-acceptable.error.js");
 const not_found_error_js_1 = require("./http-errors/not-found.error.js");
@@ -36,7 +37,7 @@ function wrapException(error) {
         case 424:
             return new failed_dependency_error_js_1.FailedDependencyError(error);
         default:
-            return new failed_dependency_error_js_1.FailedDependencyError(error);
+            return new internal_server_error_js_1.InternalServerError(error);
     }
 }
 exports.wrapException = wrapException;

package/cjs/helpers/responsive-map.js

@@ -52,11 +52,11 @@ class ResponsiveMap extends Map {
         return this;
     }
     keys() {
-        return this[kKeyOrder][Symbol.iterator]();
+        return [...this[kKeyOrder]][Symbol.iterator]();
     }
     values() {
         let i = -1;
-        const arr = this[kKeyOrder];
+        const arr = [...this[kKeyOrder]];
         const map = this;
         return {
             [Symbol.iterator]() {
@@ -73,7 +73,7 @@ class ResponsiveMap extends Map {
     }
     entries() {
         let i = -1;
-        const arr = this[kKeyOrder];
+        const arr = [...this[kKeyOrder]];
         const map = this;
         return {
             [Symbol.iterator]() {

package/cjs/http/opra-url-path.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraURLPath = void 0;
+exports.OpraURLPathComponent = exports.OpraURLPath = void 0;
 const tslib_1 = require("tslib");
 const fast_tokenizer_1 = require("fast-tokenizer");
 const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
@@ -21,6 +21,9 @@ class OpraURLPath {
     get length() {
         return this[kLength];
     }
+    slice(start, end) {
+        return new OpraURLPath(...[...this].slice(start, end));
+    }
     resolve(...items) {
         this._resolve(items);
         return this;
@@ -245,6 +248,7 @@ class OpraURLPathComponent {
         });
     }
 }
+exports.OpraURLPathComponent = OpraURLPathComponent;
 function removeLeadingSeparator(s) {
     const m = /^\/*(.*)/.exec(s);
     return m?.[1] || s;

package/cjs/schema/document/document-base.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/document/type-document.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/schema/opra-schema.ns.js

@@ -15,5 +15,7 @@ tslib_1.__exportStar(require("./resource/resource.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/singleton.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/storage.interface.js"), exports);
 tslib_1.__exportStar(require("./constants.js"), exports);
-tslib_1.__exportStar(require("./document.interface.js"), exports);
+tslib_1.__exportStar(require("./document/document-base.interface.js"), exports);
+tslib_1.__exportStar(require("./document/type-document.interface.js"), exports);
+tslib_1.__exportStar(require("./document/api-document.interface.js"), exports);
 tslib_1.__exportStar(require("./type-guards.js"), exports);

package/cjs/schema/type-guards.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isSource = exports.isEnumType = exports.isMappedType = exports.isUnionType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
+exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isResource = exports.isEnumType = exports.isMappedType = exports.isUnionType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
 const complex_type_interface_js_1 = require("./data-type/complex-type.interface.js");
 const enum_type_interface_js_1 = require("./data-type/enum-type.interface.js");
 const mapped_type_interface_js_1 = require("./data-type/mapped-type.interface.js");
@@ -39,14 +39,14 @@ function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === enum_type_interface_js_1.EnumType.Kind;
 }
 exports.isEnumType = isEnumType;
-function isSource(obj) {
+function isResource(obj) {
     return obj && typeof obj === 'object' &&
         (obj.kind === container_interface_js_1.Container.Kind ||
             obj.kind === collection_interface_js_1.Collection.Kind ||
             obj.kind === singleton_interface_js_1.Singleton.Kind ||
             obj.kind === storage_interface_js_1.Storage.Kind);
 }
-exports.isSource = isSource;
+exports.isResource = isResource;
 function isCollection(obj) {
     return obj && typeof obj === 'object' && obj.kind === collection_interface_js_1.Collection.Kind;
 }

package/esm/document/api-document.js

@@ -1,236 +1,32 @@
-import { NotAcceptableError, NotFoundError, ResourceNotFoundError } from '../exception/index.js';
-import { cloneObject, ResponsiveMap } from '../helpers/index.js';
-import { OpraSchema } from '../schema/index.js';
-import { NAMESPACE_PATTERN } from './constants.js';
-import { ComplexType } from './data-type/complex-type.js';
-export class ApiDocument {
+import { Container } from './resource/container.js';
+import { TypeDocument } from './type-document.js';
+export class ApiDocument extends TypeDocument {
     constructor() {
-        this._designCtorMap = new Map();
-        this._typeCache = new ResponsiveMap();
-        this._typesCacheByCtor = new Map();
-        this.references = new ResponsiveMap();
-        this.types = new ResponsiveMap();
-        this.resources = new ResponsiveMap();
-        this.info = {
-            version: '',
-            title: ''
-        };
-        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
-        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
-        this._designCtorMap.set(String, 'string');
-        this._designCtorMap.set(Number, 'number');
-        this._designCtorMap.set(Boolean, 'boolean');
-        this._designCtorMap.set(Object, 'any');
-        this._designCtorMap.set(Date, 'timestamp');
-        this._designCtorMap.set(BigIntConstructor, 'bigint');
-        this._designCtorMap.set(ArrayBuffer, 'base64');
-        this._designCtorMap.set(SharedArrayBuffer, 'base64');
-        this._designCtorMap.set(BufferConstructor, 'base64');
-    }
-    /**
-     *
-     */
-    getDataType(arg0, silent) {
-        let dataType;
-        const name = typeof arg0 === 'function' ? arg0.name : String(arg0);
-        // Try to get instance from cache
-        const t = typeof arg0 === 'string'
-            ? this._typeCache.get(arg0)
-            : this._typesCacheByCtor.get(arg0);
-        if (t)
-            return t;
-        // If cached as null, it means "not found"
-        if (t === null) {
-            if (silent)
-                return;
-            throw new Error(`Data type "${name}" does not exists`);
-        }
-        // Convert design ctor to type name (String -> 'string')
-        if (typeof arg0 === 'function') {
-            const x = this._designCtorMap.get(arg0);
-            if (x)
-                arg0 = x;
-        }
-        if (typeof arg0 === 'string') {
-            const m = NAMESPACE_PATTERN.exec(arg0);
-            if (!m)
-                throw new TypeError(`Invalid data type name "${name}"`);
-            // If given string has namespace pattern (ns:type_name)
-            if (m[2]) {
-                const ref = this.references.get(m[1]);
-                if (!ref) {
-                    if (silent)
-                        return;
-                    throw new Error(`No referenced document found for given namespace "${m[1]}"`);
-                }
-                dataType = ref.getDataType(m[2], silent);
-            }
-            else {
-                // Get instance from own types
-                dataType = this.types.get(arg0);
-                // if not found, search in references (from last to first)
-                if (!dataType) {
-                    const references = Array.from(this.references.values()).reverse();
-                    for (const ref of references) {
-                        dataType = ref.getDataType(name, true);
-                        if (dataType)
-                            break;
-                    }
-                }
-            }
-            if (dataType) {
-                this._typeCache.set(arg0, dataType);
-                return dataType;
-            }
-            if (!silent)
-                throw new NotFoundError(`Data type "${arg0}" does not exists`);
-            return;
-        }
-        if (typeof arg0 === 'function') {
-            const types = Array.from(this.types.values()).reverse();
-            for (const dt of types) {
-                if (dt instanceof ComplexType && dt.isTypeOf(arg0)) {
-                    dataType = dt;
-                    break;
-                }
-            }
-            // if not found, search in references (from last to first)
-            if (!dataType) {
-                const references = Array.from(this.references.values()).reverse();
-                for (const ref of references) {
-                    dataType = ref.getDataType(arg0, true);
-                    if (dataType)
-                        break;
-                }
-            }
-            if (dataType)
-                this._typesCacheByCtor.set(arg0, dataType);
-            if (dataType)
-                return dataType;
-            if (!silent)
-                throw new NotFoundError(`No data type mapping found for class "${name}"`);
-            return;
-        }
-        /* istanbul ignore next */
-        if (!silent)
-            throw new TypeError('Invalid argument');
-    }
-    getComplexType(nameOrCtor, silent) {
-        if (nameOrCtor === Object)
-            nameOrCtor = 'object';
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.ComplexType.Kind)
-            return t;
-        throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
-    }
-    getSimpleType(nameOrCtor, silent) {
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.SimpleType.Kind)
-            return t;
-        throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        super(...arguments);
+        this.root = new Container(this, { name: '' });
     }
     getResource(path, silent) {
-        let resource;
-        const m = NAMESPACE_PATTERN.exec(path);
-        if (!m)
-            throw new NotFoundError(`Invalid resource path "${path}"`);
-        // If given string has namespace pattern (ns:type_name)
-        if (m[2]) {
-            const ref = this.references.get(m[1]);
-            if (!ref) {
-                if (silent)
-                    return;
-                throw new NotFoundError(`Reference "${m[1]}" not found`);
-            }
-            return ref.getResource(m[2]);
-        }
-        else {
-            const name = m[1];
-            // Get instance from own types
-            resource = this.resources.get(name);
-            if (resource)
-                return resource;
-            // if not found, search in references (from last to first)
-            const references = Array.from(this.references.values()).reverse();
-            for (const ref of references) {
-                resource = silent ? ref.getResource(name, silent) : ref.getResource(name);
-                if (resource)
-                    return resource;
-            }
-        }
-        if (silent)
-            return;
-        throw new ResourceNotFoundError(path);
+        return this.root.getResource(path, silent);
+    }
+    getContainer(path, silent) {
+        return this.root.getContainer(path, silent);
     }
     getCollection(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Collection.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+        return this.root.getCollection(path, silent);
     }
     getSingleton(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Singleton.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+        return this.root.getSingleton(path, silent);
     }
     getStorage(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.Storage.Kind)
-            return t;
-        throw new NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
+        return this.root.getStorage(path, silent);
     }
     /**
      * Export as Opra schema definition object
      */
     exportSchema(options) {
-        if (this._metadataCache)
-            return cloneObject(this._metadataCache, options?.webSafe);
-        const schema = {
-            version: OpraSchema.SpecVersion,
-            url: this.url,
-            info: cloneObject(this.info)
-        };
-        if (this.references.size) {
-            const references = {};
-            let i = 0;
-            for (const [ns, r] of this.references.entries()) {
-                if (ns.toLowerCase() === 'opra')
-                    continue;
-                references[ns] = r.url ? r.url : r.exportSchema();
-                i++;
-            }
-            if (i)
-                schema.references = references;
-        }
-        if (this.resources.size) {
-            const resources = schema.resources = {};
-            for (const [name, r] of this.resources.entries()) {
-                resources[name] = r.exportSchema();
-            }
-        }
-        if (this.types.size) {
-            const types = schema.types = {};
-            for (const [name, r] of this.types.entries()) {
-                types[name] = r.exportSchema();
-            }
-        }
-        this._metadataCache = schema;
-        return this._metadataCache;
-    }
-    invalidate() {
-        this._metadataCache = undefined;
-        this._typeCache.clear();
-        this._typesCacheByCtor.clear();
+        const schema = super.exportSchema(options);
+        schema.root = this.root.exportSchema(options);
+        delete schema.root.kind;
+        return schema;
     }
 }