@opra/common 0.13.0 → 0.15.0

package/cjs/document/api-document.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDocument = 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 simple_type_js_1 = require("./data-type/simple-type.js");
+class ApiDocument {
+    constructor() {
+        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();
+        this.resources = new index_js_2.ResponsiveMap();
+        this.info = {
+            version: '',
+            title: ''
+        };
+    }
+    getDataType(nameOrCtor, silent) {
+        let dataType;
+        if (nameOrCtor === Object)
+            nameOrCtor = 'any';
+        const nameOrCtorName = typeof nameOrCtor === 'function' ? nameOrCtor.name : nameOrCtor;
+        // Try to get instance from cache
+        const t = typeof nameOrCtor === 'string'
+            ? this._typeCache.get(nameOrCtor)
+            : this._typesCacheByCtor.get(nameOrCtor);
+        if (t)
+            return t;
+        if (t === null) {
+            if (silent)
+                return;
+            throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+        }
+        if (typeof nameOrCtor === 'string') {
+            const m = constants_js_1.NAMESPACE_PATTERN.exec(nameOrCtor);
+            if (!m)
+                throw new index_js_1.NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
+            // 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 index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
+                }
+                dataType = ref.getDataType(m[2]);
+                this._typeCache.set(nameOrCtor, dataType);
+            }
+            else {
+                const name = m[1];
+                // Get instance from own types
+                dataType = this.types.get(name);
+                // 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);
+                        if (dataType)
+                            break;
+                    }
+                }
+                if (dataType)
+                    this._typeCache.set(dataType.name || name, dataType);
+            }
+        }
+        else if (typeof nameOrCtor === 'function') {
+            const types = Array.from(this.types.values()).reverse();
+            for (const dt of types) {
+                if ((dt instanceof complex_type_js_1.ComplexType || dt instanceof simple_type_js_1.SimpleType) && dt.own.ctor === nameOrCtor) {
+                    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(nameOrCtor, true);
+                    if (dataType)
+                        break;
+                }
+            }
+        }
+        if (dataType) {
+            if ((dataType instanceof complex_type_js_1.ComplexType || dataType instanceof simple_type_js_1.SimpleType) &&
+                dataType.own?.ctor && dataType.own.ctor !== Object)
+                this._typesCacheByCtor.set(dataType.own.ctor, dataType);
+            return dataType;
+        }
+        else {
+            if (typeof nameOrCtor === 'string')
+                this._typeCache.set(nameOrCtor, null);
+            else
+                this._typesCacheByCtor.set(nameOrCtor, null);
+        }
+        if (silent)
+            return;
+        throw new index_js_1.NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+    }
+    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`);
+    }
+    getResource(path, silent) {
+        let resource;
+        const m = constants_js_1.NAMESPACE_PATTERN.exec(path);
+        if (!m)
+            throw new index_js_1.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 index_js_1.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 index_js_1.NotFoundError(`Resource not found (${path})`);
+    }
+    getCollection(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Collection.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+    }
+    getSingleton(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Singleton.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+    }
+    /**
+     * Export as Opra schema definition object
+     */
+    exportSchema() {
+        const schema = {
+            version: index_js_3.OpraSchema.SpecVersion,
+            url: this.url,
+            info: (0, index_js_2.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();
+            }
+        }
+        return (0, index_js_2.omitUndefined)(schema);
+    }
+    invalidate() {
+        this._typeCache.clear();
+        this._typesCacheByCtor.clear();
+    }
+}
+exports.ApiDocument = ApiDocument;

package/cjs/document/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPENAME_PATTERN = exports.NAMESPACE_PATTERN = exports.METADATA_KEY = void 0;
+exports.METADATA_KEY = Symbol.for('opra.metadata');
+exports.NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
+exports.TYPENAME_PATTERN = /^(.*)Type$/;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiField = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const enum_type_js_1 = require("./enum-type.js");
+/**
+ * @class ComplexType
+ */
+exports.ApiField = function (...args) {
+    // ClassDecorator
+    if (!this) {
+        const [options] = args;
+        return function (target, propertyKey) {
+            if (typeof propertyKey !== 'string')
+                throw new TypeError(`Symbol properties can't be used as a field`);
+            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target.constructor) || {};
+            metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
+            metadata.fields = metadata.fields || {};
+            const designType = Reflect.getMetadata('design:type', target, propertyKey);
+            const isArray = designType === Array;
+            const elemMeta = metadata.fields[propertyKey] = {
+                ...options,
+                enum: undefined,
+                designType: isArray ? undefined : designType
+            };
+            if (designType === Array)
+                elemMeta.isArray = true;
+            if (options?.enum) {
+                elemMeta.type = undefined;
+                if (Array.isArray(options.enum)) {
+                    const enumObj = options.enum.reduce((o, v) => {
+                        o[v] = v;
+                        return o;
+                    }, {});
+                    (0, enum_type_js_1.EnumType)(enumObj);
+                    elemMeta.enum = enumObj;
+                }
+                else {
+                    const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, options?.enum);
+                    if (!index_js_2.OpraSchema.isEnumType(m))
+                        throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
+                    elemMeta.enum = options.enum;
+                }
+            }
+            Reflect.defineMetadata(constants_js_1.METADATA_KEY, (0, index_js_1.omitUndefined)(metadata), target.constructor);
+        };
+    }
+    // Constructor
+    const [owner, init] = args;
+    const _this = this;
+    _this.owner = owner;
+    _this.name = init.name;
+    _this.origin = init.origin || owner;
+    _this.type = init.type;
+    if (init?.description)
+        this.description = init?.description;
+    if (init?.isArray != null)
+        this.isArray = init?.isArray;
+    this.default = init?.default;
+    this.fixed = init?.fixed;
+    if (init?.deprecated != null)
+        this.deprecated = init?.deprecated;
+    if (init?.exclusive != null)
+        this.exclusive = init?.exclusive;
+    if (init?.required != null)
+        this.required = init?.required;
+};
+const proto = {
+    exportSchema() {
+        const out = {
+            type: this.type.name ? this.type.name : this.type.exportSchema(),
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            fixed: this.fixed
+        };
+        return out;
+    }
+};
+Object.assign(exports.ApiField.prototype, proto);

