@opra/common 0.33.13 → 1.0.0-alpha.1

package/cjs/http/opra-url.js

@@ -20,7 +20,7 @@ class OpraURL {
             hostname: '',
             port: '',
             hash: '',
-            password: ''
+            password: '',
         };
         this[kSearchParams] = new URLSearchParams();
         this[kPath] = new opra_url_path_js_1.OpraURLPath();
@@ -40,19 +40,22 @@ class OpraURL {
         if (this[kContext].address == null) {
             let address = '';
             if (this[kContext].hostname) {
-                address += (this[kContext].protocol || 'http:') + '//' +
-                    (this[kContext].username || this[kContext].password
-                        ? ((this[kContext].username ? encodeURIComponent(this[kContext].username) : '') +
-                            (this[kContext].password ? ':' + encodeURIComponent(this[kContext].password) : '') + '@')
-                        : '') + this.host;
+                address +=
+                    (this[kContext].protocol || 'http:') +
+                        '//' +
+                        (this[kContext].username || this[kContext].password
+                            ? (this[kContext].username ? encodeURIComponent(this[kContext].username) : '') +
+                                (this[kContext].password ? ':' + encodeURIComponent(this[kContext].password) : '') +
+                                '@'
+                            : '') +
+                        this.host;
             }
-            this[kContext].address = address +
-                (this.pathname !== '/' ? this.pathname : '');
+            this[kContext].address = address + (this.pathname !== '/' ? this.pathname : '');
         }
         return this[kContext].address;
     }
     get host() {
-        return this.hostname ? (this.hostname + (this.port ? ':' + this.port : '')) : '';
+        return this.hostname ? this.hostname + (this.port ? ':' + this.port : '') : '';
     }
     set host(v) {
         if (v) {
@@ -60,7 +63,7 @@ class OpraURL {
             if (!m)
                 throw Object.assign(new TypeError('Invalid host'), {
                     host: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this.hostname = m[1];
             this.port = m[2] || '';
@@ -78,7 +81,7 @@ class OpraURL {
             if (!hostnameRegEx.test(v))
                 throw Object.assign(new TypeError('Invalid hostname'), {
                     hostname: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].hostname = v;
         }
@@ -106,7 +109,7 @@ class OpraURL {
             if (isNaN(v) || v < 1 || v > 65535 || v % 1 > 0)
                 throw Object.assign(new TypeError(`Invalid port number (${value})`), {
                     hostname: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].port = String(v);
         }
@@ -122,7 +125,7 @@ class OpraURL {
             if (!schemeRegEx.test(v))
                 throw Object.assign(new TypeError('Invalid protocol'), {
                     protocol: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].protocol = v + (v.endsWith(':') ? '' : ':');
         }
@@ -138,7 +141,7 @@ class OpraURL {
         this.invalidate();
     }
     get origin() {
-        return this.hostname ? (this.protocol + '//' + this.hostname) : '';
+        return this.hostname ? this.protocol + '//' + this.hostname : '';
     }
     get path() {
         return this[kPath];
@@ -199,7 +202,7 @@ class OpraURL {
         if (!m)
             throw Object.assign(new TypeError('Invalid URL'), {
                 input,
-                code: 'ERR_INVALID_URL'
+                code: 'ERR_INVALID_URL',
             });
         this.protocol = m[1];
         const isAbsolute = !!m[2];

package/cjs/i18n/i18n.js

@@ -79,9 +79,9 @@ class I18n extends exports.BaseI18n {
                         keys.push(token2);
                     }
                     const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
-                    s += (fallback
+                    s += fallback
                         ? this.t(k, fallback, { ...options, ...opts })
-                        : this.t(k, { ...options, ...opts }));
+                        : this.t(k, { ...options, ...opts });
                     continue;
                 }
                 s += token;
@@ -100,9 +100,13 @@ class I18n extends exports.BaseI18n {
         if (typeof input === 'object') {
             if (Buffer.isBuffer(input))
                 return input;
-            if (Buffer.isBuffer(input) || input instanceof Symbol ||
-                input instanceof RegExp || input instanceof Map || input instanceof Set ||
-                input instanceof WeakMap || input instanceof WeakSet)
+            if (Buffer.isBuffer(input) ||
+                input instanceof Symbol ||
+                input instanceof RegExp ||
+                input instanceof Map ||
+                input instanceof Set ||
+                input instanceof WeakMap ||
+                input instanceof WeakSet)
                 return input;
             const out = {};
             objectStack.set(input, out);

package/cjs/i18n/translate.js

@@ -6,10 +6,10 @@ const bracketRegEx = /(\))/g;
 function translate(key, arg0, arg1) {
     const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
     const fallback = typeof arg0 === 'string' ? arg0 : arg1;
-    return '$t(' +
+    return ('$t(' +
         key +
         (options ? ',' + JSON.stringify(options) : '') +
         (fallback ? '?' + (0, string_utils_js_1.escapeString)(fallback).replace(bracketRegEx, '\\$1') : '') +
-        ')';
+        ')');
 }
 exports.translate = translate;

package/cjs/index.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./document/index.js"), exports);
 tslib_1.__exportStar(require("./exception/index.js"), exports);
-tslib_1.__exportStar(require("./filter/index.js"), exports); // todo  review
+tslib_1.__exportStar(require("./filter/index.js"), exports);
 tslib_1.__exportStar(require("./helpers/index.js"), exports);
 tslib_1.__exportStar(require("./http/index.js"), exports);
 tslib_1.__exportStar(require("./i18n/index.js"), exports);

package/cjs/schema/http/http-controller.interface.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpController = void 0;
+/**
+ *
+ * @namespace HttpController
+ */
+var HttpController;
+(function (HttpController) {
+    HttpController.Kind = 'HttpController';
+})(HttpController || (exports.HttpController = HttpController = {}));

package/cjs/schema/http/http-operation.interface.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOperation = void 0;
+var HttpOperation;
+(function (HttpOperation) {
+    HttpOperation.Kind = 'HttpOperation';
+})(HttpOperation || (exports.HttpOperation = HttpOperation = {}));

package/cjs/schema/index.js

@@ -2,5 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraSchema = void 0;
 const tslib_1 = require("tslib");
-const OpraSchema = tslib_1.__importStar(require("./opra-schema.ns.js"));
-exports.OpraSchema = OpraSchema;
+const constants_ = tslib_1.__importStar(require("./constants.js"));
+const complexType_ = tslib_1.__importStar(require("./data-type/complex-type.interface.js"));
+const enumType_ = tslib_1.__importStar(require("./data-type/enum-type.interface.js"));
+const mappedType_ = tslib_1.__importStar(require("./data-type/mapped-type.interface.js"));
+const mixinType_ = tslib_1.__importStar(require("./data-type/mixin-type.interface.js"));
+const simpleType_ = tslib_1.__importStar(require("./data-type/simple-type.interface.js"));
+const controller_ = tslib_1.__importStar(require("./http/http-controller.interface.js"));
+const operation_ = tslib_1.__importStar(require("./http/http-operation.interface.js"));
+const typeGuards_ = tslib_1.__importStar(require("./type-guards.js"));
+var OpraSchema;
+(function (OpraSchema) {
+    OpraSchema.SpecVersion = constants_.SpecVersion;
+    OpraSchema.ComplexType = complexType_.ComplexType;
+    OpraSchema.EnumType = enumType_.EnumType;
+    OpraSchema.MappedType = mappedType_.MappedType;
+    OpraSchema.MixinType = mixinType_.MixinType;
+    OpraSchema.SimpleType = simpleType_.SimpleType;
+    OpraSchema.HttpController = controller_.HttpController;
+    OpraSchema.HttpOperation = operation_.HttpOperation;
+    OpraSchema.isComplexType = typeGuards_.isComplexType;
+    OpraSchema.isDataType = typeGuards_.isDataType;
+    OpraSchema.isSimpleType = typeGuards_.isSimpleType;
+    OpraSchema.isMixinType = typeGuards_.isMixinType;
+    OpraSchema.isMappedType = typeGuards_.isMappedType;
+    OpraSchema.isEnumType = typeGuards_.isEnumType;
+    OpraSchema.isHttpController = typeGuards_.isHttpController;
+})(OpraSchema || (exports.OpraSchema = OpraSchema = {}));

package/cjs/schema/type-guards.js

@@ -1,22 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isResource = exports.isEnumType = exports.isMappedType = exports.isMixinType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
+exports.isHttpController = exports.isEnumType = exports.isMappedType = exports.isMixinType = 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");
 const mixin_type_interface_js_1 = require("./data-type/mixin-type.interface.js");
 const simple_type_interface_js_1 = require("./data-type/simple-type.interface.js");
-const collection_interface_js_1 = require("./resource/collection.interface.js");
-const container_interface_js_1 = require("./resource/container.interface.js");
-const singleton_interface_js_1 = require("./resource/singleton.interface.js");
-const storage_interface_js_1 = require("./resource/storage.interface.js");
+const http_controller_interface_js_1 = require("./http/http-controller.interface.js");
 function isDataType(obj) {
-    return obj && typeof obj === 'object' &&
+    return (obj &&
+        typeof obj === 'object' &&
         (obj.kind === complex_type_interface_js_1.ComplexType.Kind ||
             obj.kind === enum_type_interface_js_1.EnumType.Kind ||
             obj.kind === mapped_type_interface_js_1.MappedType.Kind ||
             obj.kind === simple_type_interface_js_1.SimpleType.Kind ||
-            obj.kind === mixin_type_interface_js_1.MixinType.Kind);
+            obj.kind === mixin_type_interface_js_1.MixinType.Kind));
 }
 exports.isDataType = isDataType;
 function isComplexType(obj) {
@@ -39,27 +37,7 @@ function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === enum_type_interface_js_1.EnumType.Kind;
 }
 exports.isEnumType = isEnumType;
-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);
+function isHttpController(obj) {
+    return obj && typeof obj === 'object' && obj.kind === http_controller_interface_js_1.HttpController.Kind;
 }
-exports.isResource = isResource;
-function isCollection(obj) {
-    return obj && typeof obj === 'object' && obj.kind === collection_interface_js_1.Collection.Kind;
-}
-exports.isCollection = isCollection;
-function isSingleton(obj) {
-    return obj && typeof obj === 'object' && obj.kind === singleton_interface_js_1.Singleton.Kind;
-}
-exports.isSingleton = isSingleton;
-function isStorage(obj) {
-    return obj && typeof obj === 'object' && obj.kind === storage_interface_js_1.Storage.Kind;
-}
-exports.isStorage = isStorage;
-function isContainer(obj) {
-    return obj && typeof obj === 'object' && obj.kind === container_interface_js_1.Container.Kind;
-}
-exports.isContainer = isContainer;
+exports.isHttpController = isHttpController;

package/cjs/schema/value.interface.js

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

package/esm/document/api-document.js

@@ -1,32 +1,121 @@
-import { Container } from './resource/container.js';
-import { TypeDocument } from './type-document.js';
-export class ApiDocument extends TypeDocument {
+var _a;
+import { cloneObject, omitUndefined, ResponsiveMap } from '../helpers/index.js';
+import { OpraSchema } from '../schema/index.js';
+import { DataTypeMap } from './common/data-type-map.js';
+import { DocumentElement } from './common/document-element.js';
+import { BUILTIN, kDataTypeMap, kTypeNSMap, NAMESPACE_PATTERN } from './constants.js';
+import { DataType } from './data-type/data-type.js';
+/**
+ *
+ * @class ApiDocument
+ */
+export class ApiDocument extends DocumentElement {
     constructor() {
-        super(...arguments);
-        this.root = new Container(this, { name: '' });
+        super(null);
+        this[_a] = new WeakMap();
+        this.references = new ResponsiveMap();
+        this.types = new DataTypeMap();
+        this.node[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 DataType ? this._findDataType(nameOrCtor.name || '') : this._findDataType(nameOrCtor);
+        if (dt)
+            return this[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 = omitUndefined({
+            spec: OpraSchema.SpecVersion,
+            url: this.url,
+            info: 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[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 = 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[kTypeNSMap].set(result, ref?.[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[kTypeNSMap].set(result, ref?.[BUILTIN] ? '' : refNs);
+                return result;
+            }
+        }
     }
 }
+_a = kTypeNSMap;

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

@@ -0,0 +1,23 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { CLASS_NAME_PATTERN } from '../constants.js';
+import { DocumentElement } from './document-element.js';
+export class ApiBase extends DocumentElement {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+    }
+    toJSON() {
+        return omitUndefined({
+            protocol: this.protocol,
+            name: this.name,
+            description: this.description,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _initialize(init, context) {
+        if (!CLASS_NAME_PATTERN.test(init.name))
+            throw new TypeError(`Invalid api name (${init.name})`);
+        this.name = init.name;
+        this.description = init?.description;
+    }
+}

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

@@ -0,0 +1,62 @@
+var _a, _b;
+import { ResponsiveMap } from '../../helpers/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
+import { DataType } from '../data-type/data-type.js';
+const kMap = Symbol.for('kMap');
+const kCtorMap = Symbol.for('kCtorMap');
+/**
+ * @class DataTypeMap
+ */
+export class DataTypeMap {
+    constructor() {
+        this[_a] = new 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(DATATYPE_METADATA, nameOrCtor);
+            name = metadata?.name;
+        }
+        if (!name && typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[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 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]();
+    }
+}

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

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

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

@@ -0,0 +1,65 @@
+import { OpraDocumentError } from './opra-document-error.js';
+export class DocumentInitContext {
+    constructor(options) {
+        this.path = '';
+        this.error = new 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;
+    }
+}