remult 0.14.2 → 0.14.5

package/src/filter/filter-interfaces.js

@@ -1,76 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFilterFromRequestParameters = exports.entityFilterToJson = exports.FilterSerializer = exports.customDatabaseFilterToken = exports.customUrlToken = exports.OrFilter = exports.AndFilter = exports.filterHelper = exports.Filter = void 0;
-var tslib_1 = require("tslib");
-var remult3_1 = require("../remult3");
-var Filter = /** @class */ (function () {
-    function Filter(apply) {
+import { getEntityRef, getEntitySettings } from "../remult3";
+export class Filter {
+    constructor(apply) {
         this.apply = apply;
         if (!this.apply) {
-            this.apply = function () { };
+            this.apply = () => { };
         }
     }
-    Filter.prototype.__applyToConsumer = function (add) {
+    __applyToConsumer(add) {
         this.apply(add);
-    };
-    Filter.resolve = function (filter) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(typeof filter === "function")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, filter()];
-                    case 1: return [2 /*return*/, _a.sent()];
-                    case 2: return [2 /*return*/, filter];
-                }
-            });
-        });
-    };
-    Filter.createCustom = function (customFilterTranslator, key) {
-        if (key === void 0) { key = ''; }
-        var customFilterInfo = { key: key, customFilterTranslator: customFilterTranslator };
-        return Object.assign(function (x) {
-            var _a;
-            var z = {};
+    }
+    static async resolve(filter) {
+        if (typeof filter === "function")
+            return await filter();
+        return filter;
+    }
+    static createCustom(customFilterTranslator, key = '') {
+        let customFilterInfo = { key: key, customFilterTranslator };
+        return Object.assign((x) => {
+            let z = {};
             if (x == undefined)
                 x = {};
             if (!customFilterInfo.key)
                 throw "Usage of custom filter before a key was assigned to it";
-            return _a = {},
-                _a[exports.customUrlToken + customFilterInfo.key] = x,
-                _a;
-        }, { customFilterInfo: customFilterInfo });
-    };
-    Filter.fromEntityFilter = function (entity, whereItem) {
-        var result = [];
-        var _loop_1 = function (key) {
+            return {
+                [customUrlToken + customFilterInfo.key]: x
+            };
+        }, { customFilterInfo });
+    }
+    static fromEntityFilter(entity, whereItem) {
+        let result = [];
+        for (const key in whereItem) {
             if (Object.prototype.hasOwnProperty.call(whereItem, key)) {
-                var fieldToFilter_1 = whereItem[key];
+                let fieldToFilter = whereItem[key];
                 {
                     if (key == "$or") {
-                        result.push(new (OrFilter.bind.apply(OrFilter, tslib_1.__spread([void 0], fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); }))))());
+                        result.push(new OrFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
                     }
                     else if (key == "$and") {
-                        result.push(new (AndFilter.bind.apply(AndFilter, tslib_1.__spread([void 0], fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); }))))());
+                        result.push(new AndFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
                     }
-                    else if (key.startsWith(exports.customUrlToken)) {
-                        result.push(new Filter(function (x) {
-                            x.custom(key.substring(exports.customUrlToken.length), fieldToFilter_1);
+                    else if (key.startsWith(customUrlToken)) {
+                        result.push(new Filter(x => {
+                            x.custom(key.substring(customUrlToken.length), fieldToFilter);
                         }));
                     }
-                    else if (key == exports.customDatabaseFilterToken) {
-                        result.push(new Filter(function (x) { return x.databaseCustom(fieldToFilter_1); }));
+                    else if (key == customDatabaseFilterToken) {
+                        result.push(new Filter(x => x.databaseCustom(fieldToFilter)));
                     }
                     else {
-                        var fh = new filterHelper(entity.fields[key]);
-                        var found = false;
-                        if (fieldToFilter_1 !== undefined && fieldToFilter_1 != null) {
-                            if (fieldToFilter_1.$id)
-                                fieldToFilter_1 = fieldToFilter_1.$id;
-                            for (var key_1 in fieldToFilter_1) {
-                                if (Object.prototype.hasOwnProperty.call(fieldToFilter_1, key_1)) {
-                                    var element = fieldToFilter_1[key_1];
-                                    switch (key_1) {
+                        let fh = new filterHelper(entity.fields[key]);
+                        let found = false;
+                        if (fieldToFilter !== undefined && fieldToFilter != null) {
+                            if (fieldToFilter.$id)
+                                fieldToFilter = fieldToFilter.$id;
+                            for (const key in fieldToFilter) {
+                                if (Object.prototype.hasOwnProperty.call(fieldToFilter, key)) {
+                                    const element = fieldToFilter[key];
+                                    switch (key) {
                                         case "$gte":
                                         case ">=":
                                             result.push(fh.isGreaterOrEqualTo(element));
@@ -107,328 +93,234 @@ var Filter = /** @class */ (function () {
                                     }
                                 }
                             }
-                            if (Array.isArray(fieldToFilter_1)) {
+                            if (Array.isArray(fieldToFilter)) {
                                 found = true;
-                                result.push(fh.isIn(fieldToFilter_1));
+                                result.push(fh.isIn(fieldToFilter));
                             }
                         }
-                        if (!found && fieldToFilter_1 !== undefined) {
-                            result.push(fh.isEqualTo(fieldToFilter_1));
+                        if (!found && fieldToFilter !== undefined) {
+                            result.push(fh.isEqualTo(fieldToFilter));
                         }
                     }
                 }
             }
-        };
-        for (var key in whereItem) {
-            _loop_1(key);
         }
-        return new (AndFilter.bind.apply(AndFilter, tslib_1.__spread([void 0], result)))();
-    };
-    Filter.prototype.toJson = function () {
-        var r = new FilterSerializer();
+        return new AndFilter(...result);
+    }
+    toJson() {
+        let r = new FilterSerializer();
         this.__applyToConsumer(r);
         return r.result;
-    };
-    Filter.entityFilterToJson = function (entityDefs, where) {
+    }
+    static entityFilterToJson(entityDefs, where) {
         return Filter.fromEntityFilter(entityDefs, where).toJson();
-    };
-    Filter.entityFilterFromJson = function (entityDefs, packed) {
-        return buildFilterFromRequestParameters(entityDefs, { get: function (key) { return packed[key]; } });
-    };
-    Filter.translateCustomWhere = function (r, entity, remult) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var f;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        f = new customTranslator(function (filterKey, custom) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var r, _a, _b, _i, key, element, _c, _d, _e, _f, _g;
-                            return tslib_1.__generator(this, function (_h) {
-                                switch (_h.label) {
-                                    case 0:
-                                        r = [];
-                                        _a = [];
-                                        for (_b in entity.entityType)
-                                            _a.push(_b);
-                                        _i = 0;
-                                        _h.label = 1;
-                                    case 1:
-                                        if (!(_i < _a.length)) return [3 /*break*/, 5];
-                                        key = _a[_i];
-                                        element = entity.entityType[key];
-                                        if (!(element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator)) return [3 /*break*/, 4];
-                                        if (!(element.customFilterInfo.key == filterKey)) return [3 /*break*/, 4];
-                                        _d = (_c = r).push;
-                                        _f = (_e = Filter).fromEntityFilter;
-                                        _g = [entity];
-                                        return [4 /*yield*/, element.customFilterInfo.customFilterTranslator(remult, custom)];
-                                    case 2: return [4 /*yield*/, _f.apply(_e, _g.concat([_h.sent()]))];
-                                    case 3:
-                                        _d.apply(_c, [_h.sent()]);
-                                        _h.label = 4;
-                                    case 4:
-                                        _i++;
-                                        return [3 /*break*/, 1];
-                                    case 5: return [2 /*return*/, r];
-                                }
-                            });
-                        }); });
-                        r.__applyToConsumer(f);
-                        return [4 /*yield*/, f.resolve()];
-                    case 1:
-                        _a.sent();
-                        r = new Filter(function (x) { return f.applyTo(x); });
-                        return [2 /*return*/, r];
+    }
+    static entityFilterFromJson(entityDefs, packed) {
+        return buildFilterFromRequestParameters(entityDefs, { get: (key) => packed[key] });
+    }
+    static async translateCustomWhere(r, entity, remult) {
+        let f = new customTranslator(async (filterKey, custom) => {
+            let r = [];
+            for (const key in entity.entityType) {
+                const element = entity.entityType[key];
+                if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+                    if (element.customFilterInfo.key == filterKey) {
+                        r.push(await Filter.fromEntityFilter(entity, await element.customFilterInfo.customFilterTranslator(remult, custom)));
+                    }
                 }
-            });
+            }
+            return r;
         });
-    };
-    return Filter;
-}());
-exports.Filter = Filter;
-var filterHelper = /** @class */ (function () {
-    function filterHelper(metadata) {
+        r.__applyToConsumer(f);
+        await f.resolve();
+        r = new Filter(x => f.applyTo(x));
+        return r;
+    }
+}
+export class filterHelper {
+    constructor(metadata) {
         this.metadata = metadata;
     }
-    filterHelper.prototype.processVal = function (val) {
-        var ei = remult3_1.getEntitySettings(this.metadata.valueType, false);
+    processVal(val) {
+        let ei = getEntitySettings(this.metadata.valueType, false);
         if (ei) {
             if (!val)
                 return null;
             if (typeof val === "string" || typeof val === "number")
                 return val;
-            return remult3_1.getEntityRef(val).getId();
+            return getEntityRef(val).getId();
         }
         return val;
-    };
-    filterHelper.prototype.contains = function (val) {
-        var _this = this;
-        return new Filter(function (add) { return add.containsCaseInsensitive(_this.metadata, val); });
-    };
-    filterHelper.prototype.isLessThan = function (val) {
-        var _this = this;
+    }
+    contains(val) {
+        return new Filter(add => add.containsCaseInsensitive(this.metadata, val));
+    }
+    isLessThan(val) {
         val = this.processVal(val);
-        return new Filter(function (add) { return add.isLessThan(_this.metadata, val); });
-    };
-    filterHelper.prototype.isGreaterOrEqualTo = function (val) {
-        var _this = this;
+        return new Filter(add => add.isLessThan(this.metadata, val));
+    }
+    isGreaterOrEqualTo(val) {
         val = this.processVal(val);
-        return new Filter(function (add) { return add.isGreaterOrEqualTo(_this.metadata, val); });
-    };
-    filterHelper.prototype.isNotIn = function (values) {
-        var _this = this;
-        return new Filter(function (add) {
-            var e_1, _a;
-            try {
-                for (var values_1 = tslib_1.__values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
-                    var v = values_1_1.value;
-                    add.isDifferentFrom(_this.metadata, _this.processVal(v));
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
-                }
-                finally { if (e_1) throw e_1.error; }
+        return new Filter(add => add.isGreaterOrEqualTo(this.metadata, val));
+    }
+    isNotIn(values) {
+        return new Filter(add => {
+            for (const v of values) {
+                add.isDifferentFrom(this.metadata, this.processVal(v));
             }
         });
-    };
-    filterHelper.prototype.isDifferentFrom = function (val) {
-        var _this = this;
+    }
+    isDifferentFrom(val) {
         val = this.processVal(val);
         if ((val === null || val === undefined) && this.metadata.allowNull)
-            return new Filter(function (add) { return add.isNotNull(_this.metadata); });
-        return new Filter(function (add) { return add.isDifferentFrom(_this.metadata, val); });
-    };
-    filterHelper.prototype.isLessOrEqualTo = function (val) {
-        var _this = this;
+            return new Filter(add => add.isNotNull(this.metadata));
+        return new Filter(add => add.isDifferentFrom(this.metadata, val));
+    }
+    isLessOrEqualTo(val) {
         val = this.processVal(val);
-        return new Filter(function (add) { return add.isLessOrEqualTo(_this.metadata, val); });
-    };
-    filterHelper.prototype.isGreaterThan = function (val) {
-        var _this = this;
+        return new Filter(add => add.isLessOrEqualTo(this.metadata, val));
+    }
+    isGreaterThan(val) {
         val = this.processVal(val);
-        return new Filter(function (add) { return add.isGreaterThan(_this.metadata, val); });
-    };
-    filterHelper.prototype.isEqualTo = function (val) {
-        var _this = this;
+        return new Filter(add => add.isGreaterThan(this.metadata, val));
+    }
+    isEqualTo(val) {
         val = this.processVal(val);
         if ((val === null || val === undefined) && this.metadata.allowNull)
-            return new Filter(function (add) { return add.isNull(_this.metadata); });
-        return new Filter(function (add) { return add.isEqualTo(_this.metadata, val); });
-    };
-    filterHelper.prototype.isIn = function (val) {
-        var _this = this;
-        val = val.map(function (x) { return _this.processVal(x); });
-        return new Filter(function (add) { return add.isIn(_this.metadata, val); });
-    };
-    return filterHelper;
-}());
-exports.filterHelper = filterHelper;
-var AndFilter = /** @class */ (function (_super) {
-    tslib_1.__extends(AndFilter, _super);
-    function AndFilter() {
-        var filters = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            filters[_i] = arguments[_i];
-        }
-        var _this = _super.call(this, function (add) {
-            var e_2, _a;
-            try {
-                for (var _b = tslib_1.__values(_this.filters), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var iterator = _c.value;
-                    if (iterator)
-                        iterator.__applyToConsumer(add);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_2) throw e_2.error; }
+            return new Filter(add => add.isNull(this.metadata));
+        return new Filter(add => add.isEqualTo(this.metadata, val));
+    }
+    isIn(val) {
+        val = val.map(x => this.processVal(x));
+        return new Filter(add => add.isIn(this.metadata, val));
+    }
+}
+export class AndFilter extends Filter {
+    constructor(...filters) {
+        super(add => {
+            for (const iterator of this.filters) {
+                if (iterator)
+                    iterator.__applyToConsumer(add);
             }
-        }) || this;
-        _this.filters = filters;
-        return _this;
+        });
+        this.filters = filters;
     }
-    AndFilter.prototype.add = function (filter) {
+    add(filter) {
         this.filters.push(filter);
-    };
-    return AndFilter;
-}(Filter));
-exports.AndFilter = AndFilter;
-var OrFilter = /** @class */ (function (_super) {
-    tslib_1.__extends(OrFilter, _super);
-    function OrFilter() {
-        var filters = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            filters[_i] = arguments[_i];
-        }
-        var _this = _super.call(this, function (add) {
-            var f = _this.filters.filter(function (x) { return x !== undefined; });
+    }
+}
+export class OrFilter extends Filter {
+    constructor(...filters) {
+        super(add => {
+            let f = this.filters.filter(x => x !== undefined);
             if (f.length > 1) {
                 add.or(f);
             }
             else if (f.length == 1)
                 f[0].__applyToConsumer(add);
-        }) || this;
-        _this.filters = filters;
-        return _this;
-    }
-    return OrFilter;
-}(Filter));
-exports.OrFilter = OrFilter;
-exports.customUrlToken = "$custom$";
-exports.customDatabaseFilterToken = "$db$";
-var FilterSerializer = /** @class */ (function () {
-    function FilterSerializer() {
+        });
+        this.filters = filters;
+    }
+}
+export const customUrlToken = "$custom$";
+export const customDatabaseFilterToken = "$db$";
+export class FilterSerializer {
+    constructor() {
         this.result = {};
         this.hasUndefined = false;
     }
-    FilterSerializer.prototype.databaseCustom = function (databaseCustom) {
+    databaseCustom(databaseCustom) {
         throw new Error("database custom is not allowed with api calls.");
-    };
-    FilterSerializer.prototype.custom = function (key, customItem) {
-        this.add(exports.customUrlToken + key, customItem);
-    };
-    FilterSerializer.prototype.add = function (key, val) {
+    }
+    custom(key, customItem) {
+        this.add(customUrlToken + key, customItem);
+    }
+    add(key, val) {
         if (val === undefined)
             this.hasUndefined = true;
-        var r = this.result;
+        let r = this.result;
         if (!r[key]) {
             r[key] = val;
             return;
         }
-        var v = r[key];
+        let v = r[key];
         if (v instanceof Array) {
             v.push(val);
         }
         else
             v = [v, val];
         r[key] = v;
-    };
-    FilterSerializer.prototype.or = function (orElements) {
-        this.add("OR", orElements.map(function (x) {
-            var f = new FilterSerializer();
+    }
+    or(orElements) {
+        this.add("OR", orElements.map(x => {
+            let f = new FilterSerializer();
             x.__applyToConsumer(f);
             return f.result;
         }));
-    };
-    FilterSerializer.prototype.isNull = function (col) {
+    }
+    isNull(col) {
         this.add(col.key + "_null", true);
-    };
-    FilterSerializer.prototype.isNotNull = function (col) {
+    }
+    isNotNull(col) {
         this.add(col.key + "_null", false);
-    };
-    FilterSerializer.prototype.isIn = function (col, val) {
-        this.add(col.key + "_in", val.map(function (x) { return col.valueConverter.toJson(x); }));
-    };
-    FilterSerializer.prototype.isEqualTo = function (col, val) {
+    }
+    isIn(col, val) {
+        this.add(col.key + "_in", val.map(x => col.valueConverter.toJson(x)));
+    }
+    isEqualTo(col, val) {
         this.add(col.key, col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.isDifferentFrom = function (col, val) {
+    }
+    isDifferentFrom(col, val) {
         this.add(col.key + '_ne', col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.isGreaterOrEqualTo = function (col, val) {
+    }
+    isGreaterOrEqualTo(col, val) {
         this.add(col.key + '_gte', col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.isGreaterThan = function (col, val) {
+    }
+    isGreaterThan(col, val) {
         this.add(col.key + '_gt', col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.isLessOrEqualTo = function (col, val) {
+    }
+    isLessOrEqualTo(col, val) {
         this.add(col.key + '_lte', col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.isLessThan = function (col, val) {
+    }
+    isLessThan(col, val) {
         this.add(col.key + '_lt', col.valueConverter.toJson(val));
-    };
-    FilterSerializer.prototype.containsCaseInsensitive = function (col, val) {
+    }
+    containsCaseInsensitive(col, val) {
         this.add(col.key + "_contains", val);
-    };
-    return FilterSerializer;
-}());
-exports.FilterSerializer = FilterSerializer;
-function entityFilterToJson(entityDefs, where) {
+    }
+}
+export function entityFilterToJson(entityDefs, where) {
     if (!where)
         return {};
     return (Filter.fromEntityFilter(entityDefs, where)).toJson();
 }
-exports.entityFilterToJson = entityFilterToJson;
-function buildFilterFromRequestParameters(entity, filterInfo) {
-    var _a;
-    var where = [];
-    tslib_1.__spread(entity.fields).forEach(function (col) {
-        var _a, _b;
-        function addFilter(operation, theFilter, jsonArray, asString) {
-            var e_3, _a;
-            if (jsonArray === void 0) { jsonArray = false; }
-            if (asString === void 0) { asString = false; }
-            var val = filterInfo.get(col.key + operation);
+export function buildFilterFromRequestParameters(entity, filterInfo) {
+    let where = [];
+    [...entity.fields].forEach(col => {
+        function addFilter(operation, theFilter, jsonArray = false, asString = false) {
+            let val = filterInfo.get(col.key + operation);
             if (val !== undefined) {
-                var addFilter_1 = function (val) {
-                    var _a;
-                    var theVal = val;
+                let addFilter = (val) => {
+                    let theVal = val;
                     if (jsonArray) {
-                        var arr = void 0;
+                        let arr;
                         if (typeof val === 'string')
                             arr = JSON.parse(val);
                         else
                             arr = val;
-                        theVal = arr.map(function (x) { return asString ? x : col.valueConverter.fromJson(x); });
+                        theVal = arr.map(x => asString ? x : col.valueConverter.fromJson(x));
                     }
                     else {
                         theVal = asString ? theVal : col.valueConverter.fromJson(theVal);
                     }
-                    var f = theFilter(theVal);
+                    let f = theFilter(theVal);
                     if (f !== undefined) {
-                        where.push((_a = {}, _a[col.key] = f, _a));
+                        where.push({ [col.key]: f });
                     }
                 };
                 if (!jsonArray && val instanceof Array) {
-                    val.forEach(function (v) {
-                        addFilter_1(v);
+                    val.forEach(v => {
+                        addFilter(v);
                     });
                 }
                 else {
@@ -436,31 +328,21 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                         if (typeof val === 'string')
                             val = JSON.parse(val);
                     }
-                    var array = separateArrayFromInnerArray(val);
-                    try {
-                        for (var array_1 = tslib_1.__values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
-                            var x = array_1_1.value;
-                            addFilter_1(x);
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
+                    const array = separateArrayFromInnerArray(val);
+                    for (const x of array) {
+                        addFilter(x);
                     }
                 }
             }
         }
-        var c = new filterHelper(col);
-        addFilter('', function (val) { return val; });
-        addFilter('_gt', function (val) { return ({ "$gt": val }); });
-        addFilter('_gte', function (val) { return ({ "$gte": val }); });
-        addFilter('_lt', function (val) { return ({ "$lt": val }); });
-        addFilter('_lte', function (val) { return ({ "$lte": val }); });
-        addFilter('_ne', function (val) { return ({ "$ne": val }); });
-        addFilter('_in', function (val) { return val; }, true);
+        let c = new filterHelper(col);
+        addFilter('', val => val);
+        addFilter('_gt', val => ({ "$gt": val }));
+        addFilter('_gte', val => ({ "$gte": val }));
+        addFilter('_lt', val => ({ "$lt": val }));
+        addFilter('_lte', val => ({ "$lte": val }));
+        addFilter('_ne', val => ({ "$ne": val }));
+        addFilter('_in', val => val, true);
         var nullFilter = filterInfo.get(col.key + "_null");
         if (nullFilter) {
             nullFilter = nullFilter.toString().trim().toLowerCase();
@@ -468,163 +350,118 @@ function buildFilterFromRequestParameters(entity, filterInfo) {
                 case "y":
                 case "true":
                 case "yes":
-                    where.push((_a = {}, _a[col.key] = null, _a));
+                    where.push({ [col.key]: null });
                     break;
                 default:
-                    where.push((_b = {}, _b[col.key] = { "$ne": null }, _b));
+                    where.push({ [col.key]: { "$ne": null } });
                     break;
             }
         }
-        addFilter('_contains', function (val) { return ({ $contains: val }); }, false, true);
+        addFilter('_contains', val => ({ $contains: val }), false, true);
     });
-    var val = filterInfo.get('OR');
+    let val = filterInfo.get('OR');
     if (val) {
-        var array = separateArrayFromInnerArray(val);
+        const array = separateArrayFromInnerArray(val);
         where.push({
-            $and: array.map(function (v) { return ({
-                $or: v.map(function (x) {
-                    return buildFilterFromRequestParameters(entity, { get: function (key) { return x[key]; } });
-                })
-            }); })
+            $and: array.map(v => ({
+                $or: v.map(x => buildFilterFromRequestParameters(entity, { get: (key) => x[key] }))
+            }))
         });
     }
-    for (var key in entity.entityType) {
-        var element = entity.entityType[key];
+    for (const key in entity.entityType) {
+        const element = entity.entityType[key];
         if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
-            var custom = filterInfo.get(exports.customUrlToken + key);
+            let custom = filterInfo.get(customUrlToken + key);
             if (custom !== undefined) {
-                where.push((_a = {}, _a[exports.customUrlToken + key] = custom, _a));
+                where.push({ [customUrlToken + key]: custom });
             }
         }
     }
     return { $and: where };
     function separateArrayFromInnerArray(val) {
-        var e_4, _a;
         if (!Array.isArray(val))
             return [val];
-        var nonArray = [], array = [];
-        try {
-            for (var val_1 = tslib_1.__values(val), val_1_1 = val_1.next(); !val_1_1.done; val_1_1 = val_1.next()) {
-                var v = val_1_1.value;
-                if (Array.isArray(v)) {
-                    array.push(v);
-                }
-                else
-                    nonArray.push(v);
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (val_1_1 && !val_1_1.done && (_a = val_1.return)) _a.call(val_1);
+        const nonArray = [], array = [];
+        for (const v of val) {
+            if (Array.isArray(v)) {
+                array.push(v);
             }
-            finally { if (e_4) throw e_4.error; }
+            else
+                nonArray.push(v);
         }
         array.push(nonArray);
         return array;
     }
 }
-exports.buildFilterFromRequestParameters = buildFilterFromRequestParameters;
-var customTranslator = /** @class */ (function () {
-    function customTranslator(translateCustom) {
+class customTranslator {
+    constructor(translateCustom) {
         this.translateCustom = translateCustom;
         this.commands = [];
         this.promises = [];
     }
-    customTranslator.prototype.applyTo = function (x) {
-        this.commands.forEach(function (y) { return y(x); });
-    };
-    customTranslator.prototype.or = function (orElements) {
-        var _this = this;
-        var newOrElements;
-        this.promises.push(Promise.all(orElements.map(function (element) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var c;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        c = new customTranslator(this.translateCustom);
-                        element.__applyToConsumer(c);
-                        return [4 /*yield*/, c.resolve()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, new Filter(function (x) { return c.applyTo(x); })];
-                }
-            });
-        }); })).then(function (x) {
+    applyTo(x) {
+        this.commands.forEach(y => y(x));
+    }
+    or(orElements) {
+        let newOrElements;
+        this.promises.push(Promise.all(orElements.map(async (element) => {
+            let c = new customTranslator(this.translateCustom);
+            element.__applyToConsumer(c);
+            await c.resolve();
+            return new Filter(x => c.applyTo(x));
+        })).then(x => {
             newOrElements = x;
         }));
-        this.commands.push(function (x) { return x.or(newOrElements); });
-    };
-    customTranslator.prototype.isEqualTo = function (col, val) {
-        this.commands.push(function (x) { return x.isEqualTo(col, val); });
-    };
-    customTranslator.prototype.isDifferentFrom = function (col, val) {
-        this.commands.push(function (x) { return x.isDifferentFrom(col, val); });
-    };
-    customTranslator.prototype.isNull = function (col) {
-        this.commands.push(function (x) { return x.isNull(col); });
-    };
-    customTranslator.prototype.isNotNull = function (col) {
-        this.commands.push(function (x) { return x.isNotNull(col); });
-    };
-    customTranslator.prototype.isGreaterOrEqualTo = function (col, val) {
-        this.commands.push(function (x) { return x.isGreaterOrEqualTo(col, val); });
-    };
-    customTranslator.prototype.isGreaterThan = function (col, val) {
-        this.commands.push(function (x) { return x.isGreaterThan(col, val); });
-    };
-    customTranslator.prototype.isLessOrEqualTo = function (col, val) {
-        this.commands.push(function (x) { return x.isLessOrEqualTo(col, val); });
-    };
-    customTranslator.prototype.isLessThan = function (col, val) {
-        this.commands.push(function (x) { return x.isLessThan(col, val); });
-    };
-    customTranslator.prototype.containsCaseInsensitive = function (col, val) {
-        this.commands.push(function (x) { return x.containsCaseInsensitive(col, val); });
-    };
-    customTranslator.prototype.isIn = function (col, val) {
-        this.commands.push(function (x) { return x.isIn(col, val); });
-    };
-    customTranslator.prototype.custom = function (key, customItem) {
-        var _this = this;
-        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var r;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.translateCustom(key, customItem)];
-                    case 1:
-                        r = _a.sent();
-                        if (r)
-                            if (Array.isArray(r))
-                                r.forEach(function (x) { return x.__applyToConsumer(_this); });
-                            else
-                                r.__applyToConsumer(this);
-                        return [2 /*return*/];
-                }
-            });
-        }); })());
-    };
-    customTranslator.prototype.databaseCustom = function (custom) {
-        this.commands.push(function (x) { return x.databaseCustom(custom); });
-    };
-    customTranslator.prototype.resolve = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var p;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(this.promises.length > 0)) return [3 /*break*/, 2];
-                        p = this.promises;
-                        this.promises = [];
-                        return [4 /*yield*/, Promise.all(p)];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 0];
-                    case 2: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return customTranslator;
-}());
+        this.commands.push(x => x.or(newOrElements));
+    }
+    isEqualTo(col, val) {
+        this.commands.push(x => x.isEqualTo(col, val));
+    }
+    isDifferentFrom(col, val) {
+        this.commands.push(x => x.isDifferentFrom(col, val));
+    }
+    isNull(col) {
+        this.commands.push(x => x.isNull(col));
+    }
+    isNotNull(col) {
+        this.commands.push(x => x.isNotNull(col));
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.commands.push(x => x.isGreaterOrEqualTo(col, val));
+    }
+    isGreaterThan(col, val) {
+        this.commands.push(x => x.isGreaterThan(col, val));
+    }
+    isLessOrEqualTo(col, val) {
+        this.commands.push(x => x.isLessOrEqualTo(col, val));
+    }
+    isLessThan(col, val) {
+        this.commands.push(x => x.isLessThan(col, val));
+    }
+    containsCaseInsensitive(col, val) {
+        this.commands.push(x => x.containsCaseInsensitive(col, val));
+    }
+    isIn(col, val) {
+        this.commands.push(x => x.isIn(col, val));
+    }
+    custom(key, customItem) {
+        this.promises.push((async () => {
+            let r = await this.translateCustom(key, customItem);
+            if (r)
+                if (Array.isArray(r))
+                    r.forEach(x => x.__applyToConsumer(this));
+                else
+                    r.__applyToConsumer(this);
+        })());
+    }
+    databaseCustom(custom) {
+        this.commands.push(x => x.databaseCustom(custom));
+    }
+    async resolve() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            await Promise.all(p);
+        }
+    }
+}