@rebasepro/client-firebase 0.7.0 → 0.9.0

package/dist/index.es.js

@@ -4,7 +4,7 @@ import { FacebookAuthProvider, GithubAuthProvider, GoogleAuthProvider, OAuthProv
 import { deleteObject, getDownloadURL, getMetadata, getStorage, list, ref, uploadBytesResumable } from "@firebase/storage";
 import { deleteApp, getApps, initializeApp } from "@firebase/app";
 import { getToken, initializeAppCheck } from "@firebase/app-check";
-import { EntityReference, GeoPoint } from "@rebasepro/types";
+import { DEFAULT_DATA_SOURCE_KEY, EntityReference, GeoPoint } from "@rebasepro/types";
 import { DocumentReference, GeoPoint as GeoPoint$1, Timestamp, VectorValue, collection, deleteDoc, deleteField, doc, getCountFromServer, getDoc, getDocs, getFirestore, limit, onSnapshot, orderBy, query, serverTimestamp, setDoc, startAfter, vector, where } from "@firebase/firestore";
 import { COLLECTION_PATH_SEPARATOR, buildRebaseData, sortProperties, stripCollectionPath } from "@rebasepro/common";
 import Fuse from "fuse.js";
@@ -12,7 +12,7 @@ import { getFunctions, httpsCallable } from "@firebase/functions";
 import { get, getDatabase, limitToFirst, onValue, orderByChild, orderByKey, push, query as query$1, ref as ref$1, remove, set, startAt } from "@firebase/database";
 import { removeUndefined } from "@rebasepro/utils";
 import { AdminModeControllerProvider, ErrorView, ModeControllerProvider, Rebase, RebaseLogo, RebaseRoutes, SnackbarProvider, useBrowserTitleAndIcon, useBuildAdminModeController, useBuildLocalConfigurationPersistence, useBuildModeController, useModeController, useSnackbarController } from "@rebasepro/core";
-import { AppBar, CollectionRegistryContext, Drawer, NavigationStateContext, RebaseRoute, Scaffold, SideDialogs, SideEntityProvider, UrlContext, useBuildCollectionRegistryController, useBuildNavigationStateController, useBuildUrlController } from "@rebasepro/admin";
+import { AppBar, CollectionRegistryContext, Drawer, NavigationStateContext, RebaseRoute, Scaffold, SideDialogs, SidePanelProvider, UrlContext, useBuildCollectionRegistryController, useBuildNavigationStateController, useBuildUrlController } from "@rebasepro/admin";
 import { ArrowLeftIcon, Button, CenteredView, CircularProgress, CircularProgressCenter, IconButton, LoadingButton, MailIcon, PhoneIcon, TextField, Typography, UserIcon, cls, iconSize } from "@rebasepro/ui";
 import { Navigate, Outlet, Route } from "react-router-dom";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -262,8 +262,8 @@ function useFirebaseStorageSource({ firebaseApp, bucketUrl }) {
 						}, 5e3);
 					};
 					setProgressTimeout();
