@opra/common 0.22.0 → 0.23.1

package/esm/exception/http-errors/forbidden.error.js

@@ -11,10 +11,9 @@ export class ForbiddenError extends OpraException {
         super(...arguments);
         this.status = 403;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:FORBIDDEN', 'You are not authorized to perform this action'),
-            severity: 'error',
             code: 'FORBIDDEN',
             ...issue
         });

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

@@ -9,10 +9,9 @@ export class InternalServerError extends OpraException {
         super(...arguments);
         this.status = 500;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:INTERNAL_SERVER_ERROR', 'Internal server error'),
-            severity: 'error',
             code: 'INTERNAL_SERVER_ERROR',
             ...issue
         });

package/esm/exception/http-errors/method-not-allowed.error.js

@@ -10,10 +10,9 @@ export class MethodNotAllowedError extends OpraException {
         super(...arguments);
         this.status = 405;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:METHOD_NOT_ALLOWED', 'Method not allowed'),
-            severity: 'error',
             code: 'METHOD_NOT_ALLOWED',
             ...issue
         });

package/esm/exception/http-errors/not-acceptable.error.js

@@ -10,10 +10,9 @@ export class NotAcceptableError extends OpraException {
         super(...arguments);
         this.status = 406;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:NOT_ACCEPTABLE', 'Not Acceptable'),
-            severity: 'error',
             code: 'NOT_ACCEPTABLE',
             ...issue
         });

package/esm/exception/http-errors/not-found.error.js

@@ -13,10 +13,9 @@ export class NotFoundError extends OpraException {
         super(...arguments);
         this.status = 404;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:NOT_FOUND', 'Not found'),
-            severity: 'error',
             code: 'NOT_FOUND',
             ...issue
         });

package/esm/exception/http-errors/unauthorized.error.js

@@ -10,10 +10,9 @@ export class UnauthorizedError extends OpraException {
         super(...arguments);
         this.status = 401;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:UNAUTHORIZED', 'You have not been authenticated to perform this action'),
-            severity: 'error',
             code: 'UNAUTHORIZED',
             ...issue
         });

package/esm/exception/http-errors/unprocessable-entity.error.js

@@ -9,8 +9,8 @@ export class UnprocessableEntityError extends OpraException {
         super(...arguments);
         this.status = 422;
     }
