remult 3.4.0-next.1 → 3.4.0-next.4

package/esm/internals.js

@@ -7,5 +7,6 @@ export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
 export const actionInfo = remultStatic.actionInfo;
 export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';
+export { SseSubscriptionClient } from './src/live-query/SseSubscriptionClient.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';

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

@@ -46,7 +46,11 @@ export class LiveQueryClient {
                     });
                 }
                 catch (err) {
-                    onResult.error(err);
+                    // drop the half-registered channel so the next subscribe retries
+                    // instead of joining a channel that was never subscribed
+                    this.channels.delete(key);
+                    q.listeners.forEach((l) => l.error(err));
+                    this.closeIfNoListeners();
                     throw err;
                 }
             }
@@ -98,6 +102,8 @@ export class LiveQueryClient {
             if (!q) {
                 this.queries.set(eventTypeKey, (q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, options }, this.getUserId())));
                 q.subscribeCode = () => {
+                    q.snapshotReady = false;
+                    q.droppedWhilePending = false;
                     q.unsubscribeChannel();
                     let unsubscribeToChannel = () => { };
                     q.unsubscribeChannel = () => {
@@ -119,7 +125,10 @@ export class LiveQueryClient {
                             this.runPromise(r.unsubscribe());
                         };
                         snapshotDone = true;
-                        return this.runPromise(q.setAllItems(r.result));
+                        return this.runPromise(q.setAllItems(r.result).then(() => {
+                            if (q.droppedWhilePending)
+                                return this.runKeepAlive();
+                        }));
                     };
                     this.runPromise(this.subscribeChannel(q.queryChannel, {
                         next: (value) => this.runPromise(q.handle(value)),
@@ -135,7 +144,7 @@ export class LiveQueryClient {
                         }
                         unsubscribeToChannel = unsub;
                         if (snapshotDone)
-                            return this.runPromise(this.runKeepAlive({ checkVersions: true }));
+                            return this.runPromise(this.runKeepAlive());
                     })
                         .catch((err) => {
                         q.listeners.forEach((l) => l.error(err));
@@ -185,21 +194,24 @@ export class LiveQueryClient {
             return false;
         return Date.now() - conn.lastServerEvent > flags.sseStaleMs;
     }
-    async runKeepAlive(opts) {
+    async runKeepAlive() {
         if (this.keepAliveInFlight)
             return this.keepAliveInFlight;
-        this.keepAliveInFlight = this.sendKeepAlive(opts).finally(() => {
+        this.keepAliveInFlight = this.sendKeepAlive().finally(() => {
             this.keepAliveInFlight = undefined;
         });
         return this.keepAliveInFlight;
     }
-    async sendKeepAlive(opts) {
+    /** Resolves true when a query was refetched. */
+    async sendKeepAlive() {
         const ids = [];
         for (const q of this.queries.values()) {
+            if (!q.snapshotReady)
+                continue;
             ids.push(q.queryChannel);
         }
         if (ids.length === 0)
-            return;
+            return false;
         let p = this.apiProvider();
         const raw = await this.runPromise(remultStatic.actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, { queryIds: ids })));
         const unknownIds = Array.isArray(raw)
@@ -208,12 +220,13 @@ export class LiveQueryClient {
         const versions = Array.isArray(raw)
             ? {}
             : (raw?.versions ?? {});
-        const stale = opts?.checkVersions || this.isSseStale();
         let reloaded = false;
         for (const q of this.queries.values()) {
             const serverVersion = versions[q.queryChannel];
             const unknown = unknownIds.includes(q.queryChannel);
-            const mismatch = stale && serverVersion !== undefined && serverVersion !== q.version;
+            // server returns versions on every keep-alive, so a missed message is
+            // caught even while SSE pings look healthy
+            const mismatch = serverVersion !== undefined && serverVersion !== q.version;
             if (unknown || mismatch) {
                 reloaded = true;
                 if (serverVersion !== undefined)
@@ -221,14 +234,7 @@ export class LiveQueryClient {
                 q.subscribeCode();
             }
         }
-        if (this.isSseStale()) {
-            this.keepAliveBackoffMs = reloaded
-                ? flags.liveQueryPollWhenStaleMs
-                : Math.min(this.keepAliveBackoffMs * 2, flags.liveQueryKeepAliveMs);
-        }
-        else {
-            this.keepAliveBackoffMs = flags.liveQueryPollWhenStaleMs;
-        }
+        return reloaded;
     }
     async maybeKeepAlive() {
         const stale = this.isSseStale();
@@ -242,7 +248,18 @@ export class LiveQueryClient {
         this.lastKeepAliveAt = Date.now();
         if (stale)
             this.openedConnection?.resume?.(true);
-        await this.runKeepAlive();
+        let reloaded = false;
+        try {
+            reloaded = await this.runKeepAlive();
+        }
+        finally {
+            // runs on a failed post too, so an unreachable server is not polled
+            // every second; channel-only clients (no query ids) back off as well
+            if (this.isSseStale())
+                this.keepAliveBackoffMs = reloaded
+                    ? flags.liveQueryPollWhenStaleMs
+                    : Math.min(this.keepAliveBackoffMs * 2, flags.liveQueryKeepAliveMs);
+        }
     }
     detachForeground = () => { };
     attachForeground() {
@@ -255,7 +272,7 @@ export class LiveQueryClient {
                 this.foregroundKeepAliveTimer = undefined;
                 this.keepAliveBackoffMs = flags.liveQueryPollWhenStaleMs;
                 this.lastKeepAliveAt = 0;
-                this.runPromise(this.runKeepAlive({ checkVersions: true }));
+                this.runPromise(this.runKeepAlive());
             }, 300);
         });
         this.detachForeground = () => {
@@ -267,19 +284,30 @@ export class LiveQueryClient {
             this.detachForeground = () => { };
         };
     }
+    startKeepAlive() {
+        // openConnection may reject and be retried with queries still alive
+        if (this.interval !== undefined)
+            return;
+        this.lastKeepAliveAt = Date.now();
+        this.keepAliveBackoffMs = flags.liveQueryPollWhenStaleMs;
+        this.attachForeground();
+        this.interval = setInterval(() => {
+            // a failed post is transient: the backoff covers it, next tick retries
+            this.runPromise(this.maybeKeepAlive().catch(() => { }));
+        }, Math.min(flags.liveQueryPollWhenStaleMs, flags.liveQueryKeepAliveMs));
+    }
     openIfNoOpened() {
         if (!this.client) {
-            this.lastKeepAliveAt = Date.now();
-            this.keepAliveBackoffMs = flags.liveQueryPollWhenStaleMs;
-            this.attachForeground();
-            this.interval = setInterval(() => {
-                this.runPromise(this.maybeKeepAlive());
-            }, Math.min(flags.liveQueryPollWhenStaleMs, flags.liveQueryKeepAliveMs));
+            this.startKeepAlive();
             return this.runPromise((this.client = this.apiProvider()
                 .subscriptionClient.openConnection(() => {
                 for (const q of this.queries.values()) {
                     q.subscribeCode();
                 }
+                for (const c of this.channels.values()) {
+                    for (const l of c.listeners)
+                        l.reconnect?.();
+                }
             })
                 .then((c) => {
                 this.openedConnection = c;

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

@@ -1,17 +1,21 @@
 import { buildRestDataProvider } from '../buildRestDataProvider.js';
 import { remult } from '../remult-proxy.js';
 import { remultStatic } from '../remult-static.js';
+import { flags } from '../remult3/remult3.js';
 import { streamUrl } from './SubscriptionChannel.js';
 export class SseSubscriptionClient {
     openConnection(onReconnect) {
         let connectionId;
         const channels = new Map();
+        const errorHandlers = new Map();
         const provider = buildRestDataProvider(remult.apiClient.httpClient);
         let source;
         let retryCount = 0;
         let closed = false;
         let connected = false;
+        let everConnected = false;
         let reconnectTimer;
+        let lastConnectAt = 0;
         let connectionReady;
         let connectionPromise = new Promise((res) => {
             connectionReady = res;
@@ -36,15 +40,16 @@ export class SseSubscriptionClient {
         function resume(force) {
             if (closed)
                 return;
-            retryCount = 0;
-            clearReconnectTimer();
+            const open = source && source.readyState !== EVENT_SOURCE_CLOSED;
             if (force) {
+                // a source still inside its handshake window is not a zombie yet
+                if (open && Date.now() - lastConnectAt < flags.sseStaleMs)
+                    return;
                 createConnection();
                 return;
             }
-            const open = source &&
-                typeof EventSource !== 'undefined' &&
-                source.readyState !== EventSource.CLOSED;
+            retryCount = 0;
+            clearReconnectTimer();
             if (!open)
                 createConnection();
         }
@@ -56,23 +61,39 @@ export class SseSubscriptionClient {
                 clearReconnectTimer();
                 source?.close();
             },
-            async subscribe(channel, handler) {
+            async subscribe(channel, handler, onError) {
                 let listeners = channels.get(channel);
+                let onErrors = errorHandlers.get(channel);
                 if (!listeners) {
                     channels.set(channel, (listeners = []));
-                    await connectionPromise;
-                    if (!closed)
-                        await subscribeToChannel(channel);
+                    errorHandlers.set(channel, (onErrors = []));
+                    try {
+                        await connectionPromise;
+                        if (!closed)
+                            await subscribeToChannel(channel);
+                    }
+                    catch (err) {
+                        // otherwise the next subscribe sees the entry and never retries
+                        channels.delete(channel);
+                        errorHandlers.delete(channel);
+                        throw err;
+                    }
                 }
                 listeners.push(handler);
+                onErrors.push(onError);
                 return () => {
-                    listeners.splice(listeners.indexOf(handler, 1));
+                    const i = listeners.indexOf(handler);
+                    if (i >= 0) {
+                        listeners.splice(i, 1);
+                        onErrors.splice(i, 1);
+                    }
                     if (listeners.length == 0) {
                         remultStatic.actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
                             channel: channel,
                             clientId: connectionId,
                         }));
                         channels.delete(channel);
+                        errorHandlers.delete(channel);
                     }
                 };
             },
@@ -86,6 +107,7 @@ export class SseSubscriptionClient {
             clearReconnectTimer();
             if (source)
                 source.close();
+            lastConnectAt = Date.now();
             source = SseSubscriptionClient.createEventSource(remult.apiClient.url + '/' + streamUrl);
             source.onmessage = (e) => {
                 noteServerEvent();
@@ -109,16 +131,23 @@ export class SseSubscriptionClient {
                 connectionId = e.data;
                 retryCount = 0;
                 noteServerEvent();
-                if (connected) {
-                    for (const channel of channels.keys()) {
-                        await subscribeToChannel(channel);
+                // a connection the server forgot counts as a reconnect too: every
+                // channel must be re-subscribed and live queries refetched
+                const wasConnected = everConnected;
+                connected = everConnected = true;
+                if (wasConnected) {
+                    for (const channel of [...channels.keys()]) {
+                        try {
+                            await subscribeToChannel(channel);
+                        }
+                        catch (err) {
+                            // one refused channel must not block the others
+                            errorHandlers.get(channel)?.forEach((f) => f(err));
+                        }
                     }
                     onReconnect();
                 }
-                else {
-                    connected = true;
-                    connectionReady();
-                }
+                connectionReady();
             });
         }
         createConnection();
@@ -130,15 +159,13 @@ export class SseSubscriptionClient {
                     clientId: connectionId,
                 });
             });
-            if (result === ConnectionNotFoundError) {
+            if (result === ConnectionNotFoundError && connected) {
                 connected = false;
                 connectionPromise = new Promise((res) => {
                     connectionReady = res;
                 });
                 createConnection();
                 await connectionPromise;
-                if (!closed)
-                    await subscribeToChannel(channel);
             }
         }
     }
@@ -149,3 +176,5 @@ export class SseSubscriptionClient {
     }
 }
 export const ConnectionNotFoundError = 'client connection not found';
+// EventSource.CLOSED; the global is absent in Node
+const EVENT_SOURCE_CLOSED = 2;

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

@@ -14,14 +14,19 @@ export class LiveQuerySubscriber {
     unsubscribe = () => { };
     unsubscribeChannel = () => { };
     unsubscribeQuery = () => { };
+    snapshotReady = false;
+    droppedWhilePending = false;
     async setAllItems(result) {
+        // server re-registers the query at version 0; reset before the await so a
+        // version message landing mid-parse is judged against the new baseline
+        this.version = 0;
         const items = await getRepositoryInternals(this.repo)._fromJsonArray(result, this.query.options);
         this.forListeners((listener) => {
             listener(() => {
                 return items;
             });
         }, this.allItemsMessage(items));
-        this.version = 0;
+        this.snapshotReady = true;
     }
     allItemsMessage(items) {
         return [
@@ -55,16 +60,24 @@ export class LiveQuerySubscriber {
         };
     }
     async handle(messages) {
+        // the pending snapshot supersedes anything in flight; the keep-alive
+        // after it lands catches whatever was dropped here
+        if (!this.snapshotReady) {
+            this.droppedWhilePending = true;
+            return;
+        }
         const ver = messages.find((m) => m.type === 'version');
-        if (ver) {
-            if (ver.from < this.version)
-                return;
-            if (ver.from > this.version) {
-                this.version = ver.to;
-                this.subscribeCode?.();
-                return;
-            }
+        // any gap, forward or backward, means a message was missed or two servers
+        // published the same version with different diffs: refetch instead of drop
+        if (ver && ver.from !== this.version) {
+            this.version = ver.to;
+            this.subscribeCode?.();
+            return;
         }
+        // bump before the await below, so a second message delivered in the same
+        // tick is judged against this one and not mistaken for a gap
+        if (ver)
+            this.version = ver.to;
         const data = messages.filter((m) => m.type !== 'version');
         {
             let x = data.filter(({ type }) => type == 'add' || type == 'replace');
@@ -102,7 +115,8 @@ export class LiveQuerySubscriber {
                 return items;
             });
         }, data);
-        this.version = ver ? ver.to : this.version + (data.length > 0 ? 1 : 0);
+        if (!ver && data.length > 0)
+            this.version++;
     }
     defaultQueryState = [];
     listeners = [];
@@ -200,6 +214,16 @@ export const liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
  *  });
  *  ```
  *
+ *  #### Recovering after a dropped connection
+ *  Messages published while the connection was down are not replayed.
+ *  Use the `reconnect` listener to refetch state:
+ *  ```ts
+ *  chart.subscribe({
+ *    next: (message) => (chartData = message.data),
+ *    reconnect: () => loadChartData(),
+ *  });
+ *  ```
+ *
  */
 export class SubscriptionChannel {
     channelKey;

package/esm/src/remult3/remult3.js

@@ -16,8 +16,8 @@ const wnn = [
 ];
 export const flags = {
     error500RetryCount: 4,
-    /** Client treats SSE as dead if no event for this long */
-    sseStaleMs: 20_000,
+    /** Client treats SSE as dead if no event for this long. Server pings every 15s; two missed pings plus slack, so a stalled event loop does not trigger a reconnect storm */
+    sseStaleMs: 40_000,
     /** HTTP keep-alive while SSE is healthy (touches lastUsed) */
     liveQueryKeepAliveMs: 30_000,
     /** Version poll while SSE is stale */

package/internals.d.ts

@@ -15,5 +15,6 @@ export declare const actionInfo: {
 export { isOfType } from './src/isOfType.js';
 export type { ClassType } from './classType.js';
 export { flags } from './src/remult3/remult3.js';
+export { SseSubscriptionClient } from './src/live-query/SseSubscriptionClient.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';

package/internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
+exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.SseSubscriptionClient = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
 var remult_static_js_1 = require("./src/remult-static.js");
 var sql_relations_js_1 = require("./src/data-providers/sql-relations.js");
 Object.defineProperty(exports, "sqlRelations", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelations; } });
@@ -22,6 +22,8 @@ var isOfType_js_1 = require("./src/isOfType.js");
 Object.defineProperty(exports, "isOfType", { enumerable: true, get: function () { return isOfType_js_1.isOfType; } });
 var remult3_js_1 = require("./src/remult3/remult3.js");
 Object.defineProperty(exports, "flags", { enumerable: true, get: function () { return remult3_js_1.flags; } });
+var SseSubscriptionClient_js_1 = require("./src/live-query/SseSubscriptionClient.js");
+Object.defineProperty(exports, "SseSubscriptionClient", { enumerable: true, get: function () { return SseSubscriptionClient_js_1.SseSubscriptionClient; } });
 var data_interfaces_js_1 = require("./src/data-interfaces.js");
 Object.defineProperty(exports, "DataProviderPromiseWrapper", { enumerable: true, get: function () { return data_interfaces_js_1.DataProviderPromiseWrapper; } });
 var pagedQueryResult_js_1 = require("./src/remult3/pagedQueryResult.js");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.4.0-next.1",
+    "version": "3.4.0-next.4",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/src/live-query/LiveQueryClient.js

@@ -67,7 +67,11 @@ var LiveQueryClient = /** @class */ (function () {
                         return [3 /*break*/, 6];
                     case 5:
                         err_1 = _b.sent();
-                        onResult.error(err_1);
+                        // drop the half-registered channel so the next subscribe retries
+                        // instead of joining a channel that was never subscribed
+                        this.channels.delete(key);
+                        q_1.listeners.forEach(function (l) { return l.error(err_1); });
+                        this.closeIfNoListeners();
                         throw err_1;
                     case 6:
                         q_1.listeners.push(onResult);
@@ -122,6 +126,8 @@ var LiveQueryClient = /** @class */ (function () {
             if (!q) {
                 _this.queries.set(eventTypeKey, (q = new SubscriptionChannel_js_1.LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, options: options }, _this.getUserId())));
                 q.subscribeCode = function () {
+                    q.snapshotReady = false;
+                    q.droppedWhilePending = false;
                     q.unsubscribeChannel();
                     var unsubscribeToChannel = function () { };
                     q.unsubscribeChannel = function () {
@@ -143,7 +149,10 @@ var LiveQueryClient = /** @class */ (function () {
                             _this.runPromise(r.unsubscribe());
                         };
                         snapshotDone = true;
-                        return _this.runPromise(q.setAllItems(r.result));
+                        return _this.runPromise(q.setAllItems(r.result).then(function () {
+                            if (q.droppedWhilePending)
+                                return _this.runKeepAlive();
+                        }));
                     };
                     _this.runPromise(_this.subscribeChannel(q.queryChannel, {
                         next: function (value) { return _this.runPromise(q.handle(value)); },
@@ -159,7 +168,7 @@ var LiveQueryClient = /** @class */ (function () {
                         }
                         unsubscribeToChannel = unsub;
                         if (snapshotDone)
-                            return _this.runPromise(_this.runKeepAlive({ checkVersions: true }));
+                            return _this.runPromise(_this.runKeepAlive());
                     })
                         .catch(function (err) {
                         q.listeners.forEach(function (l) { return l.error(err); });
@@ -202,22 +211,23 @@ var LiveQueryClient = /** @class */ (function () {
             return false;
         return Date.now() - conn.lastServerEvent > remult3_js_1.flags.sseStaleMs;
     };
-    LiveQueryClient.prototype.runKeepAlive = function (opts) {
+    LiveQueryClient.prototype.runKeepAlive = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 if (this.keepAliveInFlight)
                     return [2 /*return*/, this.keepAliveInFlight];
-                this.keepAliveInFlight = this.sendKeepAlive(opts).finally(function () {
+                this.keepAliveInFlight = this.sendKeepAlive().finally(function () {
                     _this.keepAliveInFlight = undefined;
                 });
                 return [2 /*return*/, this.keepAliveInFlight];
             });
         });
     };
-    LiveQueryClient.prototype.sendKeepAlive = function (opts) {
+    /** Resolves true when a query was refetched. */
+    LiveQueryClient.prototype.sendKeepAlive = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var ids, _a, _b, q, p, raw, unknownIds, versions, stale, reloaded, _c, _d, q, serverVersion, unknown, mismatch;
+            var ids, _a, _b, q, p, raw, unknownIds, versions, reloaded, _c, _d, q, serverVersion, unknown, mismatch;
             var e_1, _e, e_2, _f;
             var _g, _h;
             return tslib_1.__generator(this, function (_j) {
@@ -227,6 +237,8 @@ var LiveQueryClient = /** @class */ (function () {
                         try {
                             for (_a = tslib_1.__values(this.queries.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
                                 q = _b.value;
+                                if (!q.snapshotReady)
+                                    continue;
                                 ids.push(q.queryChannel);
                             }
                         }
@@ -238,7 +250,7 @@ var LiveQueryClient = /** @class */ (function () {
                             finally { if (e_1) throw e_1.error; }
                         }
                         if (ids.length === 0)
-                            return [2 /*return*/];
+                            return [2 /*return*/, false];
                         p = this.apiProvider();
                         return [4 /*yield*/, this.runPromise(remult_static_js_1.remultStatic.actionInfo.runActionWithoutBlockingUI(function () {
                                 return (0, buildRestDataProvider_js_1.buildRestDataProvider)(p.httpClient).post(p.url + '/' + SubscriptionChannel_js_1.liveQueryKeepAliveRoute, { queryIds: ids });
@@ -251,14 +263,13 @@ var LiveQueryClient = /** @class */ (function () {
                         versions = Array.isArray(raw)
                             ? {}
                             : ((_h = raw === null || raw === void 0 ? void 0 : raw.versions) !== null && _h !== void 0 ? _h : {});
-                        stale = (opts === null || opts === void 0 ? void 0 : opts.checkVersions) || this.isSseStale();
                         reloaded = false;
                         try {
                             for (_c = tslib_1.__values(this.queries.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
                                 q = _d.value;
                                 serverVersion = versions[q.queryChannel];
                                 unknown = unknownIds.includes(q.queryChannel);
-                                mismatch = stale && serverVersion !== undefined && serverVersion !== q.version;
+                                mismatch = serverVersion !== undefined && serverVersion !== q.version;
                                 if (unknown || mismatch) {
                                     reloaded = true;
                                     if (serverVersion !== undefined)
@@ -274,22 +285,14 @@ var LiveQueryClient = /** @class */ (function () {
                             }
                             finally { if (e_2) throw e_2.error; }
                         }
-                        if (this.isSseStale()) {
-                            this.keepAliveBackoffMs = reloaded
-                                ? remult3_js_1.flags.liveQueryPollWhenStaleMs
-                                : Math.min(this.keepAliveBackoffMs * 2, remult3_js_1.flags.liveQueryKeepAliveMs);
-                        }
-                        else {
-                            this.keepAliveBackoffMs = remult3_js_1.flags.liveQueryPollWhenStaleMs;
-                        }
-                        return [2 /*return*/];
+                        return [2 /*return*/, reloaded];
                 }
             });
         });
     };
     LiveQueryClient.prototype.maybeKeepAlive = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var stale, interval;
+            var stale, interval, reloaded;
             var _a, _b;
             return tslib_1.__generator(this, function (_c) {
                 switch (_c.label) {
@@ -305,10 +308,23 @@ var LiveQueryClient = /** @class */ (function () {
                         this.lastKeepAliveAt = Date.now();
                         if (stale)
                             (_b = (_a = this.openedConnection) === null || _a === void 0 ? void 0 : _a.resume) === null || _b === void 0 ? void 0 : _b.call(_a, true);
-                        return [4 /*yield*/, this.runKeepAlive()];
+                        reloaded = false;
+                        _c.label = 1;
                     case 1:
-                        _c.sent();
-                        return [2 /*return*/];
+                        _c.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, this.runKeepAlive()];
+                    case 2:
+                        reloaded = _c.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        // runs on a failed post too, so an unreachable server is not polled
+                        // every second; channel-only clients (no query ids) back off as well
+                        if (this.isSseStale())
+                            this.keepAliveBackoffMs = reloaded
+                                ? remult3_js_1.flags.liveQueryPollWhenStaleMs
+                                : Math.min(this.keepAliveBackoffMs * 2, remult3_js_1.flags.liveQueryKeepAliveMs);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -325,7 +341,7 @@ var LiveQueryClient = /** @class */ (function () {
                 _this.foregroundKeepAliveTimer = undefined;
                 _this.keepAliveBackoffMs = remult3_js_1.flags.liveQueryPollWhenStaleMs;
                 _this.lastKeepAliveAt = 0;
-                _this.runPromise(_this.runKeepAlive({ checkVersions: true }));
+                _this.runPromise(_this.runKeepAlive());
             }, 300);
         });
         this.detachForeground = function () {
@@ -337,31 +353,65 @@ var LiveQueryClient = /** @class */ (function () {
             _this.detachForeground = function () { };
         };
     };
+    LiveQueryClient.prototype.startKeepAlive = function () {
+        var _this = this;
+        // openConnection may reject and be retried with queries still alive
+        if (this.interval !== undefined)
+            return;
+        this.lastKeepAliveAt = Date.now();
+        this.keepAliveBackoffMs = remult3_js_1.flags.liveQueryPollWhenStaleMs;
+        this.attachForeground();
+        this.interval = setInterval(function () {
+            // a failed post is transient: the backoff covers it, next tick retries
+            _this.runPromise(_this.maybeKeepAlive().catch(function () { }));
+        }, Math.min(remult3_js_1.flags.liveQueryPollWhenStaleMs, remult3_js_1.flags.liveQueryKeepAliveMs));
+    };
     LiveQueryClient.prototype.openIfNoOpened = function () {
         var _this = this;
         if (!this.client) {
-            this.lastKeepAliveAt = Date.now();
-            this.keepAliveBackoffMs = remult3_js_1.flags.liveQueryPollWhenStaleMs;
-            this.attachForeground();
-            this.interval = setInterval(function () {
-                _this.runPromise(_this.maybeKeepAlive());
-            }, Math.min(remult3_js_1.flags.liveQueryPollWhenStaleMs, remult3_js_1.flags.liveQueryKeepAliveMs));
+            this.startKeepAlive();
             return this.runPromise((this.client = this.apiProvider()
                 .subscriptionClient.openConnection(function () {
-                var e_3, _a;
+                var e_3, _a, e_4, _b, e_5, _c;
+                var _d;
                 try {
-                    for (var _b = tslib_1.__values(_this.queries.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var q = _c.value;
+                    for (var _e = tslib_1.__values(_this.queries.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var q = _f.value;
                         q.subscribeCode();
                     }
                 }
                 catch (e_3_1) { e_3 = { error: e_3_1 }; }
                 finally {
                     try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
                     }
                     finally { if (e_3) throw e_3.error; }
                 }
+                try {
+                    for (var _g = tslib_1.__values(_this.channels.values()), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var c = _h.value;
+                        try {
+                            for (var _j = (e_5 = void 0, tslib_1.__values(c.listeners)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                var l = _k.value;
+                                (_d = l.reconnect) === null || _d === void 0 ? void 0 : _d.call(l);
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
             })
                 .then(function (c) {
                 _this.openedConnection = c;
@@ -387,7 +437,7 @@ var MessageChannel = /** @class */ (function () {
     MessageChannel.prototype.handle = function (message) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b, l;
-            var e_4, _c;
+            var e_6, _c;
             return tslib_1.__generator(this, function (_d) {
                 try {
                     for (_a = tslib_1.__values(this.listeners), _b = _a.next(); !_b.done; _b = _a.next()) {
@@ -395,12 +445,12 @@ var MessageChannel = /** @class */ (function () {
                         l.next(message);
                     }
                 }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
                 finally {
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_4) throw e_4.error; }
+                    finally { if (e_6) throw e_6.error; }
                 }
                 return [2 /*return*/];
             });

package/src/live-query/SseSubscriptionClient.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var buildRestDataProvider_js_1 = require("../buildRestDataProvider.js");
 var remult_proxy_js_1 = require("../remult-proxy.js");
 var remult_static_js_1 = require("../remult-static.js");
+var remult3_js_1 = require("../remult3/remult3.js");
 var SubscriptionChannel_js_1 = require("./SubscriptionChannel.js");
 var SseSubscriptionClient = /** @class */ (function () {
     function SseSubscriptionClient() {
@@ -12,12 +13,15 @@ var SseSubscriptionClient = /** @class */ (function () {
     SseSubscriptionClient.prototype.openConnection = function (onReconnect) {
         var connectionId;
         var channels = new Map();
+        var errorHandlers = new Map();
         var provider = (0, buildRestDataProvider_js_1.buildRestDataProvider)(remult_proxy_js_1.remult.apiClient.httpClient);
         var source;
         var retryCount = 0;
         var closed = false;
         var connected = false;
+        var everConnected = false;
         var reconnectTimer;
+        var lastConnectAt = 0;
         var connectionReady;
         var connectionPromise = new Promise(function (res) {
             connectionReady = res;
@@ -42,15 +46,16 @@ var SseSubscriptionClient = /** @class */ (function () {
         function resume(force) {
             if (closed)
                 return;
-            retryCount = 0;
-            clearReconnectTimer();
+            var open = source && source.readyState !== EVENT_SOURCE_CLOSED;
             if (force) {
+                // a source still inside its handshake window is not a zombie yet
+                if (open && Date.now() - lastConnectAt < remult3_js_1.flags.sseStaleMs)
+                    return;
                 createConnection();
                 return;
             }
-            var open = source &&
-                typeof EventSource !== 'undefined' &&
-                source.readyState !== EventSource.CLOSED;
+            retryCount = 0;
+            clearReconnectTimer();
             if (!open)
                 createConnection();
         }
@@ -62,27 +67,44 @@ var SseSubscriptionClient = /** @class */ (function () {
                 clearReconnectTimer();
                 source === null || source === void 0 ? void 0 : source.close();
             },
-            subscribe: function (channel, handler) {
+            subscribe: function (channel, handler, onError) {
                 return tslib_1.__awaiter(this, void 0, void 0, function () {
-                    var listeners;
+                    var listeners, onErrors, err_1;
                     return tslib_1.__generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
                                 listeners = channels.get(channel);
-                                if (!!listeners) return [3 /*break*/, 3];
+                                onErrors = errorHandlers.get(channel);
+                                if (!!listeners) return [3 /*break*/, 6];
                                 channels.set(channel, (listeners = []));
-                                return [4 /*yield*/, connectionPromise];
+                                errorHandlers.set(channel, (onErrors = []));
+                                _a.label = 1;
                             case 1:
-                                _a.sent();
-                                if (!!closed) return [3 /*break*/, 3];
-                                return [4 /*yield*/, subscribeToChannel(channel)];
+                                _a.trys.push([1, 5, , 6]);
+                                return [4 /*yield*/, connectionPromise];
                             case 2:
                                 _a.sent();
-                                _a.label = 3;
+                                if (!!closed) return [3 /*break*/, 4];
+                                return [4 /*yield*/, subscribeToChannel(channel)];
                             case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4: return [3 /*break*/, 6];
+                            case 5:
+                                err_1 = _a.sent();
+                                // otherwise the next subscribe sees the entry and never retries
+                                channels.delete(channel);
+                                errorHandlers.delete(channel);
+                                throw err_1;
+                            case 6:
                                 listeners.push(handler);
+                                onErrors.push(onError);
                                 return [2 /*return*/, function () {
-                                        listeners.splice(listeners.indexOf(handler, 1));
+                                        var i = listeners.indexOf(handler);
+                                        if (i >= 0) {
+                                            listeners.splice(i, 1);
+                                            onErrors.splice(i, 1);
+                                        }
                                         if (listeners.length == 0) {
                                             remult_static_js_1.remultStatic.actionInfo.runActionWithoutBlockingUI(function () {
                                                 return provider.post(remult_proxy_js_1.remult.apiClient.url + '/' + SubscriptionChannel_js_1.streamUrl + '/unsubscribe', {
@@ -91,6 +113,7 @@ var SseSubscriptionClient = /** @class */ (function () {
                                                 });
                                             });
                                             channels.delete(channel);
+                                            errorHandlers.delete(channel);
                                         }
                                     }];
                         }
@@ -108,6 +131,7 @@ var SseSubscriptionClient = /** @class */ (function () {
             clearReconnectTimer();
             if (source)
                 source.close();
+            lastConnectAt = Date.now();
             source = SseSubscriptionClient.createEventSource(remult_proxy_js_1.remult.apiClient.url + '/' + SubscriptionChannel_js_1.streamUrl);
             source.onmessage = function (e) {
                 noteServerEvent();
@@ -127,50 +151,59 @@ var SseSubscriptionClient = /** @class */ (function () {
                 scheduleReconnect();
             };
             source.addEventListener('connectionId', function (e) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                var _a, _b, channel, e_1_1;
+                var wasConnected, _a, _b, channel, err_2, e_1_1;
                 var e_1, _c;
-                return tslib_1.__generator(this, function (_d) {
-                    switch (_d.label) {
+                var _d;
+                return tslib_1.__generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
                             //@ts-ignore
                             connectionId = e.data;
                             retryCount = 0;
                             noteServerEvent();
-                            if (!connected) return [3 /*break*/, 9];
-                            _d.label = 1;
+                            wasConnected = everConnected;
+                            connected = everConnected = true;
+                            if (!wasConnected) return [3 /*break*/, 11];
+                            _e.label = 1;
                         case 1:
-                            _d.trys.push([1, 6, 7, 8]);
-                            _a = tslib_1.__values(channels.keys()), _b = _a.next();
-                            _d.label = 2;
+                            _e.trys.push([1, 8, 9, 10]);
+                            _a = tslib_1.__values(tslib_1.__spreadArray([], tslib_1.__read(channels.keys()), false)), _b = _a.next();
+                            _e.label = 2;
                         case 2:
-                            if (!!_b.done) return [3 /*break*/, 5];
+                            if (!!_b.done) return [3 /*break*/, 7];
                             channel = _b.value;
-                            return [4 /*yield*/, subscribeToChannel(channel)];
+                            _e.label = 3;
                         case 3:
-                            _d.sent();
-                            _d.label = 4;
+                            _e.trys.push([3, 5, , 6]);
+                            return [4 /*yield*/, subscribeToChannel(channel)];
                         case 4:
+                            _e.sent();
+                            return [3 /*break*/, 6];
+                        case 5:
+                            err_2 = _e.sent();
+                            // one refused channel must not block the others
+                            (_d = errorHandlers.get(channel)) === null || _d === void 0 ? void 0 : _d.forEach(function (f) { return f(err_2); });
+                            return [3 /*break*/, 6];
+                        case 6:
                             _b = _a.next();
                             return [3 /*break*/, 2];
-                        case 5: return [3 /*break*/, 8];
-                        case 6:
-                            e_1_1 = _d.sent();
+                        case 7: return [3 /*break*/, 10];
+                        case 8:
+                            e_1_1 = _e.sent();
                             e_1 = { error: e_1_1 };
-                            return [3 /*break*/, 8];
-                        case 7:
+                            return [3 /*break*/, 10];
+                        case 9:
                             try {
                                 if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                             }
                             finally { if (e_1) throw e_1.error; }
                             return [7 /*endfinally*/];
-                        case 8:
+                        case 10:
                             onReconnect();
-                            return [3 /*break*/, 10];
-                        case 9:
-                            connected = true;
+                            _e.label = 11;
+                        case 11:
                             connectionReady();
-                            _d.label = 10;
-                        case 10: return [2 /*return*/];
+                            return [2 /*return*/];
                     }
                 });
             }); });
@@ -190,7 +223,7 @@ var SseSubscriptionClient = /** @class */ (function () {
                             })];
                         case 1:
                             result = _a.sent();
-                            if (!(result === exports.ConnectionNotFoundError)) return [3 /*break*/, 4];
+                            if (!(result === exports.ConnectionNotFoundError && connected)) return [3 /*break*/, 3];
                             connected = false;
                             connectionPromise = new Promise(function (res) {
                                 connectionReady = res;
@@ -199,12 +232,8 @@ var SseSubscriptionClient = /** @class */ (function () {
                             return [4 /*yield*/, connectionPromise];
                         case 2:
                             _a.sent();
-                            if (!!closed) return [3 /*break*/, 4];
-                            return [4 /*yield*/, subscribeToChannel(channel)];
-                        case 3:
-                            _a.sent();
-                            _a.label = 4;
-                        case 4: return [2 /*return*/];
+                            _a.label = 3;
+                        case 3: return [2 /*return*/];
                     }
                 });
             });
@@ -219,3 +248,5 @@ var SseSubscriptionClient = /** @class */ (function () {
 }());
 exports.SseSubscriptionClient = SseSubscriptionClient;
 exports.ConnectionNotFoundError = 'client connection not found';
+// EventSource.CLOSED; the global is absent in Node
+var EVENT_SOURCE_CLOSED = 2;

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

@@ -4,6 +4,8 @@ export interface SubscriptionListener<type> {
     next(message: type): void;
     error(err: any): void;
     complete(): void;
+    /** The connection was re-established; messages published meanwhile were lost, refetch state if needed. */
+    reconnect?(): void;
 }
 export type Unsubscribe = VoidFunction;
 export interface SubscriptionClientConnection {
@@ -106,6 +108,16 @@ export declare type LiveQueryChange = {
  *  });
  *  ```
  *
+ *  #### Recovering after a dropped connection
+ *  Messages published while the connection was down are not replayed.
+ *  Use the `reconnect` listener to refetch state:
+ *  ```ts
+ *  chart.subscribe({
+ *    next: (message) => (chartData = message.data),
+ *    reconnect: () => loadChartData(),
+ *  });
+ *  ```
+ *
  */
 export declare class SubscriptionChannel<messageType> {
     channelKey: string;

package/src/live-query/SubscriptionChannel.js

@@ -15,6 +15,8 @@ var LiveQuerySubscriber = /** @class */ (function () {
         this.unsubscribe = function () { };
         this.unsubscribeChannel = function () { };
         this.unsubscribeQuery = function () { };
+        this.snapshotReady = false;
+        this.droppedWhilePending = false;
         this.defaultQueryState = [];
         this.listeners = [];
         this.id = String(crypto.randomUUID());
@@ -31,7 +33,11 @@ var LiveQuerySubscriber = /** @class */ (function () {
             var items;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, (0, repository_internals_js_1.getRepositoryInternals)(this.repo)._fromJsonArray(result, this.query.options)];
+                    case 0:
+                        // server re-registers the query at version 0; reset before the await so a
+                        // version message landing mid-parse is judged against the new baseline
+                        this.version = 0;
+                        return [4 /*yield*/, (0, repository_internals_js_1.getRepositoryInternals)(this.repo)._fromJsonArray(result, this.query.options)];
                     case 1:
                         items = _a.sent();
                         this.forListeners(function (listener) {
@@ -39,7 +45,7 @@ var LiveQuerySubscriber = /** @class */ (function () {
                                 return items;
                             });
                         }, this.allItemsMessage(items));
-                        this.version = 0;
+                        this.snapshotReady = true;
                         return [2 /*return*/];
                 }
             });
@@ -99,18 +105,26 @@ var LiveQuerySubscriber = /** @class */ (function () {
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
+                        // the pending snapshot supersedes anything in flight; the keep-alive
+                        // after it lands catches whatever was dropped here
+                        if (!this.snapshotReady) {
+                            this.droppedWhilePending = true;
+                            return [2 /*return*/];
+                        }
                         ver = messages.find(function (m) {
                             return m.type === 'version';
                         });
-                        if (ver) {
-                            if (ver.from < this.version)
-                                return [2 /*return*/];
-                            if (ver.from > this.version) {
-                                this.version = ver.to;
-                                (_a = this.subscribeCode) === null || _a === void 0 ? void 0 : _a.call(this);
-                                return [2 /*return*/];
-                            }
+                        // any gap, forward or backward, means a message was missed or two servers
+                        // published the same version with different diffs: refetch instead of drop
+                        if (ver && ver.from !== this.version) {
+                            this.version = ver.to;
+                            (_a = this.subscribeCode) === null || _a === void 0 ? void 0 : _a.call(this);
+                            return [2 /*return*/];
                         }
+                        // bump before the await below, so a second message delivered in the same
+                        // tick is judged against this one and not mistaken for a gap
+                        if (ver)
+                            this.version = ver.to;
                         data = messages.filter(function (m) { return m.type !== 'version'; });
                         x = data.filter(function (_a) {
                             var type = _a.type;
@@ -171,7 +185,8 @@ var LiveQuerySubscriber = /** @class */ (function () {
                                 return items;
                             });
                         }, data);
-                        this.version = ver ? ver.to : this.version + (data.length > 0 ? 1 : 0);
+                        if (!ver && data.length > 0)
+                            this.version++;
                         return [2 /*return*/];
                 }
             });
@@ -265,6 +280,16 @@ exports.liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
  *  });
  *  ```
  *
+ *  #### Recovering after a dropped connection
+ *  Messages published while the connection was down are not replayed.
+ *  Use the `reconnect` listener to refetch state:
+ *  ```ts
+ *  chart.subscribe({
+ *    next: (message) => (chartData = message.data),
+ *    reconnect: () => loadChartData(),
+ *  });
+ *  ```
+ *
  */
 var SubscriptionChannel = /** @class */ (function () {
     /**

package/src/remult3/remult3.d.ts

@@ -1220,7 +1220,7 @@ export type ClassFieldDecorator<entityType, valueType> = ((target: any, context:
 };
 export declare const flags: {
     error500RetryCount: number;
-    /** Client treats SSE as dead if no event for this long */
+    /** Client treats SSE as dead if no event for this long. Server pings every 15s; two missed pings plus slack, so a stalled event loop does not trigger a reconnect storm */
     sseStaleMs: number;
     /** HTTP keep-alive while SSE is healthy (touches lastUsed) */
     liveQueryKeepAliveMs: number;

package/src/remult3/remult3.js

@@ -19,8 +19,8 @@ var wnn = [
 ];
 exports.flags = {
     error500RetryCount: 4,
-    /** Client treats SSE as dead if no event for this long */
-    sseStaleMs: 20000,
+    /** Client treats SSE as dead if no event for this long. Server pings every 15s; two missed pings plus slack, so a stalled event loop does not trigger a reconnect storm */
+    sseStaleMs: 40000,
     /** HTTP keep-alive while SSE is healthy (touches lastUsed) */
     liveQueryKeepAliveMs: 30000,
     /** Version poll while SSE is stale */