remult 0.14.2 → 0.14.5

package/remult-knex/index.js

@@ -1,740 +1,334 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createKnexDataProvider = exports.buildColumn = exports.KnexSchemaBuilder = exports.FilterConsumerBridgeToKnexRequest = exports.KnexDataProvider = void 0;
-var tslib_1 = require("tslib");
-var __1 = require("..");
-var knex_1 = require("knex");
-var filter_interfaces_1 = require("../src/filter/filter-interfaces");
-var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
-var context_1 = require("../src/context");
-var remult3_1 = require("../src/remult3");
-var valueConverters_1 = require("../valueConverters");
-var KnexDataProvider = /** @class */ (function () {
-    function KnexDataProvider(knex) {
+import { CompoundIdField, Filter, Remult } from "..";
+import knex from 'knex';
+import { customDatabaseFilterToken } from "../src/filter/filter-interfaces";
+import { getDbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { allEntities } from "../src/context";
+import { isAutoIncrement } from "../src/remult3";
+import { ValueConverters } from "../valueConverters";
+export class KnexDataProvider {
+    constructor(knex) {
         this.knex = knex;
     }
-    KnexDataProvider.prototype.getEntityDataProvider = function (entity) {
+    getEntityDataProvider(entity) {
         return new KnexEntityDataProvider(entity, this.knex);
-    };
-    KnexDataProvider.prototype.transaction = function (action) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var t, err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.knex.transaction()];
-                    case 1:
-                        t = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 5, , 7]);
-                        return [4 /*yield*/, action(new KnexDataProvider(t))];
-                    case 3:
-                        _a.sent();
-                        return [4 /*yield*/, t.commit()];
-                    case 4:
-                        _a.sent();
-                        return [3 /*break*/, 7];
-                    case 5:
-                        err_1 = _a.sent();
-                        return [4 /*yield*/, t.rollback()];
-                    case 6:
-                        _a.sent();
-                        throw err_1;
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    KnexDataProvider.customFilter = function (build) {
-        var _a;
-        return _a = {},
-            _a[filter_interfaces_1.customDatabaseFilterToken] = {
+    }
+    async transaction(action) {
+        let t = await this.knex.transaction();
+        try {
+            await action(new KnexDataProvider(t));
+            await t.commit();
+        }
+        catch (err) {
+            await t.rollback();
+            throw err;
+        }
+    }
+    static customFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
                 buildKnex: build
-            },
-            _a;
-    };
-    return KnexDataProvider;
-}());
-exports.KnexDataProvider = KnexDataProvider;
-var KnexEntityDataProvider = /** @class */ (function () {
-    function KnexEntityDataProvider(entity, knex) {
+            }
+        };
+    }
+}
+class KnexEntityDataProvider {
+    constructor(entity, knex) {
         this.entity = entity;
         this.knex = knex;
     }
-    KnexEntityDataProvider.prototype.count = function (where) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, br, r, result, row, key, element;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _a.sent();
-                        br = new FilterConsumerBridgeToKnexRequest(e);
-                        where.__applyToConsumer(br);
-                        return [4 /*yield*/, br.resolveWhere()];
-                    case 2:
-                        r = _a.sent();
-                        return [4 /*yield*/, this.knex(e.entityName)
-                                .count().where(function (b) { return r.forEach(function (w) { return w(b); }); })];
-                    case 3:
-                        result = (_a.sent());
-                        row = result[0];
-                        for (key in row) {
-                            if (Object.prototype.hasOwnProperty.call(row, key)) {
-                                element = row[key];
-                                return [2 /*return*/, +element];
-                            }
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    KnexEntityDataProvider.prototype.find = function (options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, cols, colKeys, _a, _b, x, query, br, r_1, r;
-            var e_1, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _d.sent();
-                        cols = [];
-                        colKeys = [];
-                        try {
-                            for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                x = _b.value;
-                                if (x.isServerExpression) {
-                                }
-                                else {
-                                    cols.push(e.nameOf(x));
-                                    colKeys.push(x);
-                                }
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        query = this.knex(e.entityName).select(cols);
-                        if (!(options === null || options === void 0 ? void 0 : options.where)) return [3 /*break*/, 3];
-                        br = new FilterConsumerBridgeToKnexRequest(e);
-                        options.where.__applyToConsumer(br);
-                        return [4 /*yield*/, br.resolveWhere()];
-                    case 2:
-                        r_1 = _d.sent();
-                        query.where(function (b) { return r_1.forEach(function (y) { return y(b); }); });
-                        _d.label = 3;
-                    case 3:
-                        if (options.orderBy) {
-                            query = query.orderBy(options.orderBy.Segments.map(function (s) { return ({
-                                column: e.nameOf(s.field),
-                                order: s.isDescending ? "desc" : "asc"
-                            }); }));
-                        }
-                        if (options.limit) {
-                            query = query.limit(options.limit);
-                            if (options.page)
-                                query = query.offset((options.page - 1) * options.limit);
-                        }
-                        return [4 /*yield*/, query];
-                    case 4:
-                        r = _d.sent();
-                        return [2 /*return*/, r.map(function (y) {
-                                var result = {};
-                                var i = 0;
-                                for (var m in y) {
-                                    var field = colKeys[i++];
-                                    try {
-                                        result[field.key] = field.valueConverter.fromDb(y[m]);
-                                    }
-                                    catch (err) {
-                                        throw new Error("Failed to load from db:" + field.key + "\r\n" + err);
-                                    }
-                                }
-                                return result;
-                            })];
-                }
-            });
-        });
-    };
-    KnexEntityDataProvider.prototype.init = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(this.entity)];
-                    case 1: return [2 /*return*/, _a.sent()];
+    async count(where) {
+        const e = await this.init();
+        const br = new FilterConsumerBridgeToKnexRequest(e);
+        where.__applyToConsumer(br);
+        let r = await br.resolveWhere();
+        const result = (await this.knex(e.entityName)
+            .count().where(b => r.forEach(w => w(b))));
+        var row = result[0];
+        for (const key in row) {
+            if (Object.prototype.hasOwnProperty.call(row, key)) {
+                const element = row[key];
+                return +element;
+            }
+        }
+    }
+    async find(options) {
+        const e = await this.init();
+        let cols = [];
+        let colKeys = [];
+        for (const x of this.entity.fields) {
+            if (x.isServerExpression) {
+            }
+            else {
+                cols.push(e.nameOf(x));
+                colKeys.push(x);
+            }
+        }
+        let query = this.knex(e.entityName).select(cols);
+        if (options?.where) {
+            const br = new FilterConsumerBridgeToKnexRequest(e);
+            options.where.__applyToConsumer(br);
+            let r = await br.resolveWhere();
+            query.where(b => r.forEach(y => y(b)));
+        }
+        if (options.orderBy) {
+            query = query.orderBy(options.orderBy.Segments.map(s => ({
+                column: e.nameOf(s.field),
+                order: s.isDescending ? "desc" : "asc"
+            })));
+        }
+        if (options.limit) {
+            query = query.limit(options.limit);
+            if (options.page)
+                query = query.offset((options.page - 1) * options.limit);
+        }
+        const r = await query;
+        return r.map(y => {
+            let result = {};
+            let i = 0;
+            for (let m in y) {
+                let field = colKeys[i++];
+                try {
+                    result[field.key] = field.valueConverter.fromDb(y[m]);
                 }
-            });
-        });
-    };
-    KnexEntityDataProvider.prototype.update = function (id, data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, f, resultFilter, updateObject, _a, _b, x, v, key, e_2_1, where;
-            var e_2, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _d.sent();
-                        f = new FilterConsumerBridgeToKnexRequest(e);
-                        __1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-                        resultFilter = this.entity.idMetadata.getIdFilter(id);
-                        if (data.id != undefined)
-                            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
-                        updateObject = {};
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 8, 9, 10]);
-                        _a = tslib_1.__values(this.entity.fields), _b = _a.next();
-                        _d.label = 3;
-                    case 3:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        x = _b.value;
-                        if (!e.isDbReadonly(x)) return [3 /*break*/, 4];
-                        return [3 /*break*/, 6];
-                    case 4:
-                        if (!(data[x.key] !== undefined)) return [3 /*break*/, 6];
-                        v = x.valueConverter.toDb(data[x.key]);
-                        if (!(v !== undefined)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, e.nameOf(x)];
-                    case 5:
-                        key = _d.sent();
-                        updateObject[key] = v;
-                        _d.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 3];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_2_1 = _d.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 10: return [4 /*yield*/, f.resolveWhere()];
-                    case 11:
-                        where = _d.sent();
-                        return [4 /*yield*/, this.knex(e.entityName).update(updateObject).where(function (b) { return where.forEach(function (w) { return w(b); }); })];
-                    case 12:
-                        _d.sent();
-                        return [2 /*return*/, this.find({ where: __1.Filter.fromEntityFilter(this.entity, resultFilter) }).then(function (y) { return y[0]; })];
+                catch (err) {
+                    throw new Error("Failed to load from db:" + field.key + "\r\n" + err);
                 }
