remult 0.14.6 → 0.14.7

package/src/filter/filter-interfaces.js

@@ -1,62 +1,76 @@
-import { getEntityRef, getEntitySettings } from "../remult3";
-export class Filter {
-    constructor(apply) {
+"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) {
         this.apply = apply;
         if (!this.apply) {
-            this.apply = () => { };
+            this.apply = function () { };
         }
     }
-    __applyToConsumer(add) {
+    Filter.prototype.__applyToConsumer = function (add) {
         this.apply(add);
-    }
-    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 = {};
+    };
+    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 = {};
             if (x == undefined)
                 x = {};
             if (!customFilterInfo.key)
                 throw "Usage of custom filter before a key was assigned to it";
-            return {
-                [customUrlToken + customFilterInfo.key]: x
-            };
-        }, { customFilterInfo });
-    }
-    static fromEntityFilter(entity, whereItem) {
-        let result = [];
-        for (const key in whereItem) {
+            return _a = {},
+                _a[exports.customUrlToken + customFilterInfo.key] = x,
+                _a;
+        }, { customFilterInfo: customFilterInfo });
+    };
+    Filter.fromEntityFilter = function (entity, whereItem) {
+        var result = [];
+        var _loop_1 = function (key) {
             if (Object.prototype.hasOwnProperty.call(whereItem, key)) {
-                let fieldToFilter = whereItem[key];
+                var fieldToFilter_1 = whereItem[key];
                 {
                     if (key == "$or") {
-                        result.push(new OrFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                        result.push(new (OrFilter.bind.apply(OrFilter, tslib_1.__spread([void 0], fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); }))))());
                     }
                     else if (key == "$and") {
-                        result.push(new AndFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                        result.push(new (AndFilter.bind.apply(AndFilter, tslib_1.__spread([void 0], fieldToFilter_1.map(function (x) { return Filter.fromEntityFilter(entity, x); }))))());
                     }
-                    else if (key.startsWith(customUrlToken)) {
-                        result.push(new Filter(x => {
-                            x.custom(key.substring(customUrlToken.length), fieldToFilter);
+                    else if (key.startsWith(exports.customUrlToken)) {
+                        result.push(new Filter(function (x) {
+                            x.custom(key.substring(exports.customUrlToken.length), fieldToFilter_1);
                         }));
                     }
-                    else if (key == customDatabaseFilterToken) {
-                        result.push(new Filter(x => x.databaseCustom(fieldToFilter)));
+                    else if (key == exports.customDatabaseFilterToken) {
+                        result.push(new Filter(function (x) { return x.databaseCustom(fieldToFilter_1); }));
                     }
                     else {
-                        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) {
+                        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) {
                                         case "$gte":
                                         case ">=":
                                             result.push(fh.isGreaterOrEqualTo(element));
@@ -93,234 +107,328 @@ export class Filter {
                                     }
                                 }
                             }
-                            if (Array.isArray(fieldToFilter)) {
+                            if (Array.isArray(fieldToFilter_1)) {
                                 found = true;
-                                result.push(fh.isIn(fieldToFilter));
+                                result.push(fh.isIn(fieldToFilter_1));
                             }
                         }
-                        if (!found && fieldToFilter !== undefined) {
-                            result.push(fh.isEqualTo(fieldToFilter));
+                        if (!found && fieldToFilter_1 !== undefined) {
+                            result.push(fh.isEqualTo(fieldToFilter_1));
                         }
                     }
                 }
             }
+        };
+        for (var key in whereItem) {
+            _loop_1(key);
         }
-        return new AndFilter(...result);
-    }
-    toJson() {
-        let r = new FilterSerializer();
+        return new (AndFilter.bind.apply(AndFilter, tslib_1.__spread([void 0], result)))();
+    };
+    Filter.prototype.toJson = function () {
+        var r = new FilterSerializer();
         this.__applyToConsumer(r);
         return r.result;
-    }
-    static entityFilterToJson(entityDefs, where) {
+    };
+    Filter.entityFilterToJson = function (entityDefs, where) {
         return Filter.fromEntityFilter(entityDefs, where).toJson();
-    }
-    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)));
-                    }
+    };
+    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];
                 }
-            }
-            return r;
+            });
         });
-        r.__applyToConsumer(f);
-        await f.resolve();
-        r = new Filter(x => f.applyTo(x));
-        return r;
-    }
-}
-export class filterHelper {
-    constructor(metadata) {
+    };
+    return Filter;
+}());
+exports.Filter = Filter;
+var filterHelper = /** @class */ (function () {
+    function filterHelper(metadata) {
         this.metadata = metadata;
     }
-    processVal(val) {
-        let ei = getEntitySettings(this.metadata.valueType, false);
+    filterHelper.prototype.processVal = function (val) {
+        var ei = remult3_1.getEntitySettings(this.metadata.valueType, false);
         if (ei) {
             if (!val)
                 return null;
             if (typeof val === "string" || typeof val === "number")
                 return val;
-            return getEntityRef(val).getId();
+            return remult3_1.getEntityRef(val).getId();
         }
         return val;
-    }
-    contains(val) {
-        return new Filter(add => add.containsCaseInsensitive(this.metadata, val));
-    }
-    isLessThan(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;
         val = this.processVal(val);
-        return new Filter(add => add.isLessThan(this.metadata, val));
-    }
-    isGreaterOrEqualTo(val) {
+        return new Filter(function (add) { return add.isLessThan(_this.metadata, val); });
+    };
+    filterHelper.prototype.isGreaterOrEqualTo = function (val) {
+        var _this = this;
         val = this.processVal(val);
-        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));
+        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; }
             }
         });