-					uploadTask.on("state_changed", (snapshot) => {
-						const progress = snapshot.bytesTransferred / snapshot.totalBytes * 100;
+					uploadTask.on("state_changed", (entity) => {
+						const progress = entity.bytesTransferred / entity.totalBytes * 100;
 						if (progress > lastProgress) {
 							lastProgress = progress;
 							setProgressTimeout();
@@ -586,8 +586,8 @@ function normalizePropertiesEnumValues(properties, sortObjectFormat = false) {
 //#region src/utils/database.ts
 async function getFirestoreDataInPath(firebaseApp, path, parentPaths, limit$2) {
 	const firestore = getFirestore(firebaseApp);
-	if (!parentPaths || parentPaths.length === 0) return getDocs(query(collection(firestore, path), limit(limit$2))).then((querySnapshot) => {
-		return querySnapshot.docs.map((doc) => doc.data());
+	if (!parentPaths || parentPaths.length === 0) return getDocs(query(collection(firestore, path), limit(limit$2))).then((queryEntity) => {
+		return queryEntity.docs.map((doc) => doc.data());
 	});
 	else {
 		let currentDocs = void 0;
@@ -699,9 +699,9 @@ var localSearchControllerBuilder = ({ firebaseApp }) => {
 			if (collectionProp) {
 				console.debug("Init local search controller", path);
 				listeners[path] = onSnapshot(query(collection(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path)), {
-					next: (snapshot) => {
-						if (snapshot.metadata.fromCache && snapshot.metadata.hasPendingWrites) return;
-						const docs = snapshot.docs.map((doc) => ({
+					next: (entity) => {
+						if (entity.metadata.fromCache && entity.metadata.hasPendingWrites) return;
+						const docs = entity.docs.map((doc) => ({
 							id: doc.id,
 							...doc.data()
 						}));
@@ -968,6 +968,15 @@ function useFirestoreDriver({ firebaseApp, textSearchControllerBuilder, firestor
 		const queryParams = [];
 		if (filter) Object.entries(filter).filter(([_, entry]) => !!entry).forEach(([key, filterParameter]) => {
 			const [op, value] = filterParameter;
+			if (op === "is-null") {
+				queryParams.push(where(key, "==", null));
+				return;
+			}
+			if (op === "is-not-null") {
+				queryParams.push(where(key, "!=", null));
+				return;
+			}
+			if (op === "like" || op === "ilike" || op === "not-like" || op === "not-ilike") throw new Error(`Firestore does not support the "${op}" operator (SQL pattern matching). Use a full-text search index or the collection's searchString instead.`);
 			queryParams.push(where(key, op, cmsToFirestoreModel(value, firestore)));
 		});
 		if (orderBy$1 && order) queryParams.push(orderBy(orderBy$1, order));
@@ -975,19 +984,19 @@ function useFirestoreDriver({ firebaseApp, textSearchControllerBuilder, firestor
 		if (limit$1) queryParams.push(limit(limit$1));
 		return query(collectionReference, ...queryParams);
 	}, [firebaseApp]);
-	const getAndBuildEntity = useCallback((path, entityId, databaseId) => {
+	const getAndBuildEntity = useCallback((path, id, databaseId) => {
 		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-		return getDoc(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path, String(entityId))).then((docSnapshot) => {
-			if (!docSnapshot.exists()) return;
-			return createEntityFromDocument(docSnapshot, databaseId);
+		return getDoc(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path, String(id))).then((docEntity) => {
+			if (!docEntity.exists()) return;
+			return createRowFromDocument(docEntity);
 		});
 	}, [firebaseApp]);
-	const listenEntity = useCallback(({ path, entityId, collection, onUpdate, onError }) => {
+	const listenOne = useCallback(({ path, id, collection, onUpdate, onError }) => {
 		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
 		const databaseId = collection?.databaseId;
-		return onSnapshot(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path, String(entityId)), {
-			next: (docSnapshot) => {
-				onUpdate(createEntityFromDocument(docSnapshot, databaseId));
+		return onSnapshot(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path, String(id)), {
+			next: (docEntity) => {
+				onUpdate(docEntity.exists() ? createRowFromDocument(docEntity) : null);
 			},
 			error: onError
 		});
@@ -1010,22 +1019,23 @@ function useFirestoreDriver({ firebaseApp, textSearchControllerBuilder, firestor
 				subscriptions = [];
 				onUpdate([]);
 			}
-			const entities = [];
+			const rows = [];
 			const addedEntitiesSet = /* @__PURE__ */ new Set();
-			subscriptions = (ids ?? []).map((entityId) => {
-				return listenEntity({
+			subscriptions = (ids ?? []).map((id) => {
+				return listenOne({
 					path,
-					entityId,
-					onUpdate: (entity) => {
-						if (entity?.values) {
-							if (entity.id && !addedEntitiesSet.has(entity.id)) {
-								addedEntitiesSet.add(entity.id);
-								entities.push(entity);
-								onUpdate(entities);
+					id,
+					onUpdate: (row) => {
+						const incomingId = row?.id;
+						if (row && incomingId !== void 0) {
+							if (!addedEntitiesSet.has(incomingId)) {
+								addedEntitiesSet.add(incomingId);
+								rows.push(row);
+								onUpdate(rows);
 							}
-						} else if (entity?.id) {
-							addedEntitiesSet.delete(entity.id);
-							onUpdate([...entities.filter((e) => e.id !== entityId)]);
+						} else {
+							addedEntitiesSet.delete(id);
+							onUpdate([...rows.filter((r) => r.id !== id)]);
 						}
 					}
 				});
@@ -1034,231 +1044,237 @@ function useFirestoreDriver({ firebaseApp, textSearchControllerBuilder, firestor
 		return () => {
 			subscriptions.forEach((p) => p());
 		};
-	}, [firebaseApp, listenEntity]);
-	return {
+	}, [firebaseApp, listenOne]);
+	const initTextSearch = useCallback(async (props) => {
+		console.debug("Init text search controller", searchControllerRef.current, props.path);
+		if (!searchControllerRef.current) {
+			console.warn("You are trying to use text search, but have not provided a text search controller in `useFirestoreDriver`. You can also set the flag `localTextSearchEnabled` to use local search in `useFirestoreDriver`. Local text search can incur in performance issues and higher costs for large datasets.");
+			return false;
+		}
+		try {
+			return searchControllerRef.current.init(props);
+		} catch (e) {
+			console.error("Error initializing text search controller", e);
+			return false;
+		}
+	}, []);
+	/**
+	* Fetch entities in a Firestore path
+	* @param path
+	* @param collection
+	* @param filter
+	* @param limit
+	* @param startAfter
+	* @param searchString
+	* @param orderBy
+	* @param order
+	* @return Function to cancel subscription
+	* @see useCollection if you need this functionality implemented as a hook
+	* @group Firestore
+	*/
+	const fetchCollection = useCallback(async ({ path, filter, limit, startAfter, searchString, orderBy, order, collection }) => {
+		const databaseId = collection?.databaseId;
+		const resolvedPath = path;
+		console.debug("Fetching collection", {
+			path,
+			limit,
+			filter,
+			startAfter,
+			orderBy,
+			order
+		});
+		return (await getDocs(buildQuery(resolvedPath, filter, orderBy, order, startAfter, limit, databaseId))).docs.map((doc) => createRowFromDocument(doc));
+	}, [buildQuery]);
+	/**
+	* Listen to a entities in a given path
+	* @param path
+	* @param collection
+	* @param onError
+	* @param filter
+	* @param limit
+	* @param startAfter
+	* @param searchString
+	* @param orderBy
+	* @param order
+	* @param onUpdate
+	* @return Function to cancel subscription
+	* @see useCollection if you need this functionality implemented as a hook
+	* @group Firestore
+	*/
+	const listenCollection = useCallback(({ path, filter, limit, startAfter, searchString, orderBy, order, onUpdate, onError, collection }) => {
+		console.debug("Listening collection", {
+			path,
+			searchString,
+			limit,
+			filter,
+			startAfter,
+			orderBy,
+			order,
+			collection
+		});
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		const databaseId = collection?.databaseId;
+		if (searchString) return performTextSearch({
+			path,
+			searchString,
+			onUpdate,
+			databaseId
+		});
+		const resolvedPath = path;
+		console.debug("Resolved path for listening", {
+			path,
+			resolvedPath
+		});
+		return onSnapshot(buildQuery(resolvedPath, filter, orderBy, order, startAfter, limit, databaseId), {
+			next: (entity) => {
+				if (!searchString) onUpdate(entity.docs.map((doc) => createRowFromDocument(doc)));
+			},
+			error: onError
+		});
+	}, [
+		buildQuery,
+		firebaseApp,
+		performTextSearch
+	]);
+	/**
+	* Retrieve a entity given a path and a collection
+	* @param path
+	* @param id
+	* @param collection
+	* @group Firestore
+	*/
+	const fetchOne = useCallback(({ path, id, collection }) => {
+		return getAndBuildEntity(path, id, collection?.databaseId);
+	}, [getAndBuildEntity]);
+	/**
+	* Save entity to the specified path. Note that Firestore does not allow
+	* undefined values.
+	* @param path
+	* @param id
+	* @param values
+	* @param schemaId
+	* @param collection
+	* @param status
+	* @group Firestore
+	*/
+	const save = useCallback(({ path, id, values: valuesProp, collection: collection$1, status }) => {
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		console.debug("1", {
+			path,
+			id,
+			values: valuesProp,
+			collection: collection$1
+		});
+		const values = cmsToFirestoreModel(valuesProp, getFirestore(firebaseApp));
+		console.debug("2", {
+			path,
+			id,
+			values: valuesProp,
+			collection: collection$1
+		});
+		const databaseId = collection$1?.databaseId;
+		const collectionReference = collection(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path);
+		console.debug("Saving entity", {
+			path,
+			id,
+			values,
+			databaseId
+		});
+		let documentReference;
+		if (id) documentReference = doc(collectionReference, String(id));
+		else documentReference = doc(collectionReference);
+		return setDoc(documentReference, values, { merge: true }).then(() => {
+			return {
+				...firestoreToCMSModel(values),
+				id: documentReference.id
+			};
+		}).catch((error) => {
+			console.error("Error saving entity", error);
+			throw error;
+		});
+	}, [firebaseApp]);
+	/**
+	* Delete a entity
+	* @param entity
+	* @param collection
+	* @group Firestore
+	*/
+	const deleteOne = useCallback(({ row, collection }) => {
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		const databaseId = collection?.databaseId;
+		return deleteDoc(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), row.path, String(row.id)));
+	}, [firebaseApp]);
+	/**
+	* Check if the given property is unique in the given collection
+	* @param path Collection path
+	* @param name of the property
+	* @param value
+	* @param property
+	* @param id
+	* @return `true` if there are no other fields besides the given entity
+	* @group Firestore
+	*/
+	const checkUniqueField = useCallback(async (path, name, value, id, collection$2) => {
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		const databaseId = collection$2?.databaseId;
+		const firestore = databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp);
+		if (value === void 0 || value === null) return Promise.resolve(true);
+		return (await getDocs(query(collection(firestore, path), where(name, "==", cmsToFirestoreModel(value, firestore))))).docs.filter((doc) => doc.id !== id).length === 0;
+	}, [firebaseApp]);
+	const count = useCallback(async ({ path, filter, order, orderBy, collection }) => {
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		const databaseId = collection?.databaseId;
+		return (await getCountFromServer(buildQuery(path, filter, orderBy, order, void 0, void 0, databaseId))).data().count;
+	}, [firebaseApp]);
+	const isFilterCombinationValid = useCallback(({ path, collection, filterValues, sortBy }) => {
+		if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
+		if (firestoreIndexesBuilder === void 0) return true;
+		const indexes = firestoreIndexesBuilder?.({
+			path,
+			collection
+		});
+		const sortKey = sortBy ? sortBy[0] : void 0;
+		const sortDirection = sortBy ? sortBy[1] : void 0;
+		const values = Object.values(filterValues);
+		const filterKeys = Object.keys(filterValues);
+		const filtersCount = filterKeys.length;
+		if (!sortKey && values.every((v) => v[0] === "==")) return true;
+		if (filtersCount === 1 && (!sortKey || sortKey === filterKeys[0])) return true;
+		if (!indexes && filtersCount > 1) return false;
+		return !!indexes && indexes.filter((compositeIndex) => !sortKey || sortKey in compositeIndex).find((compositeIndex) => Object.entries(filterValues).every(([key, value]) => compositeIndex[key] !== void 0 && (!sortDirection || compositeIndex[key] === sortDirection))) !== void 0;
+	}, [firebaseApp]);
+	return useMemo(() => ({
 		key: "firestore",
 		currentTime,
 		initialised: Boolean(firebaseApp),
-		initTextSearch: useCallback(async (props) => {
-			console.debug("Init text search controller", searchControllerRef.current, props.path);
-			if (!searchControllerRef.current) {
-				console.warn("You are trying to use text search, but have not provided a text search controller in `useFirestoreDriver`. You can also set the flag `localTextSearchEnabled` to use local search in `useFirestoreDriver`. Local text search can incur in performance issues and higher costs for large datasets.");
-				return false;
-			}
-			try {
-				return searchControllerRef.current.init(props);
-			} catch (e) {
-				console.error("Error initializing text search controller", e);
-				return false;
-			}
-		}, []),
-		/**
-		* Fetch entities in a Firestore path
-		* @param path
-		* @param collection
-		* @param filter
-		* @param limit
-		* @param startAfter
-		* @param searchString
-		* @param orderBy
-		* @param order
-		* @return Function to cancel subscription
-		* @see useCollectionFetch if you need this functionality implemented as a hook
-		* @group Firestore
-		*/
-		fetchCollection: useCallback(async ({ path, filter, limit, startAfter, searchString, orderBy, order, collection }) => {
-			const databaseId = collection?.databaseId;
-			const resolvedPath = path;
-			console.debug("Fetching collection", {
-				path,
-				limit,
-				filter,
-				startAfter,
-				orderBy,
-				order
-			});
-			return (await getDocs(buildQuery(resolvedPath, filter, orderBy, order, startAfter, limit, databaseId))).docs.map((doc) => createEntityFromDocument(doc, databaseId));
-		}, [buildQuery]),
-		/**
-		* Listen to a entities in a given path
-		* @param path
-		* @param collection
-		* @param onError
-		* @param filter
-		* @param limit
-		* @param startAfter
-		* @param searchString
-		* @param orderBy
-		* @param order
-		* @param onUpdate
-		* @return Function to cancel subscription
-		* @see useCollectionFetch if you need this functionality implemented as a hook
-		* @group Firestore
-		*/
-		listenCollection: useCallback(({ path, filter, limit, startAfter, searchString, orderBy, order, onUpdate, onError, collection }) => {
-			console.debug("Listening collection", {
-				path,
-				searchString,
-				limit,
-				filter,
-				startAfter,
-				orderBy,
-				order,
-				collection
-			});
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			const databaseId = collection?.databaseId;
-			if (searchString) return performTextSearch({
-				path,
-				searchString,
-				onUpdate,
-				databaseId
-			});
-			const resolvedPath = path;
-			console.debug("Resolved path for listening", {
-				path,
-				resolvedPath
-			});
-			return onSnapshot(buildQuery(resolvedPath, filter, orderBy, order, startAfter, limit, databaseId), {
-				next: (snapshot) => {
-					if (!searchString) onUpdate(snapshot.docs.map((doc) => createEntityFromDocument(doc, databaseId)));
-				},
-				error: onError
-			});
-		}, [
-			buildQuery,
-			firebaseApp,
-			performTextSearch
-		]),
-		/**
-		* Retrieve an entity given a path and a collection
-		* @param path
-		* @param entityId
-		* @param collection
-		* @group Firestore
-		*/
-		fetchEntity: useCallback(({ path, entityId, collection }) => {
-			return getAndBuildEntity(path, entityId, collection?.databaseId);
-		}, [getAndBuildEntity]),
-		/**
-		*
-		* @param path
-		* @param entityId
-		* @param collection
-		* @param onUpdate
-		* @param onError
-		* @return Function to cancel subscription
-		* @group Firestore
-		*/
-		listenEntity,
-		/**
-		* Save entity to the specified path. Note that Firestore does not allow
-		* undefined values.
-		* @param path
-		* @param entityId
-		* @param values
-		* @param schemaId
-		* @param collection
-		* @param status
-		* @group Firestore
-		*/
-		saveEntity: useCallback(({ path, entityId, values: valuesProp, collection: collection$1, status }) => {
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			console.debug("1", {
-				path,
-				entityId,
-				values: valuesProp,
-				collection: collection$1
-			});
-			const values = cmsToFirestoreModel(valuesProp, getFirestore(firebaseApp));
-			console.debug("2", {
-				path,
-				entityId,
-				values: valuesProp,
-				collection: collection$1
-			});
-			const databaseId = collection$1?.databaseId;
-			const collectionReference = collection(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), path);
-			console.debug("Saving entity", {
-				path,
-				entityId,
-				values,
-				databaseId
-			});
-			let documentReference;
-			if (entityId) documentReference = doc(collectionReference, String(entityId));
-			else documentReference = doc(collectionReference);
-			return setDoc(documentReference, values, { merge: true }).then(() => {
-				return {
-					id: documentReference.id,
-					path,
-					values: firestoreToCMSModel(values)
-				};
-			}).catch((error) => {
-				console.error("Error saving entity", error);
-				throw error;
-			});
-		}, [firebaseApp]),
-		/**
-		* Delete an entity
-		* @param entity
-		* @param collection
-		* @group Firestore
-		*/
-		deleteEntity: useCallback(({ entity }) => {
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			const databaseId = entity.databaseId;
-			return deleteDoc(doc(databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp), entity.path, String(entity.id)));
-		}, [firebaseApp]),
-		/**
-		* Check if the given property is unique in the given collection
-		* @param path Collection path
-		* @param name of the property
-		* @param value
-		* @param property
-		* @param entityId
-		* @return `true` if there are no other fields besides the given entity
-		* @group Firestore
-		*/
-		checkUniqueField: useCallback(async (path, name, value, entityId, collection$2) => {
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			const databaseId = collection$2?.databaseId;
-			const firestore = databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp);
-			if (value === void 0 || value === null) return Promise.resolve(true);
-			return (await getDocs(query(collection(firestore, path), where(name, "==", cmsToFirestoreModel(value, firestore))))).docs.filter((doc) => doc.id !== entityId).length === 0;
-		}, [firebaseApp]),
-		countEntities: useCallback(async ({ path, filter, order, orderBy, collection }) => {
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			const databaseId = collection?.databaseId;
-			return (await getCountFromServer(buildQuery(path, filter, orderBy, order, void 0, void 0, databaseId))).data().count;
-		}, [firebaseApp]),
-		isFilterCombinationValid: useCallback(({ path, collection, filterValues, sortBy }) => {
-			if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
-			if (firestoreIndexesBuilder === void 0) return true;
-			const indexes = firestoreIndexesBuilder?.({
-				path,
-				collection
-			});
-			const sortKey = sortBy ? sortBy[0] : void 0;
-			const sortDirection = sortBy ? sortBy[1] : void 0;
-			const values = Object.values(filterValues);
-			const filterKeys = Object.keys(filterValues);
-			const filtersCount = filterKeys.length;
-			if (!sortKey && values.every((v) => v[0] === "==")) return true;
-			if (filtersCount === 1 && (!sortKey || sortKey === filterKeys[0])) return true;
-			if (!indexes && filtersCount > 1) return false;
-			return !!indexes && indexes.filter((compositeIndex) => !sortKey || sortKey in compositeIndex).find((compositeIndex) => Object.entries(filterValues).every(([key, value]) => compositeIndex[key] !== void 0 && (!sortDirection || compositeIndex[key] === sortDirection))) !== void 0;
-		}, [firebaseApp])
-	};
+		initTextSearch,
+		fetchCollection,
+		listenCollection,
+		fetchOne,
+		listenOne,
+		save,
+		delete: deleteOne,
+		checkUniqueField,
+		count,
+		isFilterCombinationValid
+	}), [
+		firebaseApp,
+		initTextSearch,
+		fetchCollection,
+		listenCollection,
+		fetchOne,
+		listenOne,
+		save,
+		deleteOne,
+		checkUniqueField,
+		count,
+		isFilterCombinationValid
+	]);
 }
-var createEntityFromDocument = (docSnap, databaseId) => {
-	const values = firestoreToCMSModel(docSnap.data());
-	const path = getCMSPathFromFirestorePath(docSnap.ref.path);
+var createRowFromDocument = (docSnap) => {
 	return {
-		id: docSnap.id,
-		path,
-		values,
-		databaseId
+		...firestoreToCMSModel(docSnap.data()),
+		id: docSnap.id
 	};
 };
 /**
@@ -1373,70 +1389,65 @@ function useFirebaseRTDBDelegate({ firebaseApp }) {
 			let dbQuery = query$1(ref$1(getDatabase(firebaseApp), path));
 			if (startAfter !== void 0) dbQuery = query$1(dbQuery, orderByKey(), startAt(String(startAfter)));
 			if (limit !== void 0) dbQuery = query$1(dbQuery, limitToFirst(limit));
-			const snapshot = await get(dbQuery);
-			if (snapshot.exists()) return Object.entries(snapshot.val()).map(([id, values]) => ({
-				id,
-				path,
-				values: delegateToCMSModel(values)
+			const entity = await get(dbQuery);
+			if (entity.exists()) return Object.entries(entity.val()).map(([id, values]) => ({
+				...delegateToCMSModel(values),
+				id
 			}));
 			return [];
 		}, [firebaseApp]),
 		listenCollection: useCallback(({ path, onUpdate }) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
-			const unsubscribe = onValue(ref$1(getDatabase(firebaseApp), path), (snapshot) => {
-				if (snapshot.exists()) onUpdate(Object.entries(snapshot.val()).map(([id, values]) => ({
-					id,
-					path,
-					values: delegateToCMSModel(values)
+			const unsubscribe = onValue(ref$1(getDatabase(firebaseApp), path), (entity) => {
+				if (entity.exists()) onUpdate(Object.entries(entity.val()).map(([id, values]) => ({
+					...delegateToCMSModel(values),
+					id
 				})));
 				else onUpdate([]);
 			});
 			return () => unsubscribe();
 		}, [firebaseApp]),
-		fetchEntity: useCallback(async ({ path, entityId }) => {
+		fetchOne: useCallback(async ({ path, id }) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
-			const snapshot = await get(ref$1(getDatabase(firebaseApp), `${path}/${entityId}`));
-			if (snapshot.exists()) return {
-				id: entityId,
-				path,
-				values: delegateToCMSModel(snapshot.val())
+			const entity = await get(ref$1(getDatabase(firebaseApp), `${path}/${id}`));
+			if (entity.exists()) return {
+				...delegateToCMSModel(entity.val()),
+				id
 			};
 		}, [firebaseApp]),
-		listenEntity: useCallback(({ path, entityId, onUpdate, onError }) => {
+		listenOne: useCallback(({ path, id, onUpdate, onError }) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
-			const unsubscribe = onValue(ref$1(getDatabase(firebaseApp), `${path}/${entityId}`), (snapshot) => {
-				if (snapshot.exists()) onUpdate({
-					id: entityId,
-					path,
-					values: delegateToCMSModel(snapshot.val())
+			const unsubscribe = onValue(ref$1(getDatabase(firebaseApp), `${path}/${id}`), (entity) => {
+				if (entity.exists()) onUpdate({
+					...delegateToCMSModel(entity.val()),
+					id
 				});
 				else onError?.(/* @__PURE__ */ new Error("Entity does not exist"));
 			});
 			return () => unsubscribe();
 		}, [firebaseApp]),
-		saveEntity: useCallback(async ({ path, entityId, values }) => {
+		save: useCallback(async ({ path, id, values }) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
 			const database = getDatabase(firebaseApp);
-			const finalId = entityId ?? push(ref$1(database, path)).key;
+			const finalId = id ?? push(ref$1(database, path)).key;
 			if (!finalId) throw new Error("Could not generate a new id");
 			const transformedValues = cmsToRTDBModel(values, database);
 			await set(ref$1(database, `${path}/${finalId}`), transformedValues);
 			return {
-				id: finalId,
-				path,
-				values
+				...values,
+				id: finalId
 			};
 		}, [firebaseApp]),
-		deleteEntity: useCallback(async ({ entity }) => {
+		delete: useCallback(async ({ row }) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
-			await remove(ref$1(getDatabase(firebaseApp), `${entity.path}/${entity.id}`));
+			await remove(ref$1(getDatabase(firebaseApp), `${row.path}/${row.id}`));
 		}, [firebaseApp]),
-		checkUniqueField: useCallback(async (slug, name, value, entityId) => {
+		checkUniqueField: useCallback(async (slug, name, value, id) => {
 			if (!firebaseApp) throw new Error("Firebase app not provided");
-			const snapshot = await get(query$1(ref$1(getDatabase(firebaseApp), slug), orderByChild(name), startAt(value), limitToFirst(1)));
-			if (!snapshot.exists()) return true;
-			const [key, entityValue] = Object.entries(snapshot.val())[0];
-			if (entityValue && typeof entityValue === "object" && entityValue[name] === value && key === entityId) return true;
+			const entity = await get(query$1(ref$1(getDatabase(firebaseApp), slug), orderByChild(name), startAt(value), limitToFirst(1)));
+			if (!entity.exists()) return true;
+			const [key, entityValue] = Object.entries(entity.val())[0];
+			if (entityValue && typeof entityValue === "object" && entityValue[name] === value && key === id) return true;
 			return false;
 		}, [firebaseApp]),
 		isFilterCombinationValid: useCallback(({ path, filter, sortBy }) => {
@@ -1526,11 +1537,11 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 		setRolesLoading(true);
 		return dataSourceDelegate.listenCollection?.({
 			path: rolesPath,
-			onUpdate(entities) {
+			onUpdate(rows) {
 				setRolesError(void 0);
-				console.debug("Updating roles", entities);
+				console.debug("Updating roles", rows);
 				try {
-					const newRoles = entityToRoles(entities);
+					const newRoles = rowsToRoles(rows);
 					if (!deepEqual(newRoles, roles)) setRoles(newRoles);
 				} catch (e) {
 					setRoles([]);
@@ -1560,11 +1571,11 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 		setUsersLoading(true);
 		return dataSourceDelegate.listenCollection?.({
 			path: usersPath,
-			onUpdate(entities) {
-				console.debug("Updating users", entities);
+			onUpdate(rows) {
+				console.debug("Updating users", rows);
 				setUsersError(void 0);
 				try {
-					setUsersWithRoleIds(entitiesToUsers(entities));
+					setUsersWithRoleIds(rowsToUsers(rows));
 				} catch (e) {
 					setUsersWithRoleIds([]);
 					console.error("Error loading users", e);
@@ -1599,21 +1610,21 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 			...userExists ? {} : { created_on: /* @__PURE__ */ new Date() }
 		};
 		if (userExists && userExists.uid !== user.uid) {
-			const entity = {
+			const row = {
 				values: {},
 				path: usersPath,
 				id: userExists.uid
 			};
-			await dataSourceDelegate.deleteEntity({ entity }).then(() => {
+			await dataSourceDelegate.delete({ row }).then(() => {
 				console.debug("Deleted previous user", userExists);
 			}).catch((e) => {
 				console.error("Error deleting user", e);
 			});
 		}
-		return dataSourceDelegate.saveEntity({
+		return dataSourceDelegate.save({
 			status: "existing",
 			path: usersPath,
-			entityId: email,
+			id: email,
 			values: removeUndefined(data)
 		}).then(() => user);
 	}, [usersPath, dataSourceDelegate?.initialised]);
@@ -1622,10 +1633,10 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 		if (!rolesPath) throw Error("useBuildUserManagement Firestore not initialised");
 		console.debug("Persisting role", role);
 		const { id, ...roleData } = role;
-		return dataSourceDelegate.saveEntity({
+		return dataSourceDelegate.save({
 			status: "existing",
 			path: rolesPath,
-			entityId: id,
+			id,
 			values: removeUndefined(roleData)
 		}).then(() => {});
 	}, [rolesPath, dataSourceDelegate?.initialised]);
@@ -1634,24 +1645,24 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 		if (!usersPath) throw Error("useBuildUserManagement Firestore not initialised");
 		console.debug("Deleting", user);
 		const { uid } = user;
-		const entity = {
+		const row = {
 			path: usersPath,
 			id: uid,
 			values: {}
 		};
-		await dataSourceDelegate.deleteEntity({ entity });
+		await dataSourceDelegate.delete({ row });
 	}, [usersPath, dataSourceDelegate?.initialised]);
 	const deleteRole = useCallback(async (role) => {
 		if (!dataSourceDelegate) throw Error("useBuildUserManagement Firebase not initialised");
 		if (!rolesPath) throw Error("useBuildUserManagement Firestore not initialised");
 		console.debug("Deleting", role);
 		const { id } = role;
-		const entity = {
+		const row = {
 			path: rolesPath,
 			id,
 			values: {}
 		};
-		await dataSourceDelegate.deleteEntity({ entity });
+		await dataSourceDelegate.delete({ row });
 	}, [rolesPath, dataSourceDelegate?.initialised]);
 	const defineRolesFor = useCallback((user) => {
 		if (!usersWithRoleIds) throw Error("Users not loaded");
@@ -1727,22 +1738,21 @@ function useBuildUserManagement({ authController, dataSourceDelegate, roles: rol
 		} : null
 	};
 }
-var entitiesToUsers = (docs) => {
-	return docs.map((doc) => {
-		const data = doc.values;
-		const record = data;
+var rowsToUsers = (rows) => {
+	return rows.map((row) => {
+		const { id, ...data } = row;
 		return {
 			...data,
-			uid: doc.id,
-			created_on: record.created_on,
-			updated_on: record.updated_on
+			uid: id,
+			created_on: data.created_on,
+			updated_on: data.updated_on
 		};
 	});
 };
-var entityToRoles = (entities) => {
-	return entities.map((doc) => ({
-		id: doc.id,
-		...doc.values
+var rowsToRoles = (rows) => {
+	return rows.map((row) => ({
+		...row,
+		id: row.id
 	}));
 };
 //#endregion
@@ -2570,7 +2580,12 @@ function RebaseFirebaseApp({ name, logo, logoDark, accessGate, collections, view
 							authController,
 							userConfigPersistence,
 							dateTimeFormat,
-							driver: firestoreDelegate,
+							dataSources: [{
+								key: DEFAULT_DATA_SOURCE_KEY,
+								engine: "firestore",
+								transport: "direct",
+								driver: firestoreDelegate
+							}],
 							storageSource,
 							entityLinkBuilder: ({ entity }) => `https://console.firebase.google.com/project/${firebaseApp.options.projectId}/firestore/data/${entity.path}/${entity.id}`,
 							locale,
@@ -2596,7 +2611,7 @@ function RebaseFirebaseApp({ name, logo, logoDark, accessGate, collections, view
 											to: urlController.buildUrlCollectionPath(firstCollectionEntry.id),
 											replace: true
 										}) : /* @__PURE__ */ jsx(CenteredView, { children: "No home page or collections provided." });
-										component = /* @__PURE__ */ jsx(SideEntityProvider, { children: /* @__PURE__ */ jsx(RebaseRoutes, { children: /* @__PURE__ */ jsxs(Route, {
+										component = /* @__PURE__ */ jsx(SidePanelProvider, { children: /* @__PURE__ */ jsx(RebaseRoutes, { children: /* @__PURE__ */ jsxs(Route, {
 											element: /* @__PURE__ */ jsxs(Scaffold, {
 												logo: usedLogo,
 												autoOpenDrawer,