@opra/common 0.33.13 → 1.0.0-alpha.10

package/esm/document/type-document.js

@@ -1,200 +0,0 @@
-import { NotAcceptableError, NotFoundError } from '../exception/index.js';
-import { ResponsiveMap } from '../helpers/index.js';
-import { OpraSchema } from '../schema/index.js';
-import { DATATYPE_METADATA, NAMESPACE_PATTERN } from './constants.js';
-import { ComplexType } from './data-type/complex-type.js';
-import { DataType } from './data-type/data-type.js';
-import { EnumType } from './data-type/enum-type.js';
-import { DocumentBase } from './document-base.js';
-export class TypeDocument extends DocumentBase {
-    constructor() {
-        super();
-        this._designCtorMap = new Map();
-        this._typeIndex = new Map();
-        this._typeNsMap = new Map();
-        this.references = new ResponsiveMap();
-        this.types = new 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, 'datetime');
-        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;
-        }
-        // Try to get instance from cache
-        const t = typeof arg0 === 'string'
-            ? this._typeIndex.get(arg0.toLowerCase())
-            : this._typeIndex.get(arg0);
-        if (t)
-            return t;
-        // Determine name
-        let name;
-        if (typeof arg0 === 'string')
-            name = arg0;
-        else if (arg0 instanceof DataType)
-            name = arg0.name || '';
-        else {
-            const metadata = typeof arg0 === 'function'
-                ? Reflect.getMetadata(DATATYPE_METADATA, arg0) : arg0?.[DATATYPE_METADATA];
-            if (!metadata) {
-                /* istanbul ignore next */
-                if (!silent)
-                    throw new TypeError('Invalid argument');
-                return;
-            }
-            name = metadata.name;
-        }
-        // If cached as null, it means "not found" before
-        if (t === null) {
-            if (silent)
-                return;
-            throw new Error(`Data type "${name}" does not exists`);
-        }
-        let dataType;
-        let ns = '';
-        if (typeof arg0 === 'string' && arg0) {
-            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]) {
-                ns = m[1];
-                const ref = this.references.get(ns);
-                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.keys()).reverse();
-                    for (const refNs of references) {
-                        const ref = this.references.get(refNs);
-                        dataType = ref.getDataType(name, true);
-                        if (dataType) {
-                            ns = refNs;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const types = Array.from(this.types.values()).reverse();
-            for (const dt of types) {
-                if (dt === arg0 ||
-                    ((dt instanceof ComplexType || dt instanceof EnumType) && dt.isTypeOf(arg0))) {
-                    dataType = dt;
-                    break;
-                }
-            }
-            // if not found, search in references (from last to first)
-            if (!dataType) {
-                const references = Array.from(this.references.keys()).reverse();
-                for (const refNs of references) {
-                    const ref = this.references.get(refNs);
-                    dataType = ref.getDataType(arg0, true);
-                    if (dataType) {
-                        ns = refNs;
-                        break;
-                    }
-                }
-            }
-        }
-        if (dataType) {
-            this._typeIndex.set(arg0, dataType);
-            if (ns)
-                this._typeNsMap.set(dataType, ns);
-            return dataType;
-        }
-        if (!silent)
-            throw new NotFoundError(`Data type "${name}" does not exists`);
-        return;
-        /* istanbul ignore next */
-        if (!silent)
-            throw new TypeError('Invalid argument');
-    }
-    /**
-     *
-     */
-    getDataTypeNs(arg0, silent) {
-        const dt = this.getDataType(arg0, silent);
-        if (dt)
-            return this._typeNsMap.get(dt);
-    }
-    getComplexType(nameOrCtor, silent) {
-        if (nameOrCtor === Object)
-            nameOrCtor = 'object';
-        const t = this.getDataType(nameOrCtor, silent);
-        if (t) {
-            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, silent);
-        if (t) {
-            if (t && t.kind === OpraSchema.SimpleType.Kind)
-                return t;
-            throw new 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 === OpraSchema.EnumType.Kind)
-            return t;
-        throw new 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.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._typeIndex.clear();
-        this._typeNsMap.clear();
-    }
-}

