@opra/common 0.33.13 → 1.0.0-alpha.10

package/esm/filter/filter-rules.js

@@ -0,0 +1,91 @@
+import { OpraException } from '../exception/index.js';
+import { OpraFilter } from '../filter/index.js';
+import { omitUndefined, ResponsiveMap } from '../helpers/index.js';
+import { translate } from '../i18n/index.js';
+export class FilterRules {
+    constructor(rules, options) {
+        this._rules = new ResponsiveMap();
+        Object.defineProperty(this, '_rules', {
+            value: new ResponsiveMap(null, { caseSensitive: options?.caseSensitive }),
+            enumerable: false,
+        });
+        if (rules) {
+            for (const [k, v] of Object.entries(rules)) {
+                this.set(k, v);
+            }
+        }
+    }
+    set(fieldName, options) {
+        const operators = typeof options?.operators === 'string'
+            ? options.operators.split(/\s*[,| ]\s*/)
+            : options?.operators;
+        this._rules.set(fieldName, omitUndefined({
+            ...options,
+            operators,
+        }));
+    }
+    normalizeFilter(filter, dataType) {
+        if (!filter)
+            return;
+        const ast = typeof filter === 'string' ? OpraFilter.parse(filter) : filter;
+        if (ast instanceof OpraFilter.ComparisonExpression) {
+            this.normalizeFilter(ast.left, dataType);
+            if (!(ast.left instanceof OpraFilter.QualifiedIdentifier && ast.left.field)) {
+                throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+            }
+            // Check if filtering accepted for given field
+            // const findManyOp = this.getOperation('findMany');
+            const rule = this._rules.get(ast.left.value);
+            if (!rule) {
+                throw new OpraException({
+                    message: translate('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                    code: 'UNACCEPTED_FILTER_FIELD',
+                    details: {
+                        field: ast.left.value,
+                    },
+                });
+            }
+            // Check if filtering endpoint accepted for given field
+            if (rule.operators && !rule.operators.includes(ast.op)) {
+                throw new OpraException({
+                    message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                    code: 'UNACCEPTED_FILTER_OPERATION',
+                    details: {
+                        field: ast.left.value,
+                        operator: ast.op,
+                    },
+                });
+            }
+            this.normalizeFilter(ast.right, dataType);
+            return ast;
+        }
+        if (ast instanceof OpraFilter.LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            return ast;
+        }
+        if (ast instanceof OpraFilter.ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item.expression, dataType));
+            return ast;
+        }
+        if (ast instanceof OpraFilter.ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            return ast;
+        }
+        if (ast instanceof OpraFilter.ParenthesizedExpression) {
+            this.normalizeFilter(ast.expression, dataType);
+            return ast;
+        }
+        if (ast instanceof OpraFilter.QualifiedIdentifier && dataType) {
+            ast.value = dataType.normalizeFieldPath(ast.value);
+            ast.field = dataType.getField(ast.value);
+            ast.dataType = ast.field.type;
+        }
+        return ast;
+    }
+    toJSON() {
+        return this._rules.toObject();
+    }
+    [Symbol.iterator]() {
+        return this._rules.entries();
+    }
+}

package/esm/filter/filter-tree-visitor.js

@@ -1,10 +1,8 @@
-import antlr4 from '@browsery/antlr4';
+import { ParseTreeVisitor } from '@browsery/antlr4';
 import { LogicalExpressionContext, } from './antlr/OpraFilterParser.js';