-    }
-    isDifferentFrom(val) {
+    };
+    filterHelper.prototype.isDifferentFrom = function (val) {
+        var _this = this;
         val = this.processVal(val);
         if ((val === null || val === undefined) && this.metadata.allowNull)
-            return new Filter(add => add.isNotNull(this.metadata));
-        return new Filter(add => add.isDifferentFrom(this.metadata, val));
-    }
-    isLessOrEqualTo(val) {
+            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;
         val = this.processVal(val);
-        return new Filter(add => add.isLessOrEqualTo(this.metadata, val));
-    }
-    isGreaterThan(val) {
+        return new Filter(function (add) { return add.isLessOrEqualTo(_this.metadata, val); });
+    };
+    filterHelper.prototype.isGreaterThan = function (val) {
+        var _this = this;
         val = this.processVal(val);
-        return new Filter(add => add.isGreaterThan(this.metadata, val));
-    }
-    isEqualTo(val) {
+        return new Filter(function (add) { return add.isGreaterThan(_this.metadata, val); });
+    };
+    filterHelper.prototype.isEqualTo = function (val) {
+        var _this = this;
         val = this.processVal(val);
         if ((val === null || val === undefined) && this.metadata.allowNull)
-            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);
+            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);
+                }
             }
-        });
-        this.filters = filters;
+            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; }
+            }
+        }) || this;
+        _this.filters = filters;
+        return _this;
     }
-    add(filter) {
+    AndFilter.prototype.add = function (filter) {
         this.filters.push(filter);
-    }
-}
-export class OrFilter extends Filter {
-    constructor(...filters) {
-        super(add => {
-            let f = this.filters.filter(x => x !== undefined);
+    };
+    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; });
             if (f.length > 1) {
                 add.or(f);
             }
             else if (f.length == 1)
                 f[0].__applyToConsumer(add);
-        });
-        this.filters = filters;
-    }
-}
-export const customUrlToken = "$custom$";
-export const customDatabaseFilterToken = "$db$";
-export class FilterSerializer {
-    constructor() {
+        }) || 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.result = {};
         this.hasUndefined = false;
     }
-    databaseCustom(databaseCustom) {
+    FilterSerializer.prototype.databaseCustom = function (databaseCustom) {
         throw new Error("database custom is not allowed with api calls.");
-    }
-    custom(key, customItem) {
-        this.add(customUrlToken + key, customItem);
-    }
-    add(key, val) {
+    };
+    FilterSerializer.prototype.custom = function (key, customItem) {
+        this.add(exports.customUrlToken + key, customItem);
+    };
+    FilterSerializer.prototype.add = function (key, val) {
         if (val === undefined)
             this.hasUndefined = true;
-        let r = this.result;
+        var r = this.result;
         if (!r[key]) {
             r[key] = val;
             return;
         }
-        let v = r[key];
+        var v = r[key];
         if (v instanceof Array) {
             v.push(val);
         }
         else
             v = [v, val];
         r[key] = v;
-    }
-    or(orElements) {
-        this.add("OR", orElements.map(x => {
-            let f = new FilterSerializer();
+    };
+    FilterSerializer.prototype.or = function (orElements) {
+        this.add("OR", orElements.map(function (x) {
+            var f = new FilterSerializer();
             x.__applyToConsumer(f);
             return f.result;
         }));
-    }
-    isNull(col) {
+    };
+    FilterSerializer.prototype.isNull = function (col) {
         this.add(col.key + "_null", true);
-    }
-    isNotNull(col) {
+    };
+    FilterSerializer.prototype.isNotNull = function (col) {
         this.add(col.key + "_null", false);
-    }
-    isIn(col, val) {
-        this.add(col.key + "_in", val.map(x => col.valueConverter.toJson(x)));
-    }
-    isEqualTo(col, val) {
+    };
+    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) {
         this.add(col.key, col.valueConverter.toJson(val));
-    }
-    isDifferentFrom(col, val) {
+    };
+    FilterSerializer.prototype.isDifferentFrom = function (col, val) {
         this.add(col.key + '_ne', col.valueConverter.toJson(val));
-    }
-    isGreaterOrEqualTo(col, val) {
+    };
+    FilterSerializer.prototype.isGreaterOrEqualTo = function (col, val) {
         this.add(col.key + '_gte', col.valueConverter.toJson(val));
-    }
-    isGreaterThan(col, val) {
+    };
+    FilterSerializer.prototype.isGreaterThan = function (col, val) {
         this.add(col.key + '_gt', col.valueConverter.toJson(val));
-    }
-    isLessOrEqualTo(col, val) {
+    };
+    FilterSerializer.prototype.isLessOrEqualTo = function (col, val) {
         this.add(col.key + '_lte', col.valueConverter.toJson(val));
-    }
-    isLessThan(col, val) {
+    };
+    FilterSerializer.prototype.isLessThan = function (col, val) {
         this.add(col.key + '_lt', col.valueConverter.toJson(val));
-    }
-    containsCaseInsensitive(col, val) {
+    };
+    FilterSerializer.prototype.containsCaseInsensitive = function (col, val) {
         this.add(col.key + "_contains", val);
-    }
-}
-export function entityFilterToJson(entityDefs, where) {
+    };
+    return FilterSerializer;
+}());
+exports.FilterSerializer = FilterSerializer;
+function entityFilterToJson(entityDefs, where) {
     if (!where)
         return {};
     return (Filter.fromEntityFilter(entityDefs, where)).toJson();
 }
