remult 0.17.0-exp.3 → 0.17.0-exp.4

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

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

package/esm/live-query/ably.js

@@ -0,0 +1,25 @@
+export class AblyLiveQueryProvider {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openStreamAndReturnCloseFunction(onReconnect) {
+        return {
+            disconnect: () => {
+                this.ably.connection.close();
+            },
+            subscribe: (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => { myHandler = () => { }; };
+            }
+        };
+    }
+}
+export class AblyServerEventDispatcher {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    sendChannelMessage(channel, message) {
+        this.ably.channels.get(channel).publish({ data: message });
+    }
+}

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

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

package/esm/live-query/ablyLiveQuery.js

@@ -0,0 +1,25 @@
+export class AblyLiveQueryProvider {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    async openStreamAndReturnCloseFunction(onReconnect) {
+        return {
+            disconnect: () => {
+                this.ably.connection.close();
+            },
+            subscribe: (channel, handler) => {
+                let myHandler = (y) => handler(y.data);
+                this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => { myHandler = () => { }; };
+            }
+        };
+    }
+}
+export class AblyServerEventDispatcher {
+    constructor(ably) {
+        this.ably = ably;
+    }
+    sendChannelMessage(channel, message) {
+        this.ably.channels.get(channel).publish({ data: message });
+    }
+}

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

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "../src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from '../src/live-query/LiveQuerySubscriber';

package/esm/live-query/index.js

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

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

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';
+export {};

package/esm/live-query/live-query.js

@@ -0,0 +1,2 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';

package/esm/live-query.d.ts

@@ -0,0 +1,3 @@
+export { LiveQueryPublisher, ServerEventDispatcher } from "./src/live-query/LiveQueryPublisher";
+export { PubSubClient, LiveQueryProvider, LiveQueryClient } from './src/live-query/LiveQuerySubscriber';
+export {};

package/esm/live-query.js

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

package/esm/remult-express.d.ts

@@ -1,38 +1,30 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
 import { Remult } from './src/context';
-import { AMessageChannel, ChannelSubscribe } from './src/live-query/LiveQuerySubscriber';
-import { ServerEventDispatcher, ServerEventMessage } from './src/live-query/LiveQueryPublisher';
+import { ServerEventChannelSubscribeDTO } from './src/live-query/LiveQuerySubscriber';
+import { ServerEventDispatcher } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;
-    messageChannels?: AMessageChannel<any>[];
+    serverEventDispatcher?: (router: express.Router, server: RemultServer) => ServerEventDispatcher;
 }): express.RequestHandler & RemultServer;
 export declare class ServerEventsController implements ServerEventDispatcher {
-    private channels;
-    private messageHistoryLength;
+    private canUserConnectToChannel?;
+    subscribeToChannel({ channel, clientId }: ServerEventChannelSubscribeDTO, res: import('express').Response, remult: Remult, remove?: boolean): void;
     consoleInfo(): void;
-    subscribeToChannel(remult: Remult, info: ChannelSubscribe, res: import('express').Response): void;
     connections: clientConnection[];
-    constructor(channels: AMessageChannel<any>[], messageHistoryLength?: number);
-    sendQueryMessage({ message, clientId, queryId }: ServerEventMessage): void;
+    constructor(canUserConnectToChannel?: (channel: string, remult: Remult) => boolean);
     sendChannelMessage<T>(channel: string, message: any): void;
     openHttpServerStream(req: import('express').Request, res: import('express').Response): clientConnection;
-    messages: {
-        id: number;
-        message: any;
-        eventType: string;
-    }[];
-    SendMessage(message: any, eventType?: string): void;
 }
 declare class clientConnection {
     response: import('express').Response;
-    clientId: string;
     channels: Record<string, boolean>;
     close(): void;
     closed: boolean;
-    write(id: number, message: any, eventType: string): void;
-    constructor(response: import('express').Response, clientId: string);
+    write(eventData: string, eventType?: string): void;
+    connectionId: any;
+    constructor(response: import('express').Response);
     sendLiveMessage(): void;
 }
 export {};

package/esm/remult-express.js

@@ -2,6 +2,8 @@ import * as express from 'express';
 import { createRemultServer } from './server/expressBridge';
 import { streamUrl } from './src/live-query/LiveQuerySubscriber';
 import { LiveQueryPublisher } from './src/live-query/LiveQueryPublisher';
