remult 0.14.6 → 0.14.7

package/postgres/postgres-data-provider.js

@@ -1,194 +1,393 @@
-import { SqlDatabase } from '../';
-import { Pool } from 'pg';
-import { allEntities, Remult } from '../src/context';
-import { postgresColumnSyntax } from './postgresColumnSyntax';
-import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
-import { isAutoIncrement } from '../src/remult3';
-export class PostgresDataProvider {
-    constructor(pool) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostgresConnection = exports.preparePostgresQueueStorage = exports.PostgresSchemaBuilder = exports.verifyStructureOfAllEntities = exports.PostgresDataProvider = void 0;
+var tslib_1 = require("tslib");
+var pg_1 = require("pg");
+var context_1 = require("../src/context");
+var postgresColumnSyntax_1 = require("./postgresColumnSyntax");
+var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
+var remult3_1 = require("../src/remult3");
+var sql_database_1 = require("../src/data-providers/sql-database");
+var PostgresDataProvider = /** @class */ (function () {
+    function PostgresDataProvider(pool) {
         this.pool = pool;
     }
-    async entityIsUsedForTheFirstTime(entity) {
-    }
-    getLimitSqlSyntax(limit, offset) {
+    PostgresDataProvider.prototype.entityIsUsedForTheFirstTime = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    PostgresDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
-    }
-    createCommand() {
+    };
+    PostgresDataProvider.prototype.createCommand = function () {
         return new PostgresBridgeToSQLCommand(this.pool);
-    }
-    async transaction(action) {
-        let client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            await action({
-                createCommand: () => new PostgresBridgeToSQLCommand(client),
-                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
-                transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax
+    };
+    PostgresDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var client, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pool.connect()];
+                    case 1:
+                        client = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 6, 8, 10]);
+                        return [4 /*yield*/, client.query('BEGIN')];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, action({
+                                createCommand: function () { return new PostgresBridgeToSQLCommand(client); },
+                                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                                transaction: function () { throw "nested transactions not allowed"; },
+                                getLimitSqlSyntax: this.getLimitSqlSyntax
+                            })];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, client.query('COMMIT')];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 10];
+                    case 6:
+                        err_1 = _a.sent();
+                        return [4 /*yield*/, client.query('ROLLBACK')];
+                    case 7:
+                        _a.sent();
+                        throw err_1;
+                    case 8: return [4 /*yield*/, client.release()];
+                    case 9:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
             });
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            await client.release();
-        }
-    }
-}
-class PostgresBridgeToSQLCommand {
-    constructor(source) {
+        });
+    };
+    return PostgresDataProvider;
+}());
+exports.PostgresDataProvider = PostgresDataProvider;
+var PostgresBridgeToSQLCommand = /** @class */ (function () {
+    function PostgresBridgeToSQLCommand(source) {
         this.source = source;
         this.values = [];
     }
-    addParameterAndReturnSqlToken(val) {
+    PostgresBridgeToSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
         this.values.push(val);
         return '$' + this.values.length;
-    }
-    execute(sql) {
-        return this.source.query(sql, this.values).then(r => new PostgresBridgeToSQLQueryResult(r));
-    }
-}
-class PostgresBridgeToSQLQueryResult {
-    constructor(r) {
+    };
+    PostgresBridgeToSQLCommand.prototype.execute = function (sql) {
+        return this.source.query(sql, this.values).then(function (r) { return new PostgresBridgeToSQLQueryResult(r); });
+    };
+    return PostgresBridgeToSQLCommand;
+}());
+var PostgresBridgeToSQLQueryResult = /** @class */ (function () {
+    function PostgresBridgeToSQLQueryResult(r) {
         this.r = r;
         this.rows = r.rows;
     }
-    getColumnKeyInResultForIndexInSelect(index) {
+    PostgresBridgeToSQLQueryResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
         return this.r.fields[index].name;
-    }
-}
-export async function verifyStructureOfAllEntities(db, remult) {
-    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
+    };
+    return PostgresBridgeToSQLQueryResult;
+}());
+function verifyStructureOfAllEntities(db, remult) {
+    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*/, new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
 }