-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);
+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);
             if (val !== undefined) {
-                let addFilter = (val) => {
-                    let theVal = val;
+                var addFilter_1 = function (val) {
+                    var _a;
+                    var theVal = val;
                     if (jsonArray) {
-                        let arr;
+                        var arr = void 0;
                         if (typeof val === 'string')
                             arr = JSON.parse(val);
                         else
                             arr = val;
-                        theVal = arr.map(x => asString ? x : col.valueConverter.fromJson(x));
+                        theVal = arr.map(function (x) { return asString ? x : col.valueConverter.fromJson(x); });
                     }
                     else {
                         theVal = asString ? theVal : col.valueConverter.fromJson(theVal);
                     }
-                    let f = theFilter(theVal);
+                    var f = theFilter(theVal);
                     if (f !== undefined) {
-                        where.push({ [col.key]: f });
+                        where.push((_a = {}, _a[col.key] = f, _a));
                     }
                 };
                 if (!jsonArray && val instanceof Array) {
-                    val.forEach(v => {
-                        addFilter(v);
+                    val.forEach(function (v) {
+                        addFilter_1(v);
                     });
                 }
                 else {
@@ -328,21 +436,31 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                         if (typeof val === 'string')
                             val = JSON.parse(val);
                     }
-                    const array = separateArrayFromInnerArray(val);
-                    for (const x of array) {
-                        addFilter(x);
+                    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; }
                     }
                 }
             }
         }
-        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 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);
         var nullFilter = filterInfo.get(col.key + "_null");
         if (nullFilter) {
             nullFilter = nullFilter.toString().trim().toLowerCase();
@@ -350,118 +468,163 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 case "y":
                 case "true":
                 case "yes":
-                    where.push({ [col.key]: null });
+                    where.push((_a = {}, _a[col.key] = null, _a));
                     break;
                 default:
-                    where.push({ [col.key]: { "$ne": null } });
+                    where.push((_b = {}, _b[col.key] = { "$ne": null }, _b));
                     break;
             }
         }
-        addFilter('_contains', val => ({ $contains: val }), false, true);
+        addFilter('_contains', function (val) { return ({ $contains: val }); }, false, true);
     });
-    let val = filterInfo.get('OR');
+    var val = filterInfo.get('OR');
     if (val) {
-        const array = separateArrayFromInnerArray(val);
+        var array = separateArrayFromInnerArray(val);
         where.push({
-            $and: array.map(v => ({
-                $or: v.map(x => buildFilterFromRequestParameters(entity, { get: (key) => x[key] }))
-            }))
+            $and: array.map(function (v) { return ({
+                $or: v.map(function (x) {
+                    return buildFilterFromRequestParameters(entity, { get: function (key) { return x[key]; } });
+                })
+            }); })
         });
     }
-    for (const key in entity.entityType) {
-        const element = entity.entityType[key];
+    for (var key in entity.entityType) {
+        var element = entity.entityType[key];
         if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
-            let custom = filterInfo.get(customUrlToken + key);
+            var custom = filterInfo.get(exports.customUrlToken + key);
             if (custom !== undefined) {
-                where.push({ [customUrlToken + key]: custom });
+                where.push((_a = {}, _a[exports.customUrlToken + key] = custom, _a));
             }
         }
     }
     return { $and: where };
     function separateArrayFromInnerArray(val) {
+        var e_4, _a;
         if (!Array.isArray(val))
             return [val];
-        const nonArray = [], array = [];
-        for (const v of val) {
-            if (Array.isArray(v)) {
-                array.push(v);
+        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);
             }
-            else
-                nonArray.push(v);
+            finally { if (e_4) throw e_4.error; }
         }
         array.push(nonArray);
         return array;
     }
 }
-class customTranslator {
-    constructor(translateCustom) {
+exports.buildFilterFromRequestParameters = buildFilterFromRequestParameters;
+var customTranslator = /** @class */ (function () {
+    function customTranslator(translateCustom) {
         this.translateCustom = translateCustom;
         this.commands = [];
         this.promises = [];
     }
-    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 => {
+    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) {
             newOrElements = x;
         }));
-        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);
-        }
-    }
-}
+        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;
+}());