package/esm/exception/wrap-exception.js

@@ -1,39 +0,0 @@
-import { BadRequestError } from './http-errors/bad-request.error.js';
-import { FailedDependencyError } from './http-errors/failed-dependency.error.js';
-import { ForbiddenError } from './http-errors/forbidden.error.js';
-import { InternalServerError } from './http-errors/internal-server.error.js';
-import { MethodNotAllowedError } from './http-errors/method-not-allowed.error.js';
-import { NotAcceptableError } from './http-errors/not-acceptable.error.js';
-import { NotFoundError } from './http-errors/not-found.error.js';
-import { UnauthorizedError } from './http-errors/unauthorized.error.js';
-import { UnprocessableEntityError } from './http-errors/unprocessable-entity.error.js';
-import { OpraException } from './opra-exception.js';
-export function wrapException(error) {
-    if (error instanceof OpraException)
-        return error;
-    let status = 500;
-    if (typeof error.status === 'number')
-        status = error.status;
-    else if (typeof error.getStatus === 'function')
-        status = error.getStatus();
-    switch (status) {
-        case 400:
-            return new BadRequestError(error);
-        case 401:
-            return new UnauthorizedError(error);
-        case 403:
-            return new ForbiddenError(error);
-        case 404:
-            return new NotFoundError(error);
-        case 405:
-            return new MethodNotAllowedError(error);
-        case 406:
-            return new NotAcceptableError(error);
-        case 422:
-            return new UnprocessableEntityError(error);
-        case 424:
-            return new FailedDependencyError(error);
-        default:
-            return new InternalServerError(error);
-    }
-}

package/esm/helpers/is-url-string.js

