remult 0.18.1-exp.1 → 0.18.1-exp.3

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/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/LiveQueryPublisher';
+import type { SubscriptionClient, SubscriptionClientConnection } from '../src/live-query/LiveQuerySubscriber';
+export declare class AblyLiveQueryProvider 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 AblyServerEventDispatcher 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

@@ -2,9 +2,9 @@ export class AblyLiveQueryProvider {
     constructor(ably) {
         this.ably = ably;
     }
-    async openStreamAndReturnCloseFunction(onReconnect) {
+    async openConnection(onReconnect) {
         return {
-            disconnect: () => {
+            close: () => {
                 this.ably.connection.close();
             },
             subscribe: (channel, handler) => {
@@ -19,7 +19,7 @@ export class AblyServerEventDispatcher {
     constructor(ably) {
         this.ably = ably;
     }
-    sendChannelMessage(channel, message) {
+    publishMessage(channel, message) {
         this.ably.channels.get(channel).publish({ data: message });
     }
 }

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

@@ -1,3 +1,2 @@
-export { LiveQueryPublisher, ServerEventDispatcher, LiveQueryStorage, LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
-export { PubSubClient, LiveQueryProvider, AMessageChannel } from '../src/live-query/LiveQuerySubscriber';
-export { LiveQueryClient } from '../src/live-query/LiveQueryClient';
+export { SubscriptionServer as MessagePublisher, LiveQueryStorage, LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
+export { SubscriptionClientConnection as SubClientConnection, SubscriptionClient as SubClient, AMessageChannel } from '../src/live-query/LiveQuerySubscriber';

package/esm/live-query/index.js

@@ -1,3 +1,2 @@
-export { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
+export { LiveQueryStorageInMemoryImplementation } from "../src/live-query/LiveQueryPublisher";
 export { AMessageChannel } from '../src/live-query/LiveQuerySubscriber';
-export { LiveQueryClient } from '../src/live-query/LiveQueryClient';

package/esm/remult-express.d.ts

@@ -2,18 +2,19 @@ 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/LiveQueryPublisher';
+import { MessagePublisher } from './live-query';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
+    subscriptionServer?: (router: express.Router, server: RemultServer) => MessagePublisher;
 }): express.RequestHandler & RemultServer;
-export declare class ServerEventsController implements ServerEventDispatcher {
+export declare class ServerEventsController 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;
+    publishMessage<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;

package/esm/remult-express.js

@@ -1,7 +1,6 @@
 import * as express from 'express';
-import { createRemultServer } from './server/expressBridge';
+import { createRemultServer } from './server/index';
 import { liveQueryKeepAliveRoute, streamUrl } from './src/live-query/LiveQuerySubscriber';
-import { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from './src/live-query/LiveQueryPublisher';
 import { v4 as uuid } from 'uuid';
 import { remult } from './src/remult-proxy';
 import { getEntityKey } from './src/remult3';
@@ -19,15 +18,15 @@ export function remultExpress(options) {
     }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    if (!options.serverEventDispatcher) {
-        options.serverEventDispatcher = (router, server) => {
+    if (!options.subscriptionServer) {
+        options.subscriptionServer = (router, server) => {
             return buildHttpServerEventDispatcher(router, 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));
+        res.send(await remult.liveQueryStorage.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 +40,8 @@ export function remultExpress(options) {
             }
         }
         throw new Error("Couldn't find entity " + entityKey);
-    });
+    };
+    server.subscriptionServer = options.subscriptionServer(app, server);
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -80,7 +80,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]) {
@@ -147,13 +147,13 @@ 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);
+        remult.subscriptionServer.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);
+        remult.subscriptionServer.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);
+        remult.subscriptionServer.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.js

@@ -153,8 +153,15 @@ class KnexEntityDataProvider {
         }
         let insert = this.knex(e.entityName).insert(insertObject);
         if (isAutoIncrement(this.entity.idMetadata.field)) {
-            let result = await insert.returning(this.entity.idMetadata.field.key);
-            let newId = result[0].id;
+            let newId;
+            if (this.knex.client.config.client === 'mysql2') {
+                let result = await insert;
+                newId = result[0];
+            }
+            else {
+                let result = await insert.returning(this.entity.idMetadata.field.key);
+                newId = result[0].id;
+            }
             resultFilter = new Filter(x => x.isEqualTo(this.entity.idMetadata.field, newId));
         }
         else

package/esm/server/expressBridge.d.ts

@@ -1,11 +1,10 @@
-import { ActionInterface, queuedJobInfoResponse } from '../src/server-action';
+import { queuedJobInfoResponse } from '../src/server-action';
 import { DataProvider } from '../src/data-interfaces';
-import { DataApi, DataApiRequest, DataApiResponse } from '../src/data-api';
-import { AllowedForInstance, Remult, UserInfo } from '../src/context';
+import { Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { LiveQueryPublisher } from '../src/live-query/LiveQueryPublisher';
+import { LiveQueryStorage } from '../src/live-query/LiveQueryPublisher';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -13,6 +12,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     */
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
     queueStorage?: QueueStorage;
+    liveQueryStorageForRequest?: (remult?: Remult) => LiveQueryStorage | Promise<LiveQueryStorage>;
     initRequest?: (remult: Remult, origReq: RequestType) => Promise<void>;
     requestSerializer?: {
         toJson: (request: RequestType) => any;
@@ -26,7 +26,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;
@@ -63,39 +63,14 @@ export interface GenericResponse {
     status(statusCode: number): GenericResponse;
     end(): any;
 }
-export declare class RemultServerImplementation implements RemultServer {
-    queue: inProcessQueueHandler;
-    options: RemultServerOptions<GenericRequest>;
-    dataProvider: DataProvider | Promise<DataProvider>;
-    constructor(queue: inProcessQueueHandler, options: RemultServerOptions<GenericRequest>, dataProvider: DataProvider | Promise<DataProvider>);
-    liveQueryManager: LiveQueryPublisher;
-    withRemult<T>(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
-    routeImpl: RouteImplementation;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse>;
-    registeredRouter: boolean;
-    registerRouter(r: GenericRouter): void;
-    add(key: string, dataApiFactory: ((req: Remult) => DataApi), r: GenericRouter): void;
-    process(what: (remult: Remult, myReq: DataApiRequest, myRes: DataApiResponse, origReq: GenericRequest) => Promise<void>): (req: GenericRequest, res: GenericResponse) => Promise<void>;
-    getRemult(req: GenericRequest): Promise<Remult>;
-    hasQueue: boolean;
-    addAction(action: ActionInterface, r: GenericRouter): void;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-    backendMethodsOpenApi: {
-        path: string;
-        allowed: AllowedForInstance<any>;
-        tag: string;
-    }[];
-}
-declare class inProcessQueueHandler {
-    private storage;
-    constructor(storage: QueueStorage);
-    submitJob(url: string, req: Remult, body: any): Promise<string>;
-    mapQueuedAction(url: string, what: (data: any, r: Remult, res: ApiActionResponse) => void): void;
-    actions: Map<string, (data: any, r: Remult, res: ApiActionResponse) => void>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
+export declare class RemultAsyncLocalStorage {
+    private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
+    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    run(remult: Remult, callback: VoidFunction): void;
+    getRemult(): Remult;
+    static instance: RemultAsyncLocalStorage;
 }
 export interface queuedJobInfo {
     info: queuedJobInfoResponse;
@@ -121,12 +96,6 @@ export declare class EntityQueueStorage implements QueueStorage {
     getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
     createJob(url: string, userId: string): Promise<string>;
 }
-declare class RouteImplementation {
-    map: Map<string, Map<string, GenericRequestHandler>>;
-    route(path: string): SpecificRoute;
-    handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    middleware(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
-}
 export declare class JobsInQueueEntity extends IdEntity {
     userId: string;
     url: string;
@@ -137,4 +106,3 @@ export declare class JobsInQueueEntity extends IdEntity {
     error: boolean;
     progress: number;
 }
-export {};

package/esm/server/expressBridge.js

@@ -5,8 +5,9 @@ import { allEntities, Remult } from '../src/context';
 import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
+import { LiveQueryPublisher, LiveQueryStorageInMemoryImplementation } from '../src/live-query/LiveQueryPublisher';
 ;
-export function createRemultServer(options) {
+export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }
@@ -30,30 +31,12 @@ export function createRemultServer(options) {
             return dp;
         return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
     });
-    if (!remultObjectStorage) {
-        dataProvider = dataProvider.then(async (dp) => {
-            try {
-                const asyncHooks = await import('async_hooks');
-                remultObjectStorage = new RemultAsyncLocalStorage(new asyncHooks.AsyncLocalStorage());
-            }
-            catch {
-                remultObjectStorage = new RemultAsyncLocalStorage(undefined);
-            }
-            remult.remultFactory = () => {
-                const r = remultObjectStorage.getRemult();
-                if (r)
-                    return r;
-                else
-                    throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
-            };
-            return dp;
-        });
-    }
+    RemultAsyncLocalStorage.enable();
     if (options.initApi) {
         dataProvider = dataProvider.then(async (dp) => {
             var remult = new Remult(dp);
             await new Promise((res) => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     await options.initApi(remult);
                     res({});
                 });
@@ -95,10 +78,22 @@ export function createRemultServer(options) {
     return bridge;
 }
 ;
-class RemultAsyncLocalStorage {
+export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
+    static enable() {
+        remult.remultFactory = () => {
+            const r = RemultAsyncLocalStorage.instance.getRemult();
+            if (r)
+                return r;
+            else
+                throw new Error("remult object was requested outside of a valid context, try running it within initApi or a remult request cycle");
+        };
+    }
+    static disable() {
+        remult.resetFactory();
+    }
     run(remult, callback) {
         if (this.remultObjectStorage)
             this.remultObjectStorage.run(remult, callback);
@@ -107,17 +102,19 @@ class RemultAsyncLocalStorage {
     }
     getRemult() {
         if (!this.remultObjectStorage) {
-            throw "can't use static remult in this environment, `async_hooks` were not found";
+            throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
         return this.remultObjectStorage.getStore();
     }
 }
-let remultObjectStorage;
+RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(undefined);
+/* @internal*/
 export class RemultServerImplementation {
     constructor(queue, options, dataProvider) {
         this.queue = queue;
         this.options = options;
         this.dataProvider = dataProvider;
+        this.liveQueryStorage = new LiveQueryStorageInMemoryImplementation();
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -197,10 +194,12 @@ export class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.liveQueryPublisher = this.liveQueryManager;
+            remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithRequest);
             remult.dataProvider = (await this.dataProvider);
+            remult.subscriptionServer = this.subscriptionServer;
+            remult.liveQueryStorage = this.liveQueryStorage;
             await new Promise(res => {
-                remultObjectStorage.run(remult, async () => {
+                RemultAsyncLocalStorage.instance.run(remult, async () => {
                     if (req) {
                         let user;
                         if (this.options.getUser)
@@ -216,6 +215,11 @@ export class RemultServerImplementation {
                     if (this.options.initRequest) {
                         await this.options.initRequest(remult, req);
                     }
+                    if (this.options.liveQueryStorageForRequest) {
+                        const r = await this.options.liveQueryStorageForRequest(remult);
+                        if (r)
+                            remult.liveQueryStorage = r;
+                    }
                     await what(remult, myReq, myRes, req);
                     res({});
                 });

package/esm/server/index.d.ts

@@ -1,2 +1,4 @@
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,2 +1,7 @@
-export { createRemultServer } from './expressBridge';
+import { createRemultServerCore } from './expressBridge';
+import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export function createRemultServer(options) {
+    initAsyncHooks();
+    return createRemultServerCore(options);
+}

package/esm/src/context.d.ts

@@ -1,10 +1,9 @@
 import { DataProvider } from "./data-interfaces";
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQueryClient";
-import type { ServerEventDispatcher } from "../live-query";
-import { LiveQueryStorage } from "./live-query/LiveQueryPublisher";
+import type { MessagePublisher } from "../live-query";
 import { ExternalHttpProvider } from "./buildRestDataProvider";
+import { SubscriptionClient } from "./live-query/LiveQuerySubscriber";
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
@@ -38,11 +37,10 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
-    liveQueryPublisher: LiveQueryPublisherInterface;
+    subscriptionServer?: MessagePublisher;
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** The current data provider */
     dataProvider: DataProvider;
-    liveQuerySubscriber: LiveQueryClient;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
@@ -57,6 +55,8 @@ export interface RemultContext {
 export interface ApiClient {
     httpClient?: ExternalHttpProvider | typeof fetch;
     url?: string;
+    subscriptionClient?: SubscriptionClient;
+    wrapMessageHandling?: (x: VoidFunction) => void;
 }
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
@@ -90,14 +90,6 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
-export interface LiveQueryPublisherInterface {
-    stopLiveQuery(id: any): void;
-    sendChannelMessage<messageType>(channel: string, message: messageType): void;
-    defineLiveQueryChannel(serializeRequest: () => any, entityKey: string, options: FindOptions<any>, ids: any[], userId: string, repo: Repository<any>): string;
-    itemChanged(entityKey: string, changes: itemChange[]): void;
-    dispatcher: ServerEventDispatcher;
-    storage: LiveQueryStorage;
-}
 export interface itemChange {
     id: any;
     oldId: any;

package/esm/src/context.js

@@ -2,7 +2,7 @@ import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 import { LiveQueryClient } from "./live-query/LiveQueryClient";
-import { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
+import { EventSourceSubClient } from "./live-query/EventSourceLiveQueryProvider";
 import { RemultProxy } from "./remult-proxy";
 import { buildRestDataProvider, isExternalHttpProvider } from "./buildRestDataProvider";
 export function isBackend() {
@@ -12,24 +12,18 @@ export class Remult {
     constructor(provider) {
         /* @internal */
         this.repCache = new Map();
+        /* @internal*/
         this.liveQueryPublisher = {
-            itemChanged: () => { },
-            defineLiveQueryChannel: () => "",
-            dispatcher: undefined,
-            sendChannelMessage: function (arg0, what) {
-                throw new Error("invalid publisher.");
-            },
-            stopLiveQuery: function (id) {
-                throw new Error("Function not implemented.");
-            },
-            storage: undefined
+            itemChanged: () => { }
         };
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
-        this.liveQuerySubscriber = new LiveQueryClient(new EventSourceLiveQueryProvider());
+        /* @internal*/
+        this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient);
         this.context = {};
         this.apiClient = {
-            url: '/api'
+            url: '/api',
+            subscriptionClient: new EventSourceSubClient()
         };
         if (provider && provider.getEntityDataProvider) {
             this.dataProvider = provider;
@@ -46,6 +40,10 @@ export class Remult {
                 this.apiClient.httpClient = apiClient.httpClient;
             if (apiClient.url)
                 this.apiClient.url = apiClient.url;
+            if (apiClient.subscriptionClient)
+                this.apiClient.subscriptionClient = apiClient.subscriptionClient;
+            if (apiClient.wrapMessageHandling)
+                this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
         }
     }
     /**Return's a `Repository` of the specific entity type
@@ -188,22 +186,11 @@ export async function doTransaction(remult, what) {
         trans.flush();
     });
 }
-// TODO - talk about message size limit in ably - something that we may reach if we group the messages
 class transactionLiveQueryPublisher {
     constructor(orig) {
         this.orig = orig;
         this.transactionItems = new Map();
     }
-    get storage() {
-        return this.orig.storage;
-    }
-    ;
-    set storage(value) {
-        this.orig.storage = value;
-    }
-    stopLiveQuery(id) {
-        this.orig.stopLiveQuery(id);
-    }
     itemChanged(entityKey, changes) {
         let items = this.transactionItems.get(entityKey);
         if (!items) {
@@ -226,23 +213,8 @@ class transactionLiveQueryPublisher {
         }
     }
     flush() {
-        //TODO - figure out and resolve
-        setTimeout(() => {
-            for (const key of this.transactionItems.keys()) {
-                this.orig.itemChanged(key, this.transactionItems.get(key));
-            }
-        }, 100);
-    }
-    sendChannelMessage(channel, message) {
-        this.orig.sendChannelMessage(channel, message);
-    }
-    defineLiveQueryChannel(serializeRequest, entityKey, options, ids, userId, repo) {
-        return this.orig.defineLiveQueryChannel(serializeRequest, entityKey, options, ids, userId, repo);
-    }
-    get dispatcher() {
-        return this.orig.dispatcher;
-    }
-    set dispatcher(value) {
-        this.orig.dispatcher = value;
+        for (const key of this.transactionItems.keys()) {
+            this.orig.itemChanged(key, this.transactionItems.get(key));
+        }
     }
 }