remult 0.14.2 → 0.14.5

package/postgres/postgres-data-provider.js

@@ -1,393 +1,194 @@
-"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 __1 = require("../");
-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 PostgresDataProvider = /** @class */ (function () {
-    function PostgresDataProvider(pool) {
+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) {
         this.pool = pool;
     }
-    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) {
+    async entityIsUsedForTheFirstTime(entity) {
+    }
+    getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
-    };
-    PostgresDataProvider.prototype.createCommand = function () {
+    }
+    createCommand() {
         return new PostgresBridgeToSQLCommand(this.pool);
-    };
-    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*/];
-                }
+    }
+    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
             });
-        });
-    };
-    return PostgresDataProvider;
-}());
-exports.PostgresDataProvider = PostgresDataProvider;
-var PostgresBridgeToSQLCommand = /** @class */ (function () {
-    function PostgresBridgeToSQLCommand(source) {
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            await client.release();
+        }
+    }
+}
+class PostgresBridgeToSQLCommand {
+    constructor(source) {
         this.source = source;
         this.values = [];
     }
-    PostgresBridgeToSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+    addParameterAndReturnSqlToken(val) {
         this.values.push(val);
         return '$' + this.values.length;
-    };
-    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) {
+    }
+    execute(sql) {
+        return this.source.query(sql, this.values).then(r => new PostgresBridgeToSQLQueryResult(r));
+    }
+}
+class PostgresBridgeToSQLQueryResult {
+    constructor(r) {
         this.r = r;
         this.rows = r.rows;
     }
-    PostgresBridgeToSQLQueryResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+    getColumnKeyInResultForIndexInSelect(index) {
         return this.r.fields[index].name;
-    };
-    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 async function verifyStructureOfAllEntities(db, remult) {
+    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
 }
-exports.verifyStructureOfAllEntities = verifyStructureOfAllEntities;
-var PostgresSchemaBuilder = /** @class */ (function () {
-    function PostgresSchemaBuilder(pool, schema) {
+export class PostgresSchemaBuilder {
+    constructor(pool, schema) {
         this.pool = pool;
         this.additionalWhere = '';
         if (schema) {
             this.additionalWhere = ' and table_schema=\'' + schema + '\'';
         }
     }
-    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*/];
-                }
-            });
-        });
-    };
-    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*/];
+    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.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);
+            }
+            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';
                         }
-                        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*/];
+                    }
                 }
-            });
-        });
-    };
-    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))];
+                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                //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;
+    }
+    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);
+            }
+        }
+        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);
                     }
-                    db = new __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.js

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

package/remult-express.js

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