-export class PostgresSchemaBuilder {
-    constructor(pool, schema) {
+exports.verifyStructureOfAllEntities = verifyStructureOfAllEntities;
+var PostgresSchemaBuilder = /** @class */ (function () {
+    function PostgresSchemaBuilder(pool, schema) {
         this.pool = pool;
         this.additionalWhere = '';
         if (schema) {
             this.additionalWhere = ' and table_schema=\'' + schema + '\'';
         }
     }
-    async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
-        for (const entityClass of allEntities) {
-            let entity = remult.repo(entityClass).metadata;
-            let e = await getDbNameProvider(entity);
-            try {
-                if (!entity.options.sqlExpression) {
-                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
-                        await this.createIfNotExist(entity);
-                        await this.verifyAllColumns(entity);
-                    }
+    PostgresSchemaBuilder.prototype.verifyStructureOfAllEntities = function (remult) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allEntities_1, allEntities_1_1, entityClass, entity, e, err_2, e_1_1;
+            var e_1, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("start verify structure");
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 12, 13, 14]);
+                        allEntities_1 = tslib_1.__values(context_1.allEntities), allEntities_1_1 = allEntities_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!allEntities_1_1.done) return [3 /*break*/, 11];
+                        entityClass = allEntities_1_1.value;
+                        entity = remult.repo(entityClass).metadata;
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 3:
+                        e = _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, , 10]);
+                        if (!!entity.options.sqlExpression) return [3 /*break*/, 8];
+                        return [4 /*yield*/, e.entityName];
+                    case 5:
+                        if (!((_b.sent()).toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.createIfNotExist(entity)];
+                    case 6:
+                        _b.sent();
+                        return [4 /*yield*/, this.verifyAllColumns(entity)];
+                    case 7:
+                        _b.sent();
+                        _b.label = 8;
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        err_2 = _b.sent();
+                        console.log("failed verify structure of " + e.entityName + " ", 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_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (allEntities_1_1 && !allEntities_1_1.done && (_a = allEntities_1.return)) _a.call(allEntities_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
                 }
-            }
-            catch (err) {
-                console.log("failed verify structure of " + e.entityName + " ", err);
-            }
-        }
-    }
-    async createIfNotExist(entity) {
-        var c = this.pool.createCommand();
-        let e = await getDbNameProvider(entity);
-        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
-            if (r.rows.length == 0) {
-                let result = '';
-                for (const x of entity.fields) {
-                    if (!e.isDbReadonly(x) || isAutoIncrement(x)) {
-                        if (result.length != 0)
-                            result += ',';
-                        result += '\r\n  ';
-                        if (isAutoIncrement(x))
-                            result += e.nameOf(x) + ' serial';
-                        else {
-                            result += postgresColumnSyntax(x, e.nameOf(x));
-                            if (x == entity.idMetadata.field)
-                                result += ' primary key';
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.createIfNotExist = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var c, e;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        c = this.pool.createCommand();
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 1:
+                        e = _a.sent();
+                        return [4 /*yield*/, c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var result, _a, _b, x, sql;
+                                var e_2, _c;
+                                return tslib_1.__generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            if (!(r.rows.length == 0)) return [3 /*break*/, 2];
+                                            result = '';
+                                            try {
+                                                for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                    x = _b.value;
+                                                    if (!e.isDbReadonly(x) || remult3_1.isAutoIncrement(x)) {
+                                                        if (result.length != 0)
+                                                            result += ',';
+                                                        result += '\r\n  ';
+                                                        if (remult3_1.isAutoIncrement(x))
+                                                            result += e.nameOf(x) + ' serial';
+                                                        else {
+                                                            result += postgresColumnSyntax_1.postgresColumnSyntax(x, e.nameOf(x));
+                                                            if (x == entity.idMetadata.field)
+                                                                result += ' primary key';
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                }
+                                                finally { if (e_2) throw e_2.error; }
+                                            }
+                                            sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                                            //console.log(sql);
+                                            return [4 /*yield*/, this.pool.execute(sql)];
+                                        case 1:
+                                            //console.log(sql);
+                                            _d.sent();
+                                            _d.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.addColumnIfNotExist = function (entity, c) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, cmd, colName, sql, err_3;
+            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*/];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 6, , 7]);
+                        cmd = this.pool.createCommand();
+                        colName = e.nameOf(c(entity));
+                        return [4 /*yield*/, cmd.execute("select 1   \n        FROM information_schema.columns \n        WHERE table_name=" + cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase()) + " and column_name=" + cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase()) + this.additionalWhere)];
+                    case 3:
+                        if (!((_a.sent()).rows.length == 0)) return [3 /*break*/, 5];
+                        sql = "alter table " + e.entityName + " add column " + postgresColumnSyntax_1.postgresColumnSyntax(c(entity), colName);
+                        //console.log(sql);
+                        return [4 /*yield*/, this.pool.execute(sql)];
+                    case 4:
+                        //console.log(sql);
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        err_3 = _a.sent();
+                        console.log(err_3);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.verifyAllColumns = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var cmd, e, cols, _a, _b, col, sql, e_3_1, err_4;
+            var e_3, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 11, , 12]);
+                        cmd = this.pool.createCommand();
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 1:
+                        e = _d.sent();
+                        return [4 /*yield*/, cmd.execute("select column_name   \n        FROM information_schema.columns \n        WHERE table_name=" + cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase()) + " " + this.additionalWhere)];
+                    case 2:
+                        cols = (_d.sent()).rows.map(function (x) { return x.column_name; });
+                        _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;
+                        if (!!e.isDbReadonly(col)) return [3 /*break*/, 6];
+                        if (!!cols.includes(e.nameOf(col).toLocaleLowerCase())) return [3 /*break*/, 6];
+                        sql = "alter table " + e.entityName + " add column " + postgresColumnSyntax_1.postgresColumnSyntax(col, e.nameOf(col));
+                        //console.log(sql);
+                        return [4 /*yield*/, this.pool.execute(sql)];
+                    case 5:
+                        //console.log(sql);
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    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: return [3 /*break*/, 12];
+                    case 11:
+                        err_4 = _d.sent();
+                        console.log(err_4);
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/];
                 }