package/cjs/document/data-type/builtin/any.type.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+let AnyType = class AnyType {
+};
+AnyType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Any value',
+        ctor: Object
+    })
+], AnyType);
+exports.AnyType = AnyType;

package/cjs/document/data-type/builtin/base64.type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64Type = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:(?:[A-Za-z0-9+/][AQgw](:?==)?)|(?:[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=?))?$/;
+let Base64Type = class Base64Type {
+    decode(v) {
+        if (v == null)
+            return v;
+        if (typeof v === 'string')
+            this.validate(v);
+        return Buffer.from(v, 'base64').buffer.slice(0);
+    }
+    encode(v) {
+        if (v == null)
+            return v;
+        if (Buffer.isBuffer(v))
+            return v.toString('base64');
+        return Buffer.from(v).toString('base64');
+    }
+    coerce(v) {
+        if (v instanceof ArrayBuffer)
+            return v;
+        return this.decode(v);
+    }
+    validate(v) {
+        if (!(typeof v === 'string' && BASE64_PATTERN.test(v)))
+            throw new TypeError(`Invalid base64 value "${String(v).substring(0, 10)}..."`);
+    }
+};
+Base64Type = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'A stream of bytes, base64 encoded',
+        ctor: ArrayBuffer
+    })
+], Base64Type);
+exports.Base64Type = Base64Type;

package/cjs/document/data-type/builtin/bigint.type.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+let BigIntType = class BigIntType {
+    decode(v) {
+        if (v == null)
+            return v;
+        return typeof v === 'bigint' ? v : BigInt(v);
+    }
+    encode(v) {
+        if (v == null)
+            return v;
+        return typeof v === 'bigint' ? String(v) : undefined;
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+    validate(v) {
+        if (!((typeof v === 'number' && !isNaN(v)) || typeof v === 'bigint'))
+            throw new TypeError(`Invalid number value "${v}"`);
+    }
+};
+BigIntType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        name: 'bigint',
+        description: 'BigInt number',
+        ctor: BigIntConstructor
+    })
+], BigIntType);
+exports.BigIntType = BigIntType;

package/cjs/document/data-type/builtin/boolean.type.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+let BooleanType = class BooleanType {
+    decode(v) {
+        if (v == null)
+            return v;
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    }
+    encode(v) {
+        if (v == null)
+            return v;
+        return (0, putil_varhelpers_1.toBoolean)(v);
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+};
+BooleanType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Simple true/false value',
+        ctor: Boolean
+    })
+], BooleanType);
+exports.BooleanType = BooleanType;

package/cjs/document/data-type/builtin/date.type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const timestamp_type_js_1 = require("./timestamp.type.js");
+let DateType = class DateType extends timestamp_type_js_1.TimestampType {
+    constructor() {
+        super(...arguments);
+        this.format = 'YYYY-MM-DD';
+    }
+};
+DateType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'full-date notation as defined by RFC 3339, section 5.6, for example, 2021-04-18',
+    })
+], DateType);
+exports.DateType = DateType;

