remult 0.17.3 → 0.18.0

package/src/live-query/SubscriptionChannel.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionChannel = exports.liveQueryKeepAliveRoute = exports.LiveQuerySubscriber = exports.streamUrl = void 0;
+var tslib_1 = require("tslib");
+var index_1 = require("../../index");
+var getId_1 = require("../remult3/getId");
+var uuid_1 = require("uuid");
+var data_api_1 = require("../data-api");
+exports.streamUrl = 'stream';
+//@internal
+var LiveQuerySubscriber = /** @class */ (function () {
+    function LiveQuerySubscriber(repo, query, userId) {
+        this.repo = repo;
+        this.query = query;
+        this.unsubscribe = function () { };
+        this.defaultQueryState = [];
+        this.listeners = [];
+        this.id = uuid_1.v4();
+        this.queryChannel = data_api_1.getLiveQueryChannel(this.id, userId);
+    }
+    LiveQuerySubscriber.prototype.sendDefaultState = function (onResult) {
+        var _this = this;
+        onResult(this.createReducerType(function () { return tslib_1.__spread(_this.defaultQueryState); }, this.allItemsMessage(this.defaultQueryState)));
+    };
+    LiveQuerySubscriber.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;
+                            });
+                        }, this.allItemsMessage(items));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LiveQuerySubscriber.prototype.allItemsMessage = function (items) {
+        return [
+            {
+                type: "all",
+                data: items
+            }
+        ];
+    };
+    LiveQuerySubscriber.prototype.forListeners = function (what, changes) {
+        var e_1, _a;
+        var _this = this;
+        what(function (reducer) {
+            _this.defaultQueryState = reducer(_this.defaultQueryState);
+            if (changes.find(function (c) { return c.type === "add" || c.type === "replace"; })) {
+                if (_this.query.orderBy) {
+                    var o_1 = index_1.Sort.translateOrderByToSort(_this.repo.metadata, _this.query.orderBy);
+                    _this.defaultQueryState.sort(function (a, b) { return o_1.compare(a, b); });
+                }
+            }
+        });
+        var _loop_1 = function (l) {
+            what(function (reducer) {
+                l.next(_this.createReducerType(reducer, changes));
+            });
+        };
+        try {
+            for (var _b = tslib_1.__values(this.listeners), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var l = _c.value;
+                _loop_1(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; }
+        }
+    };
+    LiveQuerySubscriber.prototype.createReducerType = function (applyChanges, changes) {
+        return {
+            applyChanges: applyChanges,
+            changes: changes,
+            items: this.defaultQueryState
+        };
+    };
+    LiveQuerySubscriber.prototype.handle = function (messages) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var messages_1, messages_1_1, m, _a, _b, e_2_1;
+            var e_2, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 7, 8, 9]);
+                        messages_1 = tslib_1.__values(messages), messages_1_1 = messages_1.next();
+                        _d.label = 1;
+                    case 1:
+                        if (!!messages_1_1.done) return [3 /*break*/, 6];
+                        m = messages_1_1.value;
+                        _a = m.type;
+                        switch (_a) {
+                            case "add": return [3 /*break*/, 2];
+                            case "replace": return [3 /*break*/, 2];
+                            case "all": return [3 /*break*/, 4];
+                        }
+                        return [3 /*break*/, 5];
+                    case 2:
+                        _b = m.data;
+                        return [4 /*yield*/, this.repo.fromJson(m.data.item)];
+                    case 3:
+                        _b.item = _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        this.setAllItems(m.data);
+                        _d.label = 5;
+                    case 5:
+                        messages_1_1 = messages_1.next();
+                        return [3 /*break*/, 1];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (messages_1_1 && !messages_1_1.done && (_c = messages_1.return)) _c.call(messages_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this.forListeners(function (listener) {
+                            listener(function (items) {
+                                var e_3, _a;
+                                if (!items)
+                                    items = [];
+                                var _loop_2 = function (message) {
+                                    switch (message.type) {
+                                        case "all":
+                                            _this.setAllItems(message.data);
+                                            break;
+                                        case "replace": {
+                                            items = items.map(function (x) { return getId_1.getId(_this.repo.metadata, x) === message.data.oldId ? message.data.item : x; });
+                                            break;
+                                        }
+                                        case "add":
+                                            items = items.filter(function (x) { return getId_1.getId(_this.repo.metadata, x) !== getId_1.getId(_this.repo.metadata, message.data.item); });
+                                            items.push(message.data.item);
+                                            break;
+                                        case "remove":
+                                            items = items.filter(function (x) { return getId_1.getId(_this.repo.metadata, x) !== message.data.id; });
+                                            break;
+                                    }
+                                    ;
+                                };
+                                try {
+                                    for (var messages_2 = tslib_1.__values(messages), messages_2_1 = messages_2.next(); !messages_2_1.done; messages_2_1 = messages_2.next()) {
+                                        var message = messages_2_1.value;
+                                        _loop_2(message);
+                                    }
+                                }
+                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                finally {
+                                    try {
+                                        if (messages_2_1 && !messages_2_1.done && (_a = messages_2.return)) _a.call(messages_2);
+                                    }
+                                    finally { if (e_3) throw e_3.error; }
+                                }
+                                return items;
+                            });
+                        }, messages);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LiveQuerySubscriber;
+}());
+exports.LiveQuerySubscriber = LiveQuerySubscriber;
+exports.liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
+var SubscriptionChannel = /** @class */ (function () {
+    function SubscriptionChannel(channelKey) {
+        this.channelKey = channelKey;
+    }
+    SubscriptionChannel.prototype.publish = function (message, remult) {
+        remult = remult || index_1.remult;
+        remult.subscriptionServer.publishMessage(this.channelKey, message);
+    };
+    //@internal
+    SubscriptionChannel.prototype.subscribe = function (next, remult) {
+        var _a, _b;
+        remult = remult || index_1.remult;
+        var listener = next;
+        if (typeof (next) === "function") {
+            listener = {
+                next: next
+            };
+        }
+        (_a = listener.error) !== null && _a !== void 0 ? _a : (listener.error = function () { });
+        (_b = listener.complete) !== null && _b !== void 0 ? _b : (listener.complete = function () { });
+        return remult.liveQuerySubscriber.subscribeChannel(this.channelKey, listener);
+    };
+    return SubscriptionChannel;
+}());
+exports.SubscriptionChannel = SubscriptionChannel;
+//TODO2 - consider moving the queued job mechanism into this.

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

