remult 0.18.1-exp.25 → 0.18.1-exp.26

package/esm/graphql.js

@@ -1,17 +1,24 @@
 import { Remult } from ".";
 import { allEntities } from "./src/context";
-import { getEntityKey } from "./src/remult3";
 import { DataApi } from "./src/data-api";
 export function remultGraphql(api) {
     let r = new Remult();
-    let types = '';
+    let types = [];
+    let filterTypes = '';
     let query = '';
     let root = {};
+    function getType(key) {
+        let t = types.find(t => t.key === key);
+        if (!t)
+            types.push((t = ({ fields: "", key, moreFields: "", resultProcessors: [] })));
+        return t;
+    }
     for (const e of allEntities) {
         let meta = r.repo(e).metadata;
-        let fields = '';
         let filterFields = '';
-        let key = getEntityKey(e);
+        let key = meta.key;
+        const t = getType(key);
+        let q = "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
         if (key) {
             for (const f of meta.fields) {
                 {
@@ -19,6 +26,7 @@ export function remultGraphql(api) {
                     switch (f.valueType) {
                         case Boolean:
                             type = "Boolean";
+                            break;
                         case Number:
                             {
                                 if (f.valueConverter?.fieldTypeInDb == 'integer')
@@ -26,8 +34,31 @@ export function remultGraphql(api) {
                                 else
                                     type = "Float";
                             }
+                            break;
+                    }
+                    if (allEntities.includes(f.valueType)) {
+                        const refKey = r.repo(f.valueType).metadata.key;
+                        t.fields += "\n\t" + f.key + ":" + refKey;
+                        t.resultProcessors.push(r => {
+                            const val = r[f.key];
+                            r[f.key] = async (args, req, gqlInfo) => {
+                                const queryResult = await root[refKey]({ ...args.filter, filter: { id: val }, options: { limit: 1 } }, req, gqlInfo);
+                                if (queryResult.length > 0)
+                                    return queryResult[0];
+                                return null;
+                            };
+                        });
+                        let refT = getType(refKey);
+                        refT.moreFields += q;
+                        refT.resultProcessors.push(r => {
+                            const val = r.id;
+                            r[key] = async (args, req, gqlInfo) => {
+                                return await root[key]({ filter: { ...args.filter, [f.key]: val }, options: args.options }, req, gqlInfo);
+                            };
+                        });
                     }
-                    fields += "\n\t" + f.key + ":" + type;
+                    else
+                        t.fields += "\n\t" + f.key + ":" + type;
                     for (const operator of ["", "_ne"]) {
                         filterFields += "\n\t" + f.key + operator + ":" + type;
                     }
@@ -44,41 +75,49 @@ export function remultGraphql(api) {
                     filterFields += "\n\t" + f.key + "_in:[" + type + "]";
                 }
             }
-            types += "type " + key + "{" + fields + "\n}\n";
-            types += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
-            query += "\n\t" + key + "(options: options, filter:" + key + "Filter): [" + key + "]";
-            root[key] = async ({ options, filter }, req) => {
-                let remult = await api.getRemult(req);
-                let repo = remult.repo(e);
-                let dApi = new DataApi(repo, remult);
-                let result;
-                let err;
-                await dApi.getArray({
-                    success: x => result = x,
-                    created: undefined,
-                    deleted: undefined,
-                    error: x => err = x,
-                    forbidden: () => err = 'forbidden',
-                    notFound: () => err = 'not found',
-                    progress: undefined
-                }, {
-                    get: key => {
-                        if (options)
-                            switch (key) {
-                                case "_limit":
-                                    return options.limit;
-                                case "_page":
-                                    return options.page;
-                                case "_sort":
-                                    return options.sort;
-                                case "_order":
-                                    return options.order;
+            filterTypes += "input " + key + "Filter{" + filterFields + "\n\tOR:[" + key + "Filter]\n}\n";
+            query += q;
+            root[key] = async ({ options, filter }, req, a) => {
+                return new Promise(async (res, error) => {
+                    api.withRemult(req, undefined, async () => {
+                        let remult = await api.getRemult(req);
+                        let repo = remult.repo(e);
+                        let dApi = new DataApi(repo, remult);
+                        let result;
+                        let err;
+                        await dApi.getArray({
+                            success: x => result = x.map(y => {
+                                t.resultProcessors.forEach(z => z(y));
+                                return y;
+                            }),
+                            created: undefined,
+                            deleted: undefined,
+                            error: x => err = x,
+                            forbidden: () => err = 'forbidden',
+                            notFound: () => err = 'not found',
+                            progress: undefined
+                        }, {
+                            get: key => {
+                                if (options)
+                                    switch (key) {
+                                        case "_limit":
+                                            return options.limit;
+                                        case "_page":
+                                            return options.page;
+                                        case "_sort":
+                                            return options.sort;
+                                        case "_order":
+                                            return options.order;
+                                    }
                             }
-                    }
-                }, filter);
-                if (err)
-                    throw err;
-                return result;
+                        }, filter);
+                        if (err) {
+                            error(err);
+                            return;
+                        }
+                        res(result);
+                    });
+                });
             };
         }
     }
@@ -88,15 +127,15 @@ export function remultGraphql(api) {
     }
     return {
         rootValue: root,
-        schema: `
+        schema: `${types.map(({ key, fields, moreFields }) => "type " + key + "{" + fields + moreFields + "\n}\n").join('')}
+${query}
+${filterTypes}
 input options{
     limit:Int
     page:Int
     sort:String
     order:String
 }
-${types}
-${query}
 `
     };
 }

package/esm/live-query/ably.js

@@ -7,10 +7,13 @@ export class AblySubscriptionClient {
             close: () => {
                 this.ably.connection.close();
             },
-            subscribe: (channel, handler) => {
+            subscribe: async (channel, handler) => {
                 let myHandler = (y) => handler(y.data);
-                this.ably.channels.get(channel).subscribe(y => myHandler(y));
-                return () => { myHandler = () => { }; };
+                await this.ably.channels.get(channel).subscribe(y => myHandler(y));
+                return () => {
+                    myHandler = () => { };
+                    this.ably.channels.get(channel).unsubscribe();
+                };
             }
         };
     }

package/esm/src/context.js

@@ -19,7 +19,7 @@ export class Remult {
             itemChanged: () => { }
         };
         /* @internal*/
-        this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient);
+        this.liveQuerySubscriber = new LiveQueryClient(() => this.apiClient, () => this.user?.id);
         /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
         this.context = {};
         /** The api client that will be used by `remult` to perform calls to the `api` */

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

@@ -15,7 +15,7 @@ export declare class DataApi<T = any> {
         findOptions: FindOptions<T>;
     }>;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any): Promise<void>;
+    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeRequest: () => any, queryChannel: string): Promise<void>;
     private buildWhere;
     private doOnId;
     put(response: DataApiResponse, id: any, body: any): Promise<void>;
@@ -36,3 +36,4 @@ export interface DataApiRequest {
 }
 export declare function determineSort(sortUrlParm: string, dirUrlParam: string): any;
 export declare function serializeError(data: ErrorInfo): ErrorInfo<any>;
+export declare function getLiveQueryChannel(queryId: string, userId: string): string;

package/esm/src/data-api.js

@@ -1,10 +1,9 @@
-import { v4 as uuid } from 'uuid';
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
 import { doTransaction } from './context';
 import { Filter } from './filter/filter-interfaces';
 import { ForbiddenError } from './server-action';
 import { getId } from './remult3/getId';
-import { findOptionsToJson } from './data-providers/rest-data-provider';
+import { findOptionsToJson, liveQueryAction } from './data-providers/rest-data-provider';
 export class DataApi {
     constructor(repository, remult) {
         this.repository = repository;
@@ -12,9 +11,9 @@ export class DataApi {
     }
     httpGet(res, req, serializeRequest) {
         const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeRequest, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
         switch (action) {
-            case "liveQuery":
-                return this.liveQuery(res, req, undefined, serializeRequest);
             case "get":
             case "count":
                 return this.count(res, req, undefined);
@@ -23,15 +22,15 @@ export class DataApi {
     }
     httpPost(res, req, body, serializeRequest) {
         const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeRequest, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
         switch (action) {
-            case "liveQuery":
-                return this.liveQuery(res, req, body, serializeRequest);
             case "get":
                 return this.getArray(res, req, body);
             case "count":
                 return this.count(res, req, body);
             case "endLiveQuery":
-                this.remult.liveQueryStorage.remove(body.id);
+                this.remult.liveQueryStorage.remove(getLiveQueryChannel(body.id, this.remult.user?.id));
                 res.success("ok");
                 return;
             default:
@@ -122,14 +121,13 @@ export class DataApi {
                 response.error(err);
         }
     }
-    async liveQuery(response, request, filterBody, serializeRequest) {
+    async liveQuery(response, request, filterBody, serializeRequest, queryChannel) {
         if (!this.repository.metadata.apiReadAllowed) {
             response.forbidden();
             return;
         }
         try {
             const r = await this.getArrayImpl(response, request, filterBody);
-            const queryChannel = `users:${this.remult.user?.id}:queries:${uuid()}`;
             const data = {
                 requestJson: serializeRequest(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
@@ -140,10 +138,7 @@ export class DataApi {
                 id: queryChannel,
                 data
             });
-            response.success({
-                queryChannel,
-                result: r.r
-            });
+            response.success(r.r);
         }
         catch (err) {
             if (err.isForbiddenError)
@@ -271,3 +266,6 @@ export function serializeError(data) {
         data = { message: x };
     return data;
 }
+export function getLiveQueryChannel(queryId, userId) {
+    return `users:${userId}:queries:${queryId}`;
+}

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -36,3 +36,4 @@ export declare class RestDataProviderHttpProviderUsingFetch implements RestDataP
     }): Promise<any>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;
+export declare const liveQueryAction = "liveQuery|";

package/esm/src/data-providers/rest-data-provider.js

@@ -117,13 +117,13 @@ export class RestEntityDataProvider {
         return {
             createKey: () => JSON.stringify({ url, filterObject }),
             run,
-            subscribe: async () => {
-                const result = await run("liveQuery");
+            subscribe: async (queryId) => {
+                const result = await run(liveQueryAction + queryId);
                 return {
-                    ...result,
+                    result,
                     unsubscribe: async () => {
                         return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + "?__action=endLiveQuery", {
-                            id: result.queryChannel
+                            id: queryId
                         }));
                     }
                 };
@@ -239,3 +239,4 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     }
     return true;
 }
+export const liveQueryAction = "liveQuery|";

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

@@ -3,11 +3,11 @@ import { buildRestDataProvider } from "../buildRestDataProvider";
 import { LiveQuerySubscriber, liveQueryKeepAliveRoute } from './SubscriptionChannel';
 /* @internal*/
 export class LiveQueryClient {
-    constructor(apiProvider) {
+    constructor(apiProvider, getUserId) {
         this.apiProvider = apiProvider;
+        this.getUserId = getUserId;
         this.queries = new Map();
         this.channels = new Map();
-        this.timeoutToCloseWhenNotClosed = 1000;
     }
     wrapMessageHandling(handleMessage) {
         var x = this.apiProvider().wrapMessageHandling;
@@ -25,23 +25,22 @@ export class LiveQueryClient {
         this.channels.clear();
         this.closeIfNoListeners();
     }
-    subscribeChannel(key, onResult) {
+    async subscribeChannel(key, onResult) {
         let onUnsubscribe = () => { };
-        this.openIfNoOpened().then(() => {
+        const client = await this.openIfNoOpened();
+        try {
             let q = this.channels.get(key);
             if (!q) {
                 this.channels.set(key, q = new MessageChannel());
-                this.client.then(c => {
-                    try {
-                        q.unsubscribe = c.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
-                            onResult.error(err);
-                        });
-                    }
-                    catch (err) {
+                try {
+                    q.unsubscribe = await client.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
                         onResult.error(err);
-                        throw err;
-                    }
-                });
+                    });
+                }
+                catch (err) {
+                    onResult.error(err);
+                    throw err;
+                }
             }
             q.listeners.push(onResult);
             onUnsubscribe = () => {
@@ -52,67 +51,73 @@ export class LiveQueryClient {
                 }
                 this.closeIfNoListeners();
             };
-        });
+        }
+        catch (err) {
+            onResult.error(err);
+            throw err;
+        }
         return () => {
             onUnsubscribe();
             onUnsubscribe = () => { };
         };
     }
     closeIfNoListeners() {
-        this.runPromise(new Promise((res) => {
-            setTimeout(() => {
-                if (this.client)
-                    if (this.queries.size === 0 && this.channels.size === 0) {
-                        this.runPromise(this.client.then(x => x.close()));
-                        this.client = undefined;
-                        clearInterval(this.interval);
-                        this.interval = undefined;
-                    }
-                res({});
-            }, this.timeoutToCloseWhenNotClosed);
-        }));
+        if (this.client)
+            if (this.queries.size === 0 && this.channels.size === 0) {
+                this.runPromise(this.client.then(x => x.close()));
+                this.client = undefined;
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
     }
-    //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, listener) {
-        let onUnsubscribe = () => { };
+        let alive = true;
+        let onUnsubscribe = () => { alive = false; };
         this.runPromise(repo.buildEntityDataProviderFindOptions(options)
-            .then(opts => this.openIfNoOpened()
-            .then(() => {
+            .then(opts => {
+            if (!alive)
+                return;
             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 }));
+                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }, this.getUserId()));
                 q.subscribeCode = () => {
                     if (q.unsubscribe) {
                         q.unsubscribe();
-                        //TODO 1- consider race scenario where unsubscribe is called before subscribe
                         q.unsubscribe = () => { };
                     }
-                    this.runPromise(subscribe()
-                        .then(r => {
-                        if (q.listeners.length === 0) {
-                            r.unsubscribe();
+                    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 => {
+                        if (q.listeners.length == 0) {
+                            unsubscribeToChannel();
                             return;
                         }
-                        let unsubscribeToChannel = this.subscribeChannel(r.queryChannel, {
-                            next: (value) => this.runPromise(q.handle(value)),
-                            complete: () => { },
-                            error: er => {
-                                q.listeners.forEach(l => l.error(er));
+                        this.runPromise(subscribe(q.id)
+                            .then(r => {
+                            if (q.listeners.length === 0) {
+                                r.unsubscribe();
+                                unsubscribeToChannel();
+                                return;
                             }
-                        });
-                        q.unsubscribe = () => {
-                            q.unsubscribe = () => { };
-                            unsubscribeToChannel();
-                            this.runPromise(r.unsubscribe());
-                        };
-                        this.runPromise(q.setAllItems(r.result));
-                        q.queryChannel = r.queryChannel;
-                    })
-                        .catch(err => {
-                        listener.error(err);
-                    }));
+                            this.runPromise(q.setAllItems(r.result));
+                            q.unsubscribe = () => {
+                                q.unsubscribe = () => { };
+                                unsubscribeToChannel();
+                                this.runPromise(r.unsubscribe());
+                            };
+                        })
+                            .catch(err => {
+                            listener.error(err);
+                        }));
+                    })).catch(err => {
+                        q.listeners.forEach(l => l.error(err));
+                    });
                 };
                 q.subscribeCode();
             }
@@ -129,7 +134,7 @@ export class LiveQueryClient {
                 }
                 this.closeIfNoListeners();
             };
-        }))
+        })
             .catch(err => {
             listener.error(err);
         }));

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

@@ -13,11 +13,11 @@ export class SseSubscriptionClient {
             close() {
                 source.close();
             },
-            subscribe(channel, handler) {
+            async subscribe(channel, handler) {
                 let listeners = channels.get(channel);
                 if (!listeners) {
                     channels.set(channel, listeners = []);
-                    subscribeToChannel(channel);
+                    await subscribeToChannel(channel);
                 }
                 listeners.push(handler);
                 return () => {
@@ -69,8 +69,8 @@ export class SseSubscriptionClient {
                 });
             }
         });
-        function subscribeToChannel(channel) {
-            actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
+        async function subscribeToChannel(channel) {
+            return actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
                 channel: channel,
                 clientId: connectionId
             }));

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

@@ -7,7 +7,7 @@ export interface SubscriptionListener<type> {
 }
 export declare type Unsubscribe = VoidFunction;
 export interface SubscriptionClientConnection {
-    subscribe(channel: string, onMessage: (message: any) => void, onError: (err: any) => void): Unsubscribe;
+    subscribe(channel: string, onMessage: (message: any) => void, onError: (err: any) => void): Promise<Unsubscribe>;
     close(): void;
 }
 export interface SubscriptionClient {

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

@@ -1,14 +1,18 @@
 import { remult as defaultRemult, Sort } from '../../index';
 import { getId } from '../remult3/getId';
+import { v4 as uuid } from 'uuid';
+import { getLiveQueryChannel } from '../data-api';
 export const streamUrl = 'stream';
 //@internal
 export class LiveQuerySubscriber {
-    constructor(repo, query) {
+    constructor(repo, query, userId) {
         this.repo = repo;
         this.query = query;
         this.unsubscribe = () => { };
         this.defaultQueryState = [];
         this.listeners = [];
+        this.id = uuid();
+        this.queryChannel = getLiveQueryChannel(this.id, userId);
     }
     sendDefaultState(onResult) {
         onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
@@ -30,7 +34,15 @@ export class LiveQuerySubscriber {
         ];
     }
     forListeners(what, changes) {
-        what(reducer => this.defaultQueryState = reducer(this.defaultQueryState));
+        what(reducer => {
+            this.defaultQueryState = reducer(this.defaultQueryState);
+            if (changes.find(c => c.type === "add" || c.type === "replace")) {
+                if (this.query.orderBy) {
+                    const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.orderBy);
+                    this.defaultQueryState.sort((a, b) => o.compare(a, b));
+                }
+            }
+        });
         for (const l of this.listeners) {
             what(reducer => {
                 l.next(this.createReducerType(reducer, changes));
@@ -59,7 +71,6 @@ export class LiveQuerySubscriber {
             listener(items => {
                 if (!items)
                     items = [];
-                let needSort = false;
                 for (const message of messages) {
                     switch (message.type) {
                         case "all":
@@ -67,13 +78,11 @@ export class LiveQuerySubscriber {
                             break;
                         case "replace": {
                             items = items.map(x => getId(this.repo.metadata, x) === message.data.oldId ? message.data.item : x);
-                            needSort = true;
                             break;
                         }
                         case "add":
                             items = items.filter(x => getId(this.repo.metadata, x) !== getId(this.repo.metadata, message.data.item));
                             items.push(message.data.item);
-                            needSort = true;
                             break;
                         case "remove":
                             items = items.filter(x => getId(this.repo.metadata, x) !== message.data.id);
@@ -81,12 +90,6 @@ export class LiveQuerySubscriber {
                     }
                     ;
                 }
-                if (needSort) {
-                    if (this.query.orderBy) {
-                        const o = Sort.translateOrderByToSort(this.repo.metadata, this.query.orderBy);
-                        items.sort((a, b) => o.compare(a, b));
-                    }
-                }
                 return items;
             });
         }, messages);

package/esm/src/server-action.d.ts

@@ -42,7 +42,7 @@ export interface BackendMethodOptions<type> {
 export declare const actionInfo: {
     allActions: any[];
     runningOnServer: boolean;
-    runActionWithoutBlockingUI: (what: () => Promise<any>) => Promise<any>;
+    runActionWithoutBlockingUI: <T>(what: () => Promise<T>) => Promise<T>;
     startBusyWithProgress: () => {
         progress: (percent: number) => void;
         close: () => void;