remult 0.18.1-exp.2 → 0.18.1-exp.21

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,69 @@ 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;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
+            var completed, _a, _b, entityClass, entity, e, err_1, e_1_1;
+            var e_1, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        console.log("start verify structure"); //keep me
-                        _b.label = 1;
+                        if (!remult) {
+                            remult = remult_proxy_1.RemultProxy.defaultRemult;
+                        }
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.time("Postgres Auto create tables and columns");
+                        completed = new Set();
+                        _d.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;
+                        _d.trys.push([1, 12, 13, 14]);
+                        _a = tslib_1.__values(tslib_1.__spread(context_1.allEntities).reverse()), _b = _a.next();
+                        _d.label = 2;
                     case 2:
-                        if (!!allEntities_1_1.done) return [3 /*break*/, 11];
-                        entityClass = allEntities_1_1.value;
+                        if (!!_b.done) return [3 /*break*/, 11];
+                        entityClass = _b.value;
                         entity = remult.repo(entityClass).metadata;
-                        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 3:
-                        e = _b.sent();
-                        _b.label = 4;
+                        e = _d.sent();
+                        if (completed.has(e.$entityName))
+                            return [3 /*break*/, 10];
+                        completed.add(e.$entityName);
+                        _d.label = 4;
                     case 4:
-                        _b.trys.push([4, 9, , 10]);
+                        _d.trys.push([4, 9, , 10]);
                         if (!!entity.options.sqlExpression) return [3 /*break*/, 8];
-                        return [4 /*yield*/, e.entityName];
+                        return [4 /*yield*/, e.$entityName];
                     case 5:
-                        if (!((_b.sent()).toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 8];
+                        if (!((_d.sent()).toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 8];
                         return [4 /*yield*/, this.createIfNotExist(entity)];
                     case 6:
-                        _b.sent();
+                        _d.sent();
                         return [4 /*yield*/, this.verifyAllColumns(entity)];
                     case 7:
-                        _b.sent();
-                        _b.label = 8;
+                        _d.sent();
+                        _d.label = 8;
                     case 8: return [3 /*break*/, 10];
                     case 9:
-                        err_1 = _b.sent();
-                        /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err_1);
+                        err_1 = _d.sent();
+                        console.error("failed verify structure of " + e.$entityName + " ", err_1);
                         return [3 /*break*/, 10];
                     case 10:
-                        allEntities_1_1 = allEntities_1.next();
+                        _b = _a.next();
                         return [3 /*break*/, 2];
                     case 11: return [3 /*break*/, 14];
                     case 12:
-                        e_1_1 = _b.sent();
+                        e_1_1 = _d.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);
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
                         finally { if (e_1) throw e_1.error; }
                         return [7 /*endfinally*/];
-                    case 14: return [2 /*return*/];
+                    case 14:
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.timeEnd("Postgres Auto create tables and columns");
+                        return [2 /*return*/];
                 }
             });
         });
@@ -121,10 +133,10 @@ 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;
                                 return tslib_1.__generator(this, function (_d) {
@@ -135,17 +147,17 @@ 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';
                                                     }
                                                 }
                                             }
@@ -156,11 +168,11 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                                                 }
                                                 finally { if (e_2) throw e_2.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,24 +191,24 @@ 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];
@@ -218,10 +230,10 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                     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 +244,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:
@@ -265,6 +277,8 @@ var PostgresSchemaBuilder = /** @class */ (function () {
             });
         });
     };
+    //@internal
+    PostgresSchemaBuilder.logToConsole = true;
     return PostgresSchemaBuilder;
 }());
 exports.PostgresSchemaBuilder = PostgresSchemaBuilder;

package/remult-express.d.ts

@@ -1,32 +1,14 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
 import { Remult } from './src/context';
-import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
-import { ServerEventDispatcher } from './src/live-query/LiveQueryPublisher';
+import { SubscriptionServer } from './src/live-query/SubscriptionServer';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
 }): express.RequestHandler & RemultServer;