+import { v4 as uuid } from 'uuid';
+import { remult } from './src/remult-proxy';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -16,21 +18,12 @@ export function remultExpress(options) {
     }
     const server = createRemultServer(options);
     server.registerRouter(app);
-    let httpServerEvents = new ServerEventsController(options.messageChannels);
-    server.liveQueryManager = new LiveQueryPublisher(httpServerEvents);
-    const streamPath = options.rootPath + '/' + streamUrl;
-    app.get(streamPath, (req, res) => {
-        httpServerEvents.openHttpServerStream(req, res);
-    });
-    app.post(streamPath, (r, res, next) => server.withRemult(r, res, next), (req, res) => {
-        server.liveQueryManager.unsubscribe(req.body);
-        res.json("ok");
-        //httpServerEvents.subscribeToChannel(remult, req.body, res)
-    });
-    app.get(streamPath + '/stats', (req, res) => {
-        httpServerEvents.consoleInfo();
-        res.json("ok");
-    });
+    if (!options.serverEventDispatcher) {
+        options.serverEventDispatcher = (router, server) => {
+            return buildHttpServerEventDispatcher(router, options.rootPath, server);
+        };
+    }
+    server.liveQueryManager = new LiveQueryPublisher(options.serverEventDispatcher(app, server));
     return Object.assign(app, {
         getRemult: (req) => server.getRemult(req),
         openApiDoc: (options) => server.openApiDoc(options),
@@ -39,52 +32,40 @@ export function remultExpress(options) {
     });
 }
 export class ServerEventsController {
-    constructor(channels, messageHistoryLength = 1000) {
-        this.channels = channels;
-        this.messageHistoryLength = messageHistoryLength;
+    constructor(canUserConnectToChannel) {
+        this.canUserConnectToChannel = canUserConnectToChannel;
         this.connections = [];
-        this.messages = [];
-        if (channels) {
-            for (const c of channels) {
-                c.dispatcher = this;
+        if (!this.canUserConnectToChannel) {
+            this.canUserConnectToChannel = () => true;
+        }
+    }
+    subscribeToChannel({ channel, clientId }, res, remult, remove = false) {
+        for (const c of this.connections) {
+            if (c.connectionId === clientId) {
+                if (this.canUserConnectToChannel(channel, remult)) {
+                    c.channels[channel] = !remove;
+                    res.json("ok");
+                    return;
+                }
+                else {
+                    res.sendStatus(403);
+                    return;
+                }
             }
         }
+        res.sendStatus(404);
     }
     consoleInfo() {
         console.info(this.connections.map(x => ({
-            client: x.clientId,
+            client: x.connectionId,
             channels: x.channels
         })));
     }
-    subscribeToChannel(remult, info, res) {
-        let ok = false;
-        if (this.channels)
-            for (const sc of this.connections) {
-                if (sc.clientId === info.clientId) {
-                    for (const c of this.channels) {
-                        if (c.userCanSubscribe(info.channel, remult)) {
-                            sc.channels[info.channel] = !info.remove;
-                            ok = true;
-                        }
-                    }
-                }
-            }
-        if (ok)
-            res.json("ok");
-        else
-            res.status(404).json(`Channel "${info.channel}" not found`);
-    }
-    sendQueryMessage({ message, clientId, queryId }) {
-        for (const sc of this.connections) {
-            if (sc.clientId === clientId) {
-                sc.write(undefined, message, queryId);
-            }
-        }
-    }
     sendChannelMessage(channel, message) {
+        const data = JSON.stringify({ channel, data: message });
         for (const sc of this.connections) {
             if (sc.channels[channel]) {
-                sc.write(undefined, message, channel);
+                sc.write(data);
             }
         }
     }
@@ -94,11 +75,8 @@ export class ServerEventsController {
             'Cache-Control': 'no-cache',
             'Connection': 'keep-alive'
         });
-        const cc = new clientConnection(res, req.headers["client-id"] || req.query['id']);
-        const lastEventId = req.headers['last-event-id'];
-        if (lastEventId) {
-            this.messages.filter(x => x.id > +lastEventId).forEach(m => cc.write(m.id, m.message, m.eventType));
-        }
+        const cc = new clientConnection(res);
+        //const lastEventId = req.headers['last-event-id'];
         this.connections.push(cc);
         req.on("close", () => {
             cc.close();
@@ -106,32 +84,24 @@ export class ServerEventsController {
         });
         return cc;
     }
-    SendMessage(message, eventType = '') {
-        let z = this;
-        let id = i++;
-        z.messages.push({ id, message: message, eventType });
-        while (z.messages.length > z.messageHistoryLength)
-            z.messages.shift();
-        z.connections.forEach(y => y.write(id, message, eventType));
-    }
 }
 class clientConnection {
-    constructor(response, clientId) {
+    constructor(response) {
         this.response = response;
-        this.clientId = clientId;
         this.channels = {};
         this.closed = false;
-        response.write("event:authenticate\ndata:" + "key" + "\n\n");
+        this.connectionId = uuid();
+        this.write(this.connectionId, "connectionId");
         this.sendLiveMessage();
     }
     close() {
         this.closed = true;
     }
-    write(id, message, eventType) {
-        let event = "event:message";
-        if (id != undefined)
-            event += "\nid:" + id;
-        this.response.write(event + "\ndata:" + JSON.stringify({ event: eventType, data: message }) + "\n\n");
+    write(eventData, eventType = "message") {
+        let event = "event:" + eventType;
+        // if (id != undefined)
+        //     event += "\nid:" + id;
+        this.response.write(event + "\ndata:" + eventData + "\n\n");
         let r = this.response;
         if (r.flush)
             r.flush();
@@ -139,13 +109,27 @@ class clientConnection {
     sendLiveMessage() {
         if (this.closed)
             return;
-        this.response.write("event:keep-alive\ndata:\n\n");
-        let r = this.response;
-        if (r.flush)
-            r.flush();
+        this.write("", "keep-alive");
         setTimeout(() => {
             this.sendLiveMessage();
         }, 45000);
     }
 }
-let i = 0;
+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);
+    });
+    router.get(streamPath + '/stats', (r, res, next) => server.withRemult(r, res, next), (req, res) => {
+        remult.liveQueryPublisher.dispatcher.consoleInfo();
+        res.json("ok");
+    });
+    return httpServerEvents;
+}

package/esm/server/expressBridge.js

@@ -155,7 +155,7 @@ export class RemultServerImplementation {
             let key = getEntityKey(e);
             if (key != undefined)
                 this.add(key, c => {
-                    return new DataApi(c.repo(e), c, this.liveQueryManager);
+                    return new DataApi(c.repo(e), c);
                 }, r);
         });
     }
