remult 0.17.2 → 0.18.0

package/src/live-query/LiveQueryClient.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveQueryClient = void 0;
+var tslib_1 = require("tslib");
+var rest_data_provider_1 = require("../data-providers/rest-data-provider");
+var buildRestDataProvider_1 = require("../buildRestDataProvider");
+var SubscriptionChannel_1 = require("./SubscriptionChannel");
+/* @internal*/
+var LiveQueryClient = /** @class */ (function () {
+    function LiveQueryClient(apiProvider, getUserId) {
+        this.apiProvider = apiProvider;
+        this.getUserId = getUserId;
+        this.queries = new Map();
+        this.channels = new Map();
+    }
+    LiveQueryClient.prototype.wrapMessageHandling = function (handleMessage) {
+        var x = this.apiProvider().wrapMessageHandling;
+        if (x)
+            x(handleMessage);
+        else
+            handleMessage();
+    };
+    ;
+    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) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var onUnsubscribe, client, q_1, _a, err_1, err_2;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        onUnsubscribe = function () { };
+                        return [4 /*yield*/, this.openIfNoOpened()];
+                    case 1:
+                        client = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 7, , 8]);
+                        q_1 = this.channels.get(key);
+                        if (!!q_1) return [3 /*break*/, 6];
+                        this.channels.set(key, q_1 = new MessageChannel());
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        _a = q_1;
+                        return [4 /*yield*/, client.subscribe(key, function (value) { return _this.wrapMessageHandling(function () { return q_1.handle(value); }); }, function (err) {
+                                onResult.error(err);
+                            })];
+                    case 4:
+                        _a.unsubscribe = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        err_1 = _b.sent();
+                        onResult.error(err_1);
+                        throw err_1;
+                    case 6:
+                        q_1.listeners.push(onResult);
+                        onUnsubscribe = function () {
+                            q_1.listeners.splice(q_1.listeners.indexOf(onResult), 1);
+                            if (q_1.listeners.length == 0) {
+                                _this.channels.delete(key);
+                                q_1.unsubscribe();
+                            }
+                            _this.closeIfNoListeners();
+                        };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        err_2 = _b.sent();
+                        onResult.error(err_2);
+                        throw err_2;
+                    case 8: return [2 /*return*/, function () {
+                            onUnsubscribe();
+                            onUnsubscribe = function () { };
+                        }];
+                }
+            });
+        });
+    };
+    LiveQueryClient.prototype.closeIfNoListeners = function () {
+        if (this.client)
+            if (this.queries.size === 0 && this.channels.size === 0) {
+                this.runPromise(this.client.then(function (x) { return x.close(); }));
+                this.client = undefined;
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+    };
+    LiveQueryClient.prototype.subscribe = function (repo, options, listener) {
+        var _this = this;
+        var alive = true;
+        var onUnsubscribe = function () { alive = false; };
+        this.runPromise(repo.buildEntityDataProviderFindOptions(options)
+            .then(function (opts) {
+            if (!alive)
+                return;
+            var _a = new rest_data_provider_1.RestDataProvider(_this.apiProvider).getEntityDataProvider(repo.metadata).buildFindRequest(opts), createKey = _a.createKey, subscribe = _a.subscribe;
+            var eventTypeKey = createKey();
+            var q = _this.queries.get(eventTypeKey);
+            if (!q) {
+                _this.queries.set(eventTypeKey, q = new SubscriptionChannel_1.LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, orderBy: options.orderBy }, _this.getUserId()));
+                q.subscribeCode = function () {
+                    if (q.unsubscribe) {
+                        q.unsubscribe();
+                        q.unsubscribe = function () { };
+                    }
+                    _this.runPromise(_this.subscribeChannel(q.queryChannel, {
+                        next: function (value) { return _this.runPromise(q.handle(value)); },
+                        complete: function () { },
+                        error: function (er) {
+                            q.listeners.forEach(function (l) { return l.error(er); });
+                        }
+                    }).then(function (unsubscribeToChannel) {
+                        if (q.listeners.length == 0) {
+                            unsubscribeToChannel();
+                            return;
+                        }
+                        _this.runPromise(subscribe(q.id)
+                            .then(function (r) {
+                            if (q.listeners.length === 0) {
+                                r.unsubscribe();
+                                unsubscribeToChannel();
+                                return;
+                            }
+                            _this.runPromise(q.setAllItems(r.result));
+                            q.unsubscribe = function () {
+                                q.unsubscribe = function () { };
+                                unsubscribeToChannel();
+                                _this.runPromise(r.unsubscribe());
+                            };
+                        })
+                            .catch(function (err) {
+                            listener.error(err);
+                        }));
+                    })).catch(function (err) {
+                        q.listeners.forEach(function (l) { return l.error(err); });
+                    });
+                };
+                q.subscribeCode();
+            }
+            else {
+                q.sendDefaultState(listener.next);
+            }
+            q.listeners.push(listener);
+            onUnsubscribe = function () {
+                q.listeners.splice(q.listeners.indexOf(listener), 1);
+                listener.complete();
+                if (q.listeners.length == 0) {
+                    _this.queries.delete(eventTypeKey);
+                    q.unsubscribe();
+                }
+                _this.closeIfNoListeners();
+            };
+        })
+            .catch(function (err) {
+            listener.error(err);
+        }));
+        return function () {
+            onUnsubscribe();
+        };
+    };
+    LiveQueryClient.prototype.openIfNoOpened = function () {
+        var _this = this;
+        if (!this.client) {
+            this.interval = setInterval(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var ids, _a, _b, q, p_1, actionInfo, invalidIds, _c, invalidIds_1, invalidIds_1_1, id, _d, _e, q;
+                var e_1, _f, e_2, _g, e_3, _h;
+                return tslib_1.__generator(this, function (_j) {
+                    switch (_j.label) {
+                        case 0:
+                            ids = [];
+                            try {
+                                for (_a = tslib_1.__values(this.queries.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                    q = _b.value;
+                                    ids.push(q.queryChannel);
+                                }
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                            }
+                            if (!(ids.length > 0)) return [3 /*break*/, 4];
+                            p_1 = this.apiProvider();
+                            return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('../server-action')); })];
+                        case 1:
+                            actionInfo = (_j.sent()).actionInfo;
+                            _c = this.runPromise;
+                            return [4 /*yield*/, actionInfo.runActionWithoutBlockingUI(function () { return buildRestDataProvider_1.buildRestDataProvider(p_1.httpClient).post(p_1.url + '/' + SubscriptionChannel_1.liveQueryKeepAliveRoute, ids); })];
+                        case 2: return [4 /*yield*/, _c.apply(this, [_j.sent()])];
+                        case 3:
+                            invalidIds = _j.sent();
+                            try {
+                                for (invalidIds_1 = tslib_1.__values(invalidIds), invalidIds_1_1 = invalidIds_1.next(); !invalidIds_1_1.done; invalidIds_1_1 = invalidIds_1.next()) {
+                                    id = invalidIds_1_1.value;
+                                    try {
+                                        for (_d = (e_3 = void 0, tslib_1.__values(this.queries.values())), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                            q = _e.value;
+                                            if (q.queryChannel === id)
+                                                q.subscribeCode();
+                                        }
+                                    }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                    finally {
+                                        try {
+                                            if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                    }
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (invalidIds_1_1 && !invalidIds_1_1.done && (_g = invalidIds_1.return)) _g.call(invalidIds_1);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                            _j.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            }); }, 30000);
+            return this.runPromise(this.client =
+                this.apiProvider().subscriptionClient.openConnection(function () {
+                    var e_4, _a;
+                    try {
+                        for (var _b = tslib_1.__values(_this.queries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var q = _c.value;
+                            q.subscribeCode();
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }));
+        }
+        return this.client;
+    };
+    return LiveQueryClient;
+}());
+exports.LiveQueryClient = LiveQueryClient;
+var MessageChannel = /** @class */ (function () {
+    function MessageChannel() {
+        this.unsubscribe = function () { };
+        this.listeners = [];
+    }
+    MessageChannel.prototype.handle = function (message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, l;
+            var e_5, _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.next(message);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MessageChannel;
+}());

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

@@ -0,0 +1,5 @@
+import { SubscriptionClient, SubscriptionClientConnection } from "./SubscriptionChannel";
+export declare class SseSubscriptionClient implements SubscriptionClient {
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare const ConnectionNotFoundError = "client connection not found";

package/src/live-query/SseSubscriptionClient.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionNotFoundError = exports.SseSubscriptionClient = void 0;
+var tslib_1 = require("tslib");
+var buildRestDataProvider_1 = require("../buildRestDataProvider");
+var remult_proxy_1 = require("../remult-proxy");
+var server_action_1 = require("../server-action");
+var SubscriptionChannel_1 = require("./SubscriptionChannel");
+var SseSubscriptionClient = /** @class */ (function () {
+    function SseSubscriptionClient() {
+    }
+    SseSubscriptionClient.prototype.openConnection = function (onReconnect) {
+        var connectionId;
+        var channels = new Map();
+        var provider = buildRestDataProvider_1.buildRestDataProvider(remult_proxy_1.remult.apiClient.httpClient);
+        var connected = false;
+        var source;
+        var client = {
+            close: function () {
+                source.close();
+            },
+            subscribe: function (channel, handler) {
+                return tslib_1.__awaiter(this, void 0, void 0, function () {
+                    var listeners;
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                listeners = channels.get(channel);
+                                if (!!listeners) return [3 /*break*/, 2];
+                                channels.set(channel, listeners = []);
+                                return [4 /*yield*/, subscribeToChannel(channel)];
+                            case 1:
+                                _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                listeners.push(handler);
+                                return [2 /*return*/, function () {
+                                        listeners.splice(listeners.indexOf(handler, 1));
+                                        if (listeners.length == 0) {
+                                            server_action_1.actionInfo.runActionWithoutBlockingUI(function () { return provider.post(remult_proxy_1.remult.apiClient.url + '/' + SubscriptionChannel_1.streamUrl + '/unsubscribe', {
+                                                channel: channel,
+                                                clientId: connectionId
+                                            }); });
+                                            channels.delete(channel);
+                                        }
+                                    }];
+                        }
+                    });
+                });
+            },
+        };
+        var createConnectionPromise = function () { return new Promise(function (res) {
+            createConnection();
+            function createConnection() {
+                var _this = this;
+                if (source)
+                    source.close();
+                source = new EventSource(remult_proxy_1.remult.apiClient.url + '/' + SubscriptionChannel_1.streamUrl, {
+                    withCredentials: true
+                });
+                source.onmessage = function (e) {
+                    var message = JSON.parse(e.data);
+                    var listeners = channels.get(message.channel);
+                    if (listeners)
+                        listeners.forEach(function (x) { return x(message.data); });
+                };
+                source.onerror = function (e) {
+                    console.error("Live Query Event Source Error", e);
+                    source.close();
+                    setTimeout(function () {
+                        createConnection();
+                    }, 500);
+                };
+                source.addEventListener("connectionId", function (e) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var _a, _b, channel, e_1_1;
+                    var e_1, _c;
+                    return tslib_1.__generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                //@ts-ignore
+                                connectionId = e.data;
+                                if (!connected) return [3 /*break*/, 9];
+                                _d.label = 1;
+                            case 1:
+                                _d.trys.push([1, 6, 7, 8]);
+                                _a = tslib_1.__values(channels.keys()), _b = _a.next();
+                                _d.label = 2;
+                            case 2:
+                                if (!!_b.done) return [3 /*break*/, 5];
+                                channel = _b.value;
+                                return [4 /*yield*/, subscribeToChannel(channel)];
+                            case 3:
+                                _d.sent();
+                                _d.label = 4;
+                            case 4:
+                                _b = _a.next();
+                                return [3 /*break*/, 2];
+                            case 5: return [3 /*break*/, 8];
+                            case 6:
+                                e_1_1 = _d.sent();
+                                e_1 = { error: e_1_1 };
+                                return [3 /*break*/, 8];
+                            case 7:
+                                try {
+                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                                return [7 /*endfinally*/];
+                            case 8:
+                                onReconnect();
+                                return [3 /*break*/, 10];
+                            case 9:
+                                connected = true;
+                                res(client);
+                                _d.label = 10;
+                            case 10: return [2 /*return*/];
+                        }
+                    });
+                }); });
+            }
+        }); };
+        return createConnectionPromise();
+        function subscribeToChannel(channel) {
+            return tslib_1.__awaiter(this, void 0, void 0, function () {
+                var result;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, server_action_1.actionInfo.runActionWithoutBlockingUI(function () {
+                                return provider.post(remult_proxy_1.remult.apiClient.url + '/' + SubscriptionChannel_1.streamUrl + '/subscribe', {
+                                    channel: channel,
+                                    clientId: connectionId
+                                });
+                            })];
+                        case 1:
+                            result = _a.sent();
+                            if (!(result === exports.ConnectionNotFoundError)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, createConnectionPromise()];
+                        case 2:
+                            _a.sent();
+                            _a.label = 3;
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    };
+    return SseSubscriptionClient;
+}());
+exports.SseSubscriptionClient = SseSubscriptionClient;
+exports.ConnectionNotFoundError = "client connection not found";

package/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): Promise<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;
+}