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

package/dist/index.umd.js

@@ -0,0 +1,2925 @@
+(function(global, factory) {
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("mongodb"), require("@rebasepro/types"), require("@rebasepro/server"), require("@rebasepro/common"), require("@rebasepro/utils"), require("ws")) : typeof define === "function" && define.amd ? define([
+		"exports",
+		"mongodb",
+		"@rebasepro/types",
+		"@rebasepro/server",
+		"@rebasepro/common",
+		"@rebasepro/utils",
+		"ws"
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase MongoDB"] = {}, global.mongodb, global._rebasepro_types, global._rebasepro_server, global._rebasepro_common, global._rebasepro_utils, global.ws));
+})(this, function(exports, mongodb, _rebasepro_types, _rebasepro_server, _rebasepro_common, _rebasepro_utils, ws) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	var __defProp = Object.defineProperty;
+	var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+	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 mongodb.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) {
+					_rebasepro_server.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" && mongodb.ObjectId.isValid(id) && id.length === 24) return new mongodb.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 mongodb.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 _rebasepro_types.EntityReference({
+					id: value.id instanceof mongodb.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: mongodb.ObjectId.isValid(value.id) ? new mongodb.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 mongodb.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) _rebasepro_server.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 mongodb.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) => {
+					_rebasepro_server.logger.error(`Change stream error for subscription ${subscriptionId}`, { error });
+				});
+			} catch (error) {
+				_rebasepro_server.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) {
+				_rebasepro_server.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" && mongodb.ObjectId.isValid(config.id) ? new mongodb.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) => {
+					_rebasepro_server.logger.error(`Change stream error for subscription ${subscriptionId}`, { error });
+				});
+			} catch (error) {
+				_rebasepro_server.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) {
+				_rebasepro_server.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) => _rebasepro_server.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) => {
+				_rebasepro_server.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, MongoHistoryService;
+	var init_MongoHistoryService = __esmMin((() => {
+		DEFAULT_RETENTION = {
+			maxEntries: 200,
+			ttlDays: 90
+		};
+		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 mongodb.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) => {
+						_rebasepro_server.logger.error(`[HistoryService] Failed to prune history for ${tableName}/${id}`, { error: e });
+					});
+				} catch (error) {
+					_rebasepro_server.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
+	init_MongoHistoryService();
+	/**
+	* 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 = (0, _rebasepro_common.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 = (0, _rebasepro_common.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) {
+					_rebasepro_server.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) {
+					_rebasepro_server.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 = (0, _rebasepro_utils.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 = (0, _rebasepro_utils.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 = (0, _rebasepro_utils.mergeDeep)(updatedValues, result);
+				}
+			}
+			if (resolvedCollection?.properties) updatedValues = (0, _rebasepro_common.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) => {
+					_rebasepro_server.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) => {
+				_rebasepro_server.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 = (0, _rebasepro_common.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 (!(0, _rebasepro_common.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 || !(0, _rebasepro_common.checkOperation)(resolvedCollection, { user: this.user }, rowToEntityForCheck(existing, props.path), "update", { onUnknown: "deny" })) throw _rebasepro_server.ApiError.forbidden("Forbidden");
+			} else {
+				const tempEntity = {
+					id: props.id || "new",
+					path: props.path,
+					values: props.values
+				};
+				if (!(0, _rebasepro_common.checkOperation)(resolvedCollection, { user: this.user }, tempEntity, "insert", { onUnknown: "deny" })) throw _rebasepro_server.ApiError.forbidden("Forbidden");
+			}
+			const saved = await this.delegate.save({
+				...props,
+				collection: resolvedCollection
+			});
+			if (!(0, _rebasepro_common.checkOperation)(resolvedCollection, { user: this.user }, rowToEntityForCheck(saved, props.path), props.status === "existing" ? "update" : "insert", { onUnknown: "deny" })) throw _rebasepro_server.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 || !(0, _rebasepro_common.checkOperation)(resolvedCollection, { user: this.user }, rowToEntityForCheck(existing, props.row.path), "delete", { onUnknown: "deny" })) throw _rebasepro_server.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
+	init_MongoHistoryService();
+	/**
+	* 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 mongodb.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 mongodb.ObjectId().toString(),
+					id: new mongodb.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 mongodb.ObjectId().toString(),
+					userId,
+					roleId
+				}));
+				await this.userRolesCollection.insertMany(docs);
+			}
+		}
+		async assignDefaultRole(userId, roleId) {
+			await this.userRolesCollection.updateOne({
+				userId,
+				roleId
+			}, { $setOnInsert: {
+				_id: new mongodb.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 mongodb.ObjectId().toString(),
+				id: new mongodb.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 mongodb.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/auth/ensure-collections.ts
+	var ensure_collections_exports = /* @__PURE__ */ __exportAll({ ensureAuthCollectionsExist: () => ensureAuthCollectionsExist });
+	async function ensureAuthCollectionsExist(db) {
+		_rebasepro_server.logger.info("🔍 Checking MongoDB auth collections and indexes...");
+		try {
+			await db.collection("rebase_users").createIndex({ email: 1 }, { unique: true });
+			const identities = db.collection("rebase_user_identities");
+			await identities.createIndex({
+				provider: 1,
+				provider_id: 1
+			}, { unique: true });
+			await identities.createIndex({ user_id: 1 });
+			const userRoles = db.collection("rebase_user_roles");
+			await userRoles.createIndex({
+				user_id: 1,
+				role_id: 1
+			}, { unique: true });
+			await userRoles.createIndex({ user_id: 1 });
+			const refreshTokens = db.collection("rebase_refresh_tokens");
+			await refreshTokens.createIndex({ token_hash: 1 }, { unique: true });
+			await refreshTokens.createIndex({
+				user_id: 1,
+				user_agent: 1,
+				ip_address: 1
+			}, { unique: true });
+			await refreshTokens.createIndex({ user_id: 1 });
+			const resetTokens = db.collection("rebase_password_reset_tokens");
+			await resetTokens.createIndex({ token_hash: 1 }, { unique: true });
+			await resetTokens.createIndex({ user_id: 1 });
+			await seedDefaultRoles(db);
+			_rebasepro_server.logger.info("✅ MongoDB Auth collections ready");
+		} catch (error) {
+			_rebasepro_server.logger.error("❌ Failed to set up MongoDB auth collections", { error });
+		}
+	}
+	async function seedDefaultRoles(db) {
+		const roles = db.collection("rebase_roles");
+		const count = await roles.countDocuments();
+		if (count > 0) {
+			_rebasepro_server.logger.info(`📋 Found ${count} existing roles`);
+			return;
+		}
+		_rebasepro_server.logger.info("🌱 Seeding default roles...");
+		for (const role of DEFAULT_ROLES) await roles.updateOne({ id: role.id }, { $setOnInsert: role }, { upsert: true });
+		_rebasepro_server.logger.info("✅ Default roles created: admin, editor, viewer");
+	}
+	var DEFAULT_ROLES;
+	var init_ensure_collections = __esmMin((() => {
+		DEFAULT_ROLES = [
+			{
+				_id: "admin",
+				id: "admin",
+				name: "Admin",
+				isAdmin: true,
+				defaultPermissions: {
+					read: true,
+					create: true,
+					edit: true,
+					delete: true
+				},
+				createdAt: /* @__PURE__ */ new Date()
+			},
+			{
+				_id: "editor",
+				id: "editor",
+				name: "Editor",
+				isAdmin: false,
+				defaultPermissions: {
+					read: true,
+					create: true,
+					edit: true,
+					delete: true
+				},
+				createdAt: /* @__PURE__ */ new Date()
+			},
+			{
+				_id: "viewer",
+				id: "viewer",
+				name: "Viewer",
+				isAdmin: false,
+				defaultPermissions: {
+					read: true,
+					create: false,
+					edit: false,
+					delete: false
+				},
+				createdAt: /* @__PURE__ */ new Date()
+			}
+		];
+	}));
+	//#endregion
+	//#region src/history/ensure-history-collection.ts
+	var ensure_history_collection_exports = /* @__PURE__ */ __exportAll({ ensureHistoryCollectionExists: () => ensureHistoryCollectionExists });
+	async function ensureHistoryCollectionExists(db) {
+		_rebasepro_server.logger.info("🔍 Checking MongoDB history collection and indexes...");
+		try {
+			const history = db.collection("__rebase_history");
+			await history.createIndex({
+				entity_id: 1,
+				table_name: 1,
+				updated_at: -1
+			});
+			await history.createIndex({ updated_at: 1 });
+			_rebasepro_server.logger.info("✅ MongoDB History collection ready");
+		} catch (error) {
+			_rebasepro_server.logger.error("❌ Failed to set up MongoDB history collection", { error });
+		}
+	}
+	var init_ensure_history_collection = __esmMin((() => {}));
+	//#endregion
+	//#region src/websocket.ts
+	var websocket_exports = /* @__PURE__ */ __exportAll({ createMongoWebSocket: () => createMongoWebSocket });
+	function isDriverWithAuth(driver) {
+		return "withAuth" in driver && typeof driver.withAuth === "function";
+	}
+	function isAdminSession(session) {
+		if (!session?.user?.roles) return false;
+		return session.user.roles.includes("admin");
+	}
+	function createMongoWebSocket(server, realtimeService, driver, authConfig, admin) {
+		const isProduction = process.env.NODE_ENV === "production";
+		const wsDebug = (...args) => {
+			if (!isProduction) console.debug(...args);
+		};
+		const wss = new ws.WebSocketServer({ server });
+		wss.on("error", (err) => {
+			if (err.code === "EADDRINUSE") return;
+			_rebasepro_server.logger.error("❌ [WebSocket Server] Error", { error: err });
+		});
+		const requireAuth = authConfig?.requireAuth !== false && authConfig?.jwtSecret;
+		wss.on("connection", (ws$1) => {
+			const clientId = `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			wsDebug(`WebSocket client connected: ${clientId}`);
+			clientSessions.set(clientId, {
+				ws: ws$1,
+				authenticated: !requireAuth,
+				messageCount: 0,
+				messageWindowStart: Date.now()
+			});
+			realtimeService.addClient(clientId, ws$1);
+			ws$1.on("close", () => {
+				wsDebug(`WebSocket client disconnected: ${clientId}`);
+				clientSessions.delete(clientId);
+			});
+			ws$1.on("message", async (message) => {
+				let requestId;
+				try {
+					const { type, payload, requestId: reqId } = JSON.parse(message.toString());
+					requestId = reqId;
+					wsDebug(`[WS] ${clientId} → ${type}`, requestId ? `(${requestId})` : "");
+					const sendError = (errType, code, msg) => {
+						ws$1.send(JSON.stringify({
+							type: errType,
+							requestId,
+							payload: { error: {
+								message: msg,
+								code
+							} }
+						}));
+					};
+					if (type === "AUTHENTICATE") {
+						const { token } = payload || {};
+						if (!token) {
+							sendError("AUTH_ERROR", "INVALID_INPUT", "Token is required");
+							return;
+						}
+						const user = (0, _rebasepro_server.extractUserFromToken)(token);
+						if (user) {
+							const session = clientSessions.get(clientId);
+							if (session) {
+								session.user = user;
+								session.authenticated = true;
+							}
+							ws$1.send(JSON.stringify({
+								type: "AUTH_SUCCESS",
+								requestId,
+								payload: {
+									userId: user.userId,
+									roles: user.roles
+								}
+							}));
+						} else sendError("AUTH_ERROR", "INVALID_TOKEN", "Invalid or expired token");
+						return;
+					}
+					if (requireAuth) {
+						if (!clientSessions.get(clientId)?.authenticated) {
+							sendError("ERROR", "UNAUTHORIZED", "Authentication required");
+							return;
+						}
+					}
+					{
+						const session = clientSessions.get(clientId);
+						if (session) {
+							const now = Date.now();
+							if (now - session.messageWindowStart > WS_RATE_WINDOW_MS) {
+								session.messageCount = 0;
+								session.messageWindowStart = now;
+							}
+							session.messageCount++;
+							if (session.messageCount > WS_RATE_LIMIT) {
+								sendError("ERROR", "RATE_LIMITED", "Too many requests. Please slow down.");
+								return;
+							}
+						}
+					}
+					if (ADMIN_ONLY_TYPES.has(type)) {
+						if (!isAdminSession(clientSessions.get(clientId))) {
+							sendError("ERROR", "FORBIDDEN", "Admin access required for this operation");
+							return;
+						}
+					}
+					const getScopedDelegate = async () => {
+						const session = clientSessions.get(clientId);
+						if (session?.user && isDriverWithAuth(driver)) try {
+							const userForAuth = {
+								uid: session.user.userId,
+								email: session.user.email ?? "",
+								displayName: session.user.displayName ?? "",
+								photoURL: session.user.photoURL ?? "",
+								providerId: "jwt",
+								isAnonymous: false,
+								roles: session.user.roles ?? []
+							};
+							return await driver.withAuth(userForAuth);
+						} catch (e) {
+							_rebasepro_server.logger.error("Failed to create authenticated delegate for WS request", { error: e });
+							return driver;
+						}
+						return driver;
+					};
+					switch (type) {
+						case "FETCH_COLLECTION": {
+							const request = payload;
+							const rows = await (await getScopedDelegate()).fetchCollection(request);
+							ws$1.send(JSON.stringify({
+								type: "FETCH_COLLECTION_SUCCESS",
+								payload: { rows },
+								requestId
+							}));
+							break;
+						}
+						case "FETCH_ONE": {
+							const request = payload;
+							const row = await (await getScopedDelegate()).fetchOne(request);
+							ws$1.send(JSON.stringify({
+								type: "FETCH_ONE_SUCCESS",
+								payload: { row },
+								requestId
+							}));
+							break;
+						}
+						case "SAVE": {
+							const request = payload;
+							const row = await (await getScopedDelegate()).save(request);
+							ws$1.send(JSON.stringify({
+								type: "SAVE_SUCCESS",
+								payload: { row },
+								requestId
+							}));
+							break;
+						}
+						case "DELETE": {
+							const request = payload;
+							await (await getScopedDelegate()).delete(request);
+							ws$1.send(JSON.stringify({
+								type: "DELETE_SUCCESS",
+								payload: { success: true },
+								requestId
+							}));
+							break;
+						}
+						case "CHECK_UNIQUE_FIELD": {
+							const { path, name, value, id, collection } = payload;
+							const isUnique = await (await getScopedDelegate()).checkUniqueField(path, name, value, id, collection);
+							ws$1.send(JSON.stringify({
+								type: "CHECK_UNIQUE_FIELD_SUCCESS",
+								payload: { isUnique },
+								requestId
+							}));
+							break;
+						}
+						case "COUNT": {
+							const request = payload;
+							const count = await (await getScopedDelegate()).count(request);
+							ws$1.send(JSON.stringify({
+								type: "COUNT_SUCCESS",
+								payload: { count },
+								requestId
+							}));
+							break;
+						}
+						case "EXECUTE_SQL": {
+							const { sql, options } = payload;
+							if (admin && (0, _rebasepro_types.isDocumentAdmin)(admin) && admin.executeAggregate) {
+								const result = await admin.executeAggregate(sql);
+								ws$1.send(JSON.stringify({
+									type: "EXECUTE_SQL_SUCCESS",
+									payload: { result },
+									requestId
+								}));
+							} else ws$1.send(JSON.stringify({
+								type: "ERROR",
+								requestId,
+								payload: { error: {
+									message: "SQL execution not supported for this driver",
+									code: "NOT_SUPPORTED"
+								} }
+							}));
+							break;
+						}
+						case "FETCH_UNMAPPED_TABLES":
+							if (admin && (0, _rebasepro_types.isSchemaAdmin)(admin)) {
+								const tables = await admin.fetchUnmappedTables?.(payload?.mappedPaths) || [];
+								ws$1.send(JSON.stringify({
+									type: "FETCH_UNMAPPED_TABLES_SUCCESS",
+									payload: { tables },
+									requestId
+								}));
+							} else ws$1.send(JSON.stringify({
+								type: "FETCH_UNMAPPED_TABLES_SUCCESS",
+								payload: { tables: [] },
+								requestId
+							}));
+							break;
+						case "FETCH_TABLE_METADATA": {
+							const { tableName } = payload;
+							if (admin && (0, _rebasepro_types.isSchemaAdmin)(admin)) {
+								const metadata = await admin.fetchTableMetadata?.(tableName);
+								ws$1.send(JSON.stringify({
+									type: "FETCH_TABLE_METADATA_SUCCESS",
+									payload: { metadata },
+									requestId
+								}));
+							} else ws$1.send(JSON.stringify({
+								type: "FETCH_TABLE_METADATA_SUCCESS",
+								payload: { metadata: null },
+								requestId
+							}));
+							break;
+						}
+						case "subscribe_collection":
+						case "subscribe_one":
+						case "unsubscribe": {
+							const session = clientSessions.get(clientId);
+							const authContext = session?.user ? {
+								userId: session.user.userId,
+								roles: session.user.roles ?? []
+							} : void 0;
+							await realtimeService.handleClientMessage(clientId, {
+								type,
+								payload,
+								subscriptionId: payload?.subscriptionId
+							}, authContext);
+							break;
+						}
+						default: _rebasepro_server.logger.error("❌ [WebSocket Server] Unknown message type", { detail: type });
+					}
+				} catch (error) {
+					const errorMessage = process.env.NODE_ENV === "production" ? "An unexpected error occurred" : error instanceof Error ? error.message : "An unexpected error occurred";
+					ws$1.send(JSON.stringify({
+						type: "ERROR",
+						requestId,
+						payload: { error: {
+							message: errorMessage,
+							code: "INTERNAL_ERROR"
+						} }
+					}));
+				}
+			});
+		});
+	}
+	var clientSessions, WS_RATE_LIMIT, WS_RATE_WINDOW_MS, ADMIN_ONLY_TYPES;
+	var init_websocket = __esmMin((() => {
+		clientSessions = /* @__PURE__ */ new Map();
+		WS_RATE_LIMIT = 2e3;
+		WS_RATE_WINDOW_MS = 6e4;
+		ADMIN_ONLY_TYPES = new Set([
+			"EXECUTE_SQL",
+			"FETCH_DATABASES",
+			"FETCH_ROLES",
+			"FETCH_UNMAPPED_TABLES",
+			"FETCH_TABLE_METADATA",
+			"FETCH_CURRENT_DATABASE",
+			"CREATE_BRANCH",
+			"DELETE_BRANCH",
+			"LIST_BRANCHES"
+		]);
+	}));
+	//#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) {
+					_rebasepro_server.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 Promise.resolve().then(() => (init_ensure_collections(), ensure_collections_exports));
+				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 Promise.resolve().then(() => (init_ensure_history_collection(), ensure_history_collection_exports));
+				await ensureHistoryCollectionExists(db);
+				const { MongoHistoryService } = await Promise.resolve().then(() => (init_MongoHistoryService(), 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 Promise.resolve().then(() => (init_websocket(), websocket_exports));
+				createMongoWebSocket(server, realtimeService, driver, config, cachedAdmin);
+			}
+		};
+	}
+	//#endregion
+	exports.AuthenticatedMongoDriver = AuthenticatedMongoDriver;
+	exports.MongoCollectionRegistry = MongoCollectionRegistry;
+	exports.MongoConditionBuilder = MongoConditionBuilder;
+	exports.MongoDBConnection = MongoDBConnection;
+	exports.MongoDataService = MongoDataService;
+	exports.MongoDriver = MongoDriver;
+	exports.MongoRealtimeService = MongoRealtimeService;
+	exports.createMongoBackend = createMongoBackend;
+	exports.createMongoBootstrapper = createMongoBootstrapper;
+	exports.createMongoDBConnection = createMongoDBConnection;
+	exports.createMongoDelegate = createMongoDelegate;
+	exports.createMongoEntityRepository = createMongoEntityRepository;
+	exports.createMongoRealtimeService = createMongoRealtimeService;
+	exports.isMongoBackendConfig = isMongoBackendConfig;
+	exports.isMongoDriverConfig = isMongoDriverConfig;
+});
+
+//# sourceMappingURL=index.umd.js.map