remult 0.14.7 → 0.14.8

package/esm/valueConverters.d.ts

@@ -0,0 +1,12 @@
+import { ValueConverter } from "./src/column-interfaces";
+export declare class ValueConverters {
+    static readonly Date: ValueConverter<Date>;
+    static readonly DateOnly: ValueConverter<Date>;
+    static readonly DateOnlyString: ValueConverter<Date>;
+    static readonly Boolean: ValueConverter<Boolean>;
+    static readonly Number: ValueConverter<number>;
+    static readonly Integer: ValueConverter<number>;
+    static readonly Default: ValueConverter<any>;
+    static readonly JsonString: ValueConverter<any>;
+    static readonly JsonValue: ValueConverter<any>;
+}

package/esm/valueConverters.js

@@ -0,0 +1,169 @@
+import { InputTypes } from "./inputTypes";
+export class ValueConverters {
+}
+ValueConverters.Date = {
+    toJson: (val) => {
+        if (!val)
+            return '';
+        if (typeof (val) === "string")
+            val = new Date(val);
+        if (val instanceof Date) {
+            return val.toISOString();
+        }
+        else {
+            console.log("ToJsonError", val);
+            throw new Error("Expected date but got val");
+        }
+    },
+    fromJson: (val) => {
+        if (val == undefined)
+            return undefined;
+        if (val == '')
+            return undefined;
+        if (val.startsWith('0000-00-00'))
+            return undefined;
+        return new Date(Date.parse(val));
+    },
+    toDb: x => x,
+    fromDb: x => x,
+    fromInput: x => ValueConverters.Date.fromJson(x),
+    toInput: x => ValueConverters.Date.toJson(x),
+    displayValue: (val) => {
+        if (!val)
+            return '';
+        return val.toLocaleString();
+    }
+};
+ValueConverters.DateOnly = {
+    fromInput: x => ValueConverters.DateOnly.fromJson(x),
+    toInput: x => ValueConverters.DateOnly.toJson(x),
+    toJson: (val) => {
+        var d = val;
+        if (typeof d === "string" || typeof (d) === "number")
+            d = new Date(d);
+        if (!d || d == null)
+            return null;
+        if (d.getHours() == 0)
+            return new Date(d.valueOf() - d.getTimezoneOffset() * 60000).toISOString().substring(0, 10);
+        else
+            return d.toISOString().substring(0, 10);
+    },
+    fromJson: (value) => {
+        if (!value || value == '' || value == '0000-00-00')
+            return null;
+        let d = new Date(Date.parse(value));
+        d.setMinutes(d.getMinutes() + d.getTimezoneOffset());
+        return d;
+    },
+    inputType: InputTypes.date,
+    toDb: (val) => {
+        if (!val)
+            return null;
+        return ValueConverters.DateOnly.fromJson(ValueConverters.DateOnly.toJson(val));
+    } //when using date storage,  the database expects and returns a date local and every where else we reflect on date iso
+    ,
+    fromDb: (val) => {
+        var d = val;
+        if (!d)
+            return null;
+        return val;
+    },
+    fieldTypeInDb: 'date',
+    displayValue: (value) => {
+        if (!value)
+            return '';
+        return value.toLocaleDateString(undefined);
+    }
+};
+ValueConverters.DateOnlyString = {
+    ...ValueConverters.DateOnly,
+    toDb: (d) => {
+        let val = ValueConverters.DateOnly.toJson(d);
+        if (!val)
+            return undefined;
+        return val.replace(/-/g, '');
+    },
+    fromDb: (val) => {
+        if (val === null)
+            return null;
+        if (!val)
+            return undefined;
+        return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
+    }
+};
+ValueConverters.Boolean = {
+    toDb: (val) => val,
+    inputType: InputTypes.checkbox,
+    fromDb: (value) => {
+        return ValueConverters.Boolean.fromJson(value);
+    },
+    fromJson: value => {
+        if (typeof value === "boolean")
+            return value;
+        if (value !== undefined && value !== null) {
+            return value.toString().trim().toLowerCase() == 'true';
+        }
+        return value;
+    },
+    toJson: x => x,
+    fromInput: x => ValueConverters.Boolean.fromJson(x),
+    toInput: x => ValueConverters.Boolean.toJson(x)
+};
+ValueConverters.Number = {
+    fromDb: value => {
+        if (value === null)
+            return null;
+        if (value !== undefined)
+            return +value;
+        return undefined;
+    },
+    toDb: value => value,
+    fromJson: value => ValueConverters.Number.fromDb(value),
+    toJson: value => ValueConverters.Number.toDb(value),
+    fromInput: (x, type) => {
+        let r = +x;
+        if (!x)
+            return undefined;
+        return r;
+    },
+    toInput: (x, type) => {
+        return x?.toString();
+    },
+    inputType: InputTypes.number
+};
+ValueConverters.Integer = {
+    ...ValueConverters.Number,
+    toJson: value => {
+        let val = ValueConverters.Number.toDb(value);
+        if (!val)
+            return val;
+        return +(+val).toFixed(0);
+    },
+    toDb: value => ValueConverters.Integer.toJson(value),
+    fieldTypeInDb: 'integer'
+};
+ValueConverters.Default = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => ValueConverters.JsonString.fromDb(x),
+    toDb: x => ValueConverters.JsonString.toDb(x),
+    fromInput: x => ValueConverters.Default.fromJson(x),
+    toInput: x => ValueConverters.Default.toJson(x)
+};
+ValueConverters.JsonString = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => x == null ? null : x ? JSON.parse(ValueConverters.JsonString.fromJson(x)) : undefined,
+    toDb: x => x !== undefined ? x === null ? null : JSON.stringify(ValueConverters.JsonString.toJson(x)) : undefined,
+    fromInput: x => ValueConverters.JsonString.fromJson(x),
+    toInput: x => ValueConverters.JsonString.toJson(x)
+};
+ValueConverters.JsonValue = {
+    fromJson: x => x,
+    toJson: x => x,
+    fromDb: x => x,
+    toDb: x => x,
+    fromInput: x => ValueConverters.JsonString.fromJson(x),
+    toInput: x => ValueConverters.JsonString.toJson(x),
+    fieldTypeInDb: 'json'
+};