-export declare class ServerEventsController implements ServerEventDispatcher {
+export declare class SseSubscriptionServer implements SubscriptionServer {
     private canUserConnectToChannel?;
-    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
-    connections: clientConnection[];
     constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
-    sendChannelMessage<T>(channel: string, message: any): void;
-    debugMessageFileSaver: (id: any, channel: any, message: any) => void;
-    openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
-    debug(): void;
-    debugFileSaver: (x: any) => void;
+    publishMessage<T>(channel: string, message: any): void;
+    registerRoutes(router: express.Router, apiPath: string, server: RemultServer): void;
 }
-declare class clientConnection {
-    response: import('express').Response;
-    channels: Record<string, boolean>;
-    close(): void;
-    closed: boolean;
-    write(eventData: string, eventType?: string): void;
-    connectionId: any;
-    constructor(response: import('express').Response);
-    sendLiveMessage(): void;
-}
-export {};

package/remult-express.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerEventsController = exports.remultExpress = void 0;
+exports.SseSubscriptionServer = exports.remultExpress = void 0;
 var tslib_1 = require("tslib");
-var express = require("express");
-var expressBridge_1 = require("./server/expressBridge");
-var LiveQuerySubscriber_1 = require("./src/live-query/LiveQuerySubscriber");
-var LiveQueryPublisher_1 = require("./src/live-query/LiveQueryPublisher");
+var express = tslib_1.__importStar(require("express"));
+var index_1 = require("./server/index");
+var SubscriptionChannel_1 = require("./src/live-query/SubscriptionChannel");
 var uuid_1 = require("uuid");
 var remult_proxy_1 = require("./src/remult-proxy");
 var remult3_1 = require("./src/remult3");
@@ -22,27 +21,16 @@ function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    var server = expressBridge_1.createRemultServer(options);
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer();
+    }
+    var server = index_1.createRemultServer(options);
     server.registerRouter(app);
-    if (!options.serverEventDispatcher) {
-        options.serverEventDispatcher = function (router, server) {
-            return buildHttpServerEventDispatcher(router, options.rootPath, server);
-        };
+    var canRegisterRoute = options.subscriptionServer;
+    if (canRegisterRoute.registerRoutes) {
+        canRegisterRoute.registerRoutes(app, options.rootPath, server);
     }
-    app.post(options.rootPath + LiveQuerySubscriber_1.liveQueryKeepAliveRoute, function (r, res, n) { return server.withRemult(r, res, n); }, function (req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        var _a, _b;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _b = (_a = res).send;
-                    return [4 /*yield*/, remult_proxy_1.remult.liveQueryPublisher.storage.keepAliveAndReturnUnknownIds(req.body)];
-                case 1:
-                    _b.apply(_a, [_c.sent()]);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    server.liveQueryManager = new LiveQueryPublisher_1.LiveQueryPublisher(options.serverEventDispatcher(app, server), new LiveQueryPublisher_1.LiveQueryStorageInMemoryImplementation(), function (req, entityKey, what) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+    server.runWithRequest = function (req, entityKey, what) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var _loop_1, _a, _b, e, state_1, e_1_1;
         var e_1, _c;
         var _this = this;
@@ -107,7 +95,7 @@ function remultExpress(options) {
                 case 8: throw new Error("Couldn't find entity " + entityKey);
             }
         });
-    }); });
+    }); };
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },
         openApiDoc: function (options) { return server.openApiDoc(options); },
@@ -122,17 +110,21 @@ function remultExpress(options) {
     });
 }
 exports.remultExpress = remultExpress;
