@rebasepro/server-mongo 0.0.1-canary.4829d6e

package/dist/index.es.js

@@ -0,0 +1,2508 @@
+import { MongoClient, ObjectId } from "mongodb";
+import { EntityReference } from "@rebasepro/types";
+import { ApiError, logger } from "@rebasepro/server";
+import { buildPropertyCallbacks, buildSdkData, checkOperation, updateDateAutoValues } from "@rebasepro/common";
+import { mergeDeep } from "@rebasepro/utils";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/connection.ts
+/**
+* MongoDB Connection
+*
+* Wraps MongoDB connection to implement the DatabaseConnection interface.
+*/
+/**
+* MongoDB database connection wrapper that implements DatabaseConnection interface.
+*/
+var MongoDBConnection = class {
+	db;
+	client;
+	type = "mongodb";
+	constructor(db, client) {
+		this.db = db;
+		this.client = client;
+	}
+	get isConnected() {
+		try {
+			return this.client.topology?.isConnected?.() ?? false;
+		} catch {
+			return false;
+		}
+	}
+	async close() {
+		await this.client.close();
+	}
+};
+/**
+* Create a MongoDB database connection from a connection string.
+*
+* @param connectionString - MongoDB connection string (e.g., mongodb://localhost:27017)
+* @param databaseName - Name of the database to use
+* @returns Promise resolving to MongoDBConnection
+*
+* @example
+* ```typescript
+* const connection = await createMongoDBConnection(
+*     "mongodb://localhost:27017",
+*     "my_database"
+* );
+* ```
+*/
+async function createMongoDBConnection(connectionString, databaseName) {
+	const client = new MongoClient(connectionString);
+	await client.connect();
+	return new MongoDBConnection(client.db(databaseName), client);
+}
+//#endregion
+//#region src/db/MongoConditionBuilder.ts
+/**
+* Mapping from Rebase filter operators to MongoDB query operators
+*/
+var REBASE_TO_MONGO_OP = {
+	"<": "$lt",
+	"<=": "$lte",
+	"==": "$eq",
+	"!=": "$ne",
+	">=": "$gte",
+	">": "$gt",
+	"array-contains": "$elemMatch",
+	"array-contains-any": "$in",
+	"in": "$in",
+	"not-in": "$nin"
+};
+function escapeRegExp$1(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Translate a SQL LIKE/ILIKE pattern into an anchored regular expression.
+* `%` matches any sequence of characters, `_` matches a single character;
+* every other character is matched literally.
+*/
+function likePatternToRegExp(pattern, caseInsensitive) {
+	let body = "";
+	for (const ch of String(pattern)) if (ch === "%") body += ".*";
+	else if (ch === "_") body += ".";
+	else body += escapeRegExp$1(ch);
+	return new RegExp(`^${body}$`, caseInsensitive ? "i" : "");
+}
+/**
+* MongoDB Condition Builder
+*
+* Provides static methods to translate Rebase filter conditions
+* to MongoDB query filters.
+*/
+var MongoConditionBuilder = class {
+	/**
+	* Build MongoDB filter conditions from Rebase FilterValues
+	*
+	* @param filter - Rebase filter values
+	* @returns Array of MongoDB filter objects
+	*/
+	static buildFilterConditions(filter) {
+		if (!filter) return [];
+		const conditions = [];
+		for (const [field, filterParam] of Object.entries(filter)) {
+			if (!filterParam) continue;
+			const [op, value] = filterParam;
+			if (op === "is-null") {
+				conditions.push({ [field]: { $eq: null } });
+				continue;
+			}
+			if (op === "is-not-null") {
+				conditions.push({ [field]: { $ne: null } });
+				continue;
+			}
+			if (op === "like" || op === "ilike" || op === "not-like" || op === "not-ilike") {
+				const regex = likePatternToRegExp(value, op === "ilike" || op === "not-ilike");
+				const negated = op === "not-like" || op === "not-ilike";
+				conditions.push({ [field]: negated ? { $not: regex } : { $regex: regex } });
+				continue;
+			}
+			const mongoOp = REBASE_TO_MONGO_OP[op];
+			if (!mongoOp) {
+				logger.warn(`Unsupported filter operator: ${op}`);
+				continue;
+			}
+			if (op === "array-contains") conditions.push({ [field]: { $elemMatch: { $eq: value } } });
+			else conditions.push({ [field]: { [mongoOp]: value } });
+		}
+		return conditions;
+	}
+	/**
+	* Build search conditions for text search
+	*
+	* @param searchString - Text to search for
+	* @param properties - Properties to search in
+	* @returns Array of MongoDB filter objects for text search
+	*/
+	static buildSearchConditions(searchString, properties) {
+		if (!searchString) return [];
+		const orConditions = [];
+		const escapedSearch = escapeRegExp$1(searchString);
+		const searchRegex = new RegExp(escapedSearch, "i");
+		for (const [key, prop] of Object.entries(properties)) if (prop?.dataType === "string" || typeof prop === "string") orConditions.push({ [key]: { $regex: searchRegex } });
+		if (orConditions.length === 0) return [{ $text: { $search: searchString } }];
+		return orConditions;
+	}
+	/**
+	* Combine multiple conditions with AND operator
+	*
+	* @param conditions - Array of filter conditions
+	* @returns Combined filter or undefined if empty
+	*/
+	static combineConditionsWithAnd(conditions) {
+		if (conditions.length === 0) return void 0;
+		if (conditions.length === 1) return conditions[0];
+		return { $and: conditions };
+	}
+	/**
+	* Combine multiple conditions with OR operator
+	*
+	* @param conditions - Array of filter conditions
+	* @returns Combined filter or undefined if empty
+	*/
+	static combineConditionsWithOr(conditions) {
+		if (conditions.length === 0) return void 0;
+		if (conditions.length === 1) return conditions[0];
+		return { $or: conditions };
+	}
+	/**
+	* Build a complete MongoDB query from Rebase options
+	*
+	* @param options - Rebase fetch options
+	* @returns MongoDB filter object
+	*/
+	static buildQuery(options) {
+		const conditions = [];
+		if (options.filter) {
+			const filterConditions = this.buildFilterConditions(options.filter);
+			conditions.push(...filterConditions);
+		}
+		if (options.searchString && options.properties) {
+			const searchConditions = this.buildSearchConditions(options.searchString, options.properties);
+			if (searchConditions.length > 0) {
+				const searchFilter = this.combineConditionsWithOr(searchConditions);
+				if (searchFilter) conditions.push(searchFilter);
+			}
+		}
+		return this.combineConditionsWithAnd(conditions) ?? {};
+	}
+	/**
+	* Build MongoDB sort options from Rebase options
+	*
+	* @param orderBy - Field to order by
+	* @param order - Sort direction
+	* @returns MongoDB sort object
+	*/
+	static buildSort(orderBy, order) {
+		if (!orderBy) return void 0;
+		return { [orderBy]: order === "desc" ? -1 : 1 };
+	}
+};
+//#endregion
+//#region src/db/MongoDataService.ts
+/**
+* MongoDB Row Service
+*
+* Implements DataRepository interface for MongoDB.
+* Provides all CRUD operations for rows.
+*/
+/**
+* MongoDB Row Service
+*
+* Implements the DataRepository interface for MongoDB.
+* Provides all CRUD operations for rows stored in MongoDB collections.
+*/
+var MongoDataService = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Get a MongoDB collection by its path
+	*/
+	getCollection(collectionPath) {
+		const collectionName = collectionPath.replace(/\//g, "_");
+		return this.db.collection(collectionName);
+	}
+	/**
+	* Convert a string ID to ObjectId if it's a valid ObjectId string
+	*/
+	toObjectId(id) {
+		if (typeof id === "string" && ObjectId.isValid(id) && id.length === 24) return new ObjectId(id);
+		return id;
+	}
+	/**
+	* Convert a MongoDB document to a flat row (`{ id, ...fields }`)
+	*/
+	documentToRow(doc) {
+		const { _id, ...values } = doc;
+		return {
+			...this.convertFromMongoValues(values),
+			id: _id.toString()
+		};
+	}
+	/**
+	* Convert values from MongoDB format to Rebase format
+	*/
+	convertFromMongoValues(values) {
+		const result = {};
+		for (const [key, value] of Object.entries(values)) result[key] = this.convertFromMongoValue(value);
+		return result;
+	}
+	/**
+	* Convert a single value from MongoDB format
+	*/
+	convertFromMongoValue(value) {
+		if (value === null || value === void 0) return value;
+		if (value instanceof ObjectId) return value.toString();
+		if (value instanceof Date) return value;
+		if (Array.isArray(value)) return value.map((v) => this.convertFromMongoValue(v));
+		if (typeof value === "object") {
+			const keys = Object.keys(value);
+			const isTagged = value.__type === "reference" && "id" in value && "path" in value;
+			const isLegacy = keys.length === 2 && keys.includes("id") && keys.includes("path");
+			if (isTagged || isLegacy) return new EntityReference({
+				id: value.id instanceof ObjectId ? value.id.toString() : String(value.id),
+				path: value.path,
+				driver: value.driver,
+				databaseId: value.databaseId
+			});
+		}
+		if (typeof value === "object") return this.convertFromMongoValues(value);
+		return value;
+	}
+	/**
+	* Convert values to MongoDB format for storage
+	*/
+	convertToMongoValues(values) {
+		const result = {};
+		for (const [key, value] of Object.entries(values)) result[key] = this.convertToMongoValue(value);
+		return result;
+	}
+	/**
+	* Convert a single value to MongoDB format
+	*/
+	convertToMongoValue(value) {
+		if (value === null || value === void 0) return value;
+		if (typeof value === "object" && value.isEntityReference?.()) {
+			const ref = {
+				__type: "reference",
+				id: ObjectId.isValid(value.id) ? new ObjectId(value.id) : value.id,
+				path: value.path
+			};
+			if (value.driver !== void 0) ref.driver = value.driver;
+			if (value.databaseId !== void 0) ref.databaseId = value.databaseId;
+			return ref;
+		}
+		if (value instanceof Date) return value;
+		if (Array.isArray(value)) return value.map((v) => this.convertToMongoValue(v));
+		if (typeof value === "object") return this.convertToMongoValues(value);
+		return value;
+	}
+	/**
+	* Fetch a single row by ID
+	*/
+	async fetchOne(collectionPath, id, _databaseId) {
+		const collection = this.getCollection(collectionPath);
+		const objectId = this.toObjectId(id);
+		const doc = await collection.findOne({ _id: objectId });
+		if (!doc) return void 0;
+		return this.documentToRow(doc);
+	}
+	/**
+	* Fetch a collection of rows with optional filtering, ordering, and pagination
+	*/
+	async fetchCollection(collectionPath, options = {}) {
+		const collection = this.getCollection(collectionPath);
+		const query = options.rawQuery ?? MongoConditionBuilder.buildQuery({
+			filter: options.filter,
+			searchString: options.searchString,
+			properties: options.collection?.properties ?? {}
+		});
+		const findOptions = {};
+		const sort = MongoConditionBuilder.buildSort(options.orderBy, options.order);
+		if (sort) findOptions.sort = sort;
+		if (options.limit) findOptions.limit = options.limit;
+		if (options.startAfter !== void 0) findOptions.skip = Number(options.startAfter);
+		return (await collection.find(query, findOptions).toArray()).map((doc) => this.documentToRow(doc));
+	}
+	/**
+	* Search rows by text
+	*/
+	async searchRows(collectionPath, searchString, options = {}) {
+		return this.fetchCollection(collectionPath, {
+			...options,
+			searchString
+		});
+	}
+	/**
+	* Count rows in a collection
+	*/
+	async count(collectionPath, options = {}) {
+		const collection = this.getCollection(collectionPath);
+		const query = options.rawQuery ?? (options.filter ? MongoConditionBuilder.buildQuery({ filter: options.filter }) : {});
+		return collection.countDocuments(query);
+	}
+	/**
+	* Save an row (create or update)
+	*/
+	async save(collectionPath, values, id, _databaseId) {
+		const collection = this.getCollection(collectionPath);
+		const mongoValues = this.convertToMongoValues(values);
+		if (id) {
+			const objectId = this.toObjectId(id);
+			await collection.updateOne({ _id: objectId }, { $set: mongoValues }, { upsert: true });
+			return {
+				...values,
+				id: id.toString()
+			};
+		} else {
+			const newId = new ObjectId();
+			await collection.insertOne({
+				_id: newId,
+				...mongoValues
+			});
+			return {
+				...values,
+				id: newId.toString()
+			};
+		}
+	}
+	/**
+	* Delete an row by ID
+	*/
+	async delete(collectionPath, id, _databaseId) {
+		const collection = this.getCollection(collectionPath);
+		const objectId = this.toObjectId(id);
+		if ((await collection.deleteOne({ _id: objectId })).deletedCount === 0) logger.warn(`Row ${id} not found in collection ${collectionPath}`);
+	}
+	/**
+	* Check if a field value is unique in a collection
+	*/
+	async checkUniqueField(collectionPath, fieldName, value, excludeEntityId, _databaseId) {
+		const collection = this.getCollection(collectionPath);
+		const query = { [fieldName]: value };
+		if (excludeEntityId) query._id = { $ne: this.toObjectId(excludeEntityId) };
+		return await collection.countDocuments(query) === 0;
+	}
+	/**
+	* Generate a new row ID
+	*/
+	generateId() {
+		return new ObjectId().toString();
+	}
+};
+//#endregion
+//#region src/services/MongoRealtimeService.ts
+/**
+* MongoDB Realtime Service
+*
+* Implements RealtimeProvider interface using MongoDB Change Streams.
+* Provides real-time subscriptions to collection and row changes.
+*/
+/**
+* MongoDB Realtime Service
+*
+* Implements real-time subscriptions using MongoDB Change Streams.
+* Requires MongoDB replica set for change streams to work.
+*/
+var MongoRealtimeService = class {
+	db;
+	subscriptions = /* @__PURE__ */ new Map();
+	clients = /* @__PURE__ */ new Map();
+	dataService;
+	driver;
+	constructor(db) {
+		this.db = db;
+		this.dataService = new MongoDataService(db);
+	}
+	setDataDriver(driver) {
+		this.driver = driver;
+	}
+	/**
+	* Get the collection name from a path
+	*/
+	getCollectionName(path) {
+		return path.replace(/\//g, "_");
+	}
+	/**
+	* Subscribe to collection changes
+	*/
+	subscribeToCollection(subscriptionId, config, callback) {
+		this.unsubscribe(subscriptionId);
+		const collectionName = this.getCollectionName(config.path);
+		const collection = this.db.collection(collectionName);
+		const pipeline = [];
+		pipeline.push({ $match: { operationType: { $in: [
+			"insert",
+			"update",
+			"replace",
+			"delete"
+		] } } });
+		try {
+			const changeStream = collection.watch(pipeline, { fullDocument: "updateLookup" });
+			const subscription = {
+				type: "collection",
+				config,
+				changeStream,
+				callback,
+				authContext: config.authContext
+			};
+			this.subscriptions.set(subscriptionId, subscription);
+			this.fetchAndNotifyCollection(subscriptionId, config, callback);
+			changeStream.on("change", async (change) => {
+				await this.fetchAndNotifyCollection(subscriptionId, config, callback);
+			});
+			changeStream.on("error", (error) => {
+				logger.error(`Change stream error for subscription ${subscriptionId}`, { error });
+			});
+		} catch (error) {
+			logger.warn("Change streams not available, falling back to polling", { error });
+			const subscription = {
+				type: "collection",
+				config,
+				callback,
+				authContext: config.authContext
+			};
+			this.subscriptions.set(subscriptionId, subscription);
+			this.fetchAndNotifyCollection(subscriptionId, config, callback);
+		}
+	}
+	/**
+	* Fetch collection and notify callback
+	*/
+	async fetchAndNotifyCollection(subscriptionId, config, callback) {
+		try {
+			let rows;
+			const registryCollection = this.driver?.registry?.getCollectionByPath(config.path);
+			if (config.authContext && this.driver) {
+				const mockUser = {
+					uid: config.authContext.userId,
+					roles: config.authContext.roles
+				};
+				rows = await (await this.driver.withAuth(mockUser)).fetchCollection({
+					path: config.path,
+					collection: registryCollection,
+					filter: config.filter,
+					orderBy: config.orderBy,
+					order: config.order,
+					limit: config.limit,
+					startAfter: config.startAfter,
+					searchString: config.searchString
+				});
+			} else rows = await this.dataService.fetchCollection(config.path, {
+				filter: config.filter,
+				orderBy: config.orderBy,
+				order: config.order,
+				limit: config.limit,
+				startAfter: config.startAfter,
+				searchString: config.searchString,
+				collection: registryCollection
+			});
+			if (callback) callback(rows);
+		} catch (error) {
+			logger.error(`Error fetching collection for subscription ${subscriptionId}`, { error });
+		}
+	}
+	/**
+	* Subscribe to single row changes
+	*/
+	subscribeToOne(subscriptionId, config, callback) {
+		this.unsubscribe(subscriptionId);
+		const collectionName = this.getCollectionName(config.path);
+		const collection = this.db.collection(collectionName);
+		const pipeline = [{ $match: {
+			"documentKey._id": typeof config.id === "string" && ObjectId.isValid(config.id) ? new ObjectId(config.id) : config.id,
+			operationType: { $in: [
+				"insert",
+				"update",
+				"replace",
+				"delete"
+			] }
+		} }];
+		try {
+			const changeStream = collection.watch(pipeline, { fullDocument: "updateLookup" });
+			const subscription = {
+				type: "single",
+				config,
+				changeStream,
+				callback,
+				authContext: config.authContext
+			};
+			this.subscriptions.set(subscriptionId, subscription);
+			this.fetchAndNotifyOne(subscriptionId, config, callback);
+			changeStream.on("change", async (change) => {
+				if (change.operationType === "delete") {
+					if (callback) callback(null);
+				} else await this.fetchAndNotifyOne(subscriptionId, config, callback);
+			});
+			changeStream.on("error", (error) => {
+				logger.error(`Change stream error for subscription ${subscriptionId}`, { error });
+			});
+		} catch (error) {
+			logger.warn("Change streams not available, falling back to polling", { error });
+			const subscription = {
+				type: "single",
+				config,
+				callback,
+				authContext: config.authContext
+			};
+			this.subscriptions.set(subscriptionId, subscription);
+			this.fetchAndNotifyOne(subscriptionId, config, callback);
+		}
+	}
+	/**
+	* Fetch row and notify callback
+	*/
+	async fetchAndNotifyOne(subscriptionId, config, callback) {
+		try {
+			let row;
+			const registryCollection = this.driver?.registry?.getCollectionByPath(config.path);
+			if (config.authContext && this.driver) {
+				const mockUser = {
+					uid: config.authContext.userId,
+					roles: config.authContext.roles
+				};
+				row = await (await this.driver.withAuth(mockUser)).fetchOne({
+					path: config.path,
+					id: config.id,
+					collection: registryCollection
+				});
+			} else row = await this.dataService.fetchOne(config.path, config.id);
+			if (callback) callback(row || null);
+		} catch (error) {
+			logger.error(`Error fetching row for subscription ${subscriptionId}`, { error });
+		}
+	}
+	/**
+	* Unsubscribe from a subscription
+	*/
+	unsubscribe(subscriptionId) {
+		const subscription = this.subscriptions.get(subscriptionId);
+		if (subscription) {
+			if (subscription.changeStream) subscription.changeStream.close().catch((err) => logger.error("Operation failed", { error: err }));
+			this.subscriptions.delete(subscriptionId);
+		}
+	}
+	/**
+	* Notify all relevant subscribers of an row update
+	* This is called after save/delete operations to push updates
+	*/
+	async notifyUpdate(path, id, row, _databaseId) {
+		for (const [subscriptionId, subscription] of this.subscriptions) if (subscription.type === "single") {
+			const config = subscription.config;
+			if (config.path === path && config.id.toString() === id) {
+				if (subscription.callback) subscription.callback(row);
+			}
+		} else if (subscription.type === "collection") {
+			const config = subscription.config;
+			if (config.path === path) await this.fetchAndNotifyCollection(subscriptionId, config, subscription.callback);
+		}
+	}
+	/**
+	* Get all active subscriptions (for debugging)
+	*/
+	getSubscriptions() {
+		return this.subscriptions;
+	}
+	/**
+	* Close all subscriptions
+	*/
+	async closeAll() {
+		for (const [subscriptionId] of this.subscriptions) this.unsubscribe(subscriptionId);
+	}
+	/**
+	* Register a WebSocket client for real-time communication
+	*/
+	addClient(clientId, ws) {
+		this.clients.set(clientId, ws);
+		ws.on("close", () => {
+			this.removeClient(clientId);
+		});
+		ws.on("error", (error) => {
+			logger.error("WebSocket error for client", {
+				detail: clientId,
+				error
+			});
+			this.removeClient(clientId);
+		});
+	}
+	/**
+	* Remove a WebSocket client and clean up its subscriptions
+	*/
+	removeClient(clientId) {
+		this.clients.delete(clientId);
+	}
+	/**
+	* Handle an incoming WebSocket message for subscription management
+	*/
+	async handleClientMessage(clientId, message, _authContext) {
+		const ws = this.clients.get(clientId);
+		if (!ws) return;
+		const authContext = _authContext ? {
+			userId: _authContext.userId,
+			roles: (_authContext.roles ?? []).map(String)
+		} : void 0;
+		switch (message.type) {
+			case "subscribe_collection": {
+				const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+				if (!subscriptionId) return;
+				this.subscribeToCollection(subscriptionId, {
+					clientId,
+					path: message.payload?.path,
+					filter: message.payload?.filter,
+					orderBy: message.payload?.orderBy,
+					order: message.payload?.order,
+					limit: message.payload?.limit,
+					startAfter: message.payload?.startAfter,
+					searchString: message.payload?.searchString,
+					authContext
+				}, (rows) => {
+					ws.send(JSON.stringify({
+						type: "collection_update",
+						subscriptionId,
+						rows
+					}));
+				});
+				break;
+			}
+			case "subscribe_one": {
+				const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+				if (!subscriptionId) return;
+				this.subscribeToOne(subscriptionId, {
+					clientId,
+					path: message.payload?.path,
+					id: message.payload?.id,
+					authContext
+				}, (row) => {
+					ws.send(JSON.stringify({
+						type: "single_update",
+						subscriptionId,
+						row
+					}));
+				});
+				break;
+			}
+			case "unsubscribe": {
+				const subscriptionId = message.payload?.subscriptionId ?? message.subscriptionId;
+				if (subscriptionId) this.unsubscribe(subscriptionId);
+				break;
+			}
+		}
+	}
+};
+//#endregion
+//#region src/services/MongoHistoryService.ts
+var MongoHistoryService_exports = /* @__PURE__ */ __exportAll({
+	MongoHistoryService: () => MongoHistoryService,
+	findChangedFields: () => findChangedFields
+});
+/**
+* Deep equality without JSON.stringify.
+* Handles primitives, arrays, Dates, and plain objects recursively.
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((v, i) => deepEqual(v, b[i]));
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const aObj = a;
+		const bObj = b;
+		const aKeys = Object.keys(aObj);
+		const bKeys = Object.keys(bObj);
+		if (aKeys.length !== bKeys.length) return false;
+		return aKeys.every((k) => deepEqual(aObj[k], bObj[k]));
+	}
+	return false;
+}
+/**
+* Shallow comparison to find top-level keys that changed between two objects.
+*/
+function findChangedFields(oldValues, newValues) {
+	const changed = [];
+	const allKeys = new Set([...Object.keys(oldValues), ...Object.keys(newValues)]);
+	for (const key of allKeys) {
+		const oldVal = oldValues[key];
+		const newVal = newValues[key];
+		if (key.startsWith("__")) continue;
+		if (oldVal !== newVal) if (typeof oldVal === "object" && oldVal !== null && typeof newVal === "object" && newVal !== null) {
+			if (!deepEqual(oldVal, newVal)) changed.push(key);
+		} else changed.push(key);
+	}
+	return changed.length > 0 ? changed : null;
+}
+var DEFAULT_RETENTION = {
+	maxEntries: 200,
+	ttlDays: 90
+};
+var MongoHistoryService = class {
+	db;
+	retention;
+	constructor(db, retention) {
+		this.db = db;
+		this.retention = {
+			...DEFAULT_RETENTION,
+			...retention
+		};
+	}
+	async recordHistory(params) {
+		const { tableName, id, action, values, previousValues, updatedBy } = params;
+		const changedFields = previousValues && values ? findChangedFields(previousValues, values) : null;
+		if (action === "update" && (!changedFields || changedFields.length === 0)) return;
+		try {
+			const entry = {
+				id: new ObjectId().toString(),
+				table_name: tableName,
+				entity_id: String(id),
+				action,
+				changed_fields: changedFields,
+				values: values || null,
+				previous_values: previousValues || null,
+				updated_by: updatedBy || null,
+				updated_at: /* @__PURE__ */ new Date()
+			};
+			await this.db.collection("__rebase_history").insertOne(entry);
+			this.pruneHistory(String(id), tableName).catch((e) => {
+				logger.error(`[HistoryService] Failed to prune history for ${tableName}/${id}`, { error: e });
+			});
+		} catch (error) {
+			logger.error(`[HistoryService] Failed to record history for ${tableName}/${id}`, { error });
+		}
+	}
+	async pruneHistory(id, tableName) {
+		const collection = this.db.collection("__rebase_history");
+		const count = await collection.countDocuments({
+			entity_id: id,
+			table_name: tableName
+		});
+		if (count > this.retention.maxEntries) {
+			const toDelete = count - this.retention.maxEntries;
+			const oldestEntries = await collection.find({
+				entity_id: id,
+				table_name: tableName
+			}).sort({ updated_at: 1 }).limit(toDelete).toArray();
+			if (oldestEntries.length > 0) {
+				const idsToDelete = oldestEntries.map((entry) => entry._id);
+				await collection.deleteMany({ _id: { $in: idsToDelete } });
+			}
+		}
+		const cutoffDate = /* @__PURE__ */ new Date();
+		cutoffDate.setDate(cutoffDate.getDate() - this.retention.ttlDays);
+		await collection.deleteMany({
+			entity_id: id,
+			table_name: tableName,
+			updated_at: { $lt: cutoffDate }
+		});
+	}
+};
+//#endregion
+//#region src/services/MongoDriver.ts
+/**
+* MongoDB DataDriver Delegate
+*
+* Implements the DataDriver interface for Rebase.
+* Provides all data operations needed by the Rebase frontend.
+*/
+var MongoDriver = class {
+	db;
+	registry;
+	key = "mongodb";
+	initialised = true;
+	dataService;
+	realtimeService;
+	historyService;
+	user;
+	data;
+	client;
+	constructor(db, realtimeService, historyService, registry, user) {
+		this.db = db;
+		this.registry = registry;
+		this.dataService = new MongoDataService(db);
+		this.realtimeService = realtimeService ?? new MongoRealtimeService(db);
+		this.historyService = historyService ?? new MongoHistoryService(db);
+		this.user = user;
+		this.data = buildSdkData(this);
+		this.realtimeService.setDataDriver(this);
+	}
+	/**
+	* Get the current timestamp
+	*/
+	currentTime() {
+		return /* @__PURE__ */ new Date();
+	}
+	/**
+	* Resolve a collection's callbacks and property callbacks from the registry.
+	* Used by AuthenticatedMongoDriver to apply callbacks after RLS filtering.
+	*/
+	resolveCollectionCallbacks(collection, path) {
+		if (!collection && !path) return {
+			collection: void 0,
+			callbacks: void 0,
+			globalCallbacks: void 0,
+			propertyCallbacks: void 0
+		};
+		const registryCollection = this.registry?.getCollectionByPath(path);
+		const resolvedCollection = registryCollection ? {
+			...collection,
+			...registryCollection
+		} : collection;
+		const callbacks = resolvedCollection?.callbacks;
+		const globalCallbacks = this.registry?.getGlobalCallbacks();
+		const properties = resolvedCollection?.properties;
+		let propertyCallbacks;
+		if (properties) propertyCallbacks = buildPropertyCallbacks(properties);
+		return {
+			collection: resolvedCollection,
+			callbacks,
+			globalCallbacks,
+			propertyCallbacks
+		};
+	}
+	/**
+	* Fetch a collection of rows
+	*/
+	async fetchCollection({ path, collection, filter, limit, startAfter, orderBy, searchString, order }) {
+		const rows = await this.dataService.fetchCollection(path, {
+			filter,
+			limit,
+			startAfter,
+			orderBy,
+			order,
+			searchString,
+			collection
+		});
+		const { collection: resolvedCollection, callbacks, globalCallbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+		if (globalCallbacks?.afterRead || callbacks?.afterRead || propertyCallbacks?.afterRead) {
+			const contextForCallback = {
+				user: this.user,
+				driver: this,
+				data: this.data,
+				client: this.client,
+				storageSource: this.client?.storage
+			};
+			return Promise.all(rows.map(async (row) => {
+				let fetched = row;
+				if (globalCallbacks?.afterRead) fetched = await globalCallbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				if (callbacks?.afterRead) fetched = await callbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				if (propertyCallbacks?.afterRead) fetched = await propertyCallbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				return fetched;
+			}));
+		}
+		return rows;
+	}
+	/**
+	* Listen to collection changes
+	*/
+	listenCollection({ path, collection, filter, limit, startAfter, orderBy, searchString, order, onUpdate, onError }) {
+		const subscriptionId = this.generateSubscriptionId();
+		const callback = (rows) => {
+			try {
+				onUpdate(rows);
+			} catch (error) {
+				logger.error("Error in collection update callback", { error });
+				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		this.realtimeService.subscribeToCollection(subscriptionId, {
+			clientId: "driver",
+			path,
+			filter,
+			orderBy,
+			order,
+			limit,
+			startAfter,
+			searchString
+		}, callback);
+		return () => {
+			this.realtimeService.unsubscribe(subscriptionId);
+		};
+	}
+	/**
+	* Fetch a single row
+	*/
+	async fetchOne({ path, id, databaseId, collection }) {
+		let row = await this.dataService.fetchOne(path, id, databaseId);
+		const { collection: resolvedCollection, callbacks, globalCallbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+		if (row && (globalCallbacks?.afterRead || callbacks?.afterRead || propertyCallbacks?.afterRead)) {
+			const contextForCallback = {
+				user: this.user,
+				driver: this,
+				data: this.data,
+				client: this.client,
+				storageSource: this.client?.storage
+			};
+			let processedRow = row;
+			if (globalCallbacks?.afterRead) processedRow = await globalCallbacks.afterRead({
+				collection: resolvedCollection,
+				path,
+				row: processedRow,
+				context: contextForCallback
+			}) ?? processedRow;
+			if (callbacks?.afterRead) processedRow = await callbacks.afterRead({
+				collection: resolvedCollection,
+				path,
+				row: processedRow,
+				context: contextForCallback
+			}) ?? processedRow;
+			if (propertyCallbacks?.afterRead) processedRow = await propertyCallbacks.afterRead({
+				collection: resolvedCollection,
+				path,
+				row: processedRow,
+				context: contextForCallback
+			}) ?? processedRow;
+			row = processedRow;
+		}
+		return row;
+	}
+	/**
+	* Listen to row changes
+	*/
+	listenOne({ path, id, collection, onUpdate, onError }) {
+		const subscriptionId = this.generateSubscriptionId();
+		const callback = (row) => {
+			try {
+				onUpdate(row);
+			} catch (error) {
+				logger.error("Error in row update callback", { error });
+				if (onError) onError(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		this.realtimeService.subscribeToOne(subscriptionId, {
+			clientId: "driver",
+			path,
+			id
+		}, callback);
+		return () => {
+			this.realtimeService.unsubscribe(subscriptionId);
+		};
+	}
+	/**
+	* Save an row (create or update)
+	*/
+	async save({ path, id, values, collection, status }) {
+		const { collection: resolvedCollection, callbacks, globalCallbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
+		let updatedValues = values;
+		const contextForCallback = {
+			user: this.user,
+			driver: this,
+			data: this.data,
+			client: this.client,
+			storageSource: this.client?.storage
+		};
+		let previousValuesForHistory;
+		if (status === "existing" && id) {
+			const existing = await this.dataService.fetchOne(path, id, resolvedCollection?.databaseId);
+			if (existing) {
+				const { id: _existingId, ...existingValues } = existing;
+				previousValuesForHistory = existingValues;
+			}
+		}
+		if (globalCallbacks?.beforeSave || callbacks?.beforeSave || propertyCallbacks?.beforeSave) {
+			if (globalCallbacks?.beforeSave) {
+				const result = await globalCallbacks.beforeSave({
+					collection: resolvedCollection,
+					path,
+					id,
+					values: updatedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+				if (result) updatedValues = mergeDeep(updatedValues, result);
+			}
+			if (callbacks?.beforeSave) {
+				const result = await callbacks.beforeSave({
+					collection: resolvedCollection,
+					path,
+					id,
+					values: updatedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+				if (result) updatedValues = mergeDeep(updatedValues, result);
+			}
+			if (propertyCallbacks?.beforeSave) {
+				const result = await propertyCallbacks.beforeSave({
+					collection: resolvedCollection,
+					path,
+					id,
+					values: updatedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+				if (result) updatedValues = mergeDeep(updatedValues, result);
+			}
+		}
+		if (resolvedCollection?.properties) updatedValues = updateDateAutoValues({
+			inputValues: updatedValues,
+			properties: resolvedCollection.properties,
+			status: status ?? "new",
+			timestampNowValue: /* @__PURE__ */ new Date()
+		});
+		try {
+			let savedRow = await this.dataService.save(path, updatedValues, id, resolvedCollection?.databaseId);
+			if (savedRow && (globalCallbacks?.afterRead || callbacks?.afterRead || propertyCallbacks?.afterRead)) {
+				if (globalCallbacks?.afterRead) savedRow = await globalCallbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: savedRow,
+					context: contextForCallback
+				}) ?? savedRow;
+				if (callbacks?.afterRead) savedRow = await callbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: savedRow,
+					context: contextForCallback
+				}) ?? savedRow;
+				if (propertyCallbacks?.afterRead) savedRow = await propertyCallbacks.afterRead({
+					collection: resolvedCollection,
+					path,
+					row: savedRow,
+					context: contextForCallback
+				}) ?? savedRow;
+			}
+			const savedId = savedRow.id;
+			const { id: _savedId, ...savedValues } = savedRow;
+			if (globalCallbacks?.afterSave || callbacks?.afterSave || propertyCallbacks?.afterSave) {
+				if (globalCallbacks?.afterSave) await globalCallbacks.afterSave({
+					collection: resolvedCollection,
+					path,
+					id: savedId,
+					values: savedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+				if (callbacks?.afterSave) await callbacks.afterSave({
+					collection: resolvedCollection,
+					path,
+					id: savedId,
+					values: savedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+				if (propertyCallbacks?.afterSave) await propertyCallbacks.afterSave({
+					collection: resolvedCollection,
+					path,
+					id: savedId,
+					values: savedValues,
+					previousValues: previousValuesForHistory,
+					status,
+					context: contextForCallback
+				});
+			}
+			if (this.historyService && resolvedCollection?.history) this.historyService.recordHistory({
+				tableName: path,
+				id: savedId.toString(),
+				action: status === "new" ? "create" : "update",
+				values: savedValues,
+				previousValues: previousValuesForHistory,
+				updatedBy: this.user?.uid
+			}).catch((err) => {
+				logger.error(`Failed to record history for ${path}/${savedId}`, { error: err });
+			});
+			await this.realtimeService.notifyUpdate(path, savedId.toString(), savedRow);
+			return savedRow;
+		} catch (error) {
+			if (callbacks?.afterSaveError || propertyCallbacks?.afterSaveError) {
+				if (callbacks?.afterSaveError) await callbacks.afterSaveError({
+					collection: resolvedCollection,
+					path,
+					id: id || "unknown",
+					values: updatedValues,
+					previousValues: void 0,
+					status,
+					context: contextForCallback
+				});
+				if (propertyCallbacks?.afterSaveError) await propertyCallbacks.afterSaveError({
+					collection: resolvedCollection,
+					path,
+					id: id || "unknown",
+					values: updatedValues,
+					previousValues: void 0,
+					status,
+					context: contextForCallback
+				});
+			}
+			throw error;
+		}
+	}
+	/**
+	* Delete an row
+	*/
+	async delete({ row, collection }) {
+		const { collection: resolvedCollection, callbacks, globalCallbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, row.path);
+		const callbackRow = {
+			id: row.id,
+			...row.values ?? {}
+		};
+		const contextForCallback = {
+			user: this.user,
+			driver: this,
+			data: this.data,
+			client: this.client,
+			storageSource: this.client?.storage
+		};
+		if (globalCallbacks?.beforeDelete || callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
+			let preventDefault = false;
+			if (globalCallbacks?.beforeDelete) {
+				if (await globalCallbacks.beforeDelete({
+					collection: resolvedCollection,
+					path: row.path,
+					id: row.id,
+					row: callbackRow,
+					context: contextForCallback
+				}) === false) preventDefault = true;
+			}
+			if (callbacks?.beforeDelete) {
+				if (await callbacks.beforeDelete({
+					collection: resolvedCollection,
+					path: row.path,
+					id: row.id,
+					row: callbackRow,
+					context: contextForCallback
+				}) === false) preventDefault = true;
+			}
+			if (propertyCallbacks?.beforeDelete) {
+				if (await propertyCallbacks.beforeDelete({
+					collection: resolvedCollection,
+					path: row.path,
+					id: row.id,
+					row: callbackRow,
+					context: contextForCallback
+				}) === false) preventDefault = true;
+			}
+			if (preventDefault) return;
+		}
+		await this.dataService.delete(row.path, row.id);
+		if (globalCallbacks?.afterDelete || callbacks?.afterDelete || propertyCallbacks?.afterDelete) {
+			if (globalCallbacks?.afterDelete) await globalCallbacks.afterDelete({
+				collection: resolvedCollection,
+				path: row.path,
+				id: row.id,
+				row: callbackRow,
+				context: contextForCallback
+			});
+			if (callbacks?.afterDelete) await callbacks.afterDelete({
+				collection: resolvedCollection,
+				path: row.path,
+				id: row.id,
+				row: callbackRow,
+				context: contextForCallback
+			});
+			if (propertyCallbacks?.afterDelete) await propertyCallbacks.afterDelete({
+				collection: resolvedCollection,
+				path: row.path,
+				id: row.id,
+				row: callbackRow,
+				context: contextForCallback
+			});
+		}
+		if (this.historyService && resolvedCollection?.history) this.historyService.recordHistory({
+			action: "delete",
+			id: String(row.id),
+			tableName: row.path,
+			previousValues: row.values,
+			updatedBy: this.user?.uid
+		}).catch((err) => {
+			logger.error(`Failed to record history for ${row.path}/${row.id}`, { error: err });
+		});
+		await this.realtimeService.notifyUpdate(row.path, String(row.id), null);
+	}
+	/**
+	* Check if a field value is unique
+	*/
+	async checkUniqueField(path, name, value, id, collection) {
+		return this.dataService.checkUniqueField(path, name, value, id);
+	}
+	/**
+	* Generate a new row ID
+	*/
+	generateId(path, collection) {
+		return this.dataService.generateId();
+	}
+	/**
+	* Count rows in a collection
+	*/
+	async count({ path, collection, filter }) {
+		return this.dataService.count(path, { filter });
+	}
+	/**
+	* Generate a unique subscription ID
+	*/
+	generateSubscriptionId() {
+		return `mongo_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+	}
+	/**
+	* Check if the delegate is ready
+	*/
+	isReady() {
+		return this.initialised;
+	}
+	/**
+	* Get the underlying row service for direct access
+	*/
+	getDataService() {
+		return this.dataService;
+	}
+	/**
+	* Get the underlying realtime service for direct access
+	*/
+	getRealtimeService() {
+		return this.realtimeService;
+	}
+	/**
+	* Scope the MongoDriver with an authenticated user context
+	*/
+	async withAuth(user) {
+		return new AuthenticatedMongoDriver(this, user);
+	}
+};
+var AuthenticatedMongoDriver = class {
+	delegate;
+	key = "mongodb";
+	initialised = true;
+	user;
+	data;
+	constructor(delegate, user) {
+		this.delegate = delegate;
+		this.user = user;
+		this.data = buildSdkData(this);
+	}
+	currentTime() {
+		return this.delegate.currentTime();
+	}
+	async fetchCollection(props) {
+		const { collection: resolvedCollection } = this.delegate.resolveCollectionCallbacks(props.collection, props.path);
+		const rlsFilter = buildMongoFilterFromSecurityRules(resolvedCollection, this.user, "select");
+		if (rlsFilter === null) return [];
+		const userQuery = MongoConditionBuilder.buildQuery({
+			filter: props.filter,
+			searchString: props.searchString,
+			properties: resolvedCollection?.properties
+		});
+		const combinedQuery = Object.keys(rlsFilter).length > 0 ? { $and: [userQuery, rlsFilter] } : userQuery;
+		const rows = await this.delegate.getDataService().fetchCollection(props.path, {
+			...props,
+			rawQuery: combinedQuery,
+			collection: resolvedCollection
+		});
+		const { callbacks, globalCallbacks, propertyCallbacks } = this.delegate.resolveCollectionCallbacks(props.collection, props.path);
+		if (globalCallbacks?.afterRead || callbacks?.afterRead || propertyCallbacks?.afterRead) {
+			const contextForCallback = {
+				user: this.user,
+				driver: this,
+				data: this.data,
+				client: this.delegate.client,
+				storageSource: this.delegate.client?.storage
+			};
+			return Promise.all(rows.map(async (row) => {
+				let fetched = row;
+				if (globalCallbacks?.afterRead) fetched = await globalCallbacks.afterRead({
+					collection: resolvedCollection,
+					path: props.path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				if (callbacks?.afterRead) fetched = await callbacks.afterRead({
+					collection: resolvedCollection,
+					path: props.path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				if (propertyCallbacks?.afterRead) fetched = await propertyCallbacks.afterRead({
+					collection: resolvedCollection,
+					path: props.path,
+					row: fetched,
+					context: contextForCallback
+				}) ?? fetched;
+				return fetched;
+			}));
+		}
+		return rows;
+	}
+	listenCollection(props) {
+		const unsubscribe = this.delegate.listenCollection(props);
+		const authContext = {
+			userId: this.user.uid,
+			roles: this.user.roles ?? []
+		};
+		const subscriptions = this.delegate.getRealtimeService().getSubscriptions();
+		const lastSub = Array.from(subscriptions.entries()).pop()?.[1];
+		if (lastSub && lastSub.config.clientId === "driver") lastSub.authContext = authContext;
+		return unsubscribe;
+	}
+	async fetchOne(props) {
+		const { collection: resolvedCollection } = this.delegate.resolveCollectionCallbacks(props.collection, props.path);
+		const row = await this.delegate.fetchOne(props);
+		if (row) {
+			if (!checkOperation(resolvedCollection, { user: this.user }, rowToEntityForCheck(row, props.path), "select", { onUnknown: "deny" })) return;
+		}
+		return row;
+	}
+	listenOne(props) {
+		const unsubscribe = this.delegate.listenOne(props);
+		const authContext = {
+			userId: this.user.uid,
+			roles: this.user.roles ?? []
+		};
+		const subscriptions = this.delegate.getRealtimeService().getSubscriptions();
+		const lastSub = Array.from(subscriptions.entries()).pop()?.[1];
+		if (lastSub && lastSub.config.clientId === "driver") lastSub.authContext = authContext;
+		return unsubscribe;
+	}
+	async save(props) {
+		const { collection: resolvedCollection } = this.delegate.resolveCollectionCallbacks(props.collection, props.path);
+		if (props.status === "existing" && props.id) {
+			const existing = await this.delegate.fetchOne({
+				path: props.path,
+				id: props.id,
+				collection: resolvedCollection
+			});
+			if (!existing || !checkOperation(resolvedCollection, { user: this.user }, rowToEntityForCheck(existing, props.path), "update", { onUnknown: "deny" })) throw ApiError.forbidden("Forbidden");
+		} else {
+			const tempEntity = {
+				id: props.id || "new",
+				path: props.path,
+				values: props.values
+			};
+			if (!checkOperation(resolvedCollection, { user: this.user }, tempEntity, "insert", { onUnknown: "deny" })) throw ApiError.forbidden("Forbidden");
+		}
+		const saved = await this.delegate.save({
+			...props,
+			collection: resolvedCollection
+		});
+		if (!checkOperation(resolvedCollection, { user: this.user }, rowToEntityForCheck(saved, props.path), props.status === "existing" ? "update" : "insert", { onUnknown: "deny" })) throw ApiError.forbidden("Forbidden");
+		return saved;
+	}
+	async delete(props) {
+		const { collection: resolvedCollection } = this.delegate.resolveCollectionCallbacks(props.collection, props.row.path);
+		const existing = await this.delegate.fetchOne({
+			path: props.row.path,
+			id: props.row.id,
+			collection: resolvedCollection
+		});
+		if (!existing || !checkOperation(resolvedCollection, { user: this.user }, rowToEntityForCheck(existing, props.row.path), "delete", { onUnknown: "deny" })) throw ApiError.forbidden("Forbidden");
+		return this.delegate.delete(props);
+	}
+	async checkUniqueField(path, name, value, id, collection) {
+		return this.delegate.checkUniqueField(path, name, value, id, collection);
+	}
+	generateId(path, collection) {
+		return this.delegate.generateId(path, collection);
+	}
+	async count(props) {
+		const { collection: resolvedCollection } = this.delegate.resolveCollectionCallbacks(props.collection, props.path);
+		const rlsFilter = buildMongoFilterFromSecurityRules(resolvedCollection, this.user, "select");
+		if (rlsFilter === null) return 0;
+		const userQuery = MongoConditionBuilder.buildQuery({
+			filter: props.filter,
+			searchString: props.searchString,
+			properties: resolvedCollection?.properties
+		});
+		const combinedQuery = Object.keys(rlsFilter).length > 0 ? { $and: [userQuery, rlsFilter] } : userQuery;
+		return this.delegate.getDataService().count(props.path, {
+			...props,
+			rawQuery: combinedQuery
+		});
+	}
+	isReady() {
+		return this.delegate.isReady();
+	}
+};
+/**
+* Wrap a flat row into the Entity shape expected by `checkOperation`,
+* which evaluates security rules against `row.values`.
+*/
+function rowToEntityForCheck(row, path) {
+	return {
+		id: row.id,
+		path,
+		values: row
+	};
+}
+function getMongoFilterForSQL(sqlString, user) {
+	let cleanedSQL = sqlString.trim();
+	while (cleanedSQL.startsWith("(") && cleanedSQL.endsWith(")")) {
+		let openCount = 0;
+		let isEnclosing = true;
+		for (let i = 0; i < cleanedSQL.length - 1; i++) {
+			if (cleanedSQL[i] === "(") openCount++;
+			else if (cleanedSQL[i] === ")") openCount--;
+			if (openCount === 0) {
+				isEnclosing = false;
+				break;
+			}
+		}
+		if (isEnclosing) cleanedSQL = cleanedSQL.substring(1, cleanedSQL.length - 1).trim();
+		else break;
+	}
+	const splitByTopLevel = (str, delimiter) => {
+		const parts = [];
+		let current = "";
+		let openCount = 0;
+		let i = 0;
+		while (i < str.length) {
+			if (str[i] === "(") openCount++;
+			else if (str[i] === ")") openCount--;
+			if (openCount === 0 && str.substring(i).toUpperCase().startsWith(delimiter)) {
+				parts.push(current);
+				current = "";
+				i += delimiter.length;
+			} else {
+				current += str[i];
+				i++;
+			}
+		}
+		parts.push(current);
+		return parts;
+	};
+	const orParts = splitByTopLevel(cleanedSQL, " OR ");
+	if (orParts.length > 1) {
+		const subFilters = orParts.map((part) => getMongoFilterForSQL(part, user)).filter((f) => f !== null);
+		if (subFilters.length === 0) return null;
+		if (subFilters.length === 1) return subFilters[0];
+		return { $or: subFilters };
+	}
+	const andParts = splitByTopLevel(cleanedSQL, " AND ");
+	if (andParts.length > 1) {
+		const subFilters = andParts.map((part) => getMongoFilterForSQL(part, user)).filter((f) => f !== null);
+		if (subFilters.length === 0) return null;
+		if (subFilters.length === 1) return subFilters[0];
+		return { $and: subFilters };
+	}
+	const roleIntersectMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\[(.*?)\]/i);
+	if (roleIntersectMatch && roleIntersectMatch[1]) {
+		const requiredRoles = roleIntersectMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+		const userRoles = user.roles || [];
+		return requiredRoles.some((r) => userRoles.includes(r)) ? {} : { _id: { $exists: false } };
+	}
+	const roleContainMatch = cleanedSQL.match(/string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\[(.*?)\]/i);
+	if (roleContainMatch && roleContainMatch[1]) {
+		const requiredRoles = roleContainMatch[1].split(",").map((r) => r.trim().replace(/'/g, ""));
+		const userRoles = user.roles || [];
+		return requiredRoles.every((r) => userRoles.includes(r)) ? {} : { _id: { $exists: false } };
+	}
+	const pattern1 = /* @__PURE__ */ new RegExp("^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))");
+	const pattern2 = /* @__PURE__ */ new RegExp("^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?");
+	const match1 = cleanedSQL.match(pattern1);
+	if (match1 && match1[1]) return { [match1[1]]: user.uid };
+	const match2 = cleanedSQL.match(pattern2);
+	if (match2 && match2[1]) return { [match2[1]]: user.uid };
+	const simpleEqualityMatch = cleanedSQL.match(/^\{?([\w_]+)\}?\s*(=|!=)\s*'([^']+)'$/i);
+	if (simpleEqualityMatch) {
+		const field = simpleEqualityMatch[1];
+		const operator = simpleEqualityMatch[2];
+		const value = simpleEqualityMatch[3];
+		if (operator === "=") return { [field]: value };
+		if (operator === "!=") return { [field]: { $ne: value } };
+	}
+	return {};
+}
+function getMongoFilterForRule(rule, user) {
+	if (rule.access === "public") return {};
+	const filters = [];
+	if (rule.ownerField) filters.push({ [rule.ownerField]: user.uid });
+	if (rule.using) {
+		const f = getMongoFilterForSQL(rule.using, user);
+		if (f) filters.push(f);
+	}
+	if (rule.withCheck) {
+		const f = getMongoFilterForSQL(rule.withCheck, user);
+		if (f) filters.push(f);
+	}
+	if (filters.length === 0) return {};
+	if (filters.length === 1) return filters[0];
+	return { $and: filters };
+}
+function buildMongoFilterFromSecurityRules(collection, user, targetOperation) {
+	if (!collection || !collection.securityRules || collection.securityRules.length === 0) return {};
+	const applicableRules = collection.securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
+	if (applicableRules.length === 0) return null;
+	const userRoles = [...user.roles ?? [], "public"];
+	const roleApplicableRules = applicableRules.filter((rule) => {
+		if (!rule.roles || rule.roles.length === 0) return true;
+		return rule.roles.some((r) => userRoles.includes(r));
+	});
+	if (roleApplicableRules.length === 0) return null;
+	const permissiveFilters = [];
+	const restrictiveFilters = [];
+	for (const rule of roleApplicableRules) {
+		const mode = rule.mode || "permissive";
+		const filter = getMongoFilterForRule(rule, user);
+		if (filter === null) {
+			if (mode === "restrictive") return null;
+			continue;
+		}
+		if (mode === "restrictive") restrictiveFilters.push(filter);
+		else permissiveFilters.push(filter);
+	}
+	const finalAnds = [];
+	if (permissiveFilters.length > 0) {
+		if (!permissiveFilters.some((f) => Object.keys(f).length === 0)) if (permissiveFilters.length === 1) finalAnds.push(permissiveFilters[0]);
+		else finalAnds.push({ $or: permissiveFilters });
+	} else return null;
+	if (restrictiveFilters.length > 0) {
+		for (const rf of restrictiveFilters) if (Object.keys(rf).length > 0) finalAnds.push(rf);
+	}
+	if (finalAnds.length === 0) return {};
+	if (finalAnds.length === 1) return finalAnds[0];
+	return { $and: finalAnds };
+}
+//#endregion
+//#region src/factory.ts
+/**
+* Simple in-memory collection registry for MongoDB.
+*/
+var MongoCollectionRegistry = class {
+	collections = /* @__PURE__ */ new Map();
+	_globalCallbacks;
+	/**
+	* Register a collection
+	*/
+	register(collection) {
+		this.collections.set(collection.name, collection);
+	}
+	/**
+	* Get a collection by its path
+	*/
+	getCollectionByPath(path) {
+		return this.collections.get(path);
+	}
+	/**
+	* Get all registered collections
+	*/
+	getCollections() {
+		return Array.from(this.collections.values());
+	}
+	/**
+	* Get the currently registered global callbacks, if any.
+	*/
+	getGlobalCallbacks() {
+		return this._globalCallbacks;
+	}
+	/**
+	* Set global lifecycle callbacks that apply to every collection.
+	*/
+	setGlobalCallbacks(callbacks) {
+		this._globalCallbacks = callbacks;
+	}
+};
+/**
+* Create a complete MongoDB backend instance.
+*
+* This factory function creates all the necessary services for a MongoDB backend:
+* - MongoDBConnection (database connection wrapper)
+* - MongoDataService (implements DataRepository)
+* - MongoRealtimeService (implements RealtimeProvider)
+* - MongoCollectionRegistry (implements CollectionRegistryInterface)
+* - MongoDriver (for Rebase integration)
+*
+* @example
+* ```typescript
+* import { createMongoBackend } from "@rebasepro/server-mongo";
+*
+* const client = new MongoClient("mongodb://localhost:27017");
+* await client.connect();
+* const db = client.db("my_database");
+*
+* const backend = createMongoBackend({
+*     type: "mongodb",
+*     connection: db,
+*     client: client,
+*     collections: myCollections
+* });
+*
+* // Use the backend
+* const rows = await backend.entityRepository.fetchCollection("users", {});
+* ```
+*/
+function createMongoBackend(config) {
+	const { connection: db, client, collections } = config;
+	const collectionRegistry = new MongoCollectionRegistry();
+	if (collections) collections.forEach((collection) => collectionRegistry.register(collection));
+	const dataService = new MongoDataService(db);
+	const realtimeService = new MongoRealtimeService(db);
+	const driver = new MongoDriver(db, realtimeService, new MongoHistoryService(db, config.historyRetention), collectionRegistry);
+	return {
+		connection: new MongoDBConnection(db, client),
+		entityRepository: dataService,
+		realtimeProvider: realtimeService,
+		collectionRegistry,
+		admin: {
+			async executeAggregate(pipeline) {
+				const firstStage = pipeline[0];
+				const collName = typeof firstStage.$from === "string" ? firstStage.$from : "__admin__";
+				return await db.collection(collName).aggregate(pipeline).toArray();
+			},
+			async fetchCollectionStats(collectionName) {
+				const stats = await db.command({ collStats: collectionName });
+				return {
+					count: stats.count,
+					sizeBytes: stats.size
+				};
+			},
+			async fetchUnmappedTables(mappedPaths) {
+				const names = (await db.listCollections().toArray()).map((c) => c.name).filter((n) => !n.startsWith("system."));
+				if (!mappedPaths || mappedPaths.length === 0) return names;
+				const mappedSet = new Set(mappedPaths.map((p) => p.toLowerCase()));
+				return names.filter((n) => !mappedSet.has(n.toLowerCase()));
+			},
+			async fetchTableMetadata(collectionName) {
+				const sample = await db.collection(collectionName).findOne();
+				if (!sample) return {
+					columns: [],
+					foreignKeys: [],
+					junctions: [],
+					policies: []
+				};
+				return {
+					columns: Object.entries(sample).map(([key, value]) => ({
+						column_name: key,
+						data_type: typeof value,
+						udt_name: typeof value,
+						is_nullable: "YES",
+						column_default: null,
+						character_maximum_length: null
+					})),
+					foreignKeys: [],
+					junctions: [],
+					policies: []
+				};
+			}
+		},
+		async initialize() {},
+		async healthCheck() {
+			const start = Date.now();
+			try {
+				await db.command({ ping: 1 });
+				return {
+					healthy: true,
+					latencyMs: Date.now() - start
+				};
+			} catch {
+				return {
+					healthy: false,
+					latencyMs: Date.now() - start
+				};
+			}
+		},
+		async destroy() {
+			await client.close();
+		},
+		db,
+		client,
+		driver,
+		dataService,
+		realtimeService
+	};
+}
+/**
+* Create a MongoDB DataDriver.
+*
+* This is a convenience function when you only need the DataDriver
+* without the full backend instance.
+*
+* @example
+* ```typescript
+* import { createMongoDelegate } from "@rebasepro/server-mongo";
+*
+* const delegate = createMongoDelegate(db);
+* ```
+*/
+function createMongoDelegate(db, realtimeService, historyService, registry) {
+	return new MongoDriver(db, realtimeService ?? new MongoRealtimeService(db), historyService ?? new MongoHistoryService(db), registry);
+}
+/**
+* Create a RealtimeService for MongoDB.
+*
+* @example
+* ```typescript
+* import { createMongoRealtimeService } from "@rebasepro/server-mongo";
+*
+* const realtimeService = createMongoRealtimeService(db);
+* ```
+*/
+function createMongoRealtimeService(db) {
+	return new MongoRealtimeService(db);
+}
+/**
+* Create a MongoDB row repository.
+*
+* @example
+* ```typescript
+* import { createMongoEntityRepository } from "@rebasepro/server-mongo";
+*
+* const repository = createMongoEntityRepository(db);
+* const users = await repository.fetchCollection("users", {});
+* ```
+*/
+function createMongoEntityRepository(db) {
+	return new MongoDataService(db);
+}
+/**
+* Check if a backend config is for MongoDB.
+*/
+function isMongoBackendConfig(config) {
+	return config.type === "mongodb" && typeof config.connection !== "undefined" && typeof config.client !== "undefined";
+}
+/**
+* Check if a driver config is for MongoDB.
+*/
+function isMongoDriverConfig(obj) {
+	return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "mongodb" && "connection" in obj && "client" in obj;
+}
+//#endregion
+//#region src/auth/services.ts
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toUser(doc) {
+	return {
+		id: doc._id || doc.id,
+		email: doc.email,
+		passwordHash: doc.passwordHash ?? null,
+		displayName: doc.displayName ?? null,
+		photoUrl: doc.photoUrl ?? null,
+		emailVerified: doc.emailVerified ?? false,
+		emailVerificationToken: doc.emailVerificationToken ?? null,
+		emailVerificationSentAt: doc.emailVerificationSentAt ? new Date(doc.emailVerificationSentAt) : null,
+		createdAt: new Date(doc.createdAt),
+		updatedAt: new Date(doc.updatedAt)
+	};
+}
+var MongoUserService = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	get collection() {
+		return this.db.collection("rebase_users");
+	}
+	get identitiesCollection() {
+		return this.db.collection("rebase_user_identities");
+	}
+	get userRolesCollection() {
+		return this.db.collection("rebase_user_roles");
+	}
+	get rolesCollection() {
+		return this.db.collection("rebase_roles");
+	}
+	async createUser(data) {
+		const id = new ObjectId().toString();
+		const now = /* @__PURE__ */ new Date();
+		const doc = {
+			_id: id,
+			id,
+			email: data.email.toLowerCase(),
+			passwordHash: data.passwordHash ?? null,
+			displayName: data.displayName ?? null,
+			photoUrl: data.photoUrl ?? null,
+			emailVerified: data.emailVerified ?? false,
+			createdAt: now,
+			updatedAt: now
+		};
+		await this.collection.insertOne(doc);
+		return toUser(doc);
+	}
+	async getUserById(id) {
+		const doc = await this.collection.findOne({ id });
+		return doc ? toUser(doc) : null;
+	}
+	async getUserByEmail(email) {
+		const doc = await this.collection.findOne({ email: email.toLowerCase() });
+		return doc ? toUser(doc) : null;
+	}
+	async getUserByIdentity(provider, providerId) {
+		const identity = await this.identitiesCollection.findOne({
+			provider,
+			providerId
+		});
+		if (!identity) return null;
+		return this.getUserById(identity.userId);
+	}
+	async getUserIdentities(userId) {
+		return (await this.identitiesCollection.find({ userId }).toArray()).map((doc) => ({
+			id: doc.id,
+			userId: doc.userId,
+			provider: doc.provider,
+			providerId: doc.providerId,
+			profileData: doc.profileData ?? null,
+			createdAt: new Date(doc.createdAt),
+			updatedAt: new Date(doc.updatedAt)
+		}));
+	}
+	async linkUserIdentity(userId, provider, providerId, profileData) {
+		const now = /* @__PURE__ */ new Date();
+		await this.identitiesCollection.updateOne({
+			provider,
+			providerId
+		}, {
+			$setOnInsert: {
+				_id: new ObjectId().toString(),
+				id: new ObjectId().toString(),
+				userId,
+				provider,
+				providerId,
+				createdAt: now
+			},
+			$set: {
+				profileData: profileData ?? null,
+				updatedAt: now
+			}
+		}, { upsert: true });
+	}
+	async updateUser(id, data) {
+		const updateData = {
+			...data,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		if (typeof updateData.email === "string") updateData.email = updateData.email.toLowerCase();
+		await this.collection.updateOne({ id }, { $set: updateData });
+		return this.getUserById(id);
+	}
+	async deleteUser(id) {
+		await this.collection.deleteOne({ id });
+		await this.identitiesCollection.deleteMany({ userId: id });
+		await this.userRolesCollection.deleteMany({ userId: id });
+	}
+	async listUsers() {
+		return (await this.collection.find().toArray()).map(toUser);
+	}
+	async listUsersPaginated(options) {
+		const limit = options?.limit ?? 25;
+		const offset = options?.offset ?? 0;
+		const search = options?.search?.trim() || "";
+		const orderBy = options?.orderBy || "createdAt";
+		const orderDir = options?.orderDir || "desc";
+		const roleId = options?.roleId;
+		const query = {};
+		if (search) {
+			const escapedSearch = escapeRegExp(search);
+			query.$or = [{ email: {
+				$regex: escapedSearch,
+				$options: "i"
+			} }, { displayName: {
+				$regex: escapedSearch,
+				$options: "i"
+			} }];
+		}
+		if (roleId) query.id = { $in: (await this.userRolesCollection.find({ roleId }).toArray()).map((ur) => ur.userId) };
+		const sort = {};
+		sort[orderBy] = orderDir === "asc" ? 1 : -1;
+		const total = await this.collection.countDocuments(query);
+		return {
+			users: (await this.collection.find(query).sort(sort).skip(offset).limit(limit).toArray()).map(toUser),
+			total,
+			limit,
+			offset
+		};
+	}
+	async updatePassword(id, passwordHash) {
+		await this.collection.updateOne({ id }, { $set: {
+			passwordHash,
+			updatedAt: /* @__PURE__ */ new Date()
+		} });
+	}
+	async setEmailVerified(id, verified) {
+		await this.collection.updateOne({ id }, { $set: {
+			emailVerified: verified,
+			emailVerificationToken: null,
+			updatedAt: /* @__PURE__ */ new Date()
+		} });
+	}
+	async setVerificationToken(id, token) {
+		await this.collection.updateOne({ id }, { $set: {
+			emailVerificationToken: token,
+			emailVerificationSentAt: token ? /* @__PURE__ */ new Date() : null,
+			updatedAt: /* @__PURE__ */ new Date()
+		} });
+	}
+	async getUserByVerificationToken(token) {
+		const doc = await this.collection.findOne({ emailVerificationToken: token });
+		return doc ? toUser(doc) : null;
+	}
+	async getUserRoles(userId) {
+		const roleIds = (await this.userRolesCollection.find({ userId }).toArray()).map((ur) => ur.roleId);
+		if (roleIds.length === 0) return [];
+		return (await this.rolesCollection.find({ id: { $in: roleIds } }).toArray()).map((r) => ({
+			id: r.id,
+			name: r.name,
+			isAdmin: r.isAdmin ?? false,
+			defaultPermissions: r.defaultPermissions ?? null,
+			collectionPermissions: r.collectionPermissions ?? null
+		}));
+	}
+	async getUserRoleIds(userId) {
+		return (await this.userRolesCollection.find({ userId }).toArray()).map((ur) => ur.roleId);
+	}
+	async setUserRoles(userId, roleIds) {
+		await this.userRolesCollection.deleteMany({ userId });
+		if (roleIds.length > 0) {
+			const docs = roleIds.map((roleId) => ({
+				_id: new ObjectId().toString(),
+				userId,
+				roleId
+			}));
+			await this.userRolesCollection.insertMany(docs);
+		}
+	}
+	async assignDefaultRole(userId, roleId) {
+		await this.userRolesCollection.updateOne({
+			userId,
+			roleId
+		}, { $setOnInsert: {
+			_id: new ObjectId().toString(),
+			userId,
+			roleId
+		} }, { upsert: true });
+	}
+	async getUserWithRoles(userId) {
+		const user = await this.getUserById(userId);
+		if (!user) return null;
+		return {
+			user,
+			roles: await this.getUserRoles(userId)
+		};
+	}
+};
+var MongoRoleService = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	get collection() {
+		return this.db.collection("rebase_roles");
+	}
+	async getRoleById(id) {
+		const doc = await this.collection.findOne({ id });
+		if (!doc) return null;
+		return {
+			id: doc.id,
+			name: doc.name,
+			isAdmin: doc.isAdmin ?? false,
+			defaultPermissions: doc.defaultPermissions ?? null,
+			collectionPermissions: doc.collectionPermissions ?? null
+		};
+	}
+	async listRoles() {
+		return (await this.collection.find().sort({ name: 1 }).toArray()).map((doc) => ({
+			id: doc.id,
+			name: doc.name,
+			isAdmin: doc.isAdmin ?? false,
+			defaultPermissions: doc.defaultPermissions ?? null,
+			collectionPermissions: doc.collectionPermissions ?? null
+		}));
+	}
+	async createRole(data) {
+		const doc = {
+			_id: data.id,
+			id: data.id,
+			name: data.name,
+			isAdmin: data.isAdmin ?? false,
+			defaultPermissions: data.defaultPermissions ?? null,
+			collectionPermissions: data.collectionPermissions ?? null
+		};
+		await this.collection.insertOne(doc);
+		return { ...doc };
+	}
+	async updateRole(id, data) {
+		await this.collection.updateOne({ id }, { $set: data });
+		return this.getRoleById(id);
+	}
+	async deleteRole(id) {
+		await this.collection.deleteOne({ id });
+		await this.db.collection("rebase_user_roles").deleteMany({ roleId: id });
+	}
+};
+var MongoRefreshTokenService = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	get collection() {
+		return this.db.collection("rebase_refresh_tokens");
+	}
+	async createToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+		const safeUserAgent = userAgent || "";
+		const safeIpAddress = ipAddress || "";
+		await this.collection.deleteMany({
+			userId,
+			userAgent: safeUserAgent,
+			ipAddress: safeIpAddress
+		});
+		await this.collection.insertOne({
+			_id: new ObjectId().toString(),
+			id: new ObjectId().toString(),
+			userId,
+			tokenHash,
+			expiresAt,
+			createdAt: /* @__PURE__ */ new Date(),
+			userAgent: safeUserAgent,
+			ipAddress: safeIpAddress
+		});
+	}
+	async findByHash(tokenHash) {
+		const doc = await this.collection.findOne({ tokenHash });
+		if (!doc) return null;
+		return {
+			id: doc.id,
+			userId: doc.userId,
+			tokenHash: doc.tokenHash,
+			expiresAt: new Date(doc.expiresAt),
+			createdAt: new Date(doc.createdAt),
+			userAgent: doc.userAgent,
+			ipAddress: doc.ipAddress
+		};
+	}
+	async deleteByHash(tokenHash) {
+		await this.collection.deleteOne({ tokenHash });
+	}
+	async deleteAllForUser(userId) {
+		await this.collection.deleteMany({ userId });
+	}
+	async listForUser(userId) {
+		return (await this.collection.find({ userId }).sort({ createdAt: 1 }).toArray()).map((doc) => ({
+			id: doc.id,
+			userId: doc.userId,
+			tokenHash: doc.tokenHash,
+			expiresAt: new Date(doc.expiresAt),
+			createdAt: new Date(doc.createdAt),
+			userAgent: doc.userAgent,
+			ipAddress: doc.ipAddress
+		}));
+	}
+	async deleteById(id, userId) {
+		await this.collection.deleteOne({
+			id,
+			userId
+		});
+	}
+};
+var MongoPasswordResetTokenService = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	get collection() {
+		return this.db.collection("rebase_password_reset_tokens");
+	}
+	async createToken(userId, tokenHash, expiresAt) {
+		await this.collection.deleteMany({
+			userId,
+			usedAt: null
+		});
+		await this.collection.insertOne({
+			_id: new ObjectId().toString(),
+			userId,
+			tokenHash,
+			expiresAt,
+			usedAt: null
+		});
+	}
+	async findValidByHash(tokenHash) {
+		const doc = await this.collection.findOne({
+			tokenHash,
+			usedAt: null,
+			expiresAt: { $gt: /* @__PURE__ */ new Date() }
+		});
+		if (!doc) return null;
+		return {
+			userId: doc.userId,
+			expiresAt: new Date(doc.expiresAt)
+		};
+	}
+	async markAsUsed(tokenHash) {
+		await this.collection.updateOne({ tokenHash }, { $set: { usedAt: /* @__PURE__ */ new Date() } });
+	}
+	async deleteAllForUser(userId) {
+		await this.collection.deleteMany({ userId });
+	}
+	async deleteExpired() {
+		await this.collection.deleteMany({ expiresAt: { $lt: /* @__PURE__ */ new Date() } });
+	}
+};
+var MongoTokenRepository = class {
+	db;
+	refreshTokenService;
+	passwordResetTokenService;
+	constructor(db) {
+		this.db = db;
+		this.refreshTokenService = new MongoRefreshTokenService(db);
+		this.passwordResetTokenService = new MongoPasswordResetTokenService(db);
+	}
+	async createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+		await this.refreshTokenService.createToken(userId, tokenHash, expiresAt, userAgent, ipAddress);
+	}
+	async findRefreshTokenByHash(tokenHash) {
+		return this.refreshTokenService.findByHash(tokenHash);
+	}
+	async deleteRefreshToken(tokenHash) {
+		await this.refreshTokenService.deleteByHash(tokenHash);
+	}
+	async deleteAllRefreshTokensForUser(userId) {
+		await this.refreshTokenService.deleteAllForUser(userId);
+	}
+	async listRefreshTokensForUser(userId) {
+		return this.refreshTokenService.listForUser(userId);
+	}
+	async deleteRefreshTokenById(id, userId) {
+		await this.refreshTokenService.deleteById(id, userId);
+	}
+	async createPasswordResetToken(userId, tokenHash, expiresAt) {
+		await this.passwordResetTokenService.createToken(userId, tokenHash, expiresAt);
+	}
+	async findValidPasswordResetToken(tokenHash) {
+		return this.passwordResetTokenService.findValidByHash(tokenHash);
+	}
+	async markPasswordResetTokenUsed(tokenHash) {
+		await this.passwordResetTokenService.markAsUsed(tokenHash);
+	}
+	async deleteAllPasswordResetTokensForUser(userId) {
+		await this.passwordResetTokenService.deleteAllForUser(userId);
+	}
+	async deleteExpiredTokens() {
+		await this.passwordResetTokenService.deleteExpired();
+	}
+	async createMagicLinkToken(userId, tokenHash, expiresAt) {
+		const col = this.db.collection("magic_link_tokens");
+		await col.deleteMany({
+			userId,
+			usedAt: null
+		});
+		await col.insertOne({
+			userId,
+			tokenHash,
+			expiresAt,
+			usedAt: null,
+			createdAt: /* @__PURE__ */ new Date()
+		});
+	}
+	async findValidMagicLinkToken(tokenHash) {
+		const doc = await this.db.collection("magic_link_tokens").findOne({
+			tokenHash,
+			usedAt: null,
+			expiresAt: { $gt: /* @__PURE__ */ new Date() }
+		});
+		if (!doc) return null;
+		return {
+			userId: doc.userId,
+			expiresAt: doc.expiresAt
+		};
+	}
+	async markMagicLinkTokenUsed(tokenHash) {
+		await this.db.collection("magic_link_tokens").updateOne({ tokenHash }, { $set: { usedAt: /* @__PURE__ */ new Date() } });
+	}
+};
+var MongoAuthRepository = class {
+	db;
+	userService;
+	roleService;
+	tokenRepository;
+	constructor(db) {
+		this.db = db;
+		this.userService = new MongoUserService(db);
+		this.roleService = new MongoRoleService(db);
+		this.tokenRepository = new MongoTokenRepository(db);
+	}
+	async createUser(data) {
+		return this.userService.createUser(data);
+	}
+	async getUserById(id) {
+		return this.userService.getUserById(id);
+	}
+	async getUserByEmail(email) {
+		return this.userService.getUserByEmail(email);
+	}
+	async getUserByIdentity(provider, providerId) {
+		return this.userService.getUserByIdentity(provider, providerId);
+	}
+	async getUserIdentities(userId) {
+		return this.userService.getUserIdentities(userId);
+	}
+	async linkUserIdentity(userId, provider, providerId, profileData) {
+		return this.userService.linkUserIdentity(userId, provider, providerId, profileData);
+	}
+	async updateUser(id, data) {
+		return this.userService.updateUser(id, data);
+	}
+	async deleteUser(id) {
+		await this.userService.deleteUser(id);
+	}
+	async listUsers() {
+		return this.userService.listUsers();
+	}
+	async listUsersPaginated(options) {
+		return this.userService.listUsersPaginated(options);
+	}
+	async updatePassword(id, passwordHash) {
+		await this.userService.updatePassword(id, passwordHash);
+	}
+	async setEmailVerified(id, verified) {
+		await this.userService.setEmailVerified(id, verified);
+	}
+	async setVerificationToken(id, token) {
+		await this.userService.setVerificationToken(id, token);
+	}
+	async getUserByVerificationToken(token) {
+		return this.userService.getUserByVerificationToken(token);
+	}
+	async getUserRoles(userId) {
+		return this.userService.getUserRoles(userId);
+	}
+	async getUserRoleIds(userId) {
+		return this.userService.getUserRoleIds(userId);
+	}
+	async setUserRoles(userId, roleIds) {
+		await this.userService.setUserRoles(userId, roleIds);
+	}
+	async assignDefaultRole(userId, roleId) {
+		await this.userService.assignDefaultRole(userId, roleId);
+	}
+	async getUserWithRoles(userId) {
+		return this.userService.getUserWithRoles(userId);
+	}
+	async getRoleById(id) {
+		return this.roleService.getRoleById(id);
+	}
+	async listRoles() {
+		return this.roleService.listRoles();
+	}
+	async createRole(data) {
+		return this.roleService.createRole(data);
+	}
+	async updateRole(id, data) {
+		return this.roleService.updateRole(id, data);
+	}
+	async deleteRole(id) {
+		await this.roleService.deleteRole(id);
+	}
+	async createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress) {
+		await this.tokenRepository.createRefreshToken(userId, tokenHash, expiresAt, userAgent, ipAddress);
+	}
+	async findRefreshTokenByHash(tokenHash) {
+		return this.tokenRepository.findRefreshTokenByHash(tokenHash);
+	}
+	async deleteRefreshToken(tokenHash) {
+		await this.tokenRepository.deleteRefreshToken(tokenHash);
+	}
+	async deleteAllRefreshTokensForUser(userId) {
+		await this.tokenRepository.deleteAllRefreshTokensForUser(userId);
+	}
+	async listRefreshTokensForUser(userId) {
+		return this.tokenRepository.listRefreshTokensForUser(userId);
+	}
+	async deleteRefreshTokenById(id, userId) {
+		await this.tokenRepository.deleteRefreshTokenById(id, userId);
+	}
+	async createPasswordResetToken(userId, tokenHash, expiresAt) {
+		await this.tokenRepository.createPasswordResetToken(userId, tokenHash, expiresAt);
+	}
+	async findValidPasswordResetToken(tokenHash) {
+		return this.tokenRepository.findValidPasswordResetToken(tokenHash);
+	}
+	async markPasswordResetTokenUsed(tokenHash) {
+		await this.tokenRepository.markPasswordResetTokenUsed(tokenHash);
+	}
+	async deleteAllPasswordResetTokensForUser(userId) {
+		await this.tokenRepository.deleteAllPasswordResetTokensForUser(userId);
+	}
+	async deleteExpiredTokens() {
+		await this.tokenRepository.deleteExpiredTokens();
+	}
+	async createMagicLinkToken(userId, tokenHash, expiresAt) {
+		await this.tokenRepository.createMagicLinkToken(userId, tokenHash, expiresAt);
+	}
+	async findValidMagicLinkToken(tokenHash) {
+		return this.tokenRepository.findValidMagicLinkToken(tokenHash);
+	}
+	async markMagicLinkTokenUsed(tokenHash) {
+		await this.tokenRepository.markMagicLinkTokenUsed(tokenHash);
+	}
+	async createMfaFactor(userId, factorType, secretEncrypted, friendlyName) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async getMfaFactors(userId) {
+		return [];
+	}
+	async getMfaFactorById(factorId) {
+		return null;
+	}
+	async verifyMfaFactor(factorId) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async deleteMfaFactor(factorId, userId) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async createMfaChallenge(factorId, ipAddress) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async getMfaChallengeById(challengeId) {
+		return null;
+	}
+	async verifyMfaChallenge(challengeId) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async createRecoveryCodes(userId, codeHashes) {
+		throw new Error("MFA is not implemented for MongoDB");
+	}
+	async useRecoveryCode(userId, codeHash) {
+		return false;
+	}
+	async getUnusedRecoveryCodeCount(userId) {
+		return 0;
+	}
+	async deleteAllRecoveryCodes(userId) {}
+	async hasVerifiedMfaFactors(userId) {
+		return false;
+	}
+};
+//#endregion
+//#region src/MongoBootstrapper.ts
+function createMongoBootstrapper(mongoConfig) {
+	let cachedAdmin;
+	return {
+		type: "mongodb",
+		async initializeDriver(config) {
+			const { collections } = config;
+			const registry = new MongoCollectionRegistry();
+			if (collections) collections.forEach((collection) => registry.register(collection));
+			const db = mongoConfig.connection;
+			const client = mongoConfig.client;
+			try {
+				await db.command({ ping: 1 });
+			} catch (err) {
+				logger.error("❌ Failed to connect to MongoDB", { error: err });
+			}
+			const realtimeService = new MongoRealtimeService(db);
+			const driver = new MongoDriver(db, realtimeService, void 0, registry);
+			return {
+				driver,
+				realtimeProvider: realtimeService,
+				collectionRegistry: registry,
+				internals: {
+					db,
+					client,
+					registry,
+					realtimeService,
+					driver
+				}
+			};
+		},
+		async initializeAuth(config, driverResult) {
+			const db = driverResult.internals.db;
+			const { ensureAuthCollectionsExist } = await import("./ensure-collections-Bkx_O5CQ.js");
+			await ensureAuthCollectionsExist(db);
+			const { createEmailService } = await import("@rebasepro/server");
+			const authConfig = config;
+			let emailService;
+			if (authConfig?.email) emailService = createEmailService(authConfig.email);
+			return {
+				userService: new MongoUserService(db),
+				roleService: new MongoRoleService(db),
+				authRepository: new MongoAuthRepository(db),
+				emailService
+			};
+		},
+		async initializeHistory(config, driverResult) {
+			if (!config) return void 0;
+			const db = driverResult.internals.db;
+			const { ensureHistoryCollectionExists } = await import("./ensure-history-collection-yajOt2dv.js");
+			await ensureHistoryCollectionExists(db);
+			const { MongoHistoryService } = await Promise.resolve().then(() => MongoHistoryService_exports);
+			const retention = typeof config === "object" ? config.retention : void 0;
+			return { historyService: new MongoHistoryService(db, retention ? { ttlDays: retention } : void 0) };
+		},
+		async initializeRealtime(_config, driverResult) {
+			return driverResult.internals.realtimeService;
+		},
+		getAdmin(driverResult) {
+			const db = driverResult.internals.db;
+			const admin = {
+				async executeAggregate(pipeline) {
+					const collName = pipeline[0]?.$from ?? "__admin__";
+					return await db.collection(collName).aggregate(pipeline).toArray();
+				},
+				async fetchCollectionStats(collectionName) {
+					const stats = await db.command({ collStats: collectionName });
+					return {
+						count: stats.count,
+						sizeBytes: stats.size
+					};
+				},
+				async fetchUnmappedTables(mappedPaths) {
+					const names = (await db.listCollections().toArray()).map((c) => c.name).filter((n) => !n.startsWith("system."));
+					if (!mappedPaths || mappedPaths.length === 0) return names;
+					const mappedSet = new Set(mappedPaths.map((p) => p.toLowerCase()));
+					return names.filter((n) => !mappedSet.has(n.toLowerCase()));
+				},
+				async fetchTableMetadata(collectionName) {
+					const sample = await db.collection(collectionName).findOne();
+					if (!sample) return {
+						columns: [],
+						foreignKeys: [],
+						junctions: [],
+						policies: []
+					};
+					return {
+						columns: Object.entries(sample).map(([key, value]) => ({
+							column_name: key,
+							data_type: typeof value,
+							udt_name: typeof value,
+							is_nullable: "YES",
+							column_default: null,
+							character_maximum_length: null
+						})),
+						foreignKeys: [],
+						junctions: [],
+						policies: []
+					};
+				}
+			};
+			cachedAdmin = admin;
+			return admin;
+		},
+		mountRoutes() {},
+		async initializeWebsockets(server, realtimeService, driver, config) {
+			const { createMongoWebSocket } = await import("./websocket-DQlwCHFq.js");
+			createMongoWebSocket(server, realtimeService, driver, config, cachedAdmin);
+		}
+	};
+}
+//#endregion
+export { AuthenticatedMongoDriver, MongoCollectionRegistry, MongoConditionBuilder, MongoDBConnection, MongoDataService, MongoDriver, MongoRealtimeService, createMongoBackend, createMongoBootstrapper, createMongoDBConnection, createMongoDelegate, createMongoEntityRepository, createMongoRealtimeService, isMongoBackendConfig, isMongoDriverConfig };
+
+//# sourceMappingURL=index.es.js.map