@@ -1,8 +0,0 @@
-const URL_PATTERN = /^(https?:\/\/.)[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/i;
-export function isUrlString(url) {
-    return URL_PATTERN.test(url);
-}
-export const isAbsoluteUrl = (urlString) => {
-    return !urlString.includes('://') &&
-        (new URL(urlString, 'http://tempuri.org/')).host !== 'tempuri.org';
-};

package/esm/helpers/path-to-object-tree.js

@@ -1,24 +0,0 @@
-const DOT_PATTERN = /^([^.]+)\.(.*)$/;
-export function pathToObjectTree(arr, lowerCaseKeys) {
-    if (!(arr && arr.length))
-        return;
-    return _pathToObjectTree(arr, {}, lowerCaseKeys);
-}
-function _pathToObjectTree(arr, target, lowerCaseKeys) {
-    for (let k of arr) {
-        if (lowerCaseKeys)
-            k = k.toLowerCase();
-        const m = DOT_PATTERN.exec(k);
-        if (m) {
-            const key = m[1];
-            if (target[key] === true)
-                continue;
-            const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
-            _pathToObjectTree([m[2]], sub);
-        }
-        else {
-            target[k] = true;
-        }
-    }
-    return target;
-}

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

@@ -1,255 +0,0 @@
-var _a;
-import { splitString, tokenize } from 'fast-tokenizer';
-import isPlainObject from 'putil-isplainobject';
-const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-const kLength = Symbol.for('kLength');
-const pathComponentRegEx = /^([^/?#:@]+)(?:@([^/?#:]*))?(?:::(.*))?$/;
-const decimalPattern = /^[+-]?\d+(\.\d+)?$/;
-const booleanPattern = /^true|false$/;
-/**
- * @class OpraURLPath
- */
-export class OpraURLPath {
-    constructor(...init) {
-        this[_a] = 0;
-        this._resolve(init.filter(x => x));
-    }
-    get length() {
-        return this[kLength];
-    }
-    slice(start, end) {
-        return new OpraURLPath(...[...this].slice(start, end));
-    }
-    resolve(...items) {
-        this._resolve(items);
-        return this;
-    }
-    join(...items) {
-        this._resolve(items, true);
-        return this;
-    }
-    isRelativeTo(basePath) {
-        basePath = basePath instanceof OpraURLPath ? basePath : new OpraURLPath(basePath);
-        let i;
-        for (i = 0; i < basePath.length; i++) {
-            if (String(this[i]) !== String(basePath[i]))
-                return false;
-        }
-        return true;
-    }
-    forEach(callback) {
-        let i = 0;
-        for (const item of this.values()) {
-            callback.call(this, item, i++, this);
-        }
-    }
-    values() {
-        const arr = new Array(this.length);
-        for (let i = 0; i < this.length; i++)
-            arr[i] = this[i];
-        return arr.values();
-    }
-    toString() {
-        const v = Array.from(this).join('/');
-        return v ? '/' + v : '';
-    }
-    /* istanbul ignore next */
-    [(_a = kLength, nodeInspectCustom)]() {
-        return `(UrlPath [${this.toString()}])`;
-    }
-    [Symbol.iterator]() {
-        return this.values();
-    }
-    _resolve(items, join) {
-        let paths = (Array.isArray(items) ? items : [items]).map(item => {
-            if (typeof item === 'object' && !(item instanceof OpraURLPath || item instanceof OpraURLPathComponent)) {
-                item = new OpraURLPathComponent(item);
-                if (item.resource.includes('/')) {
-                    const subPath = new OpraURLPath(item.resource);
-                    subPath[subPath.length - 1].key = item.key;
-                    return String(subPath);
-                }
-            }
-            item = String(item);
-            // Remove url parts coming after path (query, hash parts)
-            if (item.includes('?'))
-                item = splitString(item, {
-                    delimiters: '?',
-                    quotes: true,
-                    brackets: true,
-                    keepBrackets: true,
-                    keepQuotes: true
-                })[0];
-            if (item.includes('#'))
-                item = splitString(item, {
-                    delimiters: '#',
-                    quotes: true,
-                    brackets: true,
-                    keepBrackets: true,
-                    keepQuotes: true
-                })[0];
-            return join ? removeLeadingSeparator(item) : item;
-        });
-        const oldLength = this.length;
-        let n = 0;
-        if (!join) {
-            for (n = paths.length - 1; n >= 0; n--) {
-                if (String(items[n]).startsWith('/'))
-                    break;
-            }
-            if (n > 0)
-                paths = paths.slice(n);
-        }
-        const newPath = paths[0]?.startsWith('/') ? [] : Array.from(this).map(String);
-        for (let i = 0; i < paths.length; i++) {
-            const pathTokenizer = tokenize(paths[i], { delimiters: '/', quotes: true, brackets: true });
-            for (const x of pathTokenizer) {
-                if (!x)
-                    continue;
-                if (x.startsWith('.')) {
-                    if (x === '.')
-                        continue;
-                    if (x === '..') {
-                        newPath.pop();
-                        continue;
-                    }
-                    throw new TypeError('Invalid path string');
-                }
-                newPath.push(x);
-            }
-        }
-        for (let i = 0; i < newPath.length; i++) {
-            this[i] = OpraURLPathComponent.parse(newPath[i]);
-        }
-        for (let i = newPath.length; i < oldLength; i++) {
-            delete this[i];
-        }
-        this[kLength] = newPath.length;
-    }
-    static join(...items) {
-        const instance = new OpraURLPath();
-        instance.join(...items);
-        return instance;
-    }
-    static resolve(...items) {
-        return new OpraURLPath(...items);
-    }
-    static relative(source, basePath) {
-        source = source instanceof OpraURLPath ? source : new OpraURLPath(source);
-        basePath = basePath instanceof OpraURLPath ? basePath : new OpraURLPath(basePath);
-        let i;
-        for (i = 0; i < basePath.length; i++) {
-            if (String(source[i]) !== String(basePath[i]))
-                return;
-        }
-        return new OpraURLPath(Array.from(source).slice(i).join('/'));
-    }
-}
-/**
- *
- * @class OpraURLPathComponent
- */
-export class OpraURLPathComponent {
-    constructor(init) {
-        this.resource = init.resource;
-        this.key = init.key;
-        this.args = init.args;
-        this.typeCast = init.typeCast;
-    }
-    toString() {
-        let out = encodeURIComponent(this.resource).replace(/%24/, '$');
-        if (this.key) {
-            if (typeof this.key === 'object' && isPlainObject(this.key)) {
-                const arr = [];
-                for (const k of Object.keys(this.key)) {
-                    let v = this.key[k];
-                    if (typeof v === 'number' || typeof v === 'boolean')
-                        v = String(v);
-                    else
-                        v = '"' + encodeURIComponent(String(v)) + '"';
-                    arr.push(encodeURIComponent(k) + '=' + v);
-                }
-                out += '@' + arr.join(';');
-            }
-            else
-                out += '@' + encodeURIComponent(String(this.key));
-        }
-        if (this.args) {
-            const arr = [];
-            for (const k of Object.keys(this.args)) {
-                arr.push(encodeURIComponent(k) + '=' + encodeURIComponent(String(this.args[k])));
-            }
-            out += '(' + arr.join(';') + ')';
-        }
-        if (this.typeCast)
-            out += '::' + encodeURIComponent(this.typeCast);
-        return out;
-    }
-    /* istanbul ignore next */
-    [nodeInspectCustom]() {
-        return this.toString();
-    }
-    /**
-     * Factory method.
-     * @param input
-     */
-    static parse(input) {
-        const m = pathComponentRegEx.exec(input);
-        if (!m)
-            throw Object.assign(new TypeError('Invalid Opra URL'), {
-                code: 'ERR_INVALID_OPRA_URL',
-                input,
-            });
-        let key;
-        if (m[2]) {
-            const s = decodeURIComponent(m[2]);
-            const b = splitString(s, { delimiters: ';', quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
-            for (const n of b) {
-                const c = splitString(n, { delimiters: '=', quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
-                if ((b.length > 1 && c.length < 2) ||
-                    (key &&
-                        (c.length >= 2 && typeof key !== 'object') ||
-                        (c.length < 2 && typeof key === 'object')))
-                    throw Object.assign(new TypeError('Invalid Opra URL. name:value pair required for multiple key format'), {
-                        pathComponent: input,
-                        code: 'ERR_INVALID_OPRA_URL'
-                    });
-                if (c.length >= 2) {
-                    key = key || {};
-                    const k = c.shift() || '';
-                    let v = c.join('=');
-                    if (decimalPattern.test(v))
-                        v = Number(v);
-                    else if (booleanPattern.test(v))
-                        v = Boolean(v);
-                    else if (v.startsWith('"') && v.endsWith('"'))
-                        v = v.substring(1, v.length - 1);
-                    else if (v.startsWith("'") && v.endsWith("'"))
-                        v = v.substring(1, v.length - 1);
-                    key[k] = v;
-                }
-                else {
-                    if (decimalPattern.test(c[0]))
-                        key = Number(c[0]);
-                    else if (booleanPattern.test(c[0]))
-                        key = Boolean(c[0]);
-                    else
-                        key = c[0];
-                }
-            }
-            return new OpraURLPathComponent({
-                resource: decodeURIComponent(m[1]),
-                key,
-                typeCast: m[3] ? decodeURIComponent(m[3]) : undefined
-            });
-        }
-        return new OpraURLPathComponent({
-            resource: decodeURIComponent(m[1]),
-            typeCast: m[3] ? decodeURIComponent(m[3]) : undefined
-        });
-    }
-}
-function removeLeadingSeparator(s) {
-    const m = /^\/*(.*)/.exec(s);
-    return m?.[1] || s;
-}