remult 0.16.3 → 0.16.4

package/src/live-query/EventSourceLiveQuery.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceLiveQuery = void 0;
+var tslib_1 = require("tslib");
+var LiveQuery_1 = require("./LiveQuery");
+var fetch_event_source_1 = require("@microsoft/fetch-event-source");
+var remult_proxy_1 = require("../remult-proxy");
+var EventSourceLiveQuery = /** @class */ (function (_super) {
+    tslib_1.__extends(EventSourceLiveQuery, _super);
+    function EventSourceLiveQuery(wrapMessage) {
+        var _this = _super.call(this, new EventSourceLiveQueryProvider(wrapMessage)) || this;
+        _this.wrapMessage = wrapMessage;
+        return _this;
+    }
+    return EventSourceLiveQuery;
+}(LiveQuery_1.LiveQueryClient));
+exports.EventSourceLiveQuery = EventSourceLiveQuery;
+var EventSourceLiveQueryProvider = /** @class */ (function () {
+    function EventSourceLiveQueryProvider(wrapMessage, url, jwtToken) {
+        if (url === void 0) { url = undefined; }
+        this.wrapMessage = wrapMessage;
+        this.url = url;
+        this.jwtToken = jwtToken;
+        this.lastId = 0;
+        if (!this.wrapMessage)
+            this.wrapMessage = function (x) { return x(); };
+        if (!this.url) {
+            this.url = remult_proxy_1.remult.apiClient.url + '/' + LiveQuery_1.streamUrl;
+        }
+    }
+    EventSourceLiveQueryProvider.prototype.openStreamAndReturnCloseFunction = function (clientId, onMessage) {
+        var _this = this;
+        var ctrl = new AbortController();
+        var headers = {
+            "client-id": clientId
+        };
+        if (this.jwtToken) {
+            headers["Authorization"] = "Bearer " + this.jwtToken;
+        }
+        fetch_event_source_1.fetchEventSource(this.url, {
+            headers: headers,
+            onmessage: function (message) {
+                var mid = +message.id;
+                if (mid <= _this.lastId && _this.lastId - mid < 10)
+                    return;
+                _this.lastId = mid;
+                console.log(message.data);
+                if (message.event !== 'keep-alive') {
+                    _this.wrapMessage(function () { return onMessage(message); });
+                }
+            },
+            onopen: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                return tslib_1.__generator(this, function (_a) {
+                    return [2 /*return*/];
+                });
+            }); },
+            signal: ctrl.signal,
+        });
+        return function () { return ctrl.abort(); };
+    };
+    return EventSourceLiveQueryProvider;
+}());

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

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

package/src/live-query/EventSourceLiveQueryProvider.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceLiveQueryProvider = void 0;
+var remult_proxy_1 = require("../remult-proxy");
+var LiveQuery_1 = require("./LiveQuery");
+var EventSourceLiveQueryProvider = /** @class */ (function () {
+    function EventSourceLiveQueryProvider(wrapMessage) {
+        this.wrapMessage = wrapMessage;
+        if (!this.wrapMessage)
+            this.wrapMessage = function (x) { return x(); };
+    }
+    EventSourceLiveQueryProvider.prototype.openStreamAndReturnCloseFunction = function (clientId, onMessage) {
+        var _this = this;
+        var source = new EventSource(remult_proxy_1.remult.apiClient.url + '/' + LiveQuery_1.streamUrl + "?id=" + clientId, {
+            withCredentials: true
+        });
+        source.onmessage = function (e) {
+            _this.wrapMessage(function () {
+                return onMessage(JSON.parse(e.data));
+            });
+        };
+        return new Promise(function (res) {
+            source.onopen = function (e) {
+                res(function () {
+                    source.close();
+                });
+            };
+        });
+    };
+    return EventSourceLiveQueryProvider;
+}());
+exports.EventSourceLiveQueryProvider = EventSourceLiveQueryProvider;

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

@@ -0,0 +1,67 @@
+import { EntityOrderBy, FindOptions, Remult, Repository, RestDataProviderHttpProvider } from '../../index';
+import { Allowed } from '../context';
+import { ServerEventDispatcher } from './LiveQueryManager';
+export declare const streamUrl = "stream1";
+export interface LiveQueryProvider {
+    openStreamAndReturnCloseFunction(clientId: string, onMessage: MessageHandler): Promise<VoidFunction>;
+}
+export declare type MessageHandler = (message: {
+    data: any;
+    event: string;
+}) => void;
+export declare class LiveQueryClient {
+    lqp: LiveQueryProvider;
+    private provider?;
+    clientId: 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;
+    private closeIfNoListeners;
+    subscribe<entityType>(repo: Repository<entityType>, options: FindOptions<entityType>, onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): () => void;
+    closeListener: Promise<VoidFunction>;
+    private openIfNoOpened;
+}
+export declare type listener = (message: any) => void;
+export interface SubscribeToQueryArgs<entityType = any> {
+    entityKey: string;
+    orderBy?: EntityOrderBy<entityType>;
+}
+export declare type liveQueryMessage = {
+    type: "all";
+    data: any[];
+} | {
+    type: "add";
+    data: any;
+} | {
+    type: 'replace';
+    data: {
+        oldId: any;
+        item: any;
+    };
+} | {
+    type: "remove";
+    data: {
+        id: any;
+    };
+};
+export interface SubscribeResult {
+    result: [];
+    id: string;
+}
+export interface ChannelSubscribe {
+    clientId: string;
+    channel: string;
+    remove: boolean;
+}
+export declare class AMessageChannel<messageType> {
+    private subscribedAllowed;
+    userCanSubscribe(channel: string, remult: Remult): boolean;
+    private key;
+    constructor(key: (string | ((remult: Remult) => string)), subscribedAllowed: Allowed);
+    send(what: messageType, remult?: Remult): void;
+    subscribe(client: LiveQueryClient, onValue: (value: messageType) => void, remult?: Remult): void;
+    dispatcher: ServerEventDispatcher;
+}

