remult 0.14.6 → 0.14.7

package/remult-knex/index.js

@@ -1,334 +1,740 @@
-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) {
+"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 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 column_1 = require("../src/column");
+var KnexDataProvider = /** @class */ (function () {
+    function KnexDataProvider(knex) {
         this.knex = knex;
     }
-    getEntityDataProvider(entity) {
+    KnexDataProvider.prototype.getEntityDataProvider = function (entity) {
         return new KnexEntityDataProvider(entity, this.knex);
-    }
-    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]: {
+    };
+    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] = {
                 buildKnex: build
-            }
-        };
-    }
-}
-class KnexEntityDataProvider {
-    constructor(entity, knex) {
+            },
+            _a;
+    };
+    return KnexDataProvider;
+}());
+exports.KnexDataProvider = KnexDataProvider;
+var KnexEntityDataProvider = /** @class */ (function () {
+    function KnexEntityDataProvider(entity, knex) {
         this.entity = entity;
         this.knex = knex;
     }
-    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.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*/];
                 }
-                catch (err) {
-                    throw new Error("Failed to load from db:" + field.key + "\r\n" + err);
+            });
+        });
+    };
+    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;
+                            })];
                 }
-            }
-            return result;
+            });
         });
-    }
-    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.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()];
                 }
-            }
-        }
-        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;
+            });
+        });
+    };
+    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);
+                        filter_interfaces_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: filter_interfaces_1.Filter.fromEntityFilter(this.entity, resultFilter) }).then(function (y) { return y[0]; })];
                 }
-            }
-        }
-        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];
+            });
         });
-    }
-}
-export class FilterConsumerBridgeToKnexRequest {
-    constructor(nameProvider) {
+    };
+    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);
+                        filter_interfaces_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*/];
+                }
+            });
+        });
+    };
+    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 column_1.CompoundIdField)
+                            resultFilter = this.entity.idMetadata.field.resultIdFilter(undefined, data);
+                        else
+                            resultFilter = filter_interfaces_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 filter_interfaces_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];
+                        })];
+                }
+            });
+        });
+    };
+    return KnexEntityDataProvider;
+}());
+var FilterConsumerBridgeToKnexRequest = /** @class */ (function () {
+    function FilterConsumerBridgeToKnexRequest(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
         this.promises = [];
         this.result = [];
     }
-    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) {
+    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) {
         throw new Error("Custom filter should be translated before it gets here");
-    }
-    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.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*/];
                 }
-                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) {
+            });
+        }); })());
+    };
+    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) {
         this.add(col, val, "=");
-    }
-    isDifferentFrom(col, val) {
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isDifferentFrom = function (col, val) {
         this.add(col, val, "<>");
-    }
-    isGreaterOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isGreaterOrEqualTo = function (col, val) {
         this.add(col, val, ">=");
-    }
-    isGreaterThan(col, val) {
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isGreaterThan = function (col, val) {
         this.add(col, val, ">");
-    }
-    isLessOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isLessOrEqualTo = function (col, val) {
         this.add(col, val, "<=");
-    }
-    isLessThan(col, val) {
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isLessThan = function (col, val) {
         this.add(col, val, "<");
-    }
-    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) {
+    };
+    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) {
         this.knex = knex;
         this.additionalWhere = '';
     }
-    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.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*/];
                 }
-            }
-            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]);
+            });
+        });
+    };
+    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; }
                         }
-                    }
+                        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*/];
                 }
-            }));
-        }
-    }
-    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);
             });
-        }
-    }
-    async verifyAllColumns(entity) {
-        let e = await getDbNameProvider(entity);
-        try {
-            for (const col of entity.fields) {
-                if (!e.isDbReadonly(col)) {
-                    await this.addColumnIfNotExist(entity, () => col);
+        });
+    };
+    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*/];
                 }
-            }
-        }
-        catch (err) {
-            console.log(err);
-        }
-    }
-}
-export function buildColumn(x, dbName, 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*/];
+                }
+            });
+        });
+    };
+    return KnexSchemaBuilder;
+}());
+exports.KnexSchemaBuilder = KnexSchemaBuilder;
+function buildColumn(x, dbName, b) {
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb) {
-            let c = b.decimal(dbName);
+            var c = b.decimal(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
         }
         else if (x.valueConverter.fieldTypeInDb == "integer") {
-            let c = b.integer(dbName);
+            var c = b.integer(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
@@ -338,7 +744,7 @@ export function buildColumn(x, dbName, b) {
     }
     else if (x.valueType == Date) {
         if (!x.valueConverter.fieldTypeInDb)
-            if (x.valueConverter == ValueConverters.DateOnly)
+            if (x.valueConverter == valueConverters_1.ValueConverters.DateOnly)
                 b.date(dbName);
             else
                 b.dateTime(dbName);
@@ -348,13 +754,13 @@ export function buildColumn(x, dbName, b) {
             b.specificType(dbName, x.valueConverter.fieldTypeInDb);
     }
     else if (x.valueType == Boolean) {
-        let c = b.boolean(dbName);
+        var c = b.boolean(dbName);
         if (!x.allowNull)
             c.defaultTo(false).notNullable();
     }
     else if (x.valueConverter.fieldTypeInDb) {
         if (x.valueConverter.fieldTypeInDb == "integer") {
-            let c = b.integer(dbName);
+            var c = b.integer(dbName);
             if (!x.allowNull) {
                 c.defaultTo(0).notNullable();
             }
@@ -363,19 +769,33 @@ export function buildColumn(x, dbName, b) {
             b.specificType(dbName, x.valueConverter.fieldTypeInDb);
     }
     else {
-        let c = b.string(dbName, x.options.maxLength);
+        var 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;
 }
-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;
+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 context_1.Remult(result))];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, result];
+            }
+        });
+    });
 }
+exports.createKnexDataProvider = createKnexDataProvider;