@rebasepro/client 0.20.0 → 0.21.0

package/dist/index.es.js

@@ -1,6 +1,6 @@
 import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, RebaseClientError as RebaseClientError$1, SCHEMA_VERSION_HEADER, Vector, hasFieldOperation, isPublicStoragePath, isUnsupported, parseRelationAggregateSort, sortKeyToString, toCanonicalOp, unsupportedMethod } from "@rebasepro/types";
 import { COMPOSITE_ID_SEPARATOR, QueryBuilder, RebasePaginationError, and, buildCompositeId, collectAllPages, cond, mergeIncludeSpecs, normalizeOrderBy, not, or, paginateFind, resolveFindWindow, serializeFilter, serializeInclude, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
-import { toSnakeCase } from "@rebasepro/utils";
+import { toSnakeCase, unref } from "@rebasepro/utils";
 //#region src/reviver.ts
 function rebaseReviver(_key, value) {
 	if (value && typeof value === "object" && "__type" in value) {
@@ -2490,6 +2490,23 @@ var CHANNEL_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 	"channel_history"
 ]);
 /**
+* The other direction: the frame types the *server* addresses by channel.
+*
+* Not the mirror of {@link CHANNEL_MESSAGE_TYPES} — a request and its answer
+* have different names (`presence_state` is the one type in both) — so the two
+* sets are listed separately rather than derived from each other. These are
+* exactly the members of `ChannelMessage`; adding one here without declaring it
+* there leaves the handler with a frame it cannot read.
+*/
+var CHANNEL_FRAME_TYPES = /* @__PURE__ */ new Set([
+	"broadcast",
+	"presence_state",
+	"presence_diff",
+	"channel_history",
+	"error",
+	"ERROR"
+]);
+/**
 * Low-level realtime WebSocket client.
 *
 * @internal Not a stable app-facing API. `createRebaseClient()` constructs and
@@ -2500,6 +2517,28 @@ var CHANNEL_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 * `@rebasepro/client-postgres` was removed; its surface may change without a
 * major bump.
 */
+/**
+* Narrow a frame to the collection-update shape. See its use below.
+*
+* `WebSocketMessage.type` is `string`, so the message types that extend it do
+* not form a discriminated union and `type === "collection_update"` narrows
+* nothing on its own.
+*/
+function isCollectionUpdate(message) {
+	return message.type === "collection_update";
+}
+/**
+* Narrow a frame to one of the channel-addressed shapes.
+*
+* Both halves of the test are load-bearing. The type says which member of
+* {@link ChannelMessage} it is; `channel` is what a channel frame is *addressed
+* by*, and an `ERROR` from a server older than the change that names the
+* channel has none — it is a generic error, and falls through to the catch-all
+* warning rather than being delivered to a channel that was never named.
+*/
+function isChannelMessage(message) {
+	return typeof message.channel === "string" && CHANNEL_FRAME_TYPES.has(message.type);
+}
 var RebaseWebSocketClient = class {
 	websocketUrl;
 	ws = null;
@@ -2683,6 +2722,7 @@ var RebaseWebSocketClient = class {
 			clearTimeout(this.reconnectTimeout);
 			this.reconnectTimeout = null;
 		}
+		this.suspendSubscribeWatchdogs();
 		if (this.ws) {
 			this.ws.onclose = null;
 			this.ws.onerror = null;
@@ -2864,7 +2904,7 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
-		if (typeof message.channel === "string" && (type === "broadcast" || type === "presence_state" || type === "presence_diff" || type === "channel_history" || type === "ERROR" || type === "error")) {
+		if (isChannelMessage(message)) {
 			const handlers = this.channelHandlers.get(message.channel);
 			if (handlers) for (const handler of [...handlers]) try {
 				handler(message);
@@ -2873,15 +2913,16 @@ var RebaseWebSocketClient = class {
 			}
 			return;
 		}
-		if (subscriptionId && type === "collection_update") {
+		if (subscriptionId && isCollectionUpdate(message)) {
+			const collectionUpdate = message;
 			const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
 			if (subscriptionKey) {
 				const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
 				if (collectionSub) {
 					const incomingRows = message.rows || [];
-					const updatePks = message.pks;
+					const updatePks = collectionUpdate.pks;
 					if (updatePks) collectionSub.pks = updatePks;
-					const updateMeta = message.meta;
+					const updateMeta = collectionUpdate.meta;
 					if (updateMeta) collectionSub.latestMeta = updateMeta;
 					const rows = this.mergeRows(collectionSub.latestData, incomingRows, collectionSub.pks);
 					collectionSub.latestData = rows;
@@ -3747,7 +3788,7 @@ var RebaseRealtimeChannel = class {
 		this.catchUpInFlight = true;
 		if (this.catchUpTimeout) clearTimeout(this.catchUpTimeout);
 		this.catchUpTimeout = setTimeout(() => this.abandonCatchUp(), CATCH_UP_TIMEOUT_MS);
-		this.catchUpTimeout.unref?.();
+		unref(this.catchUpTimeout);
 		try {
 			await this.send("channel_history", {
 				sinceSeq: this.lastSeq,
@@ -3793,7 +3834,7 @@ var RebaseRealtimeChannel = class {
 				if (!this.trackedState) return;
 				this.send("presence_track", { state: this.trackedState }).catch(() => {});
 			}, PRESENCE_HEARTBEAT_MS);
-			this.heartbeat.unref?.();
+			unref(this.heartbeat);
 		}
 	}
 	/** Stop publishing presence, without leaving the channel. */
@@ -3921,12 +3962,11 @@ var RebaseRealtimeChannel = class {
 	handle(message) {
 		switch (message.type) {
 			case "presence_state":
-				this.presences = message.presences ?? {};
+				this.presences = message.presences;
 				this.emitPresence();
 				break;
 			case "presence_diff": {
-				const joins = message.joins ?? {};
-				const leaves = message.leaves ?? {};
+				const { joins, leaves } = message;
 				for (const [id, state] of Object.entries(joins)) this.presences[id] = state;
 				for (const id of Object.keys(leaves)) delete this.presences[id];
 				this.emitPresence({
@@ -3936,7 +3976,7 @@ var RebaseRealtimeChannel = class {
 				break;
 			}
 			case "broadcast": {
-				const seq = typeof message.seq === "number" ? message.seq : void 0;
+				const seq = message.seq;
 				const event = {
 					event: message.event,
 					payload: message.payload,
@@ -3961,9 +4001,7 @@ var RebaseRealtimeChannel = class {
 					clearTimeout(this.catchUpTimeout);
 					this.catchUpTimeout = null;
 				}
-				const entries = message.messages ?? [];
-				const retained = message.retained === true;
-				const latestSeq = typeof message.latestSeq === "number" ? message.latestSeq : void 0;
+				const { messages: entries, retained, latestSeq } = message;
 				for (const resolve of this.historyWaiters.splice(0)) resolve({
 					messages: entries,
 					retained,
@@ -3985,8 +4023,8 @@ var RebaseRealtimeChannel = class {
 			case "ERROR":
 			case "error": {
 				const raw = message.payload?.error;
-				const asObject = typeof raw === "object" && raw !== null ? raw : void 0;
-				const text = asObject?.message ?? (typeof raw === "string" ? raw : void 0) ?? (typeof message.error === "string" ? message.error : void 0) ?? "The server refused a channel operation.";
+				const asObject = typeof raw === "object" ? raw : void 0;
+				const text = asObject?.message ?? (typeof raw === "string" ? raw : void 0) ?? message.error ?? "The server refused a channel operation.";
 				const error = new RebaseApiError$1(text, { ...asObject?.code ? { code: asObject.code } : {} });
 				if (this.errorHandlers.size === 0) {
 					console.warn(`[Rebase] Channel "${this.name}" error${asObject?.code ? ` (${asObject.code})` : ""}: ${text}. Attach \`channel.onError(...)\` to handle it.`);
@@ -4285,7 +4323,7 @@ var ConnectivityMonitor = class {
 			this.timer = void 0;
 			this.onRetryDue?.();
 		}, delay);
-		this.timer.unref?.();
+		unref(this.timer);
 	}
 	clearPendingTimer() {
 		if (this.timer !== void 0) {
@@ -4948,6 +4986,31 @@ function generateOfflineNumericId() {
 	lastOfflineNumericId = lastOfflineNumericId === 0 ? candidate : Math.min(candidate, lastOfflineNumericId - 1);
 	return lastOfflineNumericId;
 }
+/**
+* The row an optimistic write puts in the cache before the server has seen it.
+*
+* It is NOT an `M`, and saying so is the point of collecting this in one place.
+* `M` is the row as the database has it — every server default, every generated
+* column, every `afterRead` transform. What an optimistic write has is the
+* fields the caller supplied (plus, on an update, whatever was already cached)
+* and an id, which may itself be a locally-minted placeholder.
+*
+* The two are reconciled when the queued write drains and the server's row
+* replaces this one. Until then the SDK hands the caller this, under `M`,
+* because that is what the offline API's return type promises — and there is
+* nothing in this file that can make that promise true.
+*
+* So: one deliberate assertion, named, rather than five spread across the
+* create / createMany / update / upsert paths, each free to assemble the fields
+* differently. Fixing it properly means the offline surface saying what it
+* actually returns, which is a change to its public types.
+*/
+function optimisticRow(fields, id) {
+	return {
+		...fields,
+		id
+	};
+}
 var MISSING = "\0missing";
 /**
 * Replays to spend on a mutation whose idempotency key the server is still
@@ -5034,7 +5097,7 @@ var OfflineManager = class {
 		if ((config.crossTab ?? this.store instanceof IndexedDBOfflineStore) && typeof BroadcastChannel !== "undefined") try {
 			this.channel = new BroadcastChannel("rebase-offline");
 			this.channel.onmessage = (event) => this.onBroadcast(event.data);
-			this.channel.unref?.();
+			unref(this.channel);
 		} catch {}
 		this.api = {
 			sync: () => this.sync(),
@@ -5197,10 +5260,7 @@ var OfflineManager = class {
 				}
 				const providedId = id ?? data.id;
 				const rowId = providedId ?? this.mintOfflineId(slug);
-				const row = {
-					...data,
-					id: rowId
-				};
+				const row = optimisticRow(data, rowId);
 				await this.enqueue({
 					collection: slug,
 					type: "create",
@@ -5228,10 +5288,7 @@ var OfflineManager = class {
 					if (!isNetworkError(error)) throw error;
 					this.connectivity.markFailure();
 				}
-				const rows = data.map((r) => ({
-					...r,
-					id: r.id ?? this.mintOfflineId(slug)
-				}));
+				const rows = data.map((r) => optimisticRow(r, r.id ?? this.mintOfflineId(slug)));
 				const rollback = {};
 				for (const row of rows) {
 					const key = String(row.id);
@@ -5274,10 +5331,7 @@ var OfflineManager = class {
 				}
 				const rowId = data.id;
 				if (options?.onConflict?.length || rowId === void 0) throw new RebaseClientError(`Cannot upsert into "${slug}" while offline: the row it would replace can only be found by the server. Upserting on the primary key, with the key in the row, is queued; upserting on a natural key is not.`, { code: "OFFLINE_UPSERT_UNSUPPORTED" });
-				const row = {
-					...data,
-					id: rowId
-				};
+				const row = optimisticRow(data, rowId);
 				await this.enqueue({
 					collection: slug,
 					type: "createMany",
@@ -5309,11 +5363,10 @@ var OfflineManager = class {
 				for (const { id, data } of updates) {
 					const base = this.rawLocalRow(slug, id);
 					rollback[String(id)] = base ?? null;
-					optimistic.push({
+					optimistic.push(optimisticRow({
 						...base ?? {},
-						...data,
-						id
-					});
+						...data
+					}, id));
 				}
 				await this.enqueue({
 					collection: slug,
@@ -5376,11 +5429,10 @@ var OfflineManager = class {
 					data,
 					rollback: { rows: { [String(id)]: base ?? null } }
 				});
-				const optimistic = {
+				const optimistic = optimisticRow({
 					...base ?? {},
-					...data,
-					id
-				};
+					...data
+				}, id);
 				this.setLocalRow(slug, id, optimistic);
 				this.notifyCollection(slug);
 				return optimistic;