@@ -180,7 +180,7 @@ export class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult._changeListener = this.liveQueryManager;
+            remult.liveQueryPublisher = this.liveQueryManager;
             remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
                 remultObjectStorage.run(remult, async () => {

package/esm/src/context.d.ts

@@ -3,6 +3,7 @@ import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-da
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
 import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
+import type { ServerEventDispatcher } from "../live-query";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
@@ -63,10 +64,11 @@ export declare class Remult {
     constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
     constructor(p: DataProvider);
     constructor();
+    liveQueryPublisher: LiveQueryPublisherInterface;
     call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** The current data provider */
     dataProvider: DataProvider;
-    liveQueryProvider: LiveQueryClient;
+    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;
@@ -115,3 +117,15 @@ export declare class EventSource {
     fire(): Promise<void>;
     dispatcher: EventDispatcher;
 }
+export interface LiveQueryPublisherInterface {
+    stopLiveQuery(id: any): void;
+    sendChannelMessage<messageType>(channel: string, message: messageType): void;
+    defineLiveQueryChannel(repo: Repository<any>, options: FindOptions<any>, remult: Remult, ids: any[]): string;
+    itemChanged(entityKey: string, changes: itemChange[]): void;
+    dispatcher: ServerEventDispatcher;
+}
+export interface itemChange {
+    id: any;
+    oldId: any;
+    deleted: boolean;
+}

package/esm/src/context.js

@@ -98,14 +98,20 @@ export class Remult {
     constructor(provider) {
         /* @internal */
         this.repCache = new Map();
-        /*@internal*/
-        this._changeListener = {
-            saved: (ref) => { },
-            deleted: (ref) => { }
+        this.liveQueryPublisher = {
+            itemChanged: () => { },
+            defineLiveQueryChannel: () => "",
+            dispatcher: undefined,
+            sendChannelMessage: function (arg0, what) {
+                throw new Error("invalid publisher.");
+            },
+            stopLiveQuery: function (id) {
+                throw new Error("Function not implemented.");
+            }
         };
         /** The current data provider */
         this.dataProvider = new RestDataProvider(() => this.apiClient);
-        this.liveQueryProvider = new LiveQueryClient(new EventSourceLiveQueryProvider());
+        this.liveQuerySubscriber = new LiveQueryClient(new EventSourceLiveQueryProvider());
         this.context = {};
         this.apiClient = {
             url: '/api'

package/esm/src/data-api.d.ts

@@ -1,14 +1,10 @@
 import { Remult } from './context';
-import { FindOptions, Repository } from './remult3';
+import { Repository } from './remult3';
 import { ErrorInfo } from './data-interfaces';
-export interface LiveQueryProvider {
-    subscribe(repo: Repository<any>, id: string, options: FindOptions<any>, remult: Remult, ids: any[]): string;
-}
 export declare class DataApi<T = any> {
     private repository;
     private remult;
-    private liveQueryProvider?;
-    constructor(repository: Repository<T>, remult: Remult, liveQueryProvider?: LiveQueryProvider);
+    constructor(repository: Repository<T>, remult: Remult);
     httpGet(res: DataApiResponse, req: DataApiRequest): Promise<void>;
     httpPost(res: DataApiResponse, req: DataApiRequest, body: any): Promise<void>;
     static defaultGetLimit: number;

package/esm/src/data-api.js

@@ -2,10 +2,9 @@ import { customUrlToken, buildFilterFromRequestParameters } from './filter/filte
 import { Filter } from './filter/filter-interfaces';
 import { ForbiddenError } from './server-action';
 export class DataApi {
-    constructor(repository, remult, liveQueryProvider) {
+    constructor(repository, remult) {
         this.repository = repository;
         this.remult = remult;
-        this.liveQueryProvider = liveQueryProvider;
     }
     httpGet(res, req) {
         if (req.get("__action") == "count") {
@@ -16,13 +15,17 @@ export class DataApi {
     }
     httpPost(res, req, body) {
         const action = req?.get("__action");
-        if (action?.startsWith("subscribe"))
+        if (action?.startsWith("liveQuery"))
             return this.getArray(res, req, body);
         switch (action) {
             case "get":
                 return this.getArray(res, req, body);
             case "count":
                 return this.count(res, req, body);
+            case "endLiveQuery":
+                this.remult.liveQueryPublisher.stopLiveQuery(body.id);
+                res.success("ok");
+                return;
             default:
                 return this.post(res, body);
         }
@@ -99,9 +102,9 @@ export class DataApi {
                 .then(async (r) => {
                 return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
             });
-            if (this.liveQueryProvider && action?.startsWith("subscribe")) {
+            if (this.remult.liveQueryPublisher && action?.startsWith("liveQuery")) {
                 response.success({
-                    id: this.liveQueryProvider.subscribe(this.repository, action.split('|')[1], findOptions, this.remult, r.map(y => this.repository.getEntityRef(y).getId())),
+                    queryChannel: this.remult.liveQueryPublisher.defineLiveQueryChannel(this.repository, findOptions, this.remult, r.map(y => this.repository.getEntityRef(y).getId())),
                     result: r
                 });
                 return;

package/esm/src/live-query/EventSourceLiveQueryProvider.d.ts

@@ -1,6 +1,4 @@
-import { LiveQueryProvider, MessageHandler } from "./LiveQuerySubscriber";
+import { LiveQueryProvider, PubSubClient } from "./LiveQuerySubscriber";
 export declare class EventSourceLiveQueryProvider implements LiveQueryProvider {
-    private wrapMessage?;
-    constructor(wrapMessage?: (what: () => void) => void);
-    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler, onReconnect: VoidFunction): Promise<VoidFunction>;
+    openStreamAndReturnCloseFunction(onReconnect: VoidFunction): Promise<PubSubClient>;
 }

package/esm/src/live-query/EventSourceLiveQueryProvider.js

@@ -1,31 +1,55 @@
+import { buildRestDataProvider } from "../context";
 import { remult } from "../remult-proxy";
 import { streamUrl } from "./LiveQuerySubscriber";
 export class EventSourceLiveQueryProvider {
-    constructor(wrapMessage) {
-        this.wrapMessage = wrapMessage;
-        if (!this.wrapMessage)
-            this.wrapMessage = x => x();
-    }
-    openStreamAndReturnCloseFunction(clientId, onMessage, onReconnect) {
-        const source = new EventSource(remult.apiClient.url + '/' + streamUrl + "?id=" + clientId, {
+    openStreamAndReturnCloseFunction(onReconnect) {
+        const source = new EventSource(remult.apiClient.url + '/' + streamUrl, {
             withCredentials: true
         });
+        const channels = new Map();
         source.onmessage = e => {
-            this.wrapMessage(() => onMessage(JSON.parse(e.data)));
+            let message = JSON.parse(e.data);
+            const listeners = channels.get(message.channel);
+            if (listeners)
+                listeners.forEach(x => x(message.data));
         };
         source.onerror = e => {
             console.error("Live Query Event Source Error", e);
         };
+        let connectionId;
+        const provider = buildRestDataProvider(remult.apiClient.httpClient);
+        const client = {
+            disconnect() {
+                source.close();
+            },
+            subscribe(channel, handler) {
+                let listeners = channels.get(channel);
+                if (!listeners)
+                    channels.set(channel, listeners = []);
+                listeners.push(handler);
+                provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
+                    channel: channel,
+                    clientId: connectionId
+                });
+                return () => {
+                    listeners.splice(listeners.indexOf(handler, 1));
+                    provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
+                        channel: channel,
+                        clientId: connectionId
+                    });
+                };
+            },
+        };
         return new Promise((res) => {
             let connected = false;
-            source.onopen = e => {
+            source.addEventListener("connectionId", e => {
+                //@ts-ignore
+                connectionId = e.data;
                 if (connected)
                     onReconnect();
                 connected = true;
-                res(() => {
-                    source.close();
-                });
-            };
+                res(client);
+            });
         });
     }
 }

package/esm/src/live-query/LiveQueryPublisher.d.ts

@@ -1,33 +1,21 @@
 import { Remult } from '../..';
-import { Repository, EntityRef, FindOptions } from '../remult3';
-import { LiveQueryProvider } from '../data-api';
-import { ChannelSubscribe, liveQueryMessage } from './LiveQuerySubscriber';
-export declare class LiveQueryPublisher implements LiveQueryProvider {
-    private dispatcher;
-    unsubscribe(data: ChannelSubscribe): void;
+import { itemChange, LiveQueryPublisherInterface } from '../context';
+import { Repository, FindOptions } from '../remult3';
+export declare class LiveQueryPublisher implements LiveQueryPublisherInterface {
+    dispatcher: ServerEventDispatcher;
     constructor(dispatcher: ServerEventDispatcher);
-    subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
-    clients: clientInfo[];
-    hasListeners(ref: EntityRef<any>): boolean;
-    runPromise(p: Promise<any>): void;
-    saved(ref: EntityRef<any>): void;
-    deleted(ref: EntityRef<any>): void;
-}
-export interface clientInfo {
-    clientId: string;
+    stopLiveQuery(id: any): void;
+    sendChannelMessage<messageType>(channel: string, message: messageType): void;
+    defineLiveQueryChannel(repo: Repository<any>, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
     queries: ({
         id: string;
         repo: Repository<any>;
         findOptions: FindOptions<any>;
         ids: any[];
     })[];
+    runPromise(p: Promise<any>): void;
+    itemChanged(entityKey: string, changes: itemChange[]): void;
 }
 export interface ServerEventDispatcher {
-    sendQueryMessage(message: ServerEventMessage): void;
-    sendChannelMessage<T>(channel: string, message: any): void;
-}
-export interface ServerEventMessage {
-    clientId: string;
-    queryId: string;
-    message: liveQueryMessage;
+    sendChannelMessage<T>(channel: string, message: T): void;
 }