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

package/README.md

@@ -3,6 +3,7 @@
     <img src="https://github.com/remult/remult/raw/master/docs/.vuepress/public/logo.png" width="140" height="140">
   </a>
   <h1>Remult</h1>
+  <p>A CRUD framework for full-stack TypeScript</p>
 	<a href="https://circleci.com/gh/remult/remult/tree/master" rel="nofollow">
 		<img alt="CircleCI" src="https://circleci.com/gh/remult/remult/tree/master.svg?style=shield">
 	</a>
@@ -24,14 +25,29 @@
   <a href="https://twitter.com/intent/tweet?text=Remult%20-%20open-source%20CRUD%20framework%20for%20full-stack%20TypeScript%0A%0A%40remultjs%0A&url=https%3A%2F%2Fgithub.com%2Fremult%2Fremult">
     <img alt="Twitter URL" src="https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Ftext%3DRemult%2520-%2520open-source%2520CRUD%2520framework%2520for%2520full-stack%2520TypeScript%250A%250A%2540remultjs%250A%26url%3Dhttps%253A%252F%252Fgithub.com%252Fremult%252Fremult">
   </a>
-	<a href="https://twitter.com/remultjs" rel="nofollow">
-	  <img alt="Twitter Follow" src="https://img.shields.io/twitter/url.svg?label=Follow%20%40remultjs&style=social&url=https%3A%2F%2Ftwitter.com%2FRemultJs">
-	</a>
 </div>
+
+
+<br/>
+
+<div align="center">
+  <a href="#getting-started">Getting Started</a> |
+  <a href="#documentation">Documentation</a> |
+  <a href="#example-apps">Example Apps</a>
+</div>
+
 <hr/>
+<br/>
 
-[Getting Started](#getting-started) | [Documentation](#documentation) |
-[Example Apps](#example-apps)
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">
+    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
+  </p>
+</a>
+
+<a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
+  <p align="center">Watch code demo on YouTube here (14 mins)</p>
+</a>
 
 ## What is Remult?
 
@@ -39,6 +55,13 @@
 as a single source of truth for your API, frontend type-safe API client and
 backend ORM**.
 
+* :zap: Zero-boilerplate CRUD API routes with paging, sorting, and filtering for Express / Fastify / Next.js / NestJS / Koa / others...
+* :ok_hand: Fullstack type-safety for API queries, mutations and RPC, without code generation
+* :sparkles: Input validation, defined once, runs both on the backend and on the frontend for best UX
+* :lock: Fine-grained code-based API authorization
+* :relieved: Incrementally adoptable
+* :rocket: Production ready
+
 ### Status
 
 Remult is **production-ready** and, in fact, used in production apps since 2018.

package/esm/index.d.ts

@@ -1,4 +1,4 @@
-export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer } from './src/remult3';
+export { Field, Fields, FieldsMetadata, Entity, EntityBase, ControllerBase, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FieldType, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, getFields, EntityRef, getEntityRef, SortSegments, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, OmitEB, Paginator, CaptionTransformer, LiveQuery, LiveQueryChangeInfo } from './src/remult3';
 export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
@@ -11,7 +11,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider';
 export { SqlDatabase, } from './src/data-providers/sql-database';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, Unobserve, UserInfo } from './src/context';
@@ -20,8 +20,9 @@ export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe } from './src/live-query/SubscriptionChannel';

package/esm/index.js

@@ -8,7 +8,7 @@ export { InMemoryDataProvider } from './src/data-providers/in-memory-database';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider'; //V
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider'; //V
 export { SqlDatabase, } from './src/data-providers/sql-database'; //V
-export { CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
+export { CustomSqlFilterBuilder, dbNamesOf } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider } from './src/data-providers/json-data-provider'; //V
 //export * from './src/data-api'; //reconsider if to make internal
 export { Controller, BackendMethod, ProgressListener } from './src/server-action';