package/cjs/document/data-type/builtin/guid.type.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+const string_type_js_1 = require("./string.type.js");
+const GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+let GuidType = class GuidType extends string_type_js_1.StringType {
+    decode(v) {
+        if (v == null)
+            return v;
+        const s = (0, putil_varhelpers_1.toString)(v);
+        if (s)
+            this.validate(s);
+        return s;
+    }
+    encode(v) {
+        return this.decode(v);
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+    validate(v) {
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof v === 'string' && !GUID_PATTERN.test(v))
+            throw new TypeError(`Invalid GUID value "${v}"`);
+    }
+};
+GuidType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'A Globally Unique Identifier (GUID) value',
+    })
+], GuidType);
+exports.GuidType = GuidType;

package/cjs/document/data-type/builtin/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./any.type.js"), exports);
+tslib_1.__exportStar(require("./base64.type.js"), exports);
+tslib_1.__exportStar(require("./bigint.type.js"), exports);
+tslib_1.__exportStar(require("./boolean.type.js"), exports);
+tslib_1.__exportStar(require("./date.type.js"), exports);
+tslib_1.__exportStar(require("./guid.type.js"), exports);
+tslib_1.__exportStar(require("./integer.type.js"), exports);
+tslib_1.__exportStar(require("./number.type.js"), exports);
+tslib_1.__exportStar(require("./object.type.js"), exports);
+tslib_1.__exportStar(require("./string.type.js"), exports);

package/cjs/document/data-type/builtin/integer.type.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+const number_type_js_1 = require("./number.type.js");
+let IntegerType = class IntegerType extends number_type_js_1.NumberType {
+    decode(v) {
+        if (v == null)
+            return v;
+        return (0, putil_varhelpers_1.toInt)(super.decode(v));
+    }
+    encode(v) {
+        if (v == null)
+            return v;
+        return (0, putil_varhelpers_1.toInt)(super.encode(v));
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+};
+IntegerType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'An integer number',
+    })
+], IntegerType);
+exports.IntegerType = IntegerType;

package/cjs/document/data-type/builtin/number.type.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+let NumberType = class NumberType {
+    decode(v) {
+        if (v == null)
+            return v;
+        const x = (0, putil_varhelpers_1.toNumber)(v);
+        if (x)
+            this.validate(x);
+        return x;
+    }
+    encode(v) {
+        return this.decode(v);
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+    validate(v) {
+        if (typeof v !== 'number' || isNaN(v))
+            throw new TypeError(`Invalid number value "${v}"`);
+    }
+};
+NumberType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Both Integer as well as Floating-Point numbers',
+        ctor: Number
+    })
+], NumberType);
+exports.NumberType = NumberType;

package/cjs/document/data-type/builtin/object.type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectType = void 0;
+const tslib_1 = require("tslib");
+const complex_type_js_1 = require("../complex-type.js");
+let ObjectType = class ObjectType {
+    coerce(v) {
+        if (v == null)
+            return v;
+        return typeof v === 'object' ? v : {};
+    }
+};
+ObjectType = tslib_1.__decorate([
+    (0, complex_type_js_1.ComplexType)({
+        name: 'object',
+        description: 'A non modelled object',
+        additionalFields: true
+    })
+], ObjectType);
+exports.ObjectType = ObjectType;

package/cjs/document/data-type/builtin/string.type.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
+let StringType = class StringType {
+    decode(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+    encode(v) {
+        return (0, putil_varhelpers_1.toString)(v);
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+};
+StringType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'A sequence of characters',
+        ctor: String
+    })
+], StringType);
+exports.StringType = StringType;

package/cjs/document/data-type/builtin/time.type.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const string_type_js_1 = require("./string.type.js");
+const TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?$/;
+let TimeType = class TimeType extends string_type_js_1.StringType {
+    decode(v) {
+        if (v == null)
+            return v;
+        this.validate(v);
+        return v;
+    }
+    encode(v) {
+        return this.decode(v);
+    }
+    coerce(v) {
+        return this.decode(v);
+    }
+    validate(v) {
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof v === 'string' && !TIME_PATTERN.test(v))
+            throw new TypeError(`Invalid Time value "${v}"`);
+    }
+};
+TimeType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Time formatted string',
+    })
+], TimeType);
+exports.TimeType = TimeType;

package/cjs/document/data-type/builtin/timestamp.type.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampType = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const simple_type_js_1 = require("../simple-type.js");
+let TimestampType = class TimestampType {
+    constructor() {
+        this.format = 'YYYY-MM-DDTHH:mm:ss';
+    }
+    decode(v) {
+        return (0, dayjs_1.default)(v).toDate();
+    }
+    encode(v) {
+        if (!v)
+            return undefined;
+        const d = (0, dayjs_1.default)(v);
+        if (!d.isValid())
+            throw new TypeError(`Invalid date value ${v}`);
+        return (0, dayjs_1.default)(v).format(this.format);
+    }
+};
+TimestampType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'date-time notation as defined by RFC 3339, section 5.6, for example, 2021-04-18T09:12:53',
+        ctor: Date
+    })
+], TimestampType);
+exports.TimestampType = TimestampType;