-            });
+            }
+            return result;
         });
-    };
-    KnexEntityDataProvider.prototype.delete = function (id) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, f, where;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _a.sent();
-                        f = new FilterConsumerBridgeToKnexRequest(e);
-                        __1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-                        return [4 /*yield*/, f.resolveWhere()];
-                    case 2:
-                        where = _a.sent();
-                        return [4 /*yield*/, this.knex(e.entityName).delete().where(function (b) { return where.forEach(function (w) { return w(b); }); })];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
+    }
+    async init() {
+        return await getDbNameProvider(this.entity);
+    }
+    async update(id, data) {
+        const e = await this.init();
+        let f = new FilterConsumerBridgeToKnexRequest(e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let resultFilter = this.entity.idMetadata.getIdFilter(id);
+        if (data.id != undefined)
+            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
+        let updateObject = {};
+        for (const x of this.entity.fields) {
+            if (e.isDbReadonly(x)) { }
+            else if (data[x.key] !== undefined) {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v !== undefined) {
+                    let key = await e.nameOf(x);
+                    updateObject[key] = v;
                 }
-            });
-        });
-    };
-    KnexEntityDataProvider.prototype.insert = function (data) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, result, newId_1;
-            var e_3, _c;
-            var _this = this;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.init()];
-                    case 1:
-                        e = _d.sent();
-                        if (this.entity.idMetadata.field instanceof __1.CompoundIdField)
-                            resultFilter = this.entity.idMetadata.field.resultIdFilter(undefined, data);
-                        else
-                            resultFilter = __1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(data[this.entity.idMetadata.field.key]));
-                        insertObject = {};
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 8, 9, 10]);
-                        _a = tslib_1.__values(this.entity.fields), _b = _a.next();
-                        _d.label = 3;
-                    case 3:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        x = _b.value;
-                        if (!e.isDbReadonly(x)) return [3 /*break*/, 4];
-                        return [3 /*break*/, 6];
-                    case 4:
-                        v = x.valueConverter.toDb(data[x.key]);
-                        if (!(v != undefined)) return [3 /*break*/, 6];
-                        return [4 /*yield*/, e.nameOf(x)];
-                    case 5:
-                        key = _d.sent();
-                        insertObject[key] = v;
-                        _d.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 3];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_3_1 = _d.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 10:
-                        insert = this.knex(e.entityName).insert(insertObject);
-                        if (!remult3_1.isAutoIncrement(this.entity.idMetadata.field)) return [3 /*break*/, 12];
-                        return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
-                    case 11:
-                        result = _d.sent();
-                        newId_1 = result[0].id;
-                        resultFilter = new __1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
-                        return [3 /*break*/, 14];
-                    case 12: return [4 /*yield*/, insert];
-                    case 13:
-                        _d.sent();
-                        _d.label = 14;
-                    case 14: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
-                            return y[0];
-                        })];
+            }
+        }
+        let where = await f.resolveWhere();
+        await this.knex(e.entityName).update(updateObject).where(b => where.forEach(w => w(b)));
+        return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
+    }
+    async delete(id) {
+        const e = await this.init();
+        let f = new FilterConsumerBridgeToKnexRequest(e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let where = await f.resolveWhere();
+        await this.knex(e.entityName).delete().where(b => where.forEach(w => w(b)));
+    }
+    async insert(data) {
+        const e = await this.init();
+        let resultFilter;
+        if (this.entity.idMetadata.field instanceof CompoundIdField)
+            resultFilter = this.entity.idMetadata.field.resultIdFilter(undefined, data);
+        else
+            resultFilter = Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(data[this.entity.idMetadata.field.key]));
+        let insertObject = {};
+        for (const x of this.entity.fields) {
+            if (e.isDbReadonly(x)) { }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    let key = await e.nameOf(x);
+                    insertObject[key] = v;
                 }
-            });
+            }
+        }
+        let insert = this.knex(e.entityName).insert(insertObject);
+        if (isAutoIncrement(this.entity.idMetadata.field)) {
+            let result = await insert.returning(this.entity.idMetadata.field.key);
+            let newId = result[0].id;
+            resultFilter = new Filter(x => x.isEqualTo(this.entity.idMetadata.field, newId));
+        }
+        else
+            await insert;
+        return this.find({ where: resultFilter }).then(y => {
+            return y[0];
         });