@@ -17,8 +17,10 @@ export { IdEntity } from './src/id-entity';
 export { Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';
 export { Filter } from './src/filter/filter-interfaces';
-export { FilterConsumerBridgeToSqlRequest } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+//export { getId } from './src/remult3/getId';
+export { InMemoryLiveQueryStorage } from "./src/live-query/SubscriptionServer";
+export { SubscriptionChannel } from './src/live-query/SubscriptionChannel';

package/esm/live-query/ably.d.ts

@@ -1,13 +1,13 @@
 import type * as Ably from 'ably';
-import type { ServerEventDispatcher } from '../src/live-query/LiveQueryPublisher';
-import type { LiveQueryProvider, PubSubClient } from '../src/live-query/LiveQuerySubscriber';
-export declare class AblyLiveQueryProvider implements LiveQueryProvider {
+import type { SubscriptionServer } from '../src/live-query/SubscriptionServer';
+import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/SubscriptionChannel';
+export declare class AblySubscriptionClient implements SubscriptionClient {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
-    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
 }
-export declare class AblyServerEventDispatcher implements ServerEventDispatcher {
+export declare class AblySubscriptionServer implements SubscriptionServer {
     private ably;
     constructor(ably: Ably.Types.RealtimePromise);
-    sendChannelMessage<T>(channel: string, message: T): void;
+    publishMessage<T>(channel: string, message: T): void;
 }

package/esm/live-query/ably.js

@@ -1,10 +1,10 @@
-export class AblyLiveQueryProvider {
+export class AblySubscriptionClient {
     constructor(ably) {
         this.ably = ably;
     }
-    async openStreamAndReturnCloseFunction(onReconnect) {
+    async openConnection(onReconnect) {
         return {
-            disconnect: () => {
+            close: () => {
                 this.ably.connection.close();
             },
             subscribe: (channel, handler) => {
@@ -15,11 +15,11 @@ export class AblyLiveQueryProvider {
         };
     }
 }
-export class AblyServerEventDispatcher {
+export class AblySubscriptionServer {
     constructor(ably) {
         this.ably = ably;
     }
-    sendChannelMessage(channel, message) {
+    publishMessage(channel, message) {
         this.ably.channels.get(channel).publish({ data: message });
     }
 }

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

@@ -1,4 +1,5 @@
-import { PoolConfig, QueryResult } from 'pg';
+import { ClientBase, 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';
@@ -10,6 +11,7 @@ export interface PostgresClient extends PostgresCommandSource {
 }
 export declare class PostgresDataProvider implements SqlImplementation {
     private pool;
+    static getDb(remult?: Remult): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;

package/esm/postgres/postgres-data-provider.js

@@ -6,6 +6,14 @@ export class PostgresDataProvider {
     constructor(pool) {
         this.pool = pool;
     }
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.pool) {
+            throw "the data provider is not a PostgresDataProvider";
+        }
+        return me.pool;
+    }
     async entityIsUsedForTheFirstTime(entity) {
     }
     getLimitSqlSyntax(limit, offset) {
@@ -22,7 +30,9 @@ export class PostgresDataProvider {
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
                 transaction: () => { throw "nested transactions not allowed"; },
-                getLimitSqlSyntax: this.getLimitSqlSyntax
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                //@ts-ignore
+                pool: client
             });
             await client.query('COMMIT');
         }

package/esm/postgres/schema-builder.d.ts

@@ -6,7 +6,7 @@ export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string):
 export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
 export declare class PostgresSchemaBuilder {
     private pool;
-    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>;

package/esm/postgres/schema-builder.js

@@ -1,5 +1,6 @@
 import { allEntities } from '../src/context';
-import { getDbNameProvider } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { RemultProxy } from '../src/remult-proxy';
 import { isAutoIncrement } from '../src/remult3';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
@@ -43,61 +44,73 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure"); //keep me
-        for (const entityClass of allEntities) {
+        if (!remult) {
+            remult = RemultProxy.defaultRemult;
+        }
+        if (PostgresSchemaBuilder.logToConsole)
+            console.time("Postgres Auto create tables and columns");
+        const completed = new Set();
+        for (const entityClass of [...allEntities].reverse()) {
             let entity = remult.repo(entityClass).metadata;
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(entity);
+            if (completed.has(e.$entityName))
+                continue;
+            completed.add(e.$entityName);
             try {
                 if (!entity.options.sqlExpression) {
-                    if ((await e.entityName).toLowerCase().indexOf('from ') < 0) {
+                    if ((await e.$entityName).toLowerCase().indexOf('from ') < 0) {
                         await this.createIfNotExist(entity);
                         await this.verifyAllColumns(entity);
                     }
                 }
             }
             catch (err) {
-                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
+                console.error("failed verify structure of " + e.$entityName + " ", err);
             }
         }
+        if (PostgresSchemaBuilder.logToConsole)
+            console.timeEnd("Postgres Auto create tables and columns");
     }
     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) => {
+        let e = await dbNamesOf(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 (!isDbReadonly(x, e) || isAutoIncrement(x)) {
                         if (result.length != 0)
                             result += ',';
                         result += '\r\n  ';
                         if (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';
                     }
                 }
-                let sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
-                //console.log(sql);
+                let sql = 'create table ' + e.$entityName + ' (' + result + '\r\n)';
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
                 await this.pool.execute(sql);
             }
         });
     }
     async addColumnIfNotExist(entity, c) {
-        let e = await getDbNameProvider(entity);
-        if (e.isDbReadonly(c(entity)))
+        let e = await dbNamesOf(entity);
+        if (isDbReadonly(c(entity), e))
             return;
         try {
             let cmd = this.pool.createCommand();
-            const colName = e.nameOf(c(entity));
+            const colName = e.$dbNameOf(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);
+        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)}`;
+                if (PostgresSchemaBuilder.logToConsole)
+                    console.info(sql);
                 await this.pool.execute(sql);
             }
         }
@@ -108,15 +121,16 @@ export class PostgresSchemaBuilder {
     async verifyAllColumns(entity) {
         try {
             let cmd = this.pool.createCommand();
-            let e = await getDbNameProvider(entity);
+            let e = await dbNamesOf(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);
+        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);
+                if (!isDbReadonly(col, e))
+                    if (!cols.includes(e.$dbNameOf(col).toLocaleLowerCase())) {
+                        let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(col, e.$dbNameOf(col))}`;
+                        if (PostgresSchemaBuilder.logToConsole)
+                            console.info(sql);
                         await this.pool.execute(sql);
                     }
             }
@@ -126,3 +140,5 @@ export class PostgresSchemaBuilder {
         }
     }
 }
+//@internal
+PostgresSchemaBuilder.logToConsole = true;

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

@@ -1,7 +1,6 @@
 import * as express from 'express';
-import { createRemultServer } from './server/expressBridge';
-import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/LiveQuerySubscriber';
-import { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from './src/live-query/LiveQueryPublisher';
+import { createRemultServer } from './server/index';
+import { streamUrl } from './src/live-query/SubscriptionChannel';
 import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
 import { getEntityKey } from './src/remult3';
@@ -17,17 +16,16 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = new SseSubscriptionServer();
+    }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    if (!options.serverEventDispatcher) {
-        options.serverEventDispatcher = (router, server) => {
-            return buildHttpServerEventDispatcher(router, options.rootPath, server);
-        };
+    const canRegisterRoute = options.subscriptionServer;
+    if (canRegisterRoute.registerRoutes) {
+        canRegisterRoute.registerRoutes(app, options.rootPath, server);
     }
-    app.post(options.rootPath + liveQueryKeepAliveRoute, (r, res, n) => server.withRemult(r, res, n), async (req, res) => {
-        res.send(await remult.liveQueryPublisher.storage.keepAliveAndReturnUnknownIds(req.body));
-    });
-    server.liveQueryManager = new LiveQueryPublisher(options.serverEventDispatcher(app, server), new LiveQueryStorageInMemoryImplementation(), async (req, entityKey, what) => {
+    server.runWithRequest = async (req, entityKey, what) => {
         for (const e of options.entities) {
             let key = getEntityKey(e);
             if (key === entityKey) {
@@ -41,7 +39,7 @@ export function remultExpress(options) {
             }
         }
         throw new Error("Couldn't find entity " + entityKey);
-    });
+    };
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -49,16 +47,20 @@ export function remultExpress(options) {
         withRemult: (...args) => server.withRemult(...args)
     });
 }
-export class ServerEventsController {
+export class SseSubscriptionServer {
     constructor(canUserConnectToChannel) {
         this.canUserConnectToChannel = canUserConnectToChannel;
+        //@internal
         this.connections = [];
+        //@internal
         this.debugMessageFileSaver = (id, channel, message) => { };
+        //@internal
         this.debugFileSaver = () => { };
         if (!this.canUserConnectToChannel) {
             this.canUserConnectToChannel = () => true;
         }
     }
+    //@internal
     subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
         for (const c of this.connections) {
             if (c.connectionId === clientId) {
@@ -80,7 +82,7 @@ export class ServerEventsController {
         }
         res.sendStatus(404);
     }
-    sendChannelMessage(channel, message) {
+    publishMessage(channel, message) {
         const data = JSON.stringify({ channel, data: message });
         for (const sc of this.connections) {
             if (sc.channels[channel]) {
@@ -89,6 +91,7 @@ export class ServerEventsController {
             }
         }
     }
+    //@internal
     openHttpServerStream(req, res) {
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -106,12 +109,25 @@ export class ServerEventsController {
         });
         return cc;
     }
+    //@internal
     debug() {
         this.debugFileSaver(this.connections.map(x => ({
             id: x.connectionId,
             channels: x.channels
         })));
     }
+    registerRoutes(router, apiPath, server) {
+        const streamPath = apiPath + '/' + streamUrl;
+        router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.openHttpServerStream(req, res);
+        });
+        router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.subscribeToChannel(req.body, res, remult);
+        });
+        router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+            remult.subscriptionServer.subscribeToChannel(req.body, res, remult, true);
+        });
+    }
 }
 class clientConnection {
     constructor(response) {
@@ -143,17 +159,3 @@ class clientConnection {
         }, 45000);
     }
 }
-function buildHttpServerEventDispatcher(router, apiPath, server) {
-    const streamPath = apiPath + '/' + streamUrl;
-    let httpServerEvents = new ServerEventsController();
-    router.get(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.openHttpServerStream(req, res);
-    });
-    router.post(streamPath + '/subscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult);
-    });
-    router.post(streamPath + '/unsubscribe', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        remult.liveQueryPublisher.dispatcher.subscribeToChannel(req.body, res, remult, true);
-    });
-    return httpServerEvents;
-}

package/esm/remult-fastify.js

@@ -1,4 +1,4 @@
-import { createRemultServer } from './server/expressBridge';
+import { createRemultServer } from './server/index';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {

package/esm/remult-fresh.js

@@ -1,6 +1,6 @@
-import { createRemultServer } from "./server/expressBridge";
+import { createRemultServerCore } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = createRemultServer(options);
+    const server = createRemultServerCore(options);
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),

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