package/index.d.ts

@@ -33,3 +33,4 @@ export { Action, classBackendMethodsArray, serverActionField } from "./src/serve
 export { actionInfo } from "./src/server-action";
 export { registerActionsOnServer } from './server/register-actions-on-server';
 export { registerEntitiesOnServer } from './server/register-entities-on-server';
+/** db implementation required */ 

package/index.js

@@ -75,3 +75,4 @@ var register_actions_on_server_1 = require("./server/register-actions-on-server"
 Object.defineProperty(exports, "registerActionsOnServer", { enumerable: true, get: function () { return register_actions_on_server_1.registerActionsOnServer; } });
 var register_entities_on_server_1 = require("./server/register-entities-on-server");
 Object.defineProperty(exports, "registerEntitiesOnServer", { enumerable: true, get: function () { return register_entities_on_server_1.registerEntitiesOnServer; } });
+/** db implementation required */ 

package/package.json

@@ -1,7 +1,10 @@
 {
     "name": "remult",
-    "version": "0.14.7",
+    "version": "0.14.8",
     "description": "A CRUD framework for full-stack TypeScript",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "module": "esm/index.js",
     "homepage": "https://remult.dev/",
     "repository": {
         "type": "git",
@@ -15,5 +18,23 @@
         "uuid": "^8.3.2",
         "reflect-metadata": "^0.1.13",
         "tslib": "^2.3.1"
+    },
+    "exports": {
+        ".": {
+            "require": "./index.js",
+            "import": "./esm/index.js"
+        },
+        "./remult-express": {
+            "require": "./remult-express.js",
+            "import": "./esm/remult-express.js"
+        },
+        "./remult-middleware": {
+            "require": "./remult-middleware.js",
+            "import": "./esm/remult-middleware.js"
+        },
+        "./postgres/schema-builder": {
+            "require": "./postgres/schema-builder",
+            "import": "./esm/postgres/schema-builder"
+        }
     }
 }

package/postgres/index.d.ts

@@ -1 +1,2 @@
 export * from './postgres-data-provider';
+export * from './schema-builder';

package/postgres/index.js

@@ -2,3 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./postgres-data-provider"), exports);
+tslib_1.__exportStar(require("./schema-builder"), exports);

package/postgres/postgres-data-provider.d.ts

@@ -1,9 +1,7 @@
 import { PoolConfig, QueryResult } from 'pg';
-import { Remult } from '../src/context';
 import { EntityMetadata } from '../src/remult3';
 import { SqlCommand, SqlImplementation } from '../src/sql-command';
 import { SqlDatabase } from '../src/data-providers/sql-database';
-import { FieldMetadata } from '../src/column-interfaces';
 export interface PostgresPool extends PostgresCommandSource {
     connect(): Promise<PostgresClient>;
 }
@@ -21,20 +19,10 @@ export declare class PostgresDataProvider implements SqlImplementation {
 export interface PostgresCommandSource {
     query(queryText: string, values?: any[]): Promise<QueryResult>;
 }
-export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
-export declare class PostgresSchemaBuilder {
-    private pool;
-    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
-    createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
-    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
-    additionalWhere: string;
-    constructor(pool: SqlDatabase, schema?: string);
-}
-export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;
 export declare function createPostgresConnection(options?: {
     connectionString?: string;
     sslInDev?: boolean;
     configuration?: "heroku" | PoolConfig;
     autoCreateTables?: boolean;
 }): Promise<SqlDatabase>;
+export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/postgres/postgres-data-provider.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPostgresConnection = exports.preparePostgresQueueStorage = exports.PostgresSchemaBuilder = exports.verifyStructureOfAllEntities = exports.PostgresDataProvider = void 0;
+exports.preparePostgresQueueStorage = exports.createPostgresConnection = 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 schema_builder_1 = require("./schema-builder");
 var sql_database_1 = require("../src/data-providers/sql-database");
 var PostgresDataProvider = /** @class */ (function () {
     function PostgresDataProvider(pool) {
@@ -93,263 +91,6 @@ var PostgresBridgeToSQLQueryResult = /** @class */ (function () {
     };
     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()];
-            }
-        });
-    });
-}
-exports.verifyStructureOfAllEntities = verifyStructureOfAllEntities;
-var PostgresSchemaBuilder = /** @class */ (function () {
-    function PostgresSchemaBuilder(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*/];
-                }
-            });
-        });
-    };
-    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*/];
-                }
-            });
-        });
-    };
-    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))];
-            }
-        });
-    });
-}
-exports.preparePostgresQueueStorage = preparePostgresQueueStorage;
 function createPostgresConnection(options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var config, db, remult;
@@ -381,7 +122,7 @@ function createPostgresConnection(options) {
                     remult = new context_1.Remult();
                     remult.setDataProvider(db);
                     if (!(options.autoCreateTables === undefined || options.autoCreateTables)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, verifyStructureOfAllEntities(db, remult)];
+                    return [4 /*yield*/, schema_builder_1.verifyStructureOfAllEntities(db, remult)];
                 case 1:
                     _a.sent();
                     _a.label = 2;
@@ -391,3 +132,28 @@ function createPostgresConnection(options) {
     });
 }
 exports.createPostgresConnection = createPostgresConnection;
+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 schema_builder_1.PostgresSchemaBuilder(sql).createIfNotExist(e.metadata)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, new schema_builder_1.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))];
+            }
+        });
+    });
+}
+exports.preparePostgresQueueStorage = preparePostgresQueueStorage;

package/postgres/schema-builder.d.ts

@@ -0,0 +1,15 @@
+import { FieldMetadata } from '../src/column-interfaces';
+import { Remult } from '../src/context';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+import { EntityMetadata } from '../src/remult3';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
+export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
+export declare class PostgresSchemaBuilder {
+    private pool;
+    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    createIfNotExist(entity: EntityMetadata): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
+    additionalWhere: string;
+    constructor(pool: SqlDatabase, schema?: string);
+}