package/src/live-query/LiveQuery.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AMessageChannel = exports.LiveQueryClient = exports.streamUrl = void 0;
+var tslib_1 = require("tslib");
+var index_1 = require("../../index");
+var uuid_1 = require("uuid");
+var rest_data_provider_1 = require("../data-providers/rest-data-provider");
+var context_1 = require("../context");
+exports.streamUrl = 'stream1';
+var LiveQueryOnFrontEnd = /** @class */ (function () {
+    function LiveQueryOnFrontEnd(repo, query) {
+        this.repo = repo;
+        this.query = query;
+        this.items = [];
+        this.listeners = [];
+    }
+    LiveQueryOnFrontEnd.prototype.setAllItems = function (result) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var items;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(result.map(function (item) { return _this.repo.fromJson(item); }))];
+                    case 1:
+                        items = _a.sent();
+                        this.forListeners(function (listener) {
+                            listener(function (x) {
+                                return items;
+                            });
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LiveQueryOnFrontEnd.prototype.forListeners = function (what) {
+        var e_1, _a;
+        try {
+            for (var _b = tslib_1.__values(this.listeners), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var l = _c.value;
+                what(l);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    LiveQueryOnFrontEnd.prototype.handle = function (message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var sort, _a, item_1, item_2;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        sort = function (items) {
+                            if (_this.query.orderBy) {
+                                var o_1 = index_1.Sort.translateOrderByToSort(_this.repo.metadata, _this.query.orderBy);
+                                items.sort(function (a, b) { return o_1.compare(a, b); });
+                            }
+                            return items;
+                        };
+                        _a = message.type;
+                        switch (_a) {
+                            case "all": return [3 /*break*/, 1];
+                            case "replace": return [3 /*break*/, 2];
+                            case "add": return [3 /*break*/, 4];
+                            case "remove": return [3 /*break*/, 6];
+                        }
+                        return [3 /*break*/, 7];
+                    case 1:
+                        this.setAllItems(message.data);
+                        return [3 /*break*/, 7];
+                    case 2: return [4 /*yield*/, this.repo.fromJson(message.data.item)];
+                    case 3:
+                        item_1 = _b.sent();
+                        this.forListeners(function (listener) {
+                            listener(function (items) {
+                                if (!items)
+                                    items = [];
+                                return sort(items.map(function (x) { return _this.repo.getEntityRef(x).getId() === message.data.oldId ? item_1 : x; }));
+                            });
+                        });
+                        return [3 /*break*/, 7];
+                    case 4: return [4 /*yield*/, this.repo.fromJson(message.data.item)];
+                    case 5:
+                        item_2 = _b.sent();
+                        this.forListeners(function (listener) {
+                            return listener(function (items) {
+                                if (!items)
+                                    items = [];
+                                items.push(item_2);
+                                return sort(items);
+                            });
+                        });
+                        return [3 /*break*/, 7];
+                    case 6:
+                        this.forListeners(function (listener) {
+                            return listener(function (items) {
+                                if (!items)
+                                    items = [];
+                                return _this.items.filter(function (x) { return index_1.getEntityRef(x).getId() !== message.data.id; });
+                            });
+                        });
+                        return [3 /*break*/, 7];
+                    case 7:
+                        ;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LiveQueryOnFrontEnd;
+}());
+var MessageChannel = /** @class */ (function () {
+    function MessageChannel() {
+        this.listeners = [];
+    }
+    MessageChannel.prototype.handle = function (message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, l;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                try {
+                    for (_a = tslib_1.__values(this.listeners), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        l = _b.value;
+                        l(message);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MessageChannel;
+}());
+var LiveQueryClient = /** @class */ (function () {
+    function LiveQueryClient(lqp, provider) {
+        this.lqp = lqp;
+        this.provider = provider;
+        this.clientId = uuid_1.v4();
+        this.queries = new Map();
+        this.channels = new Map();
+    }
+    LiveQueryClient.prototype.runPromise = function (p) {
+        return p;
+    };
+    LiveQueryClient.prototype.close = function () {
+        this.queries.clear();
+        this.channels.clear();
+        this.closeIfNoListeners();
+    };
+    LiveQueryClient.prototype.subscribeChannel = function (key, onResult) {
+        var _this = this;
+        var onUnsubscribe = function () { };
+        this.openIfNoOpened().then(function () {
+            var q = _this.channels.get(key);
+            if (!q) {
+                _this.channels.set(key, q = new MessageChannel());
+                _this.provider.post(index_1.remult.apiClient.url + '/' + exports.streamUrl, {
+                    channel: key,
+                    clientId: _this.clientId,
+                    remove: false
+                });
+            }
+            else {
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = function () {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    _this.channels.delete(key);
+                }
+                _this.closeIfNoListeners();
+            };
+        });
+        return function () {
+            onUnsubscribe();
+        };
+    };
+    LiveQueryClient.prototype.closeIfNoListeners = function () {
+        if (this.queries.size === 0 && this.channels.size === 0) {
+            this.runPromise(this.closeListener.then(function (x) { return x(); }));
+            this.closeListener = undefined;
+        }
+    };
+    LiveQueryClient.prototype.subscribe = function (repo, options, onResult) {
+        var _this = this;
+        var alive = true;
+        var onUnsubscribe = function () { };
+        this.runPromise(this.openIfNoOpened().then(function () { return repo.buildEntityDataProviderFindOptions(options)
+            .then(function (opts) {
+            if (!alive)
+                return;
+            var _a = new rest_data_provider_1.RestEntityDataProvider(function () { return index_1.remult.apiClient.url + '/' + repo.metadata.key; }, function () { return _this.provider; }, repo.metadata)
+                .buildFindRequest(opts), url = _a.url, filterObject = _a.filterObject;
+            var eventTypeKey = JSON.stringify({ url: url, filterObject: filterObject });
+            var q = _this.queries.get(eventTypeKey);
+            if (!q) {
+                _this.queries.set(eventTypeKey, q = new LiveQueryOnFrontEnd(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }));
+                url.add("__action", 'subscribe|' + _this.clientId);
+                var thenResult = function (r) {
+                    _this.runPromise(q.setAllItems(r.result));
+                    q.id = r.id;
+                };
+                if (filterObject) {
+                    _this.runPromise(_this.provider.post(url.url, filterObject).then(thenResult));
+                }
+                else
+                    _this.runPromise(_this.provider.get(url.url).then(thenResult));
+            }
+            else {
+                onResult(function (x) { return q.items; });
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = function () {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    _this.queries.delete(eventTypeKey);
+                }
+                _this.closeIfNoListeners();
+            };
+        }); }));
+        return function () {
+            alive = false;
+            onUnsubscribe();
+        };
+    };
+    LiveQueryClient.prototype.openIfNoOpened = function () {
+        var _this = this;
+        if (!this.provider) {
+            this.provider = context_1.buildRestDataProvider(index_1.remult.apiClient.httpClient);
+        }
+        if (!this.closeListener)
+            return this.runPromise(this.closeListener = this.lqp.openStreamAndReturnCloseFunction(this.clientId, function (message) {
+                var e_3, _a;
+                try {
+                    for (var _b = tslib_1.__values(_this.queries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var q = _c.value;
+                        if (q.id === message.event) {
+                            _this.runPromise(q.handle(message.data));
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                var channel = _this.channels.get(message.event);
+                if (channel) {
+                    channel.handle(message.data);
+                }
+            }));
+        return this.closeListener;
+    };
+    return LiveQueryClient;
+}());
+exports.LiveQueryClient = LiveQueryClient;
+var AMessageChannel = /** @class */ (function () {
+    function AMessageChannel(key, subscribedAllowed) {
+        this.subscribedAllowed = subscribedAllowed;
+        if (typeof key === "string")
+            this.key = function () { return key; };
+        else
+            this.key = key;
+    }
+    AMessageChannel.prototype.userCanSubscribe = function (channel, remult) {
+        if (!remult)
+            remult = index_1.remult;
+        if (channel == this.key(remult) && remult.isAllowed(this.subscribedAllowed))
+            return true;
+        return false;
+    };
+    AMessageChannel.prototype.send = function (what, remult) {
+        if (!this.dispatcher)
+            throw new Error("Message couldn't be send since no dispatcher was set");
+        this.dispatcher.sendChannelMessage(this.key(remult || index_1.remult), what);
+    };
+    AMessageChannel.prototype.subscribe = function (client, onValue, remult) {
+        client.subscribeChannel(this.key(remult || index_1.remult), onValue);
+    };
+    return AMessageChannel;
+}());
+exports.AMessageChannel = AMessageChannel;
+/*
+[V] use entity normal http route for this - with __action.
+[] move id from header to url in stream registration.
+[] transaction accumulates messages.
+[] on unsubscribe, also unsubscribe on server
+[] consolidate channel & query
+[] fix stream api url on server
+[] remove client id from header
+*/ 

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

@@ -0,0 +1,33 @@
+import { Remult } from '../..';
+import { Repository, EntityRef, FindOptions } from '../remult3';
+import { LiveQueryProvider } from '../data-api';
+import { liveQueryMessage } from './LiveQuery';
+export declare class LiveQueryManager 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;
+    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;
+}