@rebasepro/server-mongo 0.21.0 → 0.21.1

package/README.md

@@ -9,26 +9,26 @@ pnpm add @rebasepro/server-mongo
 ```
 
 ESM-only: `"type": "module"` with no CommonJS build, so it is loaded with
-`import`. `require()` of it resolves only on Node 22.12+, which supports
-`require(esm)`.
+`import`. It needs Node `>=22.22.0` (its `engines` floor), where `require()`
+of it resolves too: Node has supported `require(esm)` since 22.12.
 
 ## What This Package Does
 
-Implements the Rebase `BackendBootstrapper` and backend interfaces for MongoDB. Provides a complete data driver, change-stream-based realtime, snapshot history, auth repositories, and WebSocket support. Plug it into `@rebasepro/server` via `createMongoBootstrapper()`, or use the standalone `createMongoBackend()` factory for direct access.
+Implements the Rebase `BackendBootstrapper` and backend interfaces for MongoDB. Provides a complete data driver, change-stream-based realtime, entity history, auth repositories, and WebSocket support. Plug it into `@rebasepro/server` via `createMongoBootstrapper()`, or use the standalone `createMongoBackend()` factory for direct access.
 
 ## Key Exports
 
 | Export | Description |
 |--------|-------------|
 | `createMongoBootstrapper(config)` | Creates a `BackendBootstrapper` for use with `initializeRebaseBackend({ bootstrappers: [...] })`. |
-| `createMongoBackend(config)` | Standalone factory — returns a `MongoBackendInstance` with driver, snapshot service, realtime, admin, and lifecycle methods. |
+| `createMongoBackend(config)` | Standalone factory — returns a `MongoBackendInstance` with driver, data service, realtime, admin, and lifecycle methods. |
 | `createMongoDelegate(db)` | Convenience factory for just the `MongoDriver` (DataDriver). |
 | `createMongoRealtimeService(db)` | Creates a MongoDB change-stream-based realtime provider. |
-| `createMongoSnapshotRepository(db)` | Creates an `SnapshotRepository` for direct CRUD. |
+| `createMongoEntityRepository(db)` | Creates a `DataRepository` for direct CRUD. |
 | `createMongoDBConnection(url, dbName)` | Connects to MongoDB and returns a `MongoDBConnection` wrapper. |
 | `MongoDBConnection` | `DatabaseConnection` implementation wrapping `MongoClient` + `Db`. |
 | `MongoDriver` | The `DataDriver` implementation for MongoDB. |
-| `MongoSnapshotService` | Low-level snapshot CRUD service. |
+| `MongoDataService` | Low-level entity CRUD service (the `DataRepository` implementation). |
 | `MongoRealtimeService` | Change-stream-based `RealtimeProvider`. |
 | `MongoCollectionRegistry` | In-memory collection registry. |
 | `isMongoBackendConfig(config)` | Type guard for `MongoBackendConfig`. |
@@ -74,11 +74,11 @@ const backend = createMongoBackend({
 });
 
 // Use directly
-const health = await backend.healthCheck();
-const snapshots = await backend.snapshotService.fetchCollection("users", {});
+const health = await backend.healthCheck?.();
+const users = await backend.dataService.fetchCollection("users", {});
 
 // Cleanup
-await backend.destroy();
+await backend.destroy?.();
 ```
 
 ## Related Packages

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);
 		};
@@ -1570,9 +1667,15 @@ var MongoDriver = class {
 	*/
 	async delete({ row, collection }) {
 		const { collection: resolvedCollection, callbacks, globalCallbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, row.path);
+		const stored = await this.fetchOne({
+			path: row.path,
+			id: row.id,
+			collection: resolvedCollection
+		});
+		if (!stored) throw ApiError.notFound(`No row "${row.id}" in "${row.path}" to delete.`);
 		const callbackRow = {
 			id: row.id,
-			...row.values ?? {}
+			...stored
 		};
 		const contextForCallback = callContext(this, this.user, this.data, this.client);
 		try {
@@ -1638,7 +1741,7 @@ var MongoDriver = class {
 			action: "delete",
 			id: String(row.id),
 			tableName: row.path,
-			previousValues: row.values,
+			previousValues: stored,
 			updatedBy: this.user?.uid
 		}).catch((err) => {
 			logger.error(`Failed to record history for ${row.path}/${row.id}`, { error: err });
@@ -1760,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
 		};
 	}
 	/**
@@ -2963,7 +3074,7 @@ function createMongoBootstrapper(mongoConfig) {
 		},
 		mountRoutes() {},
 		async initializeWebsockets(server, realtimeService, driver, config, authAdapter) {
-			const { createMongoWebSocket } = await import("./websocket-B3LiQfFN.js");
+			const { createMongoWebSocket } = await import("./websocket-C3iT6srl.js");
 			createMongoWebSocket(server, realtimeService, driver, config, cachedAdmin, authAdapter);
 		}
 	};