-                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
-                //console.log(sql);
-                await this.pool.execute(sql);
-            }
+            });
         });
-    }
-    async addColumnIfNotExist(entity, c) {
-        let e = await getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
-            return;
-        try {
-            let cmd = this.pool.createCommand();
-            const colName = e.nameOf(c(entity));
-            if ((await cmd.execute(`select 1   
-        FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
-                let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
-                //console.log(sql);
-                await this.pool.execute(sql);
+    };
+    return PostgresSchemaBuilder;
+}());
+exports.PostgresSchemaBuilder = PostgresSchemaBuilder;
+function preparePostgresQueueStorage(sql) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var c, JobsInQueueEntity, e;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    c = new context_1.Remult();
+                    c.setDataProvider(sql);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                case 1:
+                    JobsInQueueEntity = (_a.sent()).JobsInQueueEntity;
+                    e = c.repo(JobsInQueueEntity);
+                    return [4 /*yield*/, new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata)];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('../server/expressBridge'); })];
+                case 4: return [2 /*return*/, new (_a.sent()).EntityQueueStorage(c.repo(JobsInQueueEntity))];
             }
-        }
-        catch (err) {
-            console.log(err);
-        }
-    }
-    async verifyAllColumns(entity) {
-        try {
-            let cmd = this.pool.createCommand();
-            let e = await getDbNameProvider(entity);
-            let cols = (await cmd.execute(`select column_name   
-        FROM information_schema.columns 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name);
-            for (const col of entity.fields) {
-                if (!e.isDbReadonly(col))
-                    if (!cols.includes(e.nameOf(col).toLocaleLowerCase())) {
-                        let sql = `alter table ${e.entityName} add column ${postgresColumnSyntax(col, e.nameOf(col))}`;
-                        //console.log(sql);
-                        await this.pool.execute(sql);
+        });
+    });
+}
+exports.preparePostgresQueueStorage = preparePostgresQueueStorage;
+function createPostgresConnection(options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var config, db, remult;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!options)
+                        options = {};
+                    config = {};
+                    if (options.configuration)
+                        if (options.configuration == "heroku") {
+                            config = {
+                                connectionString: process.env.DATABASE_URL,
+                                ssl: process.env.NODE_ENV !== "production" && !options.sslInDev ? false : {
+                                    rejectUnauthorized: false
+                                }
+                            };
+                        }
+                        else
+                            config = options.configuration;
+                    else {
+                        if (!options.connectionString)
+                            options.connectionString = process.env.DATABASE_URL;
+                    }
+                    if (!config.connectionString && options.connectionString) {
+                        config.connectionString = options.connectionString;
                     }
+                    db = new sql_database_1.SqlDatabase(new PostgresDataProvider(new pg_1.Pool(config)));
+                    remult = new context_1.Remult();
+                    remult.setDataProvider(db);
+                    if (!(options.autoCreateTables === undefined || options.autoCreateTables)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, verifyStructureOfAllEntities(db, remult)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/, db];
             }