-    };
-    return KnexEntityDataProvider;
-}());
-var FilterConsumerBridgeToKnexRequest = /** @class */ (function () {
-    function FilterConsumerBridgeToKnexRequest(nameProvider) {
+    }
+}
+export class FilterConsumerBridgeToKnexRequest {
+    constructor(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
         this.promises = [];
         this.result = [];
     }
-    FilterConsumerBridgeToKnexRequest.prototype.resolveWhere = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var p, p_1, p_1_1, pr, e_4_1;
-            var e_4, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(this.promises.length > 0)) return [3 /*break*/, 9];
-                        p = this.promises;
-                        this.promises = [];
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 6, 7, 8]);
-                        p_1 = (e_4 = void 0, tslib_1.__values(p)), p_1_1 = p_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!p_1_1.done) return [3 /*break*/, 5];
-                        pr = p_1_1.value;
-                        return [4 /*yield*/, pr];
-                    case 3:
-                        _b.sent();
-                        _b.label = 4;
-                    case 4:
-                        p_1_1 = p_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_4_1 = _b.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (p_1_1 && !p_1_1.done && (_a = p_1.return)) _a.call(p_1);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                        return [7 /*endfinally*/];
-                    case 8: return [3 /*break*/, 0];
-                    case 9: return [2 /*return*/, this.result];
-                }
-            });
-        });
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.custom = function (key, customItem) {
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        return this.result;
+    }
+    custom(key, customItem) {
         throw new Error("Custom filter should be translated before it gets here");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.or = function (orElements) {
-        var _this = this;
-        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var result, _loop_1, this_1, orElements_1, orElements_1_1, element, state_1, e_5_1;
-            var e_5, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        result = [];
-                        _loop_1 = function (element) {
-                            var f, where;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        f = new FilterConsumerBridgeToKnexRequest(this_1.nameProvider);
-                                        f._addWhere = false;
-                                        element.__applyToConsumer(f);
-                                        return [4 /*yield*/, f.resolveWhere()];
-                                    case 1:
-                                        where = _a.sent();
-                                        if (where.length > 0) {
-                                            result.push(function (b) {
-                                                b.orWhere(function (b) {
-                                                    where.forEach(function (x) { return x(b); });
-                                                });
-                                            });
-                                        }
-                                        else
-                                            return [2 /*return*/, { value: void 0 }]; //empty or means all rows
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 6, 7, 8]);
-                        orElements_1 = tslib_1.__values(orElements), orElements_1_1 = orElements_1.next();
-                        _b.label = 2;
-                    case 2:
-                        if (!!orElements_1_1.done) return [3 /*break*/, 5];
-                        element = orElements_1_1.value;
-                        return [5 /*yield**/, _loop_1(element)];
-                    case 3:
-                        state_1 = _b.sent();
-                        if (typeof state_1 === "object")
-                            return [2 /*return*/, state_1.value];
-                        _b.label = 4;
-                    case 4:
-                        orElements_1_1 = orElements_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_5_1 = _b.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (orElements_1_1 && !orElements_1_1.done && (_a = orElements_1.return)) _a.call(orElements_1);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                        return [7 /*endfinally*/];
-                    case 8:
-                        if (result.length > 0) {
-                            this.result.push(function (b) { return b.where(function (x) { return result.find(function (y) { return y(x); }); }); });
-                        }
-                        return [2 /*return*/];
+    }
+    or(orElements) {
+        this.promises.push((async () => {
+            const result = [];
+            for (const element of orElements) {
+                let f = new FilterConsumerBridgeToKnexRequest(this.nameProvider);
+                f._addWhere = false;
+                element.__applyToConsumer(f);
+                let where = await f.resolveWhere();
+                if (where.length > 0) {
+                    result.push(b => {
+                        b.orWhere(b => {
+                            where.forEach(x => x(b));
+                        });
+                    });
                 }
-            });
-        }); })());
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isNull = function (col) {
-        var _this = this;
-        this.result.push(function (b) { return b.whereNull(_this.nameProvider.nameOf(col)); });
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isNotNull = function (col) {
-        var _this = this;
-        this.result.push(function (b) { return b.whereNotNull(_this.nameProvider.nameOf(col)); });
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isIn = function (col, val) {
-        var _this = this;
-        this.result.push(function (knex) {
-            return knex.whereIn(_this.nameProvider.nameOf(col), val.map(function (x) { return col.valueConverter.toDb(x); }));
-        });
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isEqualTo = function (col, val) {
+                else
+                    return; //empty or means all rows
+            }
+            if (result.length > 0) {
+                this.result.push(b => b.where(x => result.find(y => y(x))));
+            }
+        })());
+    }
+    isNull(col) {
+        this.result.push(b => b.whereNull(this.nameProvider.nameOf(col)));
+    }
+    isNotNull(col) {
+        this.result.push(b => b.whereNotNull(this.nameProvider.nameOf(col)));
+    }
+    isIn(col, val) {
+        this.result.push(knex => knex.whereIn(this.nameProvider.nameOf(col), val.map(x => col.valueConverter.toDb(x))));
+    }
+    isEqualTo(col, val) {
         this.add(col, val, "=");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isDifferentFrom = function (col, val) {
+    }
+    isDifferentFrom(col, val) {
         this.add(col, val, "<>");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isGreaterOrEqualTo = function (col, val) {
+    }
+    isGreaterOrEqualTo(col, val) {
         this.add(col, val, ">=");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isGreaterThan = function (col, val) {
+    }
+    isGreaterThan(col, val) {
         this.add(col, val, ">");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isLessOrEqualTo = function (col, val) {
+    }
+    isLessOrEqualTo(col, val) {
         this.add(col, val, "<=");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.isLessThan = function (col, val) {
+    }
+    isLessThan(col, val) {
         this.add(col, val, "<");
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.containsCaseInsensitive = function (col, val) {
-        var _this = this;
-        this.result.push(function (b) { return b.whereRaw('lower (' + _this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"); });
-        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/];
-            });
-        }); })());
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.add = function (col, val, operator) {
-        var _this = this;
-        this.result.push(function (b) { return b.where(_this.nameProvider.nameOf(col), operator, col.valueConverter.toDb(val)); });
-    };
-    FilterConsumerBridgeToKnexRequest.prototype.databaseCustom = function (databaseCustom) {
-        var _this = this;
-        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var _a, _b;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(databaseCustom === null || databaseCustom === void 0 ? void 0 : databaseCustom.buildKnex)) return [3 /*break*/, 2];
-                        _b = (_a = this.result).push;
-                        return [4 /*yield*/, databaseCustom.buildKnex()];
-                    case 1:
-                        _b.apply(_a, [_c.sent()]);
-                        _c.label = 2;
-                    case 2: return [2 /*return*/];
-                }
-            });
-        }); })());
-    };
-    return FilterConsumerBridgeToKnexRequest;
-}());
-exports.FilterConsumerBridgeToKnexRequest = FilterConsumerBridgeToKnexRequest;
-var KnexSchemaBuilder = /** @class */ (function () {
-    function KnexSchemaBuilder(knex) {
+    }
+    containsCaseInsensitive(col, val) {
+        this.result.push(b => b.whereRaw('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
+        this.promises.push((async () => {
+        })());
+    }
+    add(col, val, operator) {
+        this.result.push(b => b.where(this.nameProvider.nameOf(col), operator, col.valueConverter.toDb(val)));
+    }
+    databaseCustom(databaseCustom) {
+        this.promises.push((async () => {
+            if (databaseCustom?.buildKnex) {
+                this.result.push(await databaseCustom.buildKnex());
+            }
+        })());
+    }
+}
+export class KnexSchemaBuilder {
+    constructor(knex) {
         this.knex = knex;
         this.additionalWhere = '';
     }
-    KnexSchemaBuilder.prototype.verifyStructureOfAllEntities = function (remult) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var allEntities_1, allEntities_1_1, entity, metadata, err_2, _a, _b, _c, e_6_1;
-            var e_6, _d;
-            return tslib_1.__generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        console.log("start verify structure");
-                        _e.label = 1;
-                    case 1:
-                        _e.trys.push([1, 12, 13, 14]);
-                        allEntities_1 = tslib_1.__values(context_1.allEntities), allEntities_1_1 = allEntities_1.next();
-                        _e.label = 2;
-                    case 2:
-                        if (!!allEntities_1_1.done) return [3 /*break*/, 11];
-                        entity = allEntities_1_1.value;
-                        metadata = remult.repo(entity).metadata;
-                        _e.label = 3;
-                    case 3:
-                        _e.trys.push([3, 8, , 10]);
-                        if (!!metadata.options.sqlExpression) return [3 /*break*/, 7];
-                        return [4 /*yield*/, metadata.getDbName()];
-                    case 4:
-                        if (!((_e.sent()).toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.createIfNotExist(metadata)];
-                    case 5:
-                        _e.sent();
-                        return [4 /*yield*/, this.verifyAllColumns(metadata)];
-                    case 6:
-                        _e.sent();
-                        _e.label = 7;
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        err_2 = _e.sent();
-                        _b = (_a = console).log;
-                        _c = "failed verify structure of ";
-                        return [4 /*yield*/, metadata.getDbName()];
-                    case 9:
-                        _b.apply(_a, [_c + (_e.sent()) + " ", err_2]);
-                        return [3 /*break*/, 10];
-                    case 10:
-                        allEntities_1_1 = allEntities_1.next();
-                        return [3 /*break*/, 2];
-                    case 11: return [3 /*break*/, 14];
-                    case 12:
-                        e_6_1 = _e.sent();
-                        e_6 = { error: e_6_1 };
-                        return [3 /*break*/, 14];
-                    case 13:
-                        try {
-                            if (allEntities_1_1 && !allEntities_1_1.done && (_d = allEntities_1.return)) _d.call(allEntities_1);
-                        }
-                        finally { if (e_6) throw e_6.error; }
-                        return [7 /*endfinally*/];
-                    case 14: return [2 /*return*/];
+    async verifyStructureOfAllEntities(remult) {
+        console.log("start verify structure");
+        for (const entity of allEntities) {
+            let metadata = remult.repo(entity).metadata;
+            try {
+                if (!metadata.options.sqlExpression) {
+                    if ((await metadata.getDbName()).toLowerCase().indexOf('from ') < 0) {
+                        await this.createIfNotExist(metadata);
+                        await this.verifyAllColumns(metadata);
+                    }
                 }
-            });
-        });
-    };
-    KnexSchemaBuilder.prototype.createIfNotExist = function (entity) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, cols_1, _a, _b, f;
-            var e_7, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
-                    case 1:
-                        e = _d.sent();
-                        return [4 /*yield*/, this.knex.schema.hasTable(e.entityName)];
-                    case 2:
-                        if (!!(_d.sent())) return [3 /*break*/, 4];
-                        cols_1 = new Map();
-                        try {
-                            for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                f = _b.value;
-                                cols_1.set(f, {
-                                    name: e.nameOf(f),
-                                    readonly: e.isDbReadonly(f)
-                                });
-                            }
-                        }
-                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_7) throw e_7.error; }
+            }
+            catch (err) {
+                console.log("failed verify structure of " + await metadata.getDbName() + " ", err);
+            }
+        }
+    }
+    async createIfNotExist(entity) {
+        const e = await getDbNameProvider(entity);
+        if (!await this.knex.schema.hasTable(e.entityName)) {
+            let cols = new Map();
+            for (const f of entity.fields) {
+                cols.set(f, {
+                    name: e.nameOf(f),
+                    readonly: e.isDbReadonly(f)
+                });
+            }
+            await logSql(this.knex.schema.createTable(e.entityName, b => {
+                for (const x of entity.fields) {
+                    if (!cols.get(x).readonly || isAutoIncrement(x)) {
+                        if (isAutoIncrement(x))
+                            b.increments(cols.get(x).name);
+                        else {
+                            buildColumn(x, cols.get(x).name, b);
+                            if (x == entity.idMetadata.field)
+                                b.primary([cols.get(x).name]);
                         }
-                        return [4 /*yield*/, logSql(this.knex.schema.createTable(e.entityName, function (b) {
-                                var e_8, _a;
-                                try {
-                                    for (var _b = tslib_1.__values(entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                        var x = _c.value;
-                                        if (!cols_1.get(x).readonly || remult3_1.isAutoIncrement(x)) {
-                                            if (remult3_1.isAutoIncrement(x))
-                                                b.increments(cols_1.get(x).name);
-                                            else {
-                                                buildColumn(x, cols_1.get(x).name, b);
-                                                if (x == entity.idMetadata.field)
-                                                    b.primary([cols_1.get(x).name]);
-                                            }
-                                        }
-                                    }
-                                }
-                                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                                finally {
-                                    try {
-                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                                    }
-                                    finally { if (e_8) throw e_8.error; }
-                                }
-                            }))];
-                    case 3:
-                        _d.sent();
-                        _d.label = 4;
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    KnexSchemaBuilder.prototype.addColumnIfNotExist = function (entity, c) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, col, colName;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
-                    case 1:
-                        e = _a.sent();
-                        if (e.isDbReadonly(c(entity)))
-                            return [2 /*return*/];
-                        col = c(entity);
-                        colName = e.nameOf(col);
-                        return [4 /*yield*/, this.knex.schema.hasColumn(e.entityName, colName)];
-                    case 2:
-                        if (!!(_a.sent())) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.knex.schema.alterTable(e.entityName, function (b) {
-                                buildColumn(col, colName, b);
-                            })];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4: return [2 /*return*/];
+                    }
                 }
+            }));
+        }
+    }
+    async addColumnIfNotExist(entity, c) {
+        let e = await getDbNameProvider(entity);
+        if (e.isDbReadonly(c(entity)))
+            return;
+        let col = c(entity);
+        let colName = e.nameOf(col);
+        if (!await this.knex.schema.hasColumn(e.entityName, colName)) {
+            await this.knex.schema.alterTable(e.entityName, b => {
+                buildColumn(col, colName, b);
             });
-        });
-    };
-    KnexSchemaBuilder.prototype.verifyAllColumns = function (entity) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, _loop_2, this_2, _a, _b, col, e_9_1, err_3;
-            var e_9, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
-                    case 1:
-                        e = _d.sent();
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 11, , 12]);
-                        _loop_2 = function (col) {
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!!e.isDbReadonly(col)) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, this_2.addColumnIfNotExist(entity, function () { return col; })];
-                                    case 1:
-                                        _a.sent();
-                                        _a.label = 2;
-                                    case 2: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_2 = this;
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 8, 9, 10]);
-                        _a = tslib_1.__values(entity.fields), _b = _a.next();
-                        _d.label = 4;
-                    case 4:
-                        if (!!_b.done) return [3 /*break*/, 7];
-                        col = _b.value;
-                        return [5 /*yield**/, _loop_2(col)];
-                    case 5:
-                        _d.sent();
-                        _d.label = 6;
-                    case 6:
-                        _b = _a.next();
-                        return [3 /*break*/, 4];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_9_1 = _d.sent();
-                        e_9 = { error: e_9_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_9) throw e_9.error; }
-                        return [7 /*endfinally*/];
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
-                        err_3 = _d.sent();
-                        console.log(err_3);
-                        return [3 /*break*/, 12];
-                    case 12: return [2 /*return*/];
+        }
+    }
+    async verifyAllColumns(entity) {
+        let e = await getDbNameProvider(entity);
+        try {
+            for (const col of entity.fields) {
+                if (!e.isDbReadonly(col)) {
+                    await this.addColumnIfNotExist(entity, () => col);
                 }
-            });
-        });
-    };
-    return KnexSchemaBuilder;
-}());
-exports.KnexSchemaBuilder = KnexSchemaBuilder;
-function buildColumn(x, dbName, b) {
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+}
+export function buildColumn(x, dbName, b) {
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb) {
-            var c = b.decimal(dbName);
+            let c = b.decimal(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
         }
         else if (x.valueConverter.fieldTypeInDb == "integer") {
-            var c = b.integer(dbName);
+            let c = b.integer(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
@@ -744,7 +338,7 @@ function buildColumn(x, dbName, b) {
     }
     else if (x.valueType == Date) {
         if (!x.valueConverter.fieldTypeInDb)
-            if (x.valueConverter == valueConverters_1.ValueConverters.DateOnly)
+            if (x.valueConverter == ValueConverters.DateOnly)
                 b.date(dbName);
             else
                 b.dateTime(dbName);
@@ -754,13 +348,13 @@ function buildColumn(x, dbName, b) {
             b.specificType(dbName, x.valueConverter.fieldTypeInDb);
     }
     else if (x.valueType == Boolean) {
-        var c = b.boolean(dbName);
+        let c = b.boolean(dbName);
         if (!x.allowNull)
             c.defaultTo(false).notNullable();
     }
     else if (x.valueConverter.fieldTypeInDb) {
         if (x.valueConverter.fieldTypeInDb == "integer") {
-            var c = b.integer(dbName);
+            let c = b.integer(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
@@ -769,33 +363,19 @@ function buildColumn(x, dbName, b) {
             b.specificType(dbName, x.valueConverter.fieldTypeInDb);
     }
     else {
-        var c = b.string(dbName, x.options.maxLength);
+        let c = b.string(dbName, x.options.maxLength);
         if (!x.allowNull)
             c.defaultTo('').notNullable();
     }
 }
-exports.buildColumn = buildColumn;
 function logSql(who) {
     //console.log(who.toSQL().sql);
     return who;
 }
-function createKnexDataProvider(config, autoCreateTables) {
-    if (autoCreateTables === void 0) { autoCreateTables = true; }
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var k, result;
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    k = knex_1.default(config);
-                    result = new KnexDataProvider(k);
-                    if (!autoCreateTables) return [3 /*break*/, 2];
-                    return [4 /*yield*/, new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new __1.Remult(result))];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [2 /*return*/, result];
-            }
-        });
-    });
+export async function createKnexDataProvider(config, autoCreateTables = true) {
+    let k = knex(config);
+    let result = new KnexDataProvider(k);
+    if (autoCreateTables)
+        await new KnexSchemaBuilder(k).verifyStructureOfAllEntities(new Remult(result));
+    return result;
 }
-exports.createKnexDataProvider = createKnexDataProvider;