remult 0.17.2 → 0.18.0

package/postgres/schema-builder.js

@@ -4,6 +4,7 @@ exports.PostgresSchemaBuilder = exports.verifyStructureOfAllEntities = exports.p
 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 remult_proxy_1 = require("../src/remult-proxy");
 var remult3_1 = require("../src/remult3");
 var valueConverters_1 = require("../src/valueConverters");
 function postgresColumnSyntax(x, dbName) {
@@ -57,58 +58,103 @@ var PostgresSchemaBuilder = /** @class */ (function () {
     }
     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;
+            var completed, entities, _a, _b, entityClass, entity, e, e_1_1;
+            var e_1, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!remult) {
+                            remult = remult_proxy_1.RemultProxy.defaultRemult;
+                        }
+                        completed = new Set();
+                        entities = [];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(tslib_1.__spread(context_1.allEntities).reverse()), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        entityClass = _b.value;
+                        entity = remult.repo(entityClass).metadata;
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
+                    case 3:
+                        e = _d.sent();
+                        if (completed.has(e.$entityName))
+                            return [3 /*break*/, 4];
+                        completed.add(e.$entityName);
+                        entities.push(entity);
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [4 /*yield*/, this.ensureSchema(entities)];
+                    case 9:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.ensureSchema = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var entities_1, entities_1_1, entity, e, err_1, e_2_1;
+            var e_2, _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        console.log("start verify structure");
+                        _b.trys.push([0, 10, 11, 12]);
+                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
                         _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;
+                        if (!!entities_1_1.done) return [3 /*break*/, 9];
+                        entity = entities_1_1.value;
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
                     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];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 7, , 8]);
+                        if (!!entity.options.sqlExpression) return [3 /*break*/, 6];
+                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this.createIfNotExist(entity)];
-                    case 6:
+                    case 4:
                         _b.sent();
                         return [4 /*yield*/, this.verifyAllColumns(entity)];
-                    case 7:
+                    case 5:
                         _b.sent();
-                        _b.label = 8;
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
+                        _b.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
                         err_1 = _b.sent();
-                        console.log("failed verify structure of " + e.entityName + " ", err_1);
-                        return [3 /*break*/, 10];
+                        console.error("failed verify structure of " + e.$entityName + " ", err_1);
+                        return [3 /*break*/, 8];
+                    case 8:
+                        entities_1_1 = entities_1.next();
+                        return [3 /*break*/, 1];
+                    case 9: return [3 /*break*/, 12];
                     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:
+                        e_2_1 = _b.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
                         try {
-                            if (allEntities_1_1 && !allEntities_1_1.done && (_a = allEntities_1.return)) _a.call(allEntities_1);
+                            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 14: return [2 /*return*/];
+                    case 12: return [2 /*return*/];
                 }
             });
         });
@@ -121,12 +167,12 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         c = this.pool.createCommand();
-                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(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 () {
+                        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;
+                                var e_3, _c;
                                 return tslib_1.__generator(this, function (_d) {
                                     switch (_d.label) {
                                         case 0:
@@ -135,32 +181,32 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                                             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 (!filter_consumer_bridge_to_sql_request_1.isDbReadonly(x, e) || remult3_1.isAutoIncrement(x)) {
                                                         if (result.length != 0)
                                                             result += ',';
                                                         result += '\r\n  ';
                                                         if (remult3_1.isAutoIncrement(x))
-                                                            result += e.nameOf(x) + ' serial';
+                                                            result += e.$dbNameOf(x) + ' serial';
                                                         else {
-                                                            result += postgresColumnSyntax(x, e.nameOf(x));
-                                                            if (x == entity.idMetadata.field)
-                                                                result += ' primary key';
+                                                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
                                                         }
+                                                        if (x == entity.idMetadata.field)
+                                                            result += ' primary key';
                                                     }
                                                 }
                                             }
-                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
                                             finally {
                                                 try {
                                                     if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                                                 }
-                                                finally { if (e_2) throw e_2.error; }
+                                                finally { if (e_3) throw e_3.error; }
                                             }
-                                            sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
-                                            //console.log(sql);
+                                            sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
+                                            if (PostgresSchemaBuilder.logToConsole)
+                                                console.info(sql);
                                             return [4 /*yield*/, this.pool.execute(sql)];
                                         case 1:
-                                            //console.log(sql);
                                             _d.sent();
                                             _d.label = 2;
                                         case 2: return [2 /*return*/];
@@ -179,30 +225,30 @@ var PostgresSchemaBuilder = /** @class */ (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 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(entity)];
                     case 1:
                         e = _a.sent();
-                        if (e.isDbReadonly(c(entity)))
+                        if (filter_consumer_bridge_to_sql_request_1.isDbReadonly(c(entity), e))
                             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)];
+                        colName = e.$dbNameOf(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);
+                        sql = "alter table " + e.$entityName + " add column " + postgresColumnSyntax(c(entity), colName);
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(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);
+                        console.error(err_2);
                         return [3 /*break*/, 7];
                     case 7: return [2 /*return*/];
                 }