@@ -0,0 +1,38 @@
+export interface SubscriptionServer {
+    publishMessage<T>(channel: string, message: T): Promise<void>;
+}
+export interface LiveQueryStorage {
+    add(query: StoredQuery): Promise<void>;
+    remove(queryId: string): Promise<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): Promise<void>;
+    removeCountForTesting: number;
+    remove(id: any): Promise<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[];
+}

package/src/live-query/SubscriptionServer.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLiveQueryStorage = exports.LiveQueryPublisher = void 0;
+var tslib_1 = require("tslib");
+var rest_data_provider_1 = require("../data-providers/rest-data-provider");
+/* @internal*/
+var LiveQueryPublisher = /** @class */ (function () {
+    function LiveQueryPublisher(subscriptionServer, liveQueryStorage, performWithRequest) {
+        this.subscriptionServer = subscriptionServer;
+        this.liveQueryStorage = liveQueryStorage;
+        this.performWithRequest = performWithRequest;
+        this.debugFileSaver = function (x) { };
+    }
+    LiveQueryPublisher.prototype.runPromise = function (p) { };
+    LiveQueryPublisher.prototype.itemChanged = function (entityKey, changes) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    //TODO 2 - optimize so that the user will get their messages first. Based on user id
+                    return [4 /*yield*/, (this.liveQueryStorage().forEach(entityKey, function (_a) {
+                            var q = _a.query, setData = _a.setData;
+                            return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var query;
+                                var _this = this;
+                                return tslib_1.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            query = tslib_1.__assign({}, q.data);
+                                            return [4 /*yield*/, this.performWithRequest(query.requestJson, entityKey, function (repo) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                    var messages, currentItems, currentIds, _loop_1, _a, _b, id, _loop_2, currentItems_1, currentItems_1_1, item;
+                                                    var e_1, _c, e_2, _d;
+                                                    return tslib_1.__generator(this, function (_e) {
+                                                        switch (_e.label) {
+                                                            case 0:
+                                                                messages = [];
+                                                                return [4 /*yield*/, repo.find(rest_data_provider_1.findOptionsFromJson(query.findOptionsJson, repo.metadata))];
+                                                            case 1:
+                                                                currentItems = _e.sent();
+                                                                currentIds = currentItems.map(function (x) { return repo.getEntityRef(x).getId(); });
+                                                                _loop_1 = function (id) {
+                                                                    var c = changes.find(function (c) { return c.oldId == id; });
+                                                                    if (c === undefined || id != c.oldId || !currentIds.includes(c.id))
+                                                                        messages.push({
+                                                                            type: "remove",
+                                                                            data: {
+                                                                                id: id
+                                                                            }
+                                                                        });
+                                                                };
+                                                                try {
+                                                                    for (_a = tslib_1.__values(query.lastIds.filter(function (y) { return !currentIds.includes(y); })), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                                        id = _b.value;
+                                                                        _loop_1(id);
+                                                                    }
+                                                                }
+                                                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                                                finally {
+                                                                    try {
+                                                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                                    }
+                                                                    finally { if (e_1) throw e_1.error; }
+                                                                }
+                                                                _loop_2 = function (item) {
+                                                                    var itemRef = repo.getEntityRef(item);
+                                                                    var c = changes.find(function (c) { return c.id == itemRef.getId(); });
+                                                                    if (c !== undefined && query.lastIds.includes(c.oldId)) {
+                                                                        messages.push({
+                                                                            type: "replace",
+                                                                            data: {
+                                                                                oldId: c.oldId,
+                                                                                item: itemRef.toApiJson()
+                                                                            }
+                                                                        });
+                                                                    }
+                                                                    else if (!query.lastIds.includes(itemRef.getId())) {
+                                                                        messages.push({
+                                                                            type: "add",
+                                                                            data: { item: itemRef.toApiJson() }
+                                                                        });
+                                                                    }
+                                                                };
+                                                                try {
+                                                                    for (currentItems_1 = tslib_1.__values(currentItems), currentItems_1_1 = currentItems_1.next(); !currentItems_1_1.done; currentItems_1_1 = currentItems_1.next()) {
+                                                                        item = currentItems_1_1.value;
+                                                                        _loop_2(item);
+                                                                    }
+                                                                }
+                                                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                                finally {
+                                                                    try {
+                                                                        if (currentItems_1_1 && !currentItems_1_1.done && (_d = currentItems_1.return)) _d.call(currentItems_1);
+                                                                    }
+                                                                    finally { if (e_2) throw e_2.error; }
+                                                                }
+                                                                this.debugFileSaver({
+                                                                    query: q.id,
+                                                                    currentIds: currentIds,
+                                                                    changes: changes,
+                                                                    lastIds: query.lastIds,
+                                                                    messages: messages
+                                                                });
+                                                                query.lastIds = currentIds;
+                                                                return [4 /*yield*/, setData(query)];
+                                                            case 2:
+                                                                _e.sent();
+                                                                if (messages.length > 0)
+                                                                    this.subscriptionServer().publishMessage(q.id, messages);
+                                                                return [2 /*return*/];
+                                                        }
+                                                    });
+                                                }); })];
+                                        case 1:
+                                            _b.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        }))];
+                    case 1:
+                        //TODO 2 - optimize so that the user will get their messages first. Based on user id
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LiveQueryPublisher;
+}());
+exports.LiveQueryPublisher = LiveQueryPublisher;
+var InMemoryLiveQueryStorage = /** @class */ (function () {
+    function InMemoryLiveQueryStorage() {
+        this.debugFileSaver = function (x) { };
+        this.queries = [];
+        this.removeCountForTesting = 0;
+    }
+    InMemoryLiveQueryStorage.prototype.debug = function () {
+        this.debugFileSaver(this.queries);
+    };
+    InMemoryLiveQueryStorage.prototype.keepAliveAndReturnUnknownQueryIds = function (ids) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, _loop_3, this_1, ids_1, ids_1_1, id;
+            var e_3, _a;
+            return tslib_1.__generator(this, function (_b) {
+                result = [];
+                _loop_3 = function (id) {
+                    var q = this_1.queries.find(function (q) { return q.id === id; });
+                    if (q) {
+                        q.lastUsed = new Date().toISOString();
+                    }
+                    else
+                        result.push(id);
+                };
+                this_1 = this;
+                try {
+                    for (ids_1 = tslib_1.__values(ids), ids_1_1 = ids_1.next(); !ids_1_1.done; ids_1_1 = ids_1.next()) {
+                        id = ids_1_1.value;
+                        _loop_3(id);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (ids_1_1 && !ids_1_1.done && (_a = ids_1.return)) _a.call(ids_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                this.debug();
+                return [2 /*return*/, result];
+            });
+        });
+    };
+    InMemoryLiveQueryStorage.prototype.add = function (query) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.queries.push(tslib_1.__assign(tslib_1.__assign({}, query), { lastUsed: new Date().toISOString() }));
+                this.debug();
+                return [2 /*return*/];
+            });
+        });
+    };
+    InMemoryLiveQueryStorage.prototype.remove = function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this.queries = this.queries.filter(function (q) { return q.id !== id; });
+                this.removeCountForTesting++;
+                this.debug();
+                return [2 /*return*/];
+            });
+        });
+    };
+    InMemoryLiveQueryStorage.prototype.forEach = function (entityKey, handle) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var d, _loop_4, _a, _b, q, e_4_1;
+            var e_4, _c;
+            var _this = this;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        d = new Date();
+                        d.setMinutes(d.getMinutes() - 5);
+                        this.queries = this.queries.filter(function (x) { return x.lastUsed > d.toISOString(); });
+                        _loop_4 = function (q) {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(q.entityKey === entityKey)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, handle({
+                                                query: q,
+                                                setData: function (data) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                                    q.data = data;
+                                                    return [2 /*return*/];
+                                                }); }); },
+                                            })];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.queries), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        q = _b.value;
+                        return [5 /*yield**/, _loop_4(q)];
+                    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_4_1 = _d.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        this.debug();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return InMemoryLiveQueryStorage;
+}());
+exports.InMemoryLiveQueryStorage = InMemoryLiveQueryStorage;

package/src/remult-proxy.d.ts

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