remult 0.14.7-esm.1 → 0.14.8

package/esm/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/esm/index.js

@@ -27,3 +27,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/esm/postgres/index.d.ts

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

package/esm/postgres/index.js

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

package/esm/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/esm/postgres/postgres-data-provider.js

@@ -1,8 +1,6 @@
 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';
+import { Remult } from '../src/context';
+import { PostgresSchemaBuilder, verifyStructureOfAllEntities } from './schema-builder';
 import { SqlDatabase } from '../src/data-providers/sql-database';
 export class PostgresDataProvider {
     constructor(pool) {
@@ -59,110 +57,6 @@ class PostgresBridgeToSQLQueryResult {
         return this.r.fields[index].name;
     }
 }
-export async function verifyStructureOfAllEntities(db, remult) {
-    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
-}
-export class PostgresSchemaBuilder {
-    constructor(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);
-                    }
-                }
-            }
-            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';
-                        }
-                    }
-                }
-                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);
-            }
-        }
-        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);
-                    }
-            }
-        }
-        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 = {};
@@ -192,3 +86,12 @@ export async function createPostgresConnection(options) {
         await verifyStructureOfAllEntities(db, remult);
     return db;
 }
+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));
+}

package/esm/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);
+}

package/esm/postgres/schema-builder.js

@@ -0,0 +1,128 @@
+import { allEntities } from '../src/context';
+import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { isAutoIncrement } from '../src/remult3';
+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");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}
+export async function verifyStructureOfAllEntities(db, remult) {
+    return await new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult);
+}
+export class PostgresSchemaBuilder {
+    constructor(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);
+                    }
+                }
+            }
+            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';
+                        }
+                    }
+                }
+                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);
+            }
+        }
+        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);
+                    }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+}

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,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.7-esm.1",
+    "version": "0.14.8",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",
@@ -27,6 +27,14 @@
         "./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);
+}

package/postgres/schema-builder.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresSchemaBuilder = exports.verifyStructureOfAllEntities = exports.postgresColumnSyntax = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../src/context");
+var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
+var remult3_1 = require("../src/remult3");
+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");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == valueConverters_1.ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}
+exports.postgresColumnSyntax = postgresColumnSyntax;
+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_1, 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_1 = _b.sent();
+                        console.log("failed verify structure of " + e.entityName + " ", 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_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(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_2;
+            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(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_2 = _a.sent();
+                        console.log(err_2);
+                        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_3;
+            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(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_3 = _d.sent();
+                        console.log(err_3);
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return PostgresSchemaBuilder;
+}());
+exports.PostgresSchemaBuilder = PostgresSchemaBuilder;

package/esm/postgres/postgresColumnSyntax.d.ts

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

package/esm/postgres/postgresColumnSyntax.js

@@ -1,30 +0,0 @@
-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");
-        else
-            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
-    }
-    else if (x.valueType == Date) {
-        if (!x.valueConverter.fieldTypeInDb)
-            if (x.valueConverter == ValueConverters.DateOnly)
-                result += " date";
-            else
-                result += " timestamp";
-        else
-            result += " " + x.valueConverter.fieldTypeInDb;
-    }
-    else if (x.valueType == Boolean)
-        result += " boolean" + (x.allowNull ? "" : " default false not null");
-    else if (x.valueConverter.fieldTypeInDb) {
-        result += " " + x.valueConverter.fieldTypeInDb;
-        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
-            result += " default 0 not null";
-        }
-    }
-    else
-        result += " varchar" + (x.allowNull ? "" : " default '' not null");
-    return result;
-}