@@ -211,17 +257,17 @@ var PostgresSchemaBuilder = /** @class */ (function () {
     };
     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;
+            var cmd, e, cols, _a, _b, col, sql, e_4_1, err_3;
+            var e_4, _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)];
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.dbNamesOf(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)];
+                        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;
@@ -232,13 +278,13 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                     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);
+                        if (!!filter_consumer_bridge_to_sql_request_1.isDbReadonly(col, e)) return [3 /*break*/, 6];
+                        if (!!cols.includes(e.$dbNameOf(col).toLocaleLowerCase())) return [3 /*break*/, 6];
+                        sql = "alter table " + e.$entityName + " add column " + postgresColumnSyntax(col, e.$dbNameOf(col));
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
                         return [4 /*yield*/, this.pool.execute(sql)];
                     case 5:
-                        //console.log(sql);
                         _d.sent();
                         _d.label = 6;
                     case 6:
@@ -246,25 +292,27 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                         return [3 /*break*/, 4];
                     case 7: return [3 /*break*/, 10];
                     case 8:
-                        e_3_1 = _d.sent();
-                        e_3 = { error: e_3_1 };
+                        e_4_1 = _d.sent();
+                        e_4 = { error: e_4_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; }
+                        finally { if (e_4) throw e_4.error; }
                         return [7 /*endfinally*/];
                     case 10: return [3 /*break*/, 12];
                     case 11:
                         err_3 = _d.sent();
-                        console.log(err_3);
+                        console.error(err_3);
                         return [3 /*break*/, 12];
                     case 12: return [2 /*return*/];
                 }
             });
         });
     };
+    //@internal
+    PostgresSchemaBuilder.logToConsole = true;
     return PostgresSchemaBuilder;
 }());
 exports.PostgresSchemaBuilder = PostgresSchemaBuilder;

package/remult-express.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultExpress = void 0;
 var tslib_1 = require("tslib");
-var express = require("express");
+var express = tslib_1.__importStar(require("express"));
 var index_1 = require("./server/index");
 function remultExpress(options) {
     var app = express.Router();

package/remult-knex/index.d.ts

@@ -1,46 +1,24 @@
-import { Knex } from 'knex';
-import { Filter, FilterConsumer } from "../src/filter/filter-interfaces";
-import { dbNameProvider } from "../src/filter/filter-consumer-bridge-to-sql-request";
+import type { Knex } from 'knex';
 import { Remult } from "../src/context";
-import { EntityFilter, EntityMetadata } from "../src/remult3";
+import { EntityFilter, EntityMetadata, RepositoryOverloads } from "../src/remult3";
 import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
 import { FieldMetadata } from '../src/column-interfaces';
 export declare class KnexDataProvider implements DataProvider {
     knex: Knex;
     constructor(knex: Knex);
+    static getDb(remult?: Remult): Knex<any, any[]>;
     getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static customFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
-    supportsCustomFilter?: boolean;
+    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
+    supportsRawFilter?: boolean;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
 }
 export declare type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
-export declare class FilterConsumerBridgeToKnexRequest implements FilterConsumer {
-    private nameProvider;
-    _addWhere: boolean;
-    promises: Promise<void>[];
-    result: ((builder: Knex.QueryBuilder) => void)[];
-    resolveWhere(): Promise<((builder: Knex.QueryBuilder<any, any>) => void)[]>;
-    constructor(nameProvider: dbNameProvider);
-    custom(key: string, customItem: any): void;
-    or(orElements: Filter[]): void;
-    isNull(col: FieldMetadata): void;
-    isNotNull(col: FieldMetadata): void;
-    isIn(col: FieldMetadata, val: any[]): void;
-    isEqualTo(col: FieldMetadata, val: any): void;
-    isDifferentFrom(col: FieldMetadata, val: any): void;
-    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
-    isGreaterThan(col: FieldMetadata, val: any): void;
-    isLessOrEqualTo(col: FieldMetadata, val: any): void;
-    isLessThan(col: FieldMetadata, val: any): void;
-    containsCaseInsensitive(col: FieldMetadata, val: any): void;
-    private add;
-    databaseCustom(databaseCustom: {
-        buildKnex: CustomKnexFilterBuilderFunction;
-    }): void;
-}
 export declare class KnexSchemaBuilder {
     private knex;
-    verifyStructureOfAllEntities(remult: Remult): Promise<void>;
+    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): 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>;
@@ -48,4 +26,4 @@ export declare class KnexSchemaBuilder {
     constructor(knex: Knex);
 }
 export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder): void;
-export declare function createKnexDataProvider(config: Knex.Config, autoCreateTables?: boolean): Promise<KnexDataProvider>;
+export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;