remult 0.17.0-exp.1 → 0.17.0-exp.3

package/esm/postgres/schema-builder.js

@@ -43,7 +43,7 @@ export class PostgresSchemaBuilder {
         }
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.log("start verify structure"); //keep me
         for (const entityClass of allEntities) {
             let entity = remult.repo(entityClass).metadata;
             let e = await getDbNameProvider(entity);
@@ -56,7 +56,7 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                console.log("failed verify structure of " + e.entityName + " ", err);
+                /*keep me */ console.log("failed verify structure of " + e.entityName + " ", err);
             }
         }
     }
@@ -102,7 +102,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
     async verifyAllColumns(entity) {
@@ -122,7 +122,7 @@ export class PostgresSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/remult-express.d.ts

@@ -1,8 +1,8 @@
 import * as express from 'express';
 import { RemultServer, RemultServerOptions } from './server/expressBridge';
 import { Remult } from './src/context';
-import { AMessageChannel, ChannelSubscribe } from './src/live-query/LiveQuery';
-import { ServerEventDispatcher, ServerEventMessage } from './src/live-query/LiveQueryManager';
+import { AMessageChannel, ChannelSubscribe } from './src/live-query/LiveQuerySubscriber';
+import { ServerEventDispatcher, ServerEventMessage } from './src/live-query/LiveQueryPublisher';
 export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
     bodyParser?: boolean;
     bodySizeLimit?: string;

package/esm/remult-express.js

@@ -1,8 +1,7 @@
 import * as express from 'express';
 import { createRemultServer } from './server/expressBridge';
-import { streamUrl } from './src/live-query/LiveQuery';
-import { LiveQueryManager } from './src/live-query/LiveQueryManager';
-import { remult } from './src/remult-proxy';
+import { streamUrl } from './src/live-query/LiveQuerySubscriber';
+import { LiveQueryPublisher } from './src/live-query/LiveQueryPublisher';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -18,13 +17,15 @@ export function remultExpress(options) {
     const server = createRemultServer(options);
     server.registerRouter(app);
     let httpServerEvents = new ServerEventsController(options.messageChannels);
-    server.liveQueryManager = new LiveQueryManager(httpServerEvents);
+    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) => {
-        httpServerEvents.subscribeToChannel(remult, req.body, res);
+        server.liveQueryManager.unsubscribe(req.body);
+        res.json("ok");
+        //httpServerEvents.subscribeToChannel(remult, req.body, res)
     });
     app.get(streamPath + '/stats', (req, res) => {
         httpServerEvents.consoleInfo();
@@ -50,7 +51,7 @@ export class ServerEventsController {
         }
     }
     consoleInfo() {
-        console.log(this.connections.map(x => ({
+        console.info(this.connections.map(x => ({
             client: x.clientId,
             channels: x.channels
         })));
@@ -111,7 +112,6 @@ export class ServerEventsController {
         z.messages.push({ id, message: message, eventType });
         while (z.messages.length > z.messageHistoryLength)
             z.messages.shift();
-        //console.log({ sendingTo: z.connections.length })
         z.connections.forEach(y => y.write(id, message, eventType));
     }
 }
@@ -121,12 +121,10 @@ class clientConnection {
         this.clientId = clientId;
         this.channels = {};
         this.closed = false;
-        //console.log("open connection");
         response.write("event:authenticate\ndata:" + "key" + "\n\n");
         this.sendLiveMessage();
     }
     close() {
-        //console.log("close connection");
         this.closed = true;
     }
     write(id, message, eventType) {

package/esm/remult-knex/index.js

@@ -256,7 +256,7 @@ export class KnexSchemaBuilder {
         this.additionalWhere = '';
     }
     async verifyStructureOfAllEntities(remult) {
-        console.log("start verify structure");
+        console.info("start verify structure");
         for (const entity of allEntities) {
             let metadata = remult.repo(entity).metadata;
             try {
@@ -319,7 +319,7 @@ export class KnexSchemaBuilder {
             }
         }
         catch (err) {
-            console.log(err);
+            console.error(err);
         }
     }
 }

package/esm/server/expressBridge.d.ts

@@ -5,7 +5,7 @@ import { AllowedForInstance, Remult, UserInfo } from '../src/context';
 import { ClassType } from '../classType';
 import { Repository } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
-import { LiveQueryManager } from '../src/live-query/LiveQueryManager';
+import { LiveQueryPublisher } from '../src/live-query/LiveQueryPublisher';
 export interface RemultServerOptions<RequestType extends GenericRequest> {
     /** Sets a database connection for Remult.
      *
@@ -64,7 +64,7 @@ export declare class RemultServerImplementation implements RemultServer {
     options: RemultServerOptions<GenericRequest>;
     dataProvider: DataProvider | Promise<DataProvider>;
     constructor(queue: inProcessQueueHandler, options: RemultServerOptions<GenericRequest>, dataProvider: DataProvider | Promise<DataProvider>);
-    liveQueryManager: LiveQueryManager;
+    liveQueryManager: LiveQueryPublisher;
     withRemult<T>(req: GenericRequest, res: GenericResponse, next: VoidFunction): void;
     routeImpl: RouteImplementation;
     handle(req: GenericRequest, gRes?: GenericResponse): Promise<ServerHandleResponse>;

package/esm/server/expressBridge.js

@@ -162,7 +162,7 @@ export class RemultServerImplementation {
     add(key, dataApiFactory, r) {
         let myRoute = this.options.rootPath + '/' + key;
         if (this.options.logApiEndPoints)
-            console.log("[remult] " + myRoute);
+            console.info("[remult] " + myRoute);
         r.route(myRoute)
             .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
@@ -225,7 +225,7 @@ export class RemultServerImplementation {
             })();
             this.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
             if (this.options.logApiEndPoints)
-                console.log("[remult] " + myUrl);
+                console.info("[remult] " + myUrl);
             if (queue) {
                 this.hasQueue = true;
                 this.queue.mapQueuedAction(myUrl, what);

package/esm/server/initAsyncHooks.js

@@ -2,7 +2,6 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { RemultAsyncLocalStorage } from './expressBridge';
 let init = false;
 export function initAsyncHooks() {
-    return;
     if (init)
         return;
     init = true;

package/esm/src/context.d.ts

@@ -2,7 +2,7 @@ import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
 import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-import { LiveQueryClient } from "./live-query/LiveQuery";
+import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
 export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;

package/esm/src/context.js

@@ -1,7 +1,7 @@
 import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
-import { LiveQueryClient } from "./live-query/LiveQuery";
+import { LiveQueryClient } from "./live-query/LiveQuerySubscriber";
 import { EventSourceLiveQueryProvider } from "./live-query/EventSourceLiveQueryProvider";
 import { RemultProxy } from "./remult-proxy";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {

package/esm/src/data-api.js

@@ -1,5 +1,6 @@
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
 import { Filter } from './filter/filter-interfaces';
+import { ForbiddenError } from './server-action';
 export class DataApi {
     constructor(repository, remult, liveQueryProvider) {
         this.repository = repository;
@@ -175,17 +176,26 @@ export class DataApi {
     }
     async post(response, body) {
         try {
-            let newr = this.repository.create();
-            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body);
-            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
-                response.forbidden();
-                return;
+            const insert = async (what) => {
+                let newr = this.repository.create();
+                await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
+                if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                    throw new ForbiddenError();
+                }
+                await this.repository.getEntityRef(newr).save();
+                return this.repository.getEntityRef(newr).toApiJson();
+            };
+            if (Array.isArray(body)) {
+                response.created(await Promise.all(body.map(x => insert(x))));
             }
-            await this.repository.getEntityRef(newr).save();
-            response.created(this.repository.getEntityRef(newr).toApiJson());
+            else
+                response.created(await insert(body));
         }
         catch (err) {
-            response.error(err);
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
         }
     }
 }

package/esm/src/data-providers/sql-database.js

@@ -76,7 +76,7 @@ class LogSQLCommand {
             if (this.allQueries) {
                 var d = new Date().valueOf() - start.valueOf();
                 if (d > SqlDatabase.durationThreshold) {
-                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+                    console.info({ query: sql, arguments: this.args, duration: d / 1000 });
                 }
             }
             return r;

package/esm/src/data-providers/web-sql-data-provider.js

@@ -18,7 +18,7 @@ export class WebSqlDataProvider {
         let e = await getDbNameProvider(entity);
         let sql = 'drop  table if exists ' + e.entityName;
         if (SqlDatabase.LogToConsole)
-            console.log(sql);
+            console.info(sql);
         await this.createCommand().execute(sql);
     }
     async createTable(entity) {

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

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

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

@@ -1,20 +1,27 @@
 import { remult } from "../remult-proxy";
-import { streamUrl } from "./LiveQuery";
+import { streamUrl } from "./LiveQuerySubscriber";
 export class EventSourceLiveQueryProvider {
     constructor(wrapMessage) {
         this.wrapMessage = wrapMessage;
-        if (!wrapMessage)
-            wrapMessage = x => x();
+        if (!this.wrapMessage)
+            this.wrapMessage = x => x();
     }
-    openStreamAndReturnCloseFunction(clientId, onMessage) {
+    openStreamAndReturnCloseFunction(clientId, onMessage, onReconnect) {
         const source = new EventSource(remult.apiClient.url + '/' + streamUrl + "?id=" + clientId, {
             withCredentials: true
         });
         source.onmessage = e => {
             this.wrapMessage(() => onMessage(JSON.parse(e.data)));
         };
+        source.onerror = e => {
+            console.error("Live Query Event Source Error", e);
+        };
         return new Promise((res) => {
+            let connected = false;
             source.onopen = e => {
+                if (connected)
+                    onReconnect();
+                connected = true;
                 res(() => {
                     source.close();
                 });

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

@@ -1,6 +1,6 @@
 import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
 import { Allowed } from '../context';
-import { ServerEventDispatcher } from './LiveQueryManager';
+import { ServerEventDispatcher } from './LiveQueryPublisher';
 export declare const streamUrl = "stream1";
 export interface LiveQueryProvider {
     openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
@@ -23,7 +23,6 @@ export declare class LiveQueryClient {
     subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
     closeListener: Promise<VoidFunction>;
     private openIfNoOpened;
-    private openListener;
 }
 export declare type listener = (message: any) => void;
 export interface SubscribeToQueryArgs<entityType = any> {

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

@@ -1,13 +1,14 @@
-import { getEntityRef, remult as defaultRemult, Sort } from '../../index';
+import { remult as defaultRemult, Sort } from '../../index';
 import { v4 as uuid } from 'uuid';
 import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
 import { buildRestDataProvider } from '../context';
+import { getId } from '../remult3/getId';
 export const streamUrl = 'stream1';
-class LiveQueryOnFrontEnd {
+class LiveQuerySubscriber {
     constructor(repo, query) {
         this.repo = repo;
         this.query = query;
-        this.items = [];
+        this.defaultQueryState = [];
         this.listeners = [];
     }
     async setAllItems(result) {
@@ -19,6 +20,7 @@ class LiveQueryOnFrontEnd {
         });
     }
     forListeners(what) {
+        //   what(x => this.defaultQueryState = x(this.defaultQueryState));
         for (const l of this.listeners) {
             what(l);
         }
@@ -41,7 +43,7 @@ class LiveQueryOnFrontEnd {
                     listener(items => {
                         if (!items)
                             items = [];
-                        return sort(items.map(x => this.repo.getEntityRef(x).getId() === message.data.oldId ? item : x));
+                        return sort(items.map(x => getId(this.repo.metadata, x) === message.data.oldId ? item : x));
                     });
                 });
                 break;
@@ -52,6 +54,7 @@ class LiveQueryOnFrontEnd {
                     this.forListeners(listener => listener(items => {
                         if (!items)
                             items = [];
+                        items = items.filter(x => getId(this.repo.metadata, x) !== getId(this.repo.metadata, item));
                         items.push(item);
                         return sort(items);
                     }));
@@ -61,7 +64,7 @@ class LiveQueryOnFrontEnd {
                 this.forListeners(listener => listener(items => {
                     if (!items)
                         items = [];
-                    return this.items.filter(x => getEntityRef(x).getId() !== message.data.id);
+                    return items.filter(x => getId(this.repo.metadata, x) !== message.data.id);
                 }));
                 break;
         }
@@ -130,7 +133,7 @@ export class LiveQueryClient {
     subscribe(repo, options, onResult) {
         let alive = true;
         let onUnsubscribe = () => { };
-        this.runPromise(this.openListener().then(() => repo.buildEntityDataProviderFindOptions(options)
+        this.runPromise(this.openIfNoOpened().then(() => repo.buildEntityDataProviderFindOptions(options)
             .then(opts => {
             if (!alive)
                 return;
@@ -139,7 +142,7 @@ export class LiveQueryClient {
             const eventTypeKey = JSON.stringify({ url, filterObject });
             let q = this.queries.get(eventTypeKey);
             if (!q) {
-                this.queries.set(eventTypeKey, q = new LiveQueryOnFrontEnd(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
+                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
                 url.add("__action", 'subscribe|' + this.clientId);
                 const thenResult = (r) => {
                     this.runPromise(q.setAllItems(r.result));
@@ -152,7 +155,7 @@ export class LiveQueryClient {
                     this.runPromise(this.provider.get(url.url).then(thenResult));
             }
             else {
-                onResult(x => q.items);
+                onResult(x => [...q.defaultQueryState]);
             }
             q.listeners.push(onResult);
             onUnsubscribe = () => {
@@ -173,23 +176,18 @@ export class LiveQueryClient {
             this.provider = buildRestDataProvider(defaultRemult.apiClient.httpClient);
         }
         if (!this.closeListener)
-            return this.openListener();
-        return this.closeListener;
-    }
-    openListener() {
-        if (this.closeListener)
-            return this.closeListener;
-        return this.runPromise(this.closeListener = this.lqp.openStreamAndReturnCloseFunction(this.clientId, message => {
-            for (const q of this.queries.values()) {
-                if (q.id === message.event) {
-                    this.runPromise(q.handle(message.data));
+            return this.runPromise(this.closeListener = this.lqp.openStreamAndReturnCloseFunction(this.clientId, message => {
+                for (const q of this.queries.values()) {
+                    if (q.id === message.event) {
+                        this.runPromise(q.handle(message.data));
+                    }
                 }
-            }
-            const channel = this.channels.get(message.event);
-            if (channel) {
-                channel.handle(message.data);
-            }
-        }));
+                const channel = this.channels.get(message.event);
+                if (channel) {
+                    channel.handle(message.data);
+                }
+            }));
+        return this.closeListener;
     }
 }
 export class AMessageChannel {

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

@@ -2,12 +2,11 @@ import { Remult } from '../..';
 import { Repository, EntityRef, FindOptions } from '../remult3';
 import { LiveQueryProvider } from '../data-api';
 import { liveQueryMessage } from './LiveQuery';
-export declare class LiveQueryManager implements LiveQueryProvider {
+export declare class LiveQueryPublisher implements LiveQueryProvider {
     private dispatcher;
     constructor(dispatcher: ServerEventDispatcher);
     subscribe(repo: Repository<any>, clientId: string, findOptions: FindOptions<any>, remult: Remult, ids: any[]): string;
     clients: clientInfo[];
-    sendMessage(key: string, message: liveQueryMessage): void;
     hasListeners(ref: EntityRef<any>): boolean;
     runPromise(p: Promise<any>): void;
     saved(ref: EntityRef<any>): void;

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

@@ -1,5 +1,5 @@
 import { v4 as uuid } from 'uuid';
-export class LiveQueryManager {
+export class LiveQueryPublisher {
     constructor(dispatcher) {
         this.dispatcher = dispatcher;
         this.clients = [];
@@ -19,15 +19,6 @@ export class LiveQueryManager {
         });
         return id;
     }
-    sendMessage(key, message) {
-        for (const c of this.clients) {
-            for (const q of c.queries) {
-                if (q.repo.metadata.key === key) {
-                    this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
-                }
-            }
-        }
-    }
     hasListeners(ref) {
         for (const c of this.clients) {
             for (const q of c.queries) {
@@ -87,11 +78,22 @@ export class LiveQueryManager {
         }
     }
     deleted(ref) {
-        if (!this.hasListeners(ref))
-            return;
-        this.sendMessage(ref.metadata.key, {
-            type: "remove",
-            data: { id: ref.getId() }
-        });
+        const id = ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    if (q.ids.includes(id)) {
+                        this.dispatcher.sendQueryMessage({
+                            clientId: c.clientId, queryId: q.id, message: {
+                                type: "remove",
+                                data: {
+                                    id: id
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        }
     }
 }

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

@@ -0,0 +1,33 @@
+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;
+    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;
+    queries: ({
+        id: string;
+        repo: Repository<any>;
+        findOptions: FindOptions<any>;
+        ids: any[];
+    })[];
+}
+export interface ServerEventDispatcher {
+    sendQueryMessage(message: ServerEventMessage): void;
+    sendChannelMessage<T>(channel: string, message: any): void;
+}
+export interface ServerEventMessage {
+    clientId: string;
+    queryId: string;
+    message: liveQueryMessage;
+}

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

@@ -0,0 +1,102 @@
+import { v4 as uuid } from 'uuid';
+export class LiveQueryPublisher {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.clients = [];
+    }
+    unsubscribe(data) {
+        let client = this.clients.find(c => c.clientId === data.clientId);
+        if (client)
+            client.queries = client.queries.filter(q => q.id !== data.channel);
+    }
+    subscribe(repo, clientId, findOptions, remult, ids) {
+        let client = this.clients.find(c => c.clientId === clientId);
+        if (!client) {
+            this.clients.push(client = { clientId: clientId, queries: [] });
+        }
+        const id = uuid();
+        client.queries.push({
+            id,
+            findOptions: findOptions,
+            repo,
+            ids
+        });
+        return id;
+    }
+    hasListeners(ref) {
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key)
+                    return true;
+            }
+        }
+        return false;
+    }
+    runPromise(p) {
+    }
+    //TODO - reconsider usage of zone
+    saved(ref) {
+        const isNew = ref.isNew();
+        const origId = isNew ? ref.getId() : ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    this.runPromise(q.repo.find(q.findOptions).then(currentItems => {
+                        const currentIds = currentItems.map(x => q.repo.getEntityRef(x).getId());
+                        const sendMessage = (message) => {
+                            this.dispatcher.sendQueryMessage({ clientId: c.clientId, queryId: q.id, message });
+                        };
+                        for (const id of q.ids.filter(y => !currentIds.includes(y))) {
+                            if (id != origId || !currentIds.includes(ref.getId()))
+                                sendMessage({
+                                    type: "remove",
+                                    data: {
+                                        id: id
+                                    }
+                                });
+                        }
+                        for (const item of currentItems) {
+                            const itemRef = q.repo.getEntityRef(item);
+                            if (itemRef.getId() == ref.getId() && q.ids.includes(origId)) {
+                                sendMessage({
+                                    type: "replace",
+                                    data: {
+                                        oldId: origId,
+                                        item: itemRef.toApiJson()
+                                    }
+                                });
+                            }
+                            else if (!q.ids.includes(itemRef.getId())) {
+                                sendMessage({
+                                    type: "add",
+                                    data: { item: itemRef.toApiJson() }
+                                });
+                            }
+                        }
+                        q.ids = currentIds;
+                    }));
+                }
+            }
+        }
+    }
+    deleted(ref) {
+        const id = ref.getOriginalId();
+        for (const c of this.clients) {
+            for (const q of c.queries) {
+                if (q.repo.metadata.key === ref.metadata.key) {
+                    if (q.ids.includes(id)) {
+                        this.dispatcher.sendQueryMessage({
+                            clientId: c.clientId, queryId: q.id, message: {
+                                type: "remove",
+                                data: {
+                                    id: id
+                                }
+                            }
+                        });
+                        q.ids = q.ids.filter(y => y != id);
+                    }
+                }
+            }
+        }
+    }
+}