remult 0.21.1 → 0.22.0

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

@@ -1,6 +1,6 @@
-import { RestDataProvider } from '../data-providers/rest-data-provider';
-import { buildRestDataProvider } from "../buildRestDataProvider";
-import { LiveQuerySubscriber, liveQueryKeepAliveRoute } from './SubscriptionChannel';
+import { RestDataProvider, } from '../data-providers/rest-data-provider';
+import { buildRestDataProvider } from '../buildRestDataProvider';
+import { LiveQuerySubscriber, liveQueryKeepAliveRoute, } from './SubscriptionChannel';
 /* @internal*/
 export class LiveQueryClient {
     constructor(apiProvider, getUserId) {
@@ -16,7 +16,9 @@ export class LiveQueryClient {
         else
             handleMessage();
     }
-    ;
+    hasQueriesForTesting() {
+        return this.queries.size > 0;
+    }
     runPromise(p) {
         return p;
     }
@@ -31,9 +33,9 @@ export class LiveQueryClient {
         try {
             let q = this.channels.get(key);
             if (!q) {
-                this.channels.set(key, q = new MessageChannel());
+                this.channels.set(key, (q = new MessageChannel()));
                 try {
-                    q.unsubscribe = await client.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
+                    q.unsubscribe = await client.subscribe(key, (value) => this.wrapMessageHandling(() => q.handle(value)), (err) => {
                         onResult.error(err);
                     });
                 }
@@ -64,7 +66,7 @@ export class LiveQueryClient {
     closeIfNoListeners() {
         if (this.client)
             if (this.queries.size === 0 && this.channels.size === 0) {
-                this.runPromise(this.client.then(x => x.close()));
+                this.runPromise(this.client.then((x) => x.close()));
                 this.client = undefined;
                 clearInterval(this.interval);
                 this.interval = undefined;
@@ -72,16 +74,21 @@ export class LiveQueryClient {
     }
     subscribe(repo, options, listener) {
         let alive = true;
-        let onUnsubscribe = () => { alive = false; };
-        this.runPromise(repo.buildEntityDataProviderFindOptions(options)
-            .then(opts => {
+        let onUnsubscribe = () => {
+            alive = false;
+        };
+        this.runPromise(repo
+            .buildEntityDataProviderFindOptions(options)
+            .then((opts) => {
             if (!alive)
                 return;
-            const { createKey, subscribe } = new RestDataProvider(this.apiProvider).getEntityDataProvider(repo.metadata).buildFindRequest(opts);
+            const { createKey, subscribe } = new RestDataProvider(this.apiProvider)
+                .getEntityDataProvider(repo.metadata)
+                .buildFindRequest(opts);
             const eventTypeKey = createKey();
             let q = this.queries.get(eventTypeKey);
             if (!q) {
-                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, options }, this.getUserId()));
+                this.queries.set(eventTypeKey, (q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, options }, this.getUserId())));
                 q.subscribeCode = () => {
                     if (q.unsubscribe) {
                         q.unsubscribe();
@@ -90,16 +97,16 @@ export class LiveQueryClient {
                     this.runPromise(this.subscribeChannel(q.queryChannel, {
                         next: (value) => this.runPromise(q.handle(value)),
                         complete: () => { },
-                        error: er => {
-                            q.listeners.forEach(l => l.error(er));
-                        }
-                    }).then(unsubscribeToChannel => {
+                        error: (er) => {
+                            q.listeners.forEach((l) => l.error(er));
+                        },
+                    }).then((unsubscribeToChannel) => {
                         if (q.listeners.length == 0) {
                             unsubscribeToChannel();
                             return;
                         }
-                        this.runPromise(subscribe(q.id)
-                            .then(r => {
+                        this.runPromise(subscribe(q.queryChannel)
+                            .then((r) => {
                             if (q.listeners.length === 0) {
                                 r.unsubscribe();
                                 unsubscribeToChannel();
@@ -112,11 +119,13 @@ export class LiveQueryClient {
                                 this.runPromise(r.unsubscribe());
                             };
                         })
-                            .catch(err => {
-                            listener.error(err);
+                            .catch((err) => {
+                            q.listeners.forEach((l) => l.error(err));
+                            unsubscribeToChannel();
+                            this.queries.delete(eventTypeKey);
                         }));
-                    })).catch(err => {
-                        q.listeners.forEach(l => l.error(err));
+                    })).catch((err) => {
+                        q.listeners.forEach((l) => l.error(err));
                     });
                 };
                 q.subscribeCode();
@@ -135,7 +144,7 @@ export class LiveQueryClient {
                 this.closeIfNoListeners();
             };
         })
-            .catch(err => {
+            .catch((err) => {
             listener.error(err);
         }));
         return () => {
@@ -161,12 +170,11 @@ export class LiveQueryClient {
                     }
                 }
             }, 30000);
-            return this.runPromise(this.client =
-                this.apiProvider().subscriptionClient.openConnection(() => {
-                    for (const q of this.queries.values()) {
-                        q.subscribeCode();
-                    }
-                }));
+            return this.runPromise((this.client = this.apiProvider().subscriptionClient.openConnection(() => {
+                for (const q of this.queries.values()) {
+                    q.subscribeCode();
+                }
+            })));
         }
         return this.client;
     }

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

@@ -1,4 +1,4 @@
-import { SubscriptionClient, SubscriptionClientConnection } from "./SubscriptionChannel";
+import { SubscriptionClient, SubscriptionClientConnection } from './SubscriptionChannel';
 export declare class SseSubscriptionClient implements SubscriptionClient {
     openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
 }

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

@@ -1,7 +1,7 @@
-import { buildRestDataProvider } from "../buildRestDataProvider";
-import { remult } from "../remult-proxy";
-import { actionInfo } from "../server-action";
-import { streamUrl } from "./SubscriptionChannel";
+import { buildRestDataProvider } from '../buildRestDataProvider';
+import { remult } from '../remult-proxy';
+import { actionInfo } from '../server-action';
+import { streamUrl, } from './SubscriptionChannel';
 export class SseSubscriptionClient {
     openConnection(onReconnect) {
         let connectionId;
@@ -16,7 +16,7 @@ export class SseSubscriptionClient {
             async subscribe(channel, handler) {
                 let listeners = channels.get(channel);
                 if (!listeners) {
-                    channels.set(channel, listeners = []);
+                    channels.set(channel, (listeners = []));
                     await subscribeToChannel(channel);
                 }
                 listeners.push(handler);
@@ -25,7 +25,7 @@ export class SseSubscriptionClient {
                     if (listeners.length == 0) {
                         actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
                             channel: channel,
-                            clientId: connectionId
+                            clientId: connectionId,
                         }));
                         channels.delete(channel);
                     }
@@ -38,22 +38,22 @@ export class SseSubscriptionClient {
                 if (source)
                     source.close();
                 source = new EventSource(remult.apiClient.url + '/' + streamUrl, {
-                    withCredentials: true
+                    withCredentials: true,
                 });
-                source.onmessage = e => {
+                source.onmessage = (e) => {
                     let message = JSON.parse(e.data);
                     const listeners = channels.get(message.channel);
                     if (listeners)
-                        listeners.forEach(x => x(message.data));
+                        listeners.forEach((x) => x(message.data));
                 };
-                source.onerror = e => {
-                    console.error("Live Query Event Source Error", e);
+                source.onerror = (e) => {
+                    console.error('Live Query Event Source Error', e);
                     source.close();
                     setTimeout(() => {
                         createConnection();
                     }, 500);
                 };
-                source.addEventListener("connectionId", async (e) => {
+                source.addEventListener('connectionId', async (e) => {
                     //@ts-ignore
                     connectionId = e.data;
                     if (connected) {
@@ -74,7 +74,7 @@ export class SseSubscriptionClient {
             const result = await actionInfo.runActionWithoutBlockingUI(() => {
                 return provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
                     channel: channel,
-                    clientId: connectionId
+                    clientId: connectionId,
                 });
             });
             if (result === ConnectionNotFoundError) {
@@ -83,4 +83,4 @@ export class SseSubscriptionClient {
         }
     }
 }
-export const ConnectionNotFoundError = "client connection not found";
+export const ConnectionNotFoundError = 'client connection not found';

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

@@ -15,10 +15,10 @@ export interface SubscriptionClient {
 }
 export declare const liveQueryKeepAliveRoute = "_liveQueryKeepAlive";
 export declare type LiveQueryChange = {
-    type: "all";
+    type: 'all';
     data: any[];
 } | {
-    type: "add";
+    type: 'add';
     data: any;
 } | {
     type: 'replace';
@@ -27,7 +27,7 @@ export declare type LiveQueryChange = {
         item: any;
     };
 } | {
-    type: "remove";
+    type: 'remove';
     data: {
         id: any;
     };

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

@@ -1,6 +1,5 @@
 import { remult as defaultRemult, Sort } from '../../index';
 import { v4 as uuid } from 'uuid';
-import { getLiveQueryChannel } from '../data-api';
 export const streamUrl = 'stream';
 //@internal
 export class LiveQuerySubscriber {
@@ -11,15 +10,16 @@ export class LiveQuerySubscriber {
         this.defaultQueryState = [];
         this.listeners = [];
         this.id = uuid();
-        this.queryChannel = getLiveQueryChannel(this.id, userId);
+        this.queryChannel = `users:${userId}:queries:${this.id}`;
+        this.id = this.queryChannel;
     }
     sendDefaultState(onResult) {
         onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
     }
     async setAllItems(result) {
         const items = await this.repo.fromJsonArray(result, this.query.options.load);
-        this.forListeners(listener => {
-            listener(x => {
+        this.forListeners((listener) => {
+            listener((x) => {
                 return items;
             });
         }, this.allItemsMessage(items));
@@ -27,15 +27,15 @@ export class LiveQuerySubscriber {
     allItemsMessage(items) {
         return [
             {
-                type: "all",
-                data: items
-            }
+                type: 'all',
+                data: items,
+            },
         ];
     }
     forListeners(what, changes) {
-        what(reducer => {
+        what((reducer) => {
             this.defaultQueryState = reducer(this.defaultQueryState);
-            if (changes.find(c => c.type === "add" || c.type === "replace")) {
+            if (changes.find((c) => c.type === 'add' || c.type === 'replace')) {
                 if (this.query.options.orderBy) {
                     const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.options.orderBy);
                     this.defaultQueryState.sort((a, b) => o.compare(a, b));
@@ -43,7 +43,7 @@ export class LiveQuerySubscriber {
             }
         });
         for (const l of this.listeners) {
-            what(reducer => {
+            what((reducer) => {
                 l.next(this.createReducerType(reducer, changes));
             });
         }
@@ -52,40 +52,42 @@ export class LiveQuerySubscriber {
         return {
             applyChanges,
             changes,
-            items: this.defaultQueryState
+            items: this.defaultQueryState,
         };
     }
     async handle(messages) {
         {
-            let x = messages.filter(({ type }) => type == "add" || type == "replace");
-            let loadedItems = await this.repo.fromJsonArray(x.map(m => m.data.item), this.query.options.load);
+            let x = messages.filter(({ type }) => type == 'add' || type == 'replace');
+            let loadedItems = await this.repo.fromJsonArray(x.map((m) => m.data.item), this.query.options.load);
             for (let index = 0; index < x.length; index++) {
                 const element = x[index];
                 element.data.item = loadedItems[index];
             }
         }
-        this.forListeners(listener => {
-            listener(items => {
+        this.forListeners((listener) => {
+            listener((items) => {
                 if (!items)
                     items = [];
                 for (const message of messages) {
                     switch (message.type) {
-                        case "all":
+                        case 'all':
                             this.setAllItems(message.data);
                             break;
-                        case "replace": {
-                            items = items.map(x => this.repo.metadata.idMetadata.getId(x) === message.data.oldId ? message.data.item : x);
+                        case 'replace': {
+                            items = items.map((x) => this.repo.metadata.idMetadata.getId(x) === message.data.oldId
+                                ? message.data.item
+                                : x);
                             break;
                         }
-                        case "add":
-                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== this.repo.metadata.idMetadata.getId(message.data.item));
+                        case 'add':
+                            items = items.filter((x) => this.repo.metadata.idMetadata.getId(x) !==
+                                this.repo.metadata.idMetadata.getId(message.data.item));
                             items.push(message.data.item);
                             break;
-                        case "remove":
-                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== message.data.id);
+                        case 'remove':
+                            items = items.filter((x) => this.repo.metadata.idMetadata.getId(x) !== message.data.id);
                             break;
                     }
-                    ;
                 }
                 return items;
             });
@@ -105,9 +107,9 @@ export class SubscriptionChannel {
     subscribe(next, remult) {
         remult = remult || defaultRemult;
         let listener = next;
-        if (typeof (next) === "function") {
+        if (typeof next === 'function') {
             listener = {
-                next
+                next,
             };
         }
         listener.error ??= () => { };

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

@@ -10,38 +10,40 @@ export class LiveQueryPublisher {
     runPromise(p) { }
     async itemChanged(entityKey, changes) {
         //TODO 2 - optimize so that the user will get their messages first. Based on user id
-        await (this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
+        await this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
             let query = { ...q.data };
             await this.performWithContext(query.requestJson, entityKey, async (repo) => {
                 const messages = [];
                 const currentItems = await repo.find(findOptionsFromJson(query.findOptionsJson, repo.metadata));
-                const currentIds = currentItems.map(x => repo.getEntityRef(x).getId());
-                for (const id of query.lastIds.filter(y => !currentIds.includes(y))) {
-                    let c = changes.find(c => c.oldId == id);
-                    if (c === undefined || id != c.oldId || !currentIds.includes(c.id))
+                const currentIds = currentItems.map((x) => repo.getEntityRef(x).getId());
+                for (const id of query.lastIds.filter((y) => !currentIds.includes(y))) {
+                    let c = changes.find((c) => c.oldId == id);
+                    if (c === undefined ||
+                        id != c.oldId ||
+                        !currentIds.includes(c.id))
                         messages.push({
-                            type: "remove",
+                            type: 'remove',
                             data: {
-                                id: id
-                            }
+                                id: id,
+                            },
                         });
                 }
                 for (const item of currentItems) {
                     const itemRef = repo.getEntityRef(item);
-                    let c = changes.find(c => c.id == itemRef.getId());
+                    let c = changes.find((c) => c.id == itemRef.getId());
                     if (c !== undefined && query.lastIds.includes(c.oldId)) {
                         messages.push({
-                            type: "replace",
+                            type: 'replace',
                             data: {
                                 oldId: c.oldId,
-                                item: itemRef.toApiJson()
-                            }
+                                item: itemRef.toApiJson(),
+                            },
                         });
                     }
                     else if (!query.lastIds.includes(itemRef.getId())) {
                         messages.push({
-                            type: "add",
-                            data: { item: itemRef.toApiJson() }
+                            type: 'add',
+                            data: { item: itemRef.toApiJson() },
                         });
                     }
                 }
@@ -50,14 +52,14 @@ export class LiveQueryPublisher {
                     currentIds,
                     changes,
                     lastIds: query.lastIds,
-                    messages
+                    messages,
                 });
                 query.lastIds = currentIds;
                 await setData(query);
                 if (messages.length > 0)
                     this.subscriptionServer().publishMessage(q.id, messages);
             });
-        }));
+        });
     }
 }
 export class InMemoryLiveQueryStorage {
@@ -72,7 +74,7 @@ export class InMemoryLiveQueryStorage {
     async keepAliveAndReturnUnknownQueryIds(ids) {
         const result = [];
         for (const id of ids) {
-            let q = this.queries.find(q => q.id === id);
+            let q = this.queries.find((q) => q.id === id);
             if (q) {
                 q.lastUsed = new Date().toISOString();
             }
@@ -87,19 +89,21 @@ export class InMemoryLiveQueryStorage {
         this.debug();
     }
     async remove(id) {
-        this.queries = this.queries.filter(q => q.id !== id);
+        this.queries = this.queries.filter((q) => q.id !== id);
         this.removeCountForTesting++;
         this.debug();
     }
     async forEach(entityKey, handle) {
         let d = new Date();
         d.setMinutes(d.getMinutes() - 5);
-        this.queries = this.queries.filter(x => x.lastUsed > d.toISOString());
+        this.queries = this.queries.filter((x) => x.lastUsed > d.toISOString());
         for (const q of this.queries) {
             if (q.entityKey === entityKey) {
                 await handle({
                     query: q,
-                    setData: async (data) => { q.data = data; },
+                    setData: async (data) => {
+                        q.data = data;
+                    },
                 });
             }
         }

package/esm/src/remult-proxy.d.ts

@@ -1,2 +1,2 @@
-import type { Remult } from "./context";
+import type { Remult } from './context';
 export declare const remult: Remult;

package/esm/src/remult-proxy.js

@@ -9,7 +9,7 @@ export class RemultProxy {
             let self = this;
             let entityCache = self.repoCache.get(args[0]);
             if (!entityCache) {
-                self.repoCache.set(args[0], entityCache = new Map());
+                self.repoCache.set(args[0], (entityCache = new Map()));
             }
             let result = entityCache.get(args[1]);
             if (result)
@@ -18,43 +18,97 @@ export class RemultProxy {
                 get fields() {
                     return self.remultFactory().repo(...args).metadata.fields;
                 },
-                validate: (a, b) => self.remultFactory().repo(...args).validate(a, b),
-                addEventListener: (...args2) => self.remultFactory().repo(...args).addEventListener(...args2),
-                count: (...args2) => self.remultFactory().repo(...args).count(...args2),
-                create: (...args2) => self.remultFactory().repo(...args).create(...args2),
-                delete: (args2) => self.remultFactory().repo(...args).delete(args2),
-                find: (...args2) => self.remultFactory().repo(...args).find(...args2),
-                findFirst: (...args2) => self.remultFactory().repo(...args).findFirst(...args2),
-                findId: (a, b) => self.remultFactory().repo(...args).findId(a, b),
-                fromJson: (...args2) => self.remultFactory().repo(...args).fromJson(...args2),
-                getEntityRef: (...args2) => self.remultFactory().repo(...args).getEntityRef(...args2),
-                insert: (args2) => self.remultFactory().repo(...args).insert(args2),
-                liveQuery: (...args2) => self.remultFactory().repo(...args).liveQuery(...args2),
+                validate: (a, b) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .validate(a, b),
+                addEventListener: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .addEventListener(...args2),
+                count: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .count(...args2),
+                create: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .create(...args2),
+                delete: (args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .delete(args2),
+                find: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .find(...args2),
+                findFirst: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .findFirst(...args2),
+                findId: (a, b) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .findId(a, b),
+                //@ts-ignore
+                toJson: (json) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .toJson(json),
+                fromJson: (item, isNew) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .fromJson(item, isNew),
+                getEntityRef: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .getEntityRef(...args2),
+                insert: (args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .insert(args2),
+                liveQuery: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .liveQuery(...args2),
                 //@ts-ignore
                 addToCache: (a) => self.remultFactory().repo(...args).addToCache(a),
                 get metadata() {
                     return self.remultFactory().repo(...args).metadata;
                 },
-                query: (...args2) => self.remultFactory().repo(...args).query(...args2),
-                save: (args2) => self.remultFactory().repo(...args).save(args2),
-                update: (a, b) => self.remultFactory().repo(...args).update(a, b),
+                query: (...args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .query(...args2),
+                save: (args2) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .save(args2),
+                update: (a, b) => self
+                    .remultFactory()
+                    .repo(...args)
+                    .update(a, b),
             };
             entityCache.set(args[1], result);
             return result;
         };
     }
     /* @internal*/
-    get liveQuerySubscriber() { return this.remultFactory().liveQuerySubscriber; }
-    ;
+    get liveQuerySubscriber() {
+        return this.remultFactory().liveQuerySubscriber;
+    }
     /* @internal*/
-    set liveQuerySubscriber(val) { this.remultFactory().liveQuerySubscriber = val; }
-    ;
+    set liveQuerySubscriber(val) {
+        this.remultFactory().liveQuerySubscriber = val;
+    }
     /* @internal*/
-    get liveQueryStorage() { return this.remultFactory().liveQueryStorage; }
-    ;
+    get liveQueryStorage() {
+        return this.remultFactory().liveQueryStorage;
+    }
     /* @internal*/
-    set liveQueryStorage(val) { this.remultFactory().liveQueryStorage = val; }
-    ;
+    set liveQueryStorage(val) {
+        this.remultFactory().liveQueryStorage = val;
+    }
     /* @internal*/
     get liveQueryPublisher() {
         return this.remultFactory().liveQueryPublisher;
@@ -69,12 +123,16 @@ export class RemultProxy {
     get context() {
         return this.remultFactory().context;
     }
-    get dataProvider() { return this.remultFactory().dataProvider; }
-    ;
-    set dataProvider(provider) { this.remultFactory().dataProvider = provider; }
+    get dataProvider() {
+        return this.remultFactory().dataProvider;
+    }
+    set dataProvider(provider) {
+        this.remultFactory().dataProvider = provider;
+    }
     /*@internal*/
-    get repCache() { return this.remultFactory().repCache; }
-    ;
+    get repCache() {
+        return this.remultFactory().repCache;
+    }
     authenticated() {
         return this.remultFactory().authenticated();
     }

package/esm/src/remult3/DecoratorReplacer.d.ts

@@ -1,4 +1,4 @@
-import { OmitEB } from "./remult3";
+import { OmitEB } from './remult3';
 declare type Decorator<T = any> = (a: T, b: string, c?: any) => void;
 declare type Decorators<T> = T extends new (...args: any[]) => infer R ? {
     [K in keyof OmitEB<R>]?: Decorator;
@@ -6,5 +6,5 @@ declare type Decorators<T> = T extends new (...args: any[]) => infer R ? {
 declare type StaticDecorators<T> = {
     [K in keyof T]?: Decorator;
 };
-export declare function describeClass<classType>(classType: classType, classDecorator: ((x: any) => any) | undefined, members?: Decorators<classType> | undefined, staticMembers?: StaticDecorators<classType>): void;
+export declare function describeClass<classType>(classType: classType, classDecorator: ((x: any, context?: any) => any) | undefined, members?: Decorators<classType> | undefined, staticMembers?: StaticDecorators<classType>): void;
 export {};