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

package/esm/src/filter/filter-interfaces.js

@@ -14,18 +14,18 @@ export class Filter {
             return await filter();
         return filter;
     }
-    static createCustom(customFilterTranslator, key = '') {
-        let customFilterInfo = { key: key, customFilterTranslator };
+    static createCustom(rawFilterTranslator, key = '') {
+        let rawFilterInfo = { key: key, rawFilterTranslator };
         return Object.assign((x) => {
             let z = {};
             if (x == undefined)
                 x = {};
-            if (!customFilterInfo.key)
+            if (!rawFilterInfo.key)
                 throw "Usage of custom filter before a key was assigned to it";
             return {
-                [customUrlToken + customFilterInfo.key]: x
+                [customUrlToken + rawFilterInfo.key]: x
             };
-        }, { customFilterInfo });
+        }, { rawFilterInfo });
     }
     static fromEntityFilter(entity, whereItem) {
         let result = [];
@@ -79,6 +79,7 @@ export class Filter {
                                             break;
                                         case "$ne":
                                         case "!=":
+                                        case "$nin":
                                             found = true;
                                             if (Array.isArray(element)) {
                                                 result.push(fh.isNotIn(element));
@@ -86,6 +87,10 @@ export class Filter {
                                             else
                                                 result.push(fh.isDifferentFrom(element));
                                             break;
+                                        case "$in":
+                                            found = true;
+                                            result.push(fh.isIn(element));
+                                            break;
                                         case "$contains":
                                             found = true;
                                             result.push(fh.contains(element));
@@ -123,9 +128,9 @@ export class Filter {
             let r = [];
             for (const key in entity.entityType) {
                 const element = entity.entityType[key];
-                if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
-                    if (element.customFilterInfo.key == filterKey) {
-                        r.push(await Filter.fromEntityFilter(entity, await element.customFilterInfo.customFilterTranslator(remult, custom)));
+                if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+                    if (element.rawFilterInfo.key == filterKey) {
+                        r.push(await Filter.fromEntityFilter(entity, await element.rawFilterInfo.rawFilterTranslator(custom, remult)));
                     }
                 }
             }
@@ -259,34 +264,34 @@ export class FilterSerializer {
         }));
     }
     isNull(col) {
-        this.add(col.key + "_null", true);
+        this.add(col.key + ".null", true);
     }
     isNotNull(col) {
-        this.add(col.key + "_null", false);
+        this.add(col.key + ".null", false);
     }
     isIn(col, val) {
-        this.add(col.key + "_in", val.map(x => col.valueConverter.toJson(x)));
+        this.add(col.key + ".in", val.map(x => col.valueConverter.toJson(x)));
     }
     isEqualTo(col, val) {
         this.add(col.key, col.valueConverter.toJson(val));
     }
     isDifferentFrom(col, val) {
-        this.add(col.key + '_ne', col.valueConverter.toJson(val));
+        this.add(col.key + '.ne', col.valueConverter.toJson(val));
     }
     isGreaterOrEqualTo(col, val) {
-        this.add(col.key + '_gte', col.valueConverter.toJson(val));
+        this.add(col.key + '.gte', col.valueConverter.toJson(val));
     }
     isGreaterThan(col, val) {
-        this.add(col.key + '_gt', col.valueConverter.toJson(val));
+        this.add(col.key + '.gt', col.valueConverter.toJson(val));
     }
     isLessOrEqualTo(col, val) {
-        this.add(col.key + '_lte', col.valueConverter.toJson(val));
+        this.add(col.key + '.lte', col.valueConverter.toJson(val));
     }
     isLessThan(col, val) {
-        this.add(col.key + '_lt', col.valueConverter.toJson(val));
+        this.add(col.key + '.lt', col.valueConverter.toJson(val));
     }
     containsCaseInsensitive(col, val) {
-        this.add(col.key + "_contains", val);
+        this.add(col.key + ".contains", val);
     }
 }
 export function entityFilterToJson(entityDefs, where) {
@@ -337,13 +342,13 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
         }
         let c = new filterHelper(col);
         addFilter('', val => val);
-        addFilter('_gt', val => ({ "$gt": val }));
-        addFilter('_gte', val => ({ "$gte": val }));
-        addFilter('_lt', val => ({ "$lt": val }));
-        addFilter('_lte', val => ({ "$lte": val }));
-        addFilter('_ne', val => ({ "$ne": val }));
-        addFilter('_in', val => val, true);
-        var nullFilter = filterInfo.get(col.key + "_null");
+        addFilter('.gt', val => ({ "$gt": val }));
+        addFilter('.gte', val => ({ "$gte": val }));
+        addFilter('.lt', val => ({ "$lt": val }));
+        addFilter('.lte', val => ({ "$lte": val }));
+        addFilter('.ne', val => ({ "$ne": val }));
+        addFilter('.in', val => val, true);
+        var nullFilter = filterInfo.get(col.key + ".null");
         if (nullFilter) {
             nullFilter = nullFilter.toString().trim().toLowerCase();
             switch (nullFilter) {
@@ -357,7 +362,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                     break;
             }
         }
-        addFilter('_contains', val => ({ $contains: val }), false, true);
+        addFilter('.contains', val => ({ $contains: val }), false, true);
     });
     let val = filterInfo.get('OR');
     if (val) {
@@ -370,7 +375,7 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
     }
     for (const key in entity.entityType) {
         const element = entity.entityType[key];
-        if (element && element.customFilterInfo && element.customFilterInfo.customFilterTranslator) {
+        if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
             let custom = filterInfo.get(customUrlToken + key);
             if (custom !== undefined) {
                 where.push({ [customUrlToken + key]: custom });

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

@@ -1,19 +1 @@
-import { FindOptions, Repository, RestDataProviderHttpProvider } from '../../index';
-import { LiveQueryProvider, PubSubClient } from './LiveQuerySubscriber';
-export declare class LiveQueryClient {
-    lqp: LiveQueryProvider;
-    private provider?;
-    wrapMessageHandling: (handleMessage: any) => any;
-    private queries;
-    private channels;
-    constructor(lqp: LiveQueryProvider, provider?: RestDataProviderHttpProvider);
-    runPromise(p: Promise<any>): Promise<any>;
-    close(): void;
-    subscribeChannel<T>(key: string, onResult: (item: T) => void): () => void;
-    timeoutToCloseWhenNotClosed: number;
-    private closeIfNoListeners;
-    subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
-    client: Promise<PubSubClient>;
-    interval: any;
-    private openIfNoOpened;
-}
+export {};

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

@@ -1,16 +1,22 @@
-import { remult as defaultRemult, UrlBuilder } from '../../index';
-import { RestEntityDataProvider } from '../data-providers/rest-data-provider';
+import { RestDataProvider } from '../data-providers/rest-data-provider';
 import { buildRestDataProvider } from "../buildRestDataProvider";
-import { LiveQuerySubscriber, MessageChannel, liveQueryKeepAliveRoute } from './LiveQuerySubscriber';
+import { LiveQuerySubscriber, liveQueryKeepAliveRoute } from './SubscriptionChannel';
+/* @internal*/
 export class LiveQueryClient {
-    constructor(lqp, provider) {
-        this.lqp = lqp;
-        this.provider = provider;
-        this.wrapMessageHandling = handleMessage => handleMessage();
+    constructor(apiProvider) {
+        this.apiProvider = apiProvider;
         this.queries = new Map();
         this.channels = new Map();
         this.timeoutToCloseWhenNotClosed = 1000;
     }
+    wrapMessageHandling(handleMessage) {
+        var x = this.apiProvider().wrapMessageHandling;
+        if (x)
+            x(handleMessage);
+        else
+            handleMessage();
+    }
+    ;
     runPromise(p) {
         return p;
     }
@@ -25,19 +31,31 @@ export class LiveQueryClient {
             let q = this.channels.get(key);
             if (!q) {
                 this.channels.set(key, q = new MessageChannel());
-                this.client.then(c => q.unsubscribe = c.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value))));
+                this.client.then(c => {
+                    try {
+                        q.unsubscribe = c.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
+                            onResult.error(err);
+                        });
+                    }
+                    catch (err) {
+                        onResult.error(err);
+                        throw err;
+                    }
+                });
             }
             q.listeners.push(onResult);
             onUnsubscribe = () => {
                 q.listeners.splice(q.listeners.indexOf(onResult), 1);
                 if (q.listeners.length == 0) {
                     this.channels.delete(key);
+                    q.unsubscribe();
                 }
                 this.closeIfNoListeners();
             };
         });
         return () => {
             onUnsubscribe();
+            onUnsubscribe = () => { };
         };
     }
     closeIfNoListeners() {
@@ -45,7 +63,7 @@ export class LiveQueryClient {
             setTimeout(() => {
                 if (this.client)
                     if (this.queries.size === 0 && this.channels.size === 0) {
-                        this.runPromise(this.client.then(x => x.disconnect()));
+                        this.runPromise(this.client.then(x => x.close()));
                         this.client = undefined;
                         clearInterval(this.interval);
                         this.interval = undefined;
@@ -55,89 +73,91 @@ export class LiveQueryClient {
         }));
     }
     //TODO 1 - consider the time that may pass from the get request to the subscribe to the channel, in some cases this could mean, a call to server to get token and a call to the external provider - it may be some time
-    subscribe(repo, options, onResult) {
-        let alive = true;
+    subscribe(repo, options, listener) {
         let onUnsubscribe = () => { };
-        this.runPromise(this.openIfNoOpened().then(() => repo.buildEntityDataProviderFindOptions(options)
-            .then(opts => {
-            if (!alive)
-                return;
-            const { url, filterObject } = new RestEntityDataProvider(() => defaultRemult.apiClient.url + '/' + repo.metadata.key, () => this.provider, repo.metadata)
-                .buildFindRequest(opts);
-            const eventTypeKey = JSON.stringify({ url, filterObject });
+        this.runPromise(repo.buildEntityDataProviderFindOptions(options)
+            .then(opts => this.openIfNoOpened()
+            .then(() => {
+            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, orderBy: options.orderBy }));
-                url.add("__action", 'liveQuery');
                 q.subscribeCode = () => {
                     if (q.unsubscribe) {
                         q.unsubscribe();
-                        //TODO - consider race scenario where unsubscribe is called before subscribe
+                        //TODO 1- consider race scenario where unsubscribe is called before subscribe
                         q.unsubscribe = () => { };
                     }
-                    const thenResult = (r) => {
-                        this.client.then(c => {
-                            let unsubscribeToChannel = c.subscribe(r.queryChannel, (value) => this.wrapMessageHandling(() => this.runPromise(q.handle(value))));
-                            q.unsubscribe = () => {
-                                unsubscribeToChannel();
-                                const url = new UrlBuilder(defaultRemult.apiClient.url + '/' + repo.metadata.key);
-                                url.add("__action", "endLiveQuery");
-                                this.runPromise(this.provider.post(url.url, {
-                                    id: q.id
-                                }));
-                            };
+                    this.runPromise(subscribe()
+                        .then(r => {
+                        if (q.listeners.length === 0) {
+                            r.unsubscribe();
+                            return;
+                        }
+                        let unsubscribeToChannel = this.subscribeChannel(r.queryChannel, {
+                            next: (value) => this.runPromise(q.handle(value)),
+                            complete: () => { },
+                            error: er => {
+                                q.listeners.forEach(l => l.error(er));
+                            }
                         });
+                        q.unsubscribe = () => {
+                            q.unsubscribe = () => { };
+                            unsubscribeToChannel();
+                            this.runPromise(r.unsubscribe());
+                        };
                         this.runPromise(q.setAllItems(r.result));
-                        q.id = r.queryChannel;
-                    };
-                    if (filterObject) {
-                        this.runPromise(this.provider.post(url.url, filterObject).then(thenResult));
-                    }
-                    else
-                        this.runPromise(this.provider.get(url.url).then(thenResult));
+                        q.queryChannel = r.queryChannel;
+                    })
+                        .catch(err => {
+                        listener.error(err);
+                    }));
                 };
                 q.subscribeCode();
             }
             else {
-                onResult(x => [...q.defaultQueryState]);
+                q.sendDefaultState(listener.next);
             }
-            q.listeners.push(onResult);
+            q.listeners.push(listener);
             onUnsubscribe = () => {
-                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                q.listeners.splice(q.listeners.indexOf(listener), 1);
+                listener.complete();
                 if (q.listeners.length == 0) {
                     this.queries.delete(eventTypeKey);
                     q.unsubscribe();
                 }
                 this.closeIfNoListeners();
             };
-        })));
+        }))
+            .catch(err => {
+            listener.error(err);
+        }));
         return () => {
-            alive = false;
             onUnsubscribe();
         };
     }
     openIfNoOpened() {
-        if (!this.provider) {
-            this.provider = buildRestDataProvider(defaultRemult.apiClient.httpClient);
-        }
         if (!this.client) {
             this.interval = setInterval(async () => {
                 const ids = [];
                 for (const q of this.queries.values()) {
-                    ids.push(q.id);
+                    ids.push(q.queryChannel);
                 }
                 if (ids.length > 0) {
-                    const invalidIds = await this.runPromise(this.provider.post(defaultRemult.apiClient.url + liveQueryKeepAliveRoute, ids));
+                    let p = this.apiProvider();
+                    let { actionInfo } = await import('../server-action');
+                    const invalidIds = await this.runPromise(await actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, ids)));
                     for (const id of invalidIds) {
                         for (const q of this.queries.values()) {
-                            if (q.id === id)
+                            if (q.queryChannel === id)
                                 q.subscribeCode();
                         }
                     }
                 }
             }, 30000);
             return this.runPromise(this.client =
-                this.lqp.openStreamAndReturnCloseFunction(() => {
+                this.apiProvider().subscriptionClient.openConnection(() => {
                     for (const q of this.queries.values()) {
                         q.subscribeCode();
                     }
@@ -146,3 +166,14 @@ export class LiveQueryClient {
         return this.client;
     }
 }
+class MessageChannel {
+    constructor() {
+        this.unsubscribe = () => { };
+        this.listeners = [];
+    }
+    async handle(message) {
+        for (const l of this.listeners) {
+            l.next(message);
+        }
+    }
+}

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

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

package/esm/src/live-query/{EventSourceLiveQueryProvider.js → SseSubscriptionClient.js}

@@ -1,15 +1,16 @@
 import { buildRestDataProvider } from "../buildRestDataProvider";
 import { remult } from "../remult-proxy";
-import { streamUrl } from "./LiveQuerySubscriber";
-export class EventSourceLiveQueryProvider {
-    openStreamAndReturnCloseFunction(onReconnect) {
+import { actionInfo } from "../server-action";
+import { streamUrl } from "./SubscriptionChannel";
+export class SseSubscriptionClient {
+    openConnection(onReconnect) {
         let connectionId;
         const channels = new Map();
         const provider = buildRestDataProvider(remult.apiClient.httpClient);
         let connected = false;
         let source;
         const client = {
-            disconnect() {
+            close() {
                 source.close();
             },
             subscribe(channel, handler) {
@@ -22,10 +23,10 @@ export class EventSourceLiveQueryProvider {
                 return () => {
                     listeners.splice(listeners.indexOf(handler, 1));
                     if (listeners.length == 0) {
-                        provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
+                        actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
                             channel: channel,
                             clientId: connectionId
-                        });
+                        }));
                         channels.delete(channel);
                     }
                 };

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

@@ -0,0 +1,41 @@
+import { Remult } from '../../index';
+export declare const streamUrl = "stream";
+export interface SubscriptionListener<type> {
+    next(message: type): void;
+    error(err: any): void;
+    complete(): void;
+}
+export declare type Unsubscribe = VoidFunction;
+export interface SubscriptionClientConnection {
+    subscribe(channel: string, onMessage: (message: any) => void, onError: (err: any) => void): Unsubscribe;
+    close(): void;
+}
+export interface SubscriptionClient {
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare const liveQueryKeepAliveRoute = "_liveQueryKeepAlive";
+export declare type LiveQueryChange = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export declare class SubscriptionChannel<messageType> {
+    channelKey: string;
+    constructor(channelKey: string);
+    publish(message: messageType, remult?: Remult): void;
+    subscribe(next: (message: messageType) => void, remult?: Remult): any;
+    subscribe(listener: Partial<SubscriptionListener<messageType>>): any;
+}

package/esm/src/live-query/{LiveQuerySubscriber.js → SubscriptionChannel.js}

@@ -1,6 +1,7 @@
 import { remult as defaultRemult, Sort } from '../../index';
 import { getId } from '../remult3/getId';
 export const streamUrl = 'stream';
+//@internal
 export class LiveQuerySubscriber {
     constructor(repo, query) {
         this.repo = repo;
@@ -9,20 +10,40 @@ export class LiveQuerySubscriber {
         this.defaultQueryState = [];
         this.listeners = [];
     }
+    sendDefaultState(onResult) {
+        onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
+    }
     async setAllItems(result) {
         const items = await Promise.all(result.map(item => this.repo.fromJson(item)));
         this.forListeners(listener => {
             listener(x => {
                 return items;
             });
-        });
+        }, this.allItemsMessage(items));
+    }
+    allItemsMessage(items) {
+        return [
+            {
+                type: "all",
+                data: items
+            }
+        ];
     }
-    forListeners(what) {
+    forListeners(what, changes) {
         what(reducer => this.defaultQueryState = reducer(this.defaultQueryState));
         for (const l of this.listeners) {
-            what(l);
+            what(reducer => {
+                l.next(this.createReducerType(reducer, changes));
+            });
         }
     }
+    createReducerType(applyChanges, changes) {
+        return {
+            applyChanges,
+            changes,
+            items: this.defaultQueryState
+        };
+    }
     async handle(messages) {
         for (const m of messages) {
             switch (m.type) {
@@ -68,33 +89,30 @@ export class LiveQuerySubscriber {
                 }
                 return items;
             });
-        });
+        }, messages);
     }
 }
-export class MessageChannel {
-    constructor() {
-        this.unsubscribe = () => { };
-        this.listeners = [];
-    }
-    async handle(message) {
-        for (const l of this.listeners) {
-            l(message);
-        }
-    }
-}
-export const liveQueryKeepAliveRoute = '/_liveQueryKeepAlive';
-//TODO Yoni - keep in remult?
-export class AMessageChannel {
+export const liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
+export class SubscriptionChannel {
     constructor(channelKey) {
         this.channelKey = channelKey;
     }
-    send(what, remult) {
+    publish(message, remult) {
         remult = remult || defaultRemult;
-        remult.liveQueryPublisher.sendChannelMessage(this.channelKey, what);
+        remult.subscriptionServer.publishMessage(this.channelKey, message);
     }
-    subscribe(onValue, remult) {
+    //@internal
+    subscribe(next, remult) {
         remult = remult || defaultRemult;
-        remult.liveQuerySubscriber.subscribeChannel(this.channelKey, onValue);
+        let listener = next;
+        if (typeof (next) === "function") {
+            listener = {
+                next
+            };
+        }
+        listener.error ??= () => { };
+        listener.complete ??= () => { };
+        return remult.liveQuerySubscriber.subscribeChannel(this.channelKey, listener);
     }
 }
 //TODO2 - consider moving the queued job mechanism into this.

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

@@ -0,0 +1,38 @@
+export interface SubscriptionServer {
+    publishMessage<T>(channel: string, message: T): void;
+}
+export interface LiveQueryStorage {
+    add(query: StoredQuery): void;
+    remove(queryId: any): void;
+    forEach(entityKey: string, callback: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
+}
+export declare class InMemoryLiveQueryStorage implements LiveQueryStorage {
+    debugFileSaver: (x: any) => void;
+    debug(): void;
+    keepAliveAndReturnUnknownQueryIds(ids: string[]): Promise<string[]>;
+    queries: (StoredQuery & {
+        lastUsed: string;
+    })[];
+    constructor();
+    add(query: StoredQuery): void;
+    removeCountForTesting: number;
+    remove(id: any): void;
+    forEach(entityKey: string, handle: (args: {
+        query: StoredQuery;
+        setData(data: any): Promise<void>;
+    }) => Promise<void>): Promise<void>;
+}
+export interface StoredQuery {
+    entityKey: string;
+    id: string;
+    data: any;
+}
+export interface QueryData {
+    findOptionsJson: any;
+    requestJson: any;
+    lastIds: any[];
+}