-        }
-        catch (err) {
-            console.log(err);
-        }
-    }
-}
-export async function preparePostgresQueueStorage(sql) {
-    let c = new Remult();
-    c.setDataProvider(sql);
-    let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
-    let e = c.repo(JobsInQueueEntity);
-    await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);
-    await new PostgresSchemaBuilder(sql).verifyAllColumns(e.metadata);
-    return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));
-}
-export async function createPostgresConnection(options) {
-    if (!options)
-        options = {};
-    let config = {};
-    if (options.configuration)
-        if (options.configuration == "heroku") {
-            config = {
-                connectionString: process.env.DATABASE_URL,
-                ssl: process.env.NODE_ENV !== "production" && !options.sslInDev ? false : {
-                    rejectUnauthorized: false
-                }
-            };
-        }
-        else
-            config = options.configuration;
-    else {
-        if (!options.connectionString)
-            options.connectionString = process.env.DATABASE_URL;
-    }
-    if (!config.connectionString && options.connectionString) {
-        config.connectionString = options.connectionString;
-    }
-    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
-    let remult = new Remult();
-    remult.setDataProvider(db);
-    if (options.autoCreateTables === undefined || options.autoCreateTables)
-        await verifyStructureOfAllEntities(db, remult);
-    return db;
+        });
+    });
 }
+exports.createPostgresConnection = createPostgresConnection;

package/postgres/postgresColumnSyntax.d.ts

@@ -1,2 +1,2 @@
-import { FieldMetadata } from '../';
+import { FieldMetadata } from '../src/column-interfaces';
 export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;

package/postgres/postgresColumnSyntax.js

@@ -1,6 +1,9 @@
-import { ValueConverters } from '../valueConverters';
-export function postgresColumnSyntax(x, dbName) {
-    let result = dbName;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresColumnSyntax = void 0;
+var valueConverters_1 = require("../valueConverters");
+function postgresColumnSyntax(x, dbName) {
+    var result = dbName;
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb)
             result += " numeric" + (x.allowNull ? "" : " default 0 not null");
@@ -9,7 +12,7 @@ export function postgresColumnSyntax(x, dbName) {
     }
     else if (x.valueType == Date) {
         if (!x.valueConverter.fieldTypeInDb)
-            if (x.valueConverter == ValueConverters.DateOnly)
+            if (x.valueConverter == valueConverters_1.ValueConverters.DateOnly)
                 result += " date";
             else
                 result += " timestamp";
@@ -28,3 +31,4 @@ export function postgresColumnSyntax(x, dbName) {
         result += " varchar" + (x.allowNull ? "" : " default '' not null");
     return result;
 }
+exports.postgresColumnSyntax = postgresColumnSyntax;

package/remult-express.js

@@ -1,16 +1,20 @@
-import * as express from 'express';
-import { remultMiddlewareBase } from './server/expressBridge';
-export function remultExpress(options) {
-    let app = express.Router();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remultExpress = void 0;
+var express = require("express");
+var expressBridge_1 = require("./server/expressBridge");
+function remultExpress(options) {
+    var app = express.Router();
     if (!options) {
         options = {};
     }
     if (options.bodySizeLimit === undefined) {
         options.bodySizeLimit = '10mb';
     }
-    if (options?.bodyParser !== false) {
+    if ((options === null || options === void 0 ? void 0 : options.bodyParser) !== false) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    return remultMiddlewareBase(app, options);
+    return expressBridge_1.remultMiddlewareBase(app, options);
 }
+exports.remultExpress = remultExpress;

package/remult-knex/index.d.ts

@@ -1,7 +1,10 @@
-import { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, FieldMetadata, Filter, Remult } from "..";
 import { Knex } from 'knex';
-import { FilterConsumer } from "../src/filter/filter-interfaces";
+import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
 import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import { Remult } from "../src/context";
+import { EntityFilter, EntityMetadata } from "../src/remult3";
+import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
+import { FieldMetadata } from '../src/column-interfaces';
 export declare class KnexDataProvider implements DataProvider {
     knex: Knex;
     constructor(knex: Knex);