-    setIssue(issue) {
-        super.setIssue({
+    init(issue) {
+        super.init({
             message: translate('error:UNPROCESSABLE_ENTITY', 'Unprocessable entity'),
             severity: 'error',
             code: 'UNPROCESSABLE_ENTITY',

package/esm/exception/opra-exception.js

@@ -1,52 +1,67 @@
+import { omitUndefined } from '../helpers/index.js';
 import { i18n } from '../i18n/index.js';
+const inDevelopment = (process.env.NODE_ENV || '').startsWith('dev');
 /**
  * Defines the base Opra exception, which is handled by the default Exceptions Handler.
  */
 export class OpraException extends Error {
-    constructor(issue, cause) {
-        super('');
+    constructor(issue, arg1, arg2) {
+        super('Unknown error');
         this.status = 500;
-        this._initName();
+        let cause = arg1 && arg1 instanceof Error ? arg1 : undefined;
+        this.status = (typeof arg1 === 'number' ? arg1 : Number(arg2)) || 500;
         if (issue instanceof Error)
             cause = issue;
-        if (cause) {
+        // noinspection SuspiciousTypeOfGuard
+        if (cause && cause instanceof Error) {
             this.cause = cause;
             if (cause.stack)
                 this.stack = cause.stack;
         }
-        this._init(issue || cause || 'Unknown error');
-        this.message = i18n.deep(this.issue.message);
-    }
-    get issue() {
-        return this._issue;
-    }
-    setIssue(issue) {
-        this._issue = {
-            message: 'Unknown error',
-            severity: 'error',
-            ...issue,
-        };
+        if (typeof issue === 'string')
+            this.initString(issue);
+        else if (issue instanceof Error)
+            this.initError(issue);
+        else if (issue && typeof issue === 'object')
+            this.init(issue);
+        this.message = this.message || this.constructor.name;
     }
     setStatus(status) {
         this.status = status;
         return this;
     }
-    _initName() {
-        this.name = this.constructor.name;
+    toString() {
+        return i18n.deep(this.message);
     }
-    _init(issue) {
-        if (issue instanceof Error) {
-            if (typeof issue.status === 'number')
-                this.status = issue.status;
-            else if (typeof issue.getStatus === 'function')
-                this.status = issue.getStatus();
-            this.setIssue({ message: issue.message });
-        }
-        else if (typeof issue === 'object') {
-            this.setIssue(issue);
-        }
-        else {
-            this.setIssue({ message: String(issue) });
-        }
+    toJSON() {
+        return omitUndefined({
+            message: this.message,
+            severity: this.severity,
+            system: this.system,
+            code: this.code,
+            details: this.details,
+            stack: inDevelopment ? this.stack?.split('\n') : undefined
+        }, 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;
+    }
+    initString(issue) {
+        this.message = String(issue || '') || this.constructor.name;
+        this.severity = 'error';
+        this.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);
     }
 }

package/esm/exception/resource-errors/resource-not-found.error.js

@@ -7,14 +7,13 @@ import { OpraException } from '../opra-exception.js';
 export class ResourceNotFoundError extends OpraException {
     constructor(resource, keyValue, cause) {
         super({
-            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' could not be found`),
+            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? '@' + keyValue : '') }, `The resource '{{resource}}' not found`),
             severity: 'error',
             code: 'RESOURCE_NOT_FOUND',
             details: {
                 resource,
                 key: keyValue
             }
-        }, cause);
-        this.status = 404;
+        }, cause, 404);
     }
 }

package/esm/exception/wrap-exception.js

@@ -7,32 +7,32 @@ 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(e) {
-    if (e instanceof OpraException)
-        return e;
+export function wrapException(error) {
+    if (error instanceof OpraException)
+        return error;
     let status = 500;
-    if (typeof e.status === 'number')
-        status = e.status;
-    else if (typeof e.getStatus === 'function')
-        status = e.getStatus();
+    if (typeof error.status === 'number')
+        status = error.status;
+    else if (typeof error.getStatus === 'function')
+        status = error.getStatus();
     switch (status) {
         case 400:
-            return new BadRequestError(e);
+            return new BadRequestError(error);
         case 401:
-            return new UnauthorizedError(e);
+            return new UnauthorizedError(error);
         case 403:
-            return new ForbiddenError(e);
+            return new ForbiddenError(error);
         case 404:
-            return new NotFoundError(e);
+            return new NotFoundError(error);
         case 405:
-            return new MethodNotAllowedError(e);
+            return new MethodNotAllowedError(error);
         case 406:
-            return new NotAcceptableError(e);
+            return new NotAcceptableError(error);
         case 422:
-            return new UnprocessableEntityError(e);
+            return new UnprocessableEntityError(error);
         case 424:
-            return new FailedDependencyError(e);
+            return new FailedDependencyError(error);
         default:
-            return new FailedDependencyError(e);
+            return new FailedDependencyError(error);
     }
 }

package/esm/helpers/index.js

@@ -1,6 +1,6 @@
 export * from './function-utils.js';
 export * from './get-stack-filename.js';
-export * from './is-url.js';
+export * from './is-url-string.js';
 export * from './mixin-utils.js';
 export * from './object-utils.js';
 export * from './path-to-object-tree.js';

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

@@ -0,0 +1,9 @@
+import { URL } from 'url';
+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/object-utils.js

@@ -12,13 +12,13 @@ export function cloneObject(obj, jsonOnly) {
         }
     });
 }
-export function omitUndefined(obj) {
+export function omitUndefined(obj, recursive) {
     if (!(obj && typeof obj === 'object'))
         return obj;
     for (const k of Object.keys(obj)) {
         if (obj[k] === undefined)
             delete obj[k];
-        else if (typeof obj[k] === 'object')
+        else if (recursive && typeof obj[k] === 'object')
             omitUndefined(obj[k]);
     }
     return obj;

package/esm/helpers/responsive-map.js

@@ -2,10 +2,10 @@ var _a, _b, _c, _d;
 function isMap(v) {
     return v && typeof v.forEach === 'function';
 }
-const kKeyMap = Symbol('kKeyMap');
-const kKeyOrder = Symbol('kKeyOrder');
-const kWellKnownKeys = Symbol('kWellKnownKeys');
-const kOptions = Symbol('kOptions');
+const kKeyMap = Symbol.for('kKeyMap');
+const kKeyOrder = Symbol.for('kKeyOrder');
+const kWellKnownKeys = Symbol.for('kWellKnownKeys');
+const kOptions = Symbol.for('kOptions');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */

package/esm/helpers/type-guards.js

@@ -11,13 +11,15 @@ export function isStream(stream) {
 }
 export function isReadable(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x._read === 'function'
         && typeof x._readableState === 'object';
 }
+export function isWritable(x) {
+    return isStream(x)
+        && typeof x._write === 'function';
+}
 export function isReadableStream(x) {
     return isStream(x)
-        && x.readable !== false
         && typeof x.getReader === 'function'
         && typeof x.pipeThrough === 'function'
         && typeof x.pipeTo === 'function';
@@ -38,6 +40,13 @@ export function isFormData(x) {
 }
 export function isURL(x) {
     return x !== null
+        && typeof x == 'object'
         && typeof x.host === 'string'
         && typeof x.href === 'string';
 }
+export function isIterable(x) {
+    return Symbol.iterator in x;
+}
+export function isAsyncIterable(x) {
+    return Symbol.asyncIterator in x;
+}

package/esm/http/index.js

@@ -1,12 +1,5 @@
-export * from './http-params.js';
+export * from './opra-url.js';
+export * from './opra-url-path.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
 export * from './enums/http-status-messages.js';
-export * from './interfaces/client-http-headers.interface.js';
-export * from './interfaces/server-http-headers.interface.js';
-export * from './codecs/date-codec.js';
-export * from './codecs/boolean-codec.js';
-export * from './codecs/filter-codec.js';
-export * from './codecs/integer-codec.js';
-export * from './codecs/number-codec.js';
-export * from './codecs/string-codec.js';

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

@@ -0,0 +1,246 @@
+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];
+    }
+    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);
+            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
+ */
+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;
+}