-var ServerEventsController = /** @class */ (function () {
-    function ServerEventsController(canUserConnectToChannel) {
+var SseSubscriptionServer = /** @class */ (function () {
+    function SseSubscriptionServer(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
         this.connections = [];
+        //@internal
         this.debugMessageFileSaver = function (id, channel, message) { };
+        //@internal
         this.debugFileSaver = function () { };
         if (!this.canUserConnectToChannel) {
             this.canUserConnectToChannel = function () { return true; };
         }
     }
-    ServerEventsController.prototype.subscribeToChannel = function (_a, res, remult, remove) {
+    //@internal
+    SseSubscriptionServer.prototype.subscribeToChannel = function (_a, res, remult, remove) {
         var e_2, _b;
         var channel = _a.channel, clientId = _a.clientId;
         if (remove === void 0) { remove = false; }
@@ -166,7 +158,7 @@ var ServerEventsController = /** @class */ (function () {
         }
         res.sendStatus(404);
     };
-    ServerEventsController.prototype.sendChannelMessage = function (channel, message) {
+    SseSubscriptionServer.prototype.publishMessage = function (channel, message) {
         var e_3, _a;
         var data = JSON.stringify({ channel: channel, data: message });
         try {
@@ -186,7 +178,8 @@ var ServerEventsController = /** @class */ (function () {
             finally { if (e_3) throw e_3.error; }
         }
     };
-    ServerEventsController.prototype.openHttpServerStream = function (req, res) {
+    //@internal
+    SseSubscriptionServer.prototype.openHttpServerStream = function (req, res) {
         var _this = this;
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -204,15 +197,28 @@ var ServerEventsController = /** @class */ (function () {
         });
         return cc;
     };
-    ServerEventsController.prototype.debug = function () {
+    //@internal
+    SseSubscriptionServer.prototype.debug = function () {
         this.debugFileSaver(this.connections.map(function (x) { return ({
             id: x.connectionId,
             channels: x.channels
         }); }));
     };
-    return ServerEventsController;
+    SseSubscriptionServer.prototype.registerRoutes = function (router, apiPath, server) {
+        var streamPath = apiPath + '/' + SubscriptionChannel_1.streamUrl;
+        router.get(streamPath, function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
+            remult_proxy_1.remult.subscriptionServer.openHttpServerStream(req, res);
+        });
+        router.post(streamPath + '/subscribe', function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
+            remult_proxy_1.remult.subscriptionServer.subscribeToChannel(req.body, res, remult_proxy_1.remult);
+        });
+        router.post(streamPath + '/unsubscribe', function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
+            remult_proxy_1.remult.subscriptionServer.subscribeToChannel(req.body, res, remult_proxy_1.remult, true);
+        });
+    };
+    return SseSubscriptionServer;
 }());
-exports.ServerEventsController = ServerEventsController;
+exports.SseSubscriptionServer = SseSubscriptionServer;
 var clientConnection = /** @class */ (function () {
     function clientConnection(response) {
         this.response = response;
@@ -246,17 +252,3 @@ var clientConnection = /** @class */ (function () {
     };
     return clientConnection;
 }());
-function buildHttpServerEventDispatcher(router, apiPath, server) {
-    var streamPath = apiPath + '/' + LiveQuerySubscriber_1.streamUrl;
-    var httpServerEvents = new ServerEventsController();
-    router.get(streamPath, function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
-        remult_proxy_1.remult.liveQueryPublisher.dispatcher.openHttpServerStream(req, res);
-    });
-    router.post(streamPath + '/subscribe', function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
-        remult_proxy_1.remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult_proxy_1.remult);
-    });
-    router.post(streamPath + '/unsubscribe', function (r, res, next) { return server.withRemult(r, res, next); }, function (req, res) {
-        remult_proxy_1.remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult_proxy_1.remult, true);
-    });
-    return httpServerEvents;
-}

package/remult-fastify.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultFastify = void 0;
 var tslib_1 = require("tslib");
-var expressBridge_1 = require("./server/expressBridge");
+var index_1 = require("./server/index");
 function remultFastify(options) {
     var _this = this;
     function fastifyHandler(handler) {
@@ -23,7 +23,7 @@ function remultFastify(options) {
         };
         return response;
     }
-    var api = expressBridge_1.createRemultServer(options);
+    var api = index_1.createRemultServer(options);
     var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {

package/remult-fresh.js

@@ -5,7 +5,7 @@ var tslib_1 = require("tslib");
 var expressBridge_1 = require("./server/expressBridge");
 function remultFresh(options, response) {
     var _this = this;
-    var server = expressBridge_1.createRemultServer(options);
+    var server = expressBridge_1.createRemultServerCore(options);
     return {
         getRemult: function (r) { return server.getRemult(r); },
         openApiDoc: function (x) { return server.openApiDoc(x); },

package/remult-knex/index.d.ts

@@ -1,46 +1,22 @@
-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;
 }
 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>;
     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>;