remult 0.9.4 → 0.9.8

package/remult-knex/index.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildColumn = exports.KnexSchemaBuilder = exports.FilterConsumerBridgeToKnexRequest = exports.KnexDataProvider = void 0;
+var tslib_1 = require("tslib");
+var __1 = require("..");
+var sql_database_1 = require("../src/data-providers/sql-database");
+var context_1 = require("../src/context");
+var valueConverters_1 = require("../valueConverters");
+var KnexDataProvider = /** @class */ (function () {
+    function KnexDataProvider(knex) {
+        this.knex = knex;
+    }
+    KnexDataProvider.prototype.getEntityDataProvider = function (entity) {
+        return new KnexEntityDataProvider(entity, this.knex);
+    };
+    KnexDataProvider.prototype.transaction = function (action) {
+        throw new Error("Method not implemented.");
+    };
+    return KnexDataProvider;
+}());
+exports.KnexDataProvider = KnexDataProvider;
+var KnexEntityDataProvider = /** @class */ (function () {
+    function KnexEntityDataProvider(entity, knex) {
+        this.entity = entity;
+        this.knex = knex;
+    }
+    KnexEntityDataProvider.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var br, r, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        br = new FilterConsumerBridgeToKnexRequest();
+                        where.__applyToConsumer(br);
+                        return [4 /*yield*/, br.resolveWhere()];
+                    case 1:
+                        r = _b.sent();
+                        _a = this.knex;
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 2: return [4 /*yield*/, _a.apply(this, [_b.sent()])
+                            .count().where(function (b) { return r.forEach(function (w) { return w(b); }); })];
+                    case 3: return [2 /*return*/, +(_b.sent())[0].count];
+                }
+            });
+        });
+    };
+    KnexEntityDataProvider.prototype.find = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var cols, colKeys, _a, _b, x, _c, _d, e_1_1, query, _e, br, r_1, _f, _g, r;
+            var e_1, _h;
+            var _this = this;
+            return tslib_1.__generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        cols = [];
+                        colKeys = [];
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 7, 8, 9]);
+                        _a = tslib_1.__values(this.entity.fields), _b = _a.next();
+                        _j.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        x = _b.value;
+                        if (!x.isServerExpression) return [3 /*break*/, 3];
+                        return [3 /*break*/, 5];
+                    case 3:
+                        _d = (_c = cols).push;
+                        return [4 /*yield*/, x.getDbName()];
+                    case 4:
+                        _d.apply(_c, [_j.sent()]);
+                        colKeys.push(x);
+                        _j.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _j.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_h = _a.return)) _h.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        _e = this.knex;
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 10:
+                        query = _e.apply(this, [_j.sent()]).select(cols);
+                        if (!(options === null || options === void 0 ? void 0 : options.where)) return [3 /*break*/, 12];
+                        br = new FilterConsumerBridgeToKnexRequest();
+                        options.where.__applyToConsumer(br);
+                        return [4 /*yield*/, br.resolveWhere()];
+                    case 11:
+                        r_1 = _j.sent();
+                        query.where(function (b) { return r_1.forEach(function (y) { return y(b); }); });
+                        _j.label = 12;
+                    case 12:
+                        if (!options.orderBy) return [3 /*break*/, 14];
+                        _g = (_f = query).orderBy;
+                        return [4 /*yield*/, Promise.all(options.orderBy.Segments.map(function (s) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var _a;
+                                return tslib_1.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = {};
+                                            return [4 /*yield*/, s.field.getDbName()];
+                                        case 1: return [2 /*return*/, (_a.column = _b.sent(),
+                                                _a.order = s.isDescending ? "desc" : "asc",
+                                                _a)];
+                                    }
+                                });
+                            }); }))];
+                    case 13:
+                        query = _g.apply(_f, [_j.sent()]);
+                        _j.label = 14;
+                    case 14: return [4 /*yield*/, query];
+                    case 15:
+                        r = _j.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.update = function (id, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var f, resultFilter, updateObject, _a, _b, x, v, key, e_2_1, where, _c;
+            var e_2, _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        f = new FilterConsumerBridgeToKnexRequest();
+                        __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 = {};
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 8, 9, 10]);
+                        _a = tslib_1.__values(this.entity.fields), _b = _a.next();
+                        _e.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        x = _b.value;
+                        return [4 /*yield*/, sql_database_1.isDbReadonly(x)];
+                    case 3:
+                        if (!_e.sent()) 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*/, x.getDbName()];
+                    case 5:
+                        key = _e.sent();
+                        updateObject[key] = v;
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_2_1 = _e.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [4 /*yield*/, f.resolveWhere()];
+                    case 11:
+                        where = _e.sent();
+                        _c = this.knex;
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 12: return [4 /*yield*/, _c.apply(this, [_e.sent()]).update(updateObject).where(function (b) { return where.forEach(function (w) { return w(b); }); })];
+                    case 13:
+                        _e.sent();
+                        return [2 /*return*/, this.find({ where: __1.Filter.fromEntityFilter(this.entity, resultFilter) }).then(function (y) { return y[0]; })];
+                }
+            });
+        });
+    };
+    KnexEntityDataProvider.prototype.delete = function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var f, where, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        f = new FilterConsumerBridgeToKnexRequest();
+                        __1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 1:
+                        where = _b.sent();
+                        _a = this.knex;
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 2: return [4 /*yield*/, _a.apply(this, [_b.sent()]).delete().where(function (b) { return where.forEach(function (w) { return w(b); }); })];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KnexEntityDataProvider.prototype.insert = function (data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var resultFilter, insertObject, _a, _b, x, v, key, e_3_1, insert, _c, newId_1;
+            var e_3, _d;
+            var _this = this;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        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 = {};
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 8, 9, 10]);
+                        _a = tslib_1.__values(this.entity.fields), _b = _a.next();
+                        _e.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        x = _b.value;
+                        return [4 /*yield*/, sql_database_1.isDbReadonly(x)];
+                    case 3:
+                        if (!_e.sent()) 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*/, x.getDbName()];
+                    case 5:
+                        key = _e.sent();
+                        insertObject[key] = v;
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_3_1 = _e.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 10:
+                        _c = this.knex;
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 11:
+                        insert = _c.apply(this, [_e.sent()]).insert(insertObject);
+                        if (!this.entity.options.dbAutoIncrementId) return [3 /*break*/, 13];
+                        return [4 /*yield*/, insert.returning(this.entity.idMetadata.field.key)];
+                    case 12:
+                        newId_1 = _e.sent();
+                        resultFilter = new __1.Filter(function (x) { return x.isEqualTo(_this.entity.idMetadata.field, newId_1); });
+                        return [3 /*break*/, 15];
+                    case 13: return [4 /*yield*/, insert];
+                    case 14:
+                        _e.sent();
+                        _e.label = 15;
+                    case 15: return [2 /*return*/, this.find({ where: resultFilter }).then(function (y) {
+                            return y[0];
+                        })];
+                }
+            });
+        });
+    };
+    return KnexEntityDataProvider;
+}());
+var FilterConsumerBridgeToKnexRequest = /** @class */ (function () {
+    function FilterConsumerBridgeToKnexRequest() {
+        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) {
+        throw new Error("Custom filter should be translated before it gets here");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.or = function (orElements) {
+        var _this = this;
+        var statement = '';
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _loop_1, this_1, orElements_1, orElements_1_1, element, e_5_1;
+            var e_5, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _loop_1 = function (element) {
+                            var f, where;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        f = new FilterConsumerBridgeToKnexRequest();
+                                        f._addWhere = false;
+                                        element.__applyToConsumer(f);
+                                        return [4 /*yield*/, f.resolveWhere()];
+                                    case 1:
+                                        where = _a.sent();
+                                        if (where.length > 0) {
+                                            this_1.result.push(function (b) {
+                                                b.orWhere(function (b) {
+                                                    where.forEach(function (x) { return x(b); });
+                                                });
+                                            });
+                                        }
+                                        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:
+                        _b.sent();
+                        _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: return [2 /*return*/];
+                }
+            });
+        }); })());
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isNull = function (col) {
+        var _this = this;
+        this.promises.push(col.getDbName().then(function (col) { _this.result.push(function (b) { return b.whereNull(col); }); }));
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isNotNull = function (col) {
+        var _this = this;
+        this.promises.push(col.getDbName().then(function (col) { _this.result.push(function (b) { return b.whereNotNull(col); }); }));
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isIn = function (col, val) {
+        var _this = this;
+        this.promises.push(col.getDbName().then(function (colName) {
+            _this.result.push(function (knex) {
+                return knex.whereIn(colName, val.map(function (x) { return col.valueConverter.toDb(x); }));
+            });
+        }));
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isEqualTo = function (col, val) {
+        this.add(col, val, "=");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isDifferentFrom = function (col, val) {
+        this.add(col, val, "<>");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isGreaterOrEqualTo = function (col, val) {
+        this.add(col, val, ">=");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isGreaterThan = function (col, val) {
+        this.add(col, val, ">");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isLessOrEqualTo = function (col, val) {
+        this.add(col, val, "<=");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.isLessThan = function (col, val) {
+        this.add(col, val, "<");
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.containsCaseInsensitive = function (col, val) {
+        var _this = this;
+        this.promises.push(col.getDbName().then(function (colName) {
+            _this.result.push(function (b) { return b.whereRaw('lower (' + colName + ") 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.promises.push(col.getDbName().then(function (colName) {
+            _this.result.push(function (b) { return b.where(colName, operator, col.valueConverter.toDb(val)); });
+        }));
+    };
+    FilterConsumerBridgeToKnexRequest.prototype.databaseCustom = function (databaseCustom) {
+        throw "error";
+        //   this.promises.push((async () => {
+        //     if (databaseCustom?.buildSql) {
+        //       let item = new CustomSqlFilterBuilder(this.knex);
+        //       await databaseCustom.buildSql(item);
+        //       if (item.sql) {
+        //         this.addToWhere("(" + item.sql + ")");
+        //       }
+        //     }
+        //   })());
+    };
+    return FilterConsumerBridgeToKnexRequest;
+}());
+exports.FilterConsumerBridgeToKnexRequest = FilterConsumerBridgeToKnexRequest;
+var KnexSchemaBuilder = /** @class */ (function () {
+    function KnexSchemaBuilder(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_1, _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_1 = _e.sent();
+                        _b = (_a = console).log;
+                        _c = "failed verify structore of ";
+                        return [4 /*yield*/, metadata.getDbName()];
+                    case 9:
+                        _b.apply(_a, [_c + (_e.sent()) + " ", err_1]);
+                        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*/];
+                }
+            });
+        });
+    };
+    KnexSchemaBuilder.prototype.createIfNotExist = function (e) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, cols_1, _c, _d, f, _e, _f, _g, e_7_1, _h, _j, _k;
+            var e_7, _l, _m;
+            return tslib_1.__generator(this, function (_o) {
+                switch (_o.label) {
+                    case 0:
+                        _b = (_a = this.knex.schema).hasTable;
+                        return [4 /*yield*/, e.getDbName()];
+                    case 1: return [4 /*yield*/, _b.apply(_a, [_o.sent()])];
+                    case 2:
+                        if (!!(_o.sent())) return [3 /*break*/, 14];
+                        cols_1 = new Map();
+                        _o.label = 3;
+                    case 3:
+                        _o.trys.push([3, 9, 10, 11]);
+                        _c = tslib_1.__values(e.fields), _d = _c.next();
+                        _o.label = 4;
+                    case 4:
+                        if (!!_d.done) return [3 /*break*/, 8];
+                        f = _d.value;
+                        _f = (_e = cols_1).set;
+                        _g = [f];
+                        _m = {};
+                        return [4 /*yield*/, f.getDbName()];
+                    case 5:
+                        _m.name = _o.sent();
+                        return [4 /*yield*/, sql_database_1.isDbReadonly(f)];
+                    case 6:
+                        _f.apply(_e, _g.concat([(_m.readonly = _o.sent(),
+                                _m)]));
+                        _o.label = 7;
+                    case 7:
+                        _d = _c.next();
+                        return [3 /*break*/, 4];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_7_1 = _o.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 11];
+                    case 10:
+                        try {
+                            if (_d && !_d.done && (_l = _c.return)) _l.call(_c);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                        return [7 /*endfinally*/];
+                    case 11:
+                        _h = logSql;
+                        _k = (_j = this.knex.schema).createTable;
+                        return [4 /*yield*/, e.getDbName()];
+                    case 12: return [4 /*yield*/, _h.apply(void 0, [_k.apply(_j, [_o.sent(),
+                                function (b) {
+                                    var e_8, _a;
+                                    try {
+                                        for (var _b = tslib_1.__values(e.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                            var x = _c.value;
+                                            if (!cols_1.get(x).readonly || x == e.idMetadata.field && e.options.dbAutoIncrementId) {
+                                                if (x == e.idMetadata.field && e.options.dbAutoIncrementId)
+                                                    b.increments(cols_1.get(x).name);
+                                                else {
+                                                    buildColumn(x, cols_1.get(x).name, b);
+                                                    if (x == e.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 13:
+                        _o.sent();
+                        _o.label = 14;
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KnexSchemaBuilder.prototype.addColumnIfNotExist = function (e, c) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var col, colName, _a, _b, _c, _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, sql_database_1.isDbReadonly(c(e))];
+                    case 1:
+                        if (_e.sent())
+                            return [2 /*return*/];
+                        col = c(e);
+                        return [4 /*yield*/, col.getDbName()];
+                    case 2:
+                        colName = _e.sent();
+                        _b = (_a = this.knex.schema).hasColumn;
+                        return [4 /*yield*/, e.getDbName()];
+                    case 3: return [4 /*yield*/, _b.apply(_a, [_e.sent(), colName])];
+                    case 4:
+                        if (!!(_e.sent())) return [3 /*break*/, 7];
+                        _d = (_c = this.knex.schema).alterTable;
+                        return [4 /*yield*/, e.getDbName()];
+                    case 5: return [4 /*yield*/, _d.apply(_c, [_e.sent(), function (b) {
+                                buildColumn(col, colName, b);
+                            }])];
+                    case 6:
+                        _e.sent();
+                        _e.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KnexSchemaBuilder.prototype.verifyAllColumns = function (e) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _loop_2, this_2, _a, _b, col, e_9_1, err_2;
+            var e_9, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 9, , 10]);
+                        _loop_2 = function (col) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, sql_database_1.isDbReadonly(col)];
+                                    case 1:
+                                        if (!!(_a.sent())) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this_2.addColumnIfNotExist(e, function () { return col; })];
+                                    case 2:
+                                        _a.sent();
+                                        _a.label = 3;
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(e.fields), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        col = _b.value;
+                        return [5 /*yield**/, _loop_2(col)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_9_1 = _d.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        err_2 = _d.sent();
+                        console.log(err_2);
+                        return [3 /*break*/, 10];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return KnexSchemaBuilder;
+}());
+exports.KnexSchemaBuilder = KnexSchemaBuilder;
+function buildColumn(x, dbName, b) {
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb) {
+            var c = b.decimal(dbName);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else if (x.valueConverter.fieldTypeInDb == "integer") {
+            var c = b.integer(dbName);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == valueConverters_1.DateOnlyValueConverter)
+                b.date(dbName);
+            else
+                b.dateTime(dbName);
+        else if (x.valueConverter.fieldTypeInDb == "date")
+            b.date(dbName);
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else if (x.valueType == Boolean) {
+        var 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);
+            if (!x.allowNull) {
+                c.defaultTo(0).notNullable();
+            }
+        }
+        else
+            b.specificType(dbName, x.valueConverter.fieldTypeInDb);
+    }
+    else {
+        var c = b.string(dbName);
+        if (!x.allowNull)
+            c.defaultTo('').notNullable();
+    }
+}
+exports.buildColumn = buildColumn;
+function logSql(who) {
+    //console.log(who.toSQL().sql);
+    return who;
+}
+//# sourceMappingURL=index.js.map