@rebasepro/server-mongo 0.21.1-canary.g8c5a265 → 0.21.1

package/dist/index.es.js

@@ -1,7 +1,7 @@
 import { MongoClient, ObjectId } from "mongodb";
 import { ANONYMOUS_USER_ID, EntityReference, ListLimitError, getCollectionDataPath, isAnonymousUid, resolveClientListLimit } from "@rebasepro/types";
 import { buildPropertyCallbacks, buildSdkData, callbackRefusal, checkOperation, normalizeDriverOrderBy, normalizeEmail, requireCallbackClient, securityRuleToConditions, toCallbackError, toFilterTuples, updateDateAutoValues } from "@rebasepro/common";
-import { ApiError, logger } from "@rebasepro/server";
+import { ApiError, declaredErrorAnswer, logger } from "@rebasepro/server";
 import { mergeDeep } from "@rebasepro/utils";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -511,6 +511,44 @@ var MongoDataService = class {
 * Provides real-time subscriptions to collection and row changes.
 */
 /**
+* The answer a failed fetch chose for its caller, when it chose one.
+*
+* A deliberate 4xx — the server's `ApiError`, or the `RebaseApiError` a
+* collection callback throws because a collection file cannot import the
+* server — was decided about this caller, and its message and code are written
+* for them. It is recognised by `declaredErrorAnswer`, the predicate REST and
+* this socket's request frames use. A declared 5xx is not one: its message is
+* about the server, and the Postgres subscription path masks it too.
+*/
+var refusalOf = (error) => {
+	const answer = declaredErrorAnswer(error);
+	return answer && answer.status >= 400 && answer.status < 500 ? answer : void 0;
+};
+/**
+* The frame that tells a subscriber its fetch failed, addressed by the
+* subscription id the client keys its listeners on — the shape of the
+* `INVALID_LIMIT` refusal below.
+*
+* A refusal keeps its message, code and details. Anything else is a fault
+* whose text can name internals (hosts, collections, a document's values), so
+* the subscriber reads a generic message, the same words the Postgres path
+* uses, and the full error goes to the log.
+*/
+function subscriptionErrorFrame(subscriptionId, path, error) {
+	const refusal = refusalOf(error);
+	const message = refusal?.message ?? `Could not load data for "${path ?? ""}". Check server logs for details.`;
+	return {
+		type: "ERROR",
+		subscriptionId,
+		payload: { error: {
+			message,
+			code: refusal?.code ?? "INTERNAL_ERROR",
+			...refusal?.details !== void 0 && { details: refusal.details }
+		} },
+		error: message
+	};
+}
+/**
 * The query half of a subscription config — everything except who is watching.
 *
 * Spread into the re-fetch rather than re-listed field by field. Re-listing is
@@ -564,20 +602,53 @@ var MongoRealtimeService = class {
 	* fetch behind it is the newest thing known about the row, so it must also
 	* be the thing that closes the door on an older fetch still in flight —
 	* otherwise the deleted row reappears a moment after it vanished.
+	*
+	* `mayReportFailure()` is the same check for reporting this delivery's
+	* failure, except that it also answers yes to the delivery that already
+	* claimed the slot. That is the send itself failing (the socket closure's
+	* `JSON.stringify` on a row that will not serialise) after the check passed
+	* and before anything reached the subscriber. Same rule as the Postgres
+	* service's `beginDelivery`.
 	*/
 	beginDelivery(subscriptionId, subscription) {
 		const seq = ++subscription.started;
-		return () => {
+		const canDeliver = () => {
 			if (this.subscriptions.get(subscriptionId) !== subscription) return false;
 			if (seq <= subscription.delivered) return false;
 			subscription.delivered = seq;
 			return true;
 		};
+		const mayReportFailure = () => canDeliver() || this.subscriptions.get(subscriptionId) === subscription && subscription.delivered === seq;
+		return Object.assign(canDeliver, { mayReportFailure });
+	}
+	/**
+	* Tell the subscriber a fetch failed, through the slot the rows would have
+	* used.
+	*
+	* The slot matters as much for an error as for rows. Without it, a fetch
+	* that a newer delivery has overtaken would mark a view showing current
+	* data as failed, and one whose subscription was cancelled or replaced
+	* under the same id would fail a different subscription's view.
+	*/
+	reportFetchFailure(subscriptionId, subscription, canDeliver, error) {
+		const target = subscription.type === "single" ? "row" : "collection";
+		const refusal = refusalOf(error);
+		if (refusal) {
+			const line = `[API ${refusal.status} ${refusal.code}] fetching ${target} for subscription ${subscriptionId}: ${refusal.message}`;
+			if (refusal.expected) logger.debug(line);
+			else logger.warn(`⚠️ ${line}`);
+		} else logger.error(`Error fetching ${target} for subscription ${subscriptionId}`, { error });
+		if (!subscription.onError || !canDeliver.mayReportFailure()) return;
+		try {
+			subscription.onError(error);
+		} catch (reportError) {
+			logger.error(`Could not report a failed fetch to subscription ${subscriptionId}`, { error: reportError });
+		}
 	}
 	/**
 	* Subscribe to collection changes
 	*/
-	subscribeToCollection(subscriptionId, config, callback) {
+	subscribeToCollection(subscriptionId, config, callback, onError) {
 		this.unsubscribe(subscriptionId);
 		const collectionName = this.getCollectionName(config.path);
 		const collection = this.db.collection(collectionName);
@@ -595,6 +666,7 @@ var MongoRealtimeService = class {
 				config,
 				changeStream,
 				callback,
+				onError,
 				started: 0,
 				delivered: 0
 			};
@@ -612,6 +684,7 @@ var MongoRealtimeService = class {
 				type: "collection",
 				config,
 				callback,
+				onError,
 				started: 0,
 				delivered: 0
 			};
@@ -635,7 +708,7 @@ var MongoRealtimeService = class {
 			});
 			if (callback && canDeliver()) callback(rows);
 		} catch (error) {
-			logger.error(`Error fetching collection for subscription ${subscriptionId}`, { error });
+			this.reportFetchFailure(subscriptionId, subscription, canDeliver, error);
 		}
 	}
 	/**
@@ -648,14 +721,19 @@ var MongoRealtimeService = class {
 		if (!this.driver) throw new Error("MongoRealtimeService has no data driver — subscriptions cannot be authorized");
 		const user = {
 			uid: authContext?.uid ?? ANONYMOUS_USER_ID,
-			roles: authContext?.roles ?? []
+			roles: authContext?.roles ?? [],
+			isAnonymous: authContext?.isAnonymous === true,
+			displayName: null,
+			email: null,
+			photoURL: null,
+			providerId: "realtime"
 		};
 		return this.driver.withAuth(user);
 	}
 	/**
 	* Subscribe to single row changes
 	*/
-	subscribeToOne(subscriptionId, config, callback) {
+	subscribeToOne(subscriptionId, config, callback, onError) {
 		this.unsubscribe(subscriptionId);
 		const collectionName = this.getCollectionName(config.path);
 		const collection = this.db.collection(collectionName);
@@ -675,6 +753,7 @@ var MongoRealtimeService = class {
 				config,
 				changeStream,
 				callback,
+				onError,
 				started: 0,
 				delivered: 0
 			};
@@ -695,6 +774,7 @@ var MongoRealtimeService = class {
 				type: "single",
 				config,
 				callback,
+				onError,
 				started: 0,
 				delivered: 0
 			};
@@ -718,7 +798,7 @@ var MongoRealtimeService = class {
 			});
 			if (callback && canDeliver()) callback(row || null);
 		} catch (error) {
-			logger.error(`Error fetching row for subscription ${subscriptionId}`, { error });
+			this.reportFetchFailure(subscriptionId, subscription, canDeliver, error);
 		}
 	}
 	/**
@@ -787,7 +867,8 @@ var MongoRealtimeService = class {
 		if (!ws) return;
 		const authContext = _authContext ? {
 			uid: _authContext.uid,
-			roles: (_authContext.roles ?? []).map(String)
+			roles: (_authContext.roles ?? []).map(String),
+			isAnonymous: _authContext.isAnonymous === true
 		} : void 0;
 		switch (message.type) {
 			case "subscribe_collection": {
@@ -829,6 +910,8 @@ var MongoRealtimeService = class {
 						subscriptionId,
 						rows
 					}));
+				}, (error) => {
+					ws.send(JSON.stringify(subscriptionErrorFrame(subscriptionId, message.payload?.path, error)));
 				});
 				break;
 			}
@@ -846,6 +929,8 @@ var MongoRealtimeService = class {
 						subscriptionId,
 						row
 					}));
+				}, (error) => {
+					ws.send(JSON.stringify(subscriptionErrorFrame(subscriptionId, message.payload?.path, error)));
 				});
 				break;
 			}
@@ -1239,6 +1324,18 @@ function callContext(driver, user, data, client) {
 	};
 }
 /**
+* A listener's `onError`, in the shape the realtime service calls it with.
+*
+* Without it a failed fetch behind an in-process subscription was logged, and
+* the listener heard nothing and kept waiting for rows. The error arrives as
+* thrown, not masked the way a socket frame is: this is trusted server code,
+* so an `afterRead` refusal reaches it as the `RebaseApiError` it is.
+*/
+function fetchErrorListener(onError) {
+	if (!onError) return void 0;
+	return (error) => onError(error instanceof Error ? error : new Error(String(error)));
+}
+/**
 * MongoDB DataDriver Delegate
 *
 * Implements the DataDriver interface for Rebase.
@@ -1360,7 +1457,7 @@ var MongoDriver = class {
 			clientId: "driver",
 			...query,
 			authContext
-		}, callback);
+		}, callback, fetchErrorListener(onError));
 		return () => {
 			this.realtimeService.unsubscribe(subscriptionId);
 		};
@@ -1414,7 +1511,7 @@ var MongoDriver = class {
 			path,
 			id,
 			authContext
-		}, callback);
+		}, callback, fetchErrorListener(onError));
 		return () => {
 			this.realtimeService.unsubscribe(subscriptionId);
 		};
@@ -1766,11 +1863,19 @@ var AuthenticatedMongoDriver = class {
 	listenCollection(props) {
 		return this.delegate.listenCollection(props, this.authContext());
 	}
-	/** The acting user, in the shape the realtime subscriptions carry. */
+	/**
+	* The acting user, in the shape the realtime subscriptions carry.
+	*
+	* `isAnonymous` included: a guest has a real uid, and without the flag
+	* every fetch a listener's subscription makes reads as an account, so
+	* `policy.registered()` handed a guest's listener what it withholds from a
+	* guest's `fetchCollection` on this same driver.
+	*/
 	authContext() {
 		return {
 			uid: this.user.uid,
-			roles: this.user.roles ?? []
+			roles: this.user.roles ?? [],
+			isAnonymous: this.user.isAnonymous === true
 		};
 	}
 	/**
@@ -2969,7 +3074,7 @@ function createMongoBootstrapper(mongoConfig) {
 		},
 		mountRoutes() {},
 		async initializeWebsockets(server, realtimeService, driver, config, authAdapter) {
-			const { createMongoWebSocket } = await import("./websocket-Cc1T8ETt.js");
+			const { createMongoWebSocket } = await import("./websocket-C3iT6srl.js");
 			createMongoWebSocket(server, realtimeService, driver, config, cachedAdmin, authAdapter);
 		}
 	};