-import { ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NegativeExpression, NullLiteral, NumberLiteral, ParenthesizedExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
+import { ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, LogicalExpression, NegativeExpression, NullLiteral, NumberLiteral, ParenthesizedExpression, QualifiedIdentifier, StringLiteral, TimeLiteral, } from './ast/index.js';
 import { ExternalConstant } from './ast/terms/external-constant.js';
 import { unquoteFilterString } from './utils.js';
-// Fix: antlr4 d.ts files are invalid
-const ParseTreeVisitor = antlr4.tree.ParseTreeVisitor;
 export class FilterTreeVisitor extends ParseTreeVisitor {
     constructor(options) {
         super();
@@ -37,7 +35,7 @@ export class FilterTreeVisitor extends ParseTreeVisitor {
         return new ComparisonExpression({
             op: ctx.comparisonOperator().getText(),
             left: this.visit(ctx.comparisonLeft()),
-            right: this.visit(ctx.comparisonRight())
+            right: this.visit(ctx.comparisonRight()),
         });
     }
     visitLogicalExpression(ctx) {
@@ -55,7 +53,7 @@ export class FilterTreeVisitor extends ParseTreeVisitor {
         wrapChildren(ctx.expression_list(), ctx.logicalOperator().getText());
         return new LogicalExpression({
             op: ctx.logicalOperator().getText(),
-            items
+            items,
         });
     }
     visitQualifiedIdentifier(ctx) {

package/esm/filter/opra-filter.ns.js

@@ -1,5 +1,5 @@
 export * from './ast/index.js';
-export * from './parse.js';
 export * from './build.js';
-export * from './opra-error-listener.js';
 export * from './filter-tree-visitor.js';
+export * from './opra-error-listener.js';
+export * from './parse.js';

package/esm/filter/parse.js

@@ -21,9 +21,7 @@ export function parse(text, visitor) {
         const errMsgs = [];
         for (const err of errors) {
             errMsgs.push(err.message +
-                (text.includes('\n')
-                    ? (' at ' + 'line: ' + err.line + ' column: ' + err.column)
-                    : (' at ' + ' column: ' + err.column)));
+                (text.includes('\n') ? ' at line: ' + err.line + ' column: ' + err.column : ' at column: ' + err.column));
         }
         const e = new SyntaxError(errMsgs.join('\n'));
         e.errors = errors;

package/esm/filter/utils.js

@@ -8,9 +8,7 @@ function unescapeString(s) {
     return s.replace(unescapeRegEx, '$1');
 }
 export function quoteFilterString(s) {
-    return "'" +
-        escapeString(s).replace(quotesRegEx, '\\\'') +
-        "'";
+    return "'" + escapeString(s).replace(quotesRegEx, "\\'") + "'";
 }
 export function unquoteFilterString(s) {
     if (s && (s.startsWith("'") || s.startsWith('"')) && s.endsWith(s.charAt(0))) {

package/esm/helpers/function-utils.js

@@ -5,15 +5,7 @@ export async function resolveThunk(thunk) {
     if (typeof thunk === 'function') {
         if (isConstructor(thunk))
             return thunk;
-        return resolveClass(thunk());
+        return await thunk();
     }
     return thunk;
 }
-export async function resolveClass(thunk) {
-    thunk = promisify.isPromise(thunk) ? await thunk : thunk;
-    if (typeof thunk !== 'function')
-        throw new Error(`No Class type resolved`);
-    if (isConstructor(thunk))
-        return thunk;
-    return resolveClass(thunk());
-}

package/esm/helpers/get-stack-filename.js

@@ -2,7 +2,10 @@ const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
 export function getStackFileName(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
-            position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
+            position +
+            '` and Error.stackTraceLimit was: `' +
+            Error.stackTraceLimit +
+            '`');
     }
     const oldPrepareStackTrace = Error.prepareStackTrace;
     Error.prepareStackTrace = (_, stack) => stack;
@@ -11,8 +14,28 @@ export function getStackFileName(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        const s = stack[position] ?
-            stack[position].getFileName() : undefined;
+        const s = stack[position] ? stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
+    }
+    return '';
+}
+export function getErrorStack(position = 1) {
+    if (position >= Error.stackTraceLimit) {
+        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
+            position +
+            '` and Error.stackTraceLimit was: `' +
+            Error.stackTraceLimit +
+            '`');
+    }
+    const oldPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const stack = new Error().stack;
+    Error.prepareStackTrace = oldPrepareStackTrace;
+    if (stack !== null && typeof stack === 'object') {
+        // stack[0] holds this file
+        // stack[1] holds where this function was called
+        const s = stack[position] ? stack[position].getFileName() : undefined;
         const m = s ? PATH_PATTERN.exec(s) : undefined;
         return m ? m[1] : '';
     }

package/esm/helpers/index.js

@@ -1,8 +1,8 @@
+import './monkey-patches.js';
 export * from './function-utils.js';
 export * from './get-stack-filename.js';
-export * from './is-url-string.js';
 export * from './mixin-utils.js';
 export * from './object-utils.js';
-export * from './path-to-object-tree.js';
+export * from './parse-fields-projection.js';
 export * from './responsive-map.js';
 export * from './type-guards.js';

package/esm/helpers/mixin-utils.js

@@ -1,10 +1,9 @@
 export function mergePrototype(targetProto, baseProto, filter) {
     for (const k of Object.getOwnPropertyNames(baseProto)) {
-        if ((k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString') ||
-            filter && !filter(k))
+        if (k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString' || (filter && !filter(k))) {
             continue;
-        Object.defineProperty(targetProto, k, Object.getOwnPropertyDescriptor(baseProto, k) ||
-            Object.create(null));
+        }
+        Object.defineProperty(targetProto, k, Object.getOwnPropertyDescriptor(baseProto, k) || Object.create(null));
     }
 }
 // noinspection JSUnusedLocalSymbols
@@ -15,10 +14,9 @@ isPropertyInherited = (key) => true) {
         const tempInstance = new clazz();
         const propertyNames = Object.getOwnPropertyNames(tempInstance);
         propertyNames
-            .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&
-            typeof target[propertyName] === 'undefined')
-            .filter((propertyName) => isPropertyInherited(propertyName))
-            .forEach((propertyName) => {
+            .filter(propertyName => typeof tempInstance[propertyName] !== 'undefined' && typeof target[propertyName] === 'undefined')
+            .filter(propertyName => isPropertyInherited(propertyName))
+            .forEach(propertyName => {
             target[propertyName] = tempInstance[propertyName];
         });
     }

package/esm/helpers/monkey-patches.js

@@ -0,0 +1,14 @@
+"use strict";
+/** monkey patch (hijack)
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+ */
+if (!BigInt.prototype.toJSON) {
+    BigInt.prototype.toJSON = function () {
+        return this.toString();
+    };
+}
+if (!RegExp.prototype.toJSON) {
+    RegExp.prototype.toJSON = function () {
+        return this.toString();
+    };
+}

package/esm/helpers/object-utils.js

@@ -3,13 +3,12 @@ import merge from 'putil-merge';
 import { DATATYPE_METADATA } from '../document/constants.js';
 export function cloneObject(obj, jsonOnly) {
     return merge({}, obj, {
-        deep: (v) => isPlainObject(v) && !v[DATATYPE_METADATA],
+        deep: v => isPlainObject(v) && !v[DATATYPE_METADATA],
         filter: (source, key) => {
             const v = source[key];
-            return v != null &&
-                !jsonOnly || (typeof v !== 'function' &&
-                (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v)));
-        }
+            return ((v != null && !jsonOnly) ||
+                (typeof v !== 'function' && (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v))));
+        },
     });
 }
 export function omitUndefined(obj, recursive) {

package/esm/helpers/parse-fields-projection.js

@@ -0,0 +1,59 @@
+import { splitString } from 'fast-tokenizer';
+const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
+const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
+export class FieldsProjection {
+}
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (FieldsProjection = {}));
+export function parseFieldsProjection(projection, keepCase) {
+    const arr = Array.isArray(projection) ? projection : [projection];
+    if (!(arr && arr.length))
+        return;
+    const out = new FieldsProjection();
+    for (let s of arr) {
+        if (!keepCase)
+            s = s.toLowerCase();
+        parse(s, out);
+    }
+    return out;
+}
+export function parse(input, target) {
+    /** Add dot before brackets which is required to split fields */
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
+    const fields = splitString(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = splitString(f, {
+                delimiters: ',',
+                brackets: true,
+                keepBrackets: true,
+            });
+            for (const n of subFields) {
+                parse(n, target);
+            }
+            continue;
+        }
+        const m = FIELD_PATTERN.exec(f);
+        /* istanbul ignore next */
+        if (!m)
+            throw new TypeError(`Invalid field path (${input})`);
+        const fieldName = m[2];
+        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        if (m[1])
+            treeItem.sign = m[1];
+        if (i === fields.length - 1) {
+            delete treeItem.projection;
+        }
+        else {
+            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+        }
+    }
+}

package/esm/helpers/responsive-map.js

@@ -1,45 +1,87 @@
-var _a, _b, _c, _d;
 function isMap(v) {
     return v && typeof v.forEach === 'function';
 }
+const kEntries = Symbol.for('kEntries');
 const kKeyMap = Symbol.for('kKeyMap');
-const kKeyOrder = Symbol.for('kKeyOrder');
 const kWellKnownKeys = Symbol.for('kWellKnownKeys');
 const kOptions = Symbol.for('kOptions');
+const kSize = Symbol.for('kSize');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-export class ResponsiveMap extends Map {
+export class ResponsiveMap {
     constructor(init, options) {
-        super();
-        this[_a] = new Map();
-        this[_b] = [];
-        this[_c] = new Map();
-        this[_d] = { caseSensitive: false };
-        this[kOptions].caseSensitive = !!options?.caseSensitive;
-        if (options?.wellKnownKeys)
-            options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
+        Object.defineProperty(this, kSize, {
+            value: 0,
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kEntries, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kKeyMap, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kWellKnownKeys, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        const caseSensitive = !!options?.caseSensitive;
+        Object.defineProperty(this, kOptions, {
+            value: {
+                caseSensitive,
+            },
+            enumerable: false,
+        });
+        if (options?.wellKnownKeys) {
+            options.wellKnownKeys.forEach(k => {
+                if (caseSensitive)
+                    this[kWellKnownKeys][k] = k;
+                else
+                    this[kWellKnownKeys][k.toLowerCase()] = k;
+            });
+        }
+        this.clear();
         if (init)
             this.setAll(init);
     }
+    get size() {
+        return this[kSize];
+    }
     clear() {
-        super.clear();
-        this[kKeyMap].clear();
-        this[kKeyOrder] = [];
+        Object.keys(this[kEntries]).forEach(k => delete this[kEntries][k]);
+        Object.keys(this[kKeyMap]).forEach(k => delete this[kKeyMap][k]);
+        this[kSize] = 0;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this.entries()) {
+            callbackfn.call(thisArg, v, k, this);
+        }
     }
     get(key) {
-        const orgKey = this._getOriginalKey(key);
-        return super.get(orgKey);
+        if (!key)
+            return;
+        return this[kEntries][this._getStoringKey(key)];
     }
     has(key) {
-        return this[kKeyMap].has(this._getStoringKey(key));
+        if (!key)
+            return false;
+        return Object.prototype.hasOwnProperty.call(this[kEntries], this._getStoringKey(key));
     }
     set(key, value) {
+        const storeKey = this._getStoringKey(key);
         key = this._getOriginalKey(key);
-        this[kKeyMap].set(this._getStoringKey(key), key);
-        if (!this[kKeyOrder].includes(key))
-            this[kKeyOrder].push(key);
-        return super.set(key, value);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
+        this[kEntries][storeKey] = value;
+        if (!exists)
+            this[kSize]++;
+        this[kKeyMap][storeKey] = key;
+        return this;
     }
     setAll(source) {
         if (isMap(source))
@@ -49,122 +91,57 @@ export class ResponsiveMap extends Map {
         return this;
     }
     keys() {
-        return [...this[kKeyOrder]][Symbol.iterator]();
+        return Object.values(this[kKeyMap])[Symbol.iterator]();
     }
     values() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: map.get(arr[i])
-                };
-            }
-        };
+        return Object.values(this[kEntries])[Symbol.iterator]();
     }
     entries() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: [arr[i], map.get(arr[i])]
-                };
-            }
-        };
+        return Object.entries(this[kEntries])[Symbol.iterator]();
     }
     delete(key) {
-        const orgKey = this._getOriginalKey(key);
-        const k = this._getStoringKey(key);
-        this[kKeyMap].delete(k);
-        const i = this[kKeyOrder].indexOf(orgKey);
-        if (i >= 0)
-            this[kKeyOrder].splice(i, 1);
-        return super.delete(orgKey);
+        const storeKey = this._getStoringKey(key);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
+        delete this[kEntries][storeKey];
+        delete this[kKeyMap][storeKey];
+        if (!exists)
+            this[kSize]--;
+        return exists;
     }
     sort(compareFn) {
+        const oldValues = { ...this[kEntries] };
+        const oldKeymap = { ...this[kKeyMap] };
+        const keys = Array.from(this.keys());
         if (compareFn)
-            this[kKeyOrder].sort(compareFn);
-        else if (this[kOptions].caseSensitive)
-            this[kKeyOrder].sort();
+            keys.sort(compareFn);
         else
-            this[kKeyOrder].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            keys.sort();
+        this.clear();
+        for (const k of keys) {
+            this[kEntries][k] = oldValues[k];
+            this[kKeyMap][k] = oldKeymap[k];
+        }
+        this[kSize] = keys.length;
         return this;
     }
-    getProxy(handler) {
-        const _this = this;
-        const finalHandler = {
-            get(target, p, receiver) {
-                if (typeof p === 'string')
-                    return _this.get(p);
-                return Reflect.get(target, p, receiver);
-            },
-            set(target, p, newValue, receiver) {
-                if (typeof p === 'string') {
-                    _this.set(p, newValue);
-                    return true;
-                }
-                return Reflect.set(target, p, newValue, receiver);
-            },
-            has(target, p) {
-                if (typeof p === 'string')
-                    return _this.has(p);
-                return Reflect.has(target, p);
-            },
-            ownKeys() {
-                return Array.from(_this.keys()).map(x => x.toLowerCase());
-            },
-            getPrototypeOf() {
-                return Object.prototype;
-            },
-            defineProperty(target, property, attributes) {
-                if (typeof property === 'string') {
-                    _this.set(property, attributes.value);
-                    return true;
-                }
-                return false;
-            },
-            deleteProperty(target, p) {
-                if (typeof p === 'string')
-                    return _this.delete(p);
-                return false;
-            },
-            getOwnPropertyDescriptor(target, key) {
-                if (typeof key === 'string') {
-                    const value = finalHandler.get(target, key);
-                    return { configurable: true, enumerable: true, writable: true, value };
-                }
-            },
-            ...handler
-        };
-        return new Proxy({}, finalHandler);
-    }
     toObject() {
-        return Object.keys(this.keys()).reduce((trg, k) => {
-            trg[k] = this.get(k);
-            return trg;
-        }, {});
+        const out = {};
+        for (const [storeKey, orgKey] of Object.entries(this[kKeyMap])) {
+            out[orgKey] = this[kEntries][storeKey];
+        }
+        return out;
     }
-    [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this.entries();
     }
+    get [Symbol.toStringTag]() {
+        return '[Object ResponsiveMap]';
+    }
     _getOriginalKey(key) {
         if (!key || this[kOptions].caseSensitive)
             return key;
-        return this[kKeyMap].get(key.toLowerCase()) ??
-            (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
+        const storeKey = this._getStoringKey(key);
+        return this[kKeyMap][storeKey] ?? this[kWellKnownKeys][storeKey] ?? key;
     }
     _getStoringKey(key) {
         if (this[kOptions].caseSensitive)