@rebasepro/client-firebase 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/hooks/useBuildUserManagement.tsx

@@ -0,0 +1,374 @@
+import React, { useCallback, useEffect } from "react";
+import equal from "react-fast-compare"
+
+import { removeUndefined } from "@rebasepro/utils";
+import {
+    AuthController,
+    Authenticator,
+    DataDriver,
+    Entity,
+    Role,
+    User,
+    UserManagementDelegate
+} from "@rebasepro/types";
+
+type UserWithRoleIds<USER extends User = any> = Omit<USER, "roles"> & { roles: string[] };
+
+export interface UserManagementDelegateParams<CONTROLLER extends AuthController<any> = AuthController<any>> {
+
+    authController: CONTROLLER;
+
+    /**
+     * The delegate in charge of persisting the data.
+     */
+    dataSourceDelegate?: DataDriver;
+
+    /**
+     * Path where the plugin users configuration is stored.
+     * Default: __FIRECMS/config/users
+     * You can specify a different path if you want to store the user management configuration in a different place.
+     * Please keep in mind that the FireCMS users are not necessarily the same as the Firebase users (but they can be).
+     * The path should be relative to the root of the database, and should always have an odd number of segments.
+     */
+    usersPath?: string;
+
+    /**
+     * Path where the plugin roles configuration is stored.
+     * Default: __FIRECMS/config/roles
+     */
+    rolesPath?: string;
+
+    /**
+     * The roles that are available in the user management system.
+     * If you provide this, the user management system will not fetch the roles from the database.
+     */
+    roles?: Role[];
+
+    /**
+     * If there are no roles in the database, provide a button to create the default roles.
+     */
+    allowDefaultRolesCreation?: boolean;
+
+    /**
+     * Include the collection config permissions in the user management system.
+     */
+    includeCollectionConfigPermissions?: boolean;
+
+}
+
+/**
+ * This hook is used to build a user management object that can be used to
+ * manage users and roles in a Firestore backend.
+ * @param authController
+ * @param dataSourceDelegate
+ * @param usersPath
+ * @param rolesPath
+ * @param roles
+ * @param allowDefaultRolesCreation
+ * @param includeCollectionConfigPermissions
+ */
+export function useBuildUserManagement<CONTROLLER extends AuthController<any> = AuthController<any>,
+    USER extends User = CONTROLLER extends AuthController<infer U> ? U : any>
+({
+     authController,
+     dataSourceDelegate,
+     roles: rolesProp,
+     usersPath = "__FIRECMS/config/users",
+     rolesPath = "__FIRECMS/config/roles",
+     allowDefaultRolesCreation,
+     includeCollectionConfigPermissions
+ }: UserManagementDelegateParams<CONTROLLER>): UserManagementDelegate<USER> & CONTROLLER {
+
+    if (!authController) {
+        throw Error("useBuildUserManagement: You need to provide an authController since version 3.0.0-beta.11. Check https://firecms.co/docs/pro/migrating_from_v3_beta");
+    }
+
+    const rolesDefinedInCode = (rolesProp ?? [])?.length > 0;
+    const [rolesLoading, setRolesLoading] = React.useState<boolean>(!rolesDefinedInCode);
+    const [usersLoading, setUsersLoading] = React.useState<boolean>(true);
+    const [roles, setRoles] = React.useState<Role[]>(rolesProp ?? []);
+    const [usersWithRoleIds, setUsersWithRoleIds] = React.useState<UserWithRoleIds<USER>[]>([]);
+
+    const users = usersWithRoleIds.map(u => ({
+        ...u,
+    }) as unknown as USER);
+
+    const [rolesError, setRolesError] = React.useState<Error | undefined>();
+    const [usersError, setUsersError] = React.useState<Error | undefined>();
+
+    const _usersLoading = usersLoading;
+    const _rolesLoading = rolesLoading;
+
+    const loading = _rolesLoading || _usersLoading;
+
+    useEffect(() => {
+        if (rolesDefinedInCode) return;
+        if (!dataSourceDelegate || !rolesPath) return;
+        if (dataSourceDelegate.initialised !== undefined && !dataSourceDelegate.initialised) return;
+        if (authController?.initialLoading) return;
+
+        setRolesLoading(true);
+        return dataSourceDelegate.listenCollection?.({
+            path: rolesPath,
+            onUpdate(entities: Entity<any>[]): void {
+                setRolesError(undefined);
+                console.debug("Updating roles", entities);
+                try {
+                    const newRoles = entityToRoles(entities);
+                    if (!equal(newRoles, roles)) {
+                        setRoles(newRoles);
+                    }
+                } catch (e) {
+                    setRoles([]);
+                    console.error("Error loading roles", e);
+                    setRolesError(e as Error);
+                }
+                setRolesLoading(false);
+            },
+            onError(e: any): void {
+                setRoles([]);
+                console.error("Error loading roles", e);
+                setRolesError(e);
+                setRolesLoading(false);
+            }
+        });
+
+    }, [rolesDefinedInCode, dataSourceDelegate?.initialised, authController?.initialLoading, authController?.user?.uid, rolesPath]);
+
+    useEffect(() => {
+        if (!dataSourceDelegate || !usersPath) return;
+        if (dataSourceDelegate.initialised !== undefined && !dataSourceDelegate.initialised) {
+            return;
+        }
+        if (authController?.initialLoading) {
+            return;
+        }
+
+        setUsersLoading(true);
+        return dataSourceDelegate.listenCollection?.({
+            path: usersPath,
+            onUpdate(entities: Entity<any>[]): void {
+                console.debug("Updating users", entities);
+                setUsersError(undefined);
+                try {
+                    const newUsers = entitiesToUsers(entities);
+                    // if (!equal(newUsers, usersWithRoleIds))
+                    setUsersWithRoleIds(newUsers);
+                } catch (e) {
+                    setUsersWithRoleIds([]);
+                    console.error("Error loading users", e);
+                    setUsersError(e as Error);
+                }
+                setUsersLoading(false);
+            },
+            onError(e: any): void {
+                console.error("Error loading users", e);
+                setUsersWithRoleIds([]);
+                setUsersError(e);
+                setUsersLoading(false);
+            }
+        });
+
+    }, [dataSourceDelegate?.initialised, authController?.initialLoading, authController?.user?.uid, usersPath]);
+
+    const saveUser = useCallback(async (user: USER): Promise<USER> => {
+        if (!dataSourceDelegate) throw Error("useBuildUserManagement Firebase not initialised");
+        if (!usersPath) throw Error("useBuildUserManagement Firestore not initialised");
+
+        console.debug("Persisting user", user);
+
+        const roleIds = user.roles;
+        const email = user.email?.toLowerCase().trim();
+        if (!email) throw Error("Email is required");
+
+        const userExists = users.find(u => u.email?.toLowerCase() === email);
+        const data = {
+            ...user,
+            roles: roleIds ?? []
+        };
+        if (!userExists) {
+            // @ts-ignore
+            data.created_on = new Date();
+        }
+        // delete the previous user entry if it exists and the uid has changed
+        if (userExists && userExists.uid !== user.uid) {
+            const entity: Entity<any> = {
+                values: {},
+                path: usersPath,
+                id: userExists.uid
+            }
+            await dataSourceDelegate.deleteEntity({ entity })
+                .then(() => {
+                    console.debug("Deleted previous user", userExists);
+                })
+                .catch(e => {
+                    console.error("Error deleting user", e);
+                });
+
+        }
+
+        return dataSourceDelegate.saveEntity({
+            status: "existing",
+            path: usersPath,
+            entityId: email,
+            values: removeUndefined(data) as Record<string, unknown>
+        }).then(() => user);
+    }, [usersPath, dataSourceDelegate?.initialised]);
+
+    const saveRole = useCallback((role: Role): Promise<void> => {
+        if (!dataSourceDelegate) throw Error("useBuildUserManagement Firebase not initialised");
+        if (!rolesPath) throw Error("useBuildUserManagement Firestore not initialised");
+        console.debug("Persisting role", role);
+        const {
+            id,
+            ...roleData
+        } = role;
+        return dataSourceDelegate.saveEntity({
+            status: "existing",
+            path: rolesPath,
+            entityId: id,
+            values: removeUndefined(roleData) as Record<string, unknown>
+        }).then(() => {
+            return;
+        });
+    }, [rolesPath, dataSourceDelegate?.initialised]);
+
+    const deleteUser = useCallback(async (user: User): Promise<void> => {
+        if (!dataSourceDelegate) throw Error("useBuildUserManagement Firebase not initialised");
+        if (!usersPath) throw Error("useBuildUserManagement Firestore not initialised");
+        console.debug("Deleting", user);
+        const { uid } = user;
+        const entity: Entity<any> = {
+            path: usersPath,
+            id: uid,
+            values: {}
+        };
+        await dataSourceDelegate.deleteEntity({ entity })
+    }, [usersPath, dataSourceDelegate?.initialised]);
+
+    const deleteRole = useCallback(async (role: Role): Promise<void> => {
+        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: Entity<any> = {
+            path: rolesPath,
+            id: id,
+            values: {}
+        };
+        await dataSourceDelegate.deleteEntity({ entity })
+    }, [rolesPath, dataSourceDelegate?.initialised]);
+
+
+
+    const defineRolesFor: ((user: User) => Role[] | undefined) = useCallback((user) => {
+        if (!usersWithRoleIds) throw Error("Users not loaded");
+        const mgmtUser = usersWithRoleIds.find(u => u.email?.toLowerCase() === user?.email?.toLowerCase());
+        if (!mgmtUser || !mgmtUser.roles) return undefined;
+        return roles.filter(r => mgmtUser.roles.includes(r.id));
+    }, [roles, usersWithRoleIds]);
+
+    const authenticator: Authenticator<USER> = useCallback(({ user }) => {
+
+        if (loading) {
+            return false;
+        }
+        if (user === null) {
+            console.warn("User is null, returning");
+            return false;
+        }
+
+        if (users.length === 0) {
+            console.warn("No users created yet");
+            return true; // If there are no users created yet, we allow access to every user
+        }
+
+        const mgmtUser = users.find(u => u.email?.toLowerCase() === user?.email?.toLowerCase());
+        if (mgmtUser) {
+            // check if the uid or photoURL needs to be updated in the user management system
+            const needsUidUpdate = mgmtUser.uid !== user.uid;
+            const needsPhotoUpdate = user.photoURL && mgmtUser.photoURL !== user.photoURL;
+
+            if (needsUidUpdate || needsPhotoUpdate) {
+                const updateReason = needsUidUpdate ? "uid" : "photoURL";
+                console.debug(`User ${updateReason} has changed, updating user in user management system`);
+                saveUser({
+                    ...mgmtUser,
+                    uid: user.uid,
+                    ...(needsPhotoUpdate ? { photoURL: user.photoURL } : {})
+                }).then(() => {
+                    console.debug("User updated in user management system", mgmtUser);
+                }).catch(e => {
+                    console.error("Error updating user in user management system", e);
+                });
+            }
+            console.debug("User found in user management system", mgmtUser);
+            return true;
+        }
+
+        throw Error("Could not find a user with the provided email in the user management system.");
+    }, [loading, users]);
+
+    const userRoles = authController.user ? defineRolesFor(authController.user) : undefined;
+    const isAdmin = (userRoles ?? []).some(r => r.id === "admin");
+
+    const userRoleIds = userRoles?.map(r => r.id);
+    useEffect(() => {
+        console.debug("Setting user roles", {
+            userRoles,
+            roles
+        });
+        authController.setUserRoles?.(userRoles ?? []);
+    }, [userRoleIds]);
+
+    const getUser = useCallback((uid: string): USER | null => {
+        if (!users) return null;
+        const user = users.find(u => u.uid === uid);
+        return user ?? null;
+    }, [users]);
+
+    return {
+        loading,
+        roles,
+        users,
+        saveUser,
+        saveRole,
+        rolesError,
+        deleteUser,
+        deleteRole,
+        usersError,
+        isAdmin,
+        allowDefaultRolesCreation: allowDefaultRolesCreation === undefined ? true : allowDefaultRolesCreation,
+        includeCollectionConfigPermissions: Boolean(includeCollectionConfigPermissions),
+        defineRolesFor,
+        authenticator,
+        ...authController,
+        initialLoading: authController.initialLoading || loading,
+        userRoles: userRoles,
+        getUser,
+        user: authController.user ? {
+            ...authController.user,
+            roles: userRoles
+        } : null
+    }
+}
+
+const entitiesToUsers = (docs: Entity<Omit<UserWithRoleIds, "id">>[]): (UserWithRoleIds)[] => {
+    return docs.map((doc) => {
+        const data = doc.values as any;
+        const newVar = {
+            uid: doc.id,
+            ...data,
+            created_on: data?.created_on,
+            updated_on: data?.updated_on
+        };
+        return newVar as (UserWithRoleIds);
+    });
+}
+
+const entityToRoles = (entities: Entity<Omit<Role, "id">>[]): Role[] => {
+    return entities.map((doc) => ({
+        id: doc.id,
+        ...doc.values
+    } as Role));
+}

package/src/hooks/useFirebaseAuthController.ts

@@ -299,7 +299,7 @@ export const useFirebaseAuthController = <USER extends FirebaseUserWrapper = any
     const firebaseUserWrapper: FirebaseUserWrapper | null = loggedUser
         ? {
             ...loggedUser,
-            roles: userRoles?.map(r => r.id),  // User.roles is string[], keep Role[] internally only
+            roles: userRoles?.map(r => r.id), // User.roles is string[], keep Role[] internally only
             firebaseUser: loggedUser
         }
         : null;

package/src/hooks/useFirebaseRealTimeDBDelegate.ts

@@ -48,7 +48,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
             return Object.entries(snapshot.val()).map(([id, values]) => ({
                 id,
                 path: path,
-                values: delegateToCMSModel(values) as M,
+                values: delegateToCMSModel(values) as M
             }));
         }
         return [];
@@ -56,7 +56,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 
     const listenCollection = useCallback(<M extends Record<string, any>>({
         path,
-        onUpdate,
+        onUpdate
         // Realtime Database does not directly support onError in onValue
     }: ListenCollectionProps<M>): () => void => {
         if (!firebaseApp) {
@@ -70,7 +70,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
                 const result: Entity<M>[] = Object.entries(snapshot.val()).map(([id, values]) => ({
                     id,
                     path: path,
-                    values: delegateToCMSModel(values) as M,
+                    values: delegateToCMSModel(values) as M
                 }));
                 onUpdate(result);
             } else {
@@ -83,7 +83,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 
     const fetchEntity = useCallback(async <M extends Record<string, any>>({
         path,
-        entityId,
+        entityId
     }: FetchEntityProps<M>): Promise<Entity<M> | undefined> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
@@ -131,7 +131,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
     const saveEntity = useCallback(async <M extends Record<string, any>>({
         path,
         entityId,
-        values,
+        values
     }: SaveEntityProps<M>): Promise<Entity<M>> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
@@ -156,7 +156,7 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
     }, [firebaseApp]);
 
     const deleteEntity = useCallback(async <M extends Record<string, any>>({
-        entity,
+        entity
     }: DeleteEntityProps<M>): Promise<void> => {
         if (!firebaseApp) {
             throw new Error("Firebase app not provided");
@@ -213,7 +213,6 @@ export function useFirebaseRTDBDelegate({ firebaseApp }: { firebaseApp?: Firebas
 }
 
 
-
 /**
  * Transform data from RTDB format back to CMS format
  * This is used internally when fetching/listening to data
@@ -263,7 +262,8 @@ function cmsToRTDBModel(data: any, database: Database): any {
                 else
                     return {};
             })
-            .reduce((a, b) => ({ ...a, ...b }), {});
+            .reduce((a, b) => ({ ...a,
+...b }), {});
     }
     return data;
 }

package/src/hooks/useFirebaseStorageSource.ts

@@ -29,10 +29,9 @@ export function useFirebaseStorageSource({
     const projectId = firebaseApp?.options?.projectId;
     const urlsCache: Record<string, DownloadConfig> = {};
     return {
-        uploadFile({
+        putObject({
             file,
-            fileName,
-            path,
+            key,
             metadata,
             bucket
         }: UploadFileProps)
@@ -42,9 +41,8 @@ export function useFirebaseStorageSource({
                 const storageBucketUrl = bucket ?? bucketUrl;
                 const storage = getStorage(firebaseApp, storageBucketUrl);
                 if (!storage) throw Error("useFirebaseStorageSource Firebase not initialised");
-                const usedFilename = fileName ?? file.name;
 
-                const storageRef = ref(storage, `${path}/${usedFilename}`);
+                const storageRef = ref(storage, key);
                 const uploadTask = uploadBytesResumable(storageRef, file, metadata);
 
                 return new Promise((resolve, reject) => {
@@ -111,9 +109,9 @@ export function useFirebaseStorageSource({
                             const fullPath = uploadTask.snapshot.ref.fullPath;
                             const bucketName = uploadTask.snapshot.ref.bucket;
                             resolve({
-                                path: fullPath,
+                                key: fullPath,
                                 bucket: bucketName,
-                                storageUrl: `gs://${bucketName}/${fullPath}`
+                                storageUrl: `s3://${bucketName}/${fullPath}`
                             });
                         }
                     );
@@ -123,7 +121,7 @@ export function useFirebaseStorageSource({
             }
         },
 
-        async getFile(path: string, bucket?: string): Promise<File | null> {
+        async getObject(path: string, bucket?: string): Promise<File | null> {
             try {
                 if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
                 const storageBucketUrl = bucket ?? bucketUrl;
@@ -140,15 +138,16 @@ export function useFirebaseStorageSource({
             }
         },
 
-        async getDownloadURL(storagePathOrUrl: string, bucket?: string): Promise<DownloadConfig> {
+        async getSignedUrl(storagePathOrUrl: string, bucket?: string): Promise<DownloadConfig> {
             if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
 
-            // Support fully-qualified gs:// URLs
+            // Support fully-qualified s3:// and gs:// URLs for backward compatibility
             let resolvedPathOrUrl = storagePathOrUrl;
             let resolvedBucket = bucket;
-            if (storagePathOrUrl.startsWith("gs://")) {
-                // Format: gs://<bucket>/<path>
-                const withoutProtocol = storagePathOrUrl.substring("gs://".length);
+            const match = storagePathOrUrl.match(/^(s3|gs):\/\//);
+            if (match) {
+                const protocolLength = match[0].length;
+                const withoutProtocol = storagePathOrUrl.substring(protocolLength);
                 const firstSlash = withoutProtocol.indexOf("/");
                 if (firstSlash > 0) {
                     resolvedBucket = withoutProtocol.substring(0, firstSlash);
@@ -180,7 +179,7 @@ export function useFirebaseStorageSource({
             }
         },
 
-        async list(path: string, options?: {
+        async listObjects(prefix: string, options?: {
             bucket?: string,
             maxResults?: number,
             pageToken?: string
@@ -189,14 +188,14 @@ export function useFirebaseStorageSource({
             const storageBucketUrl = options?.bucket ?? bucketUrl;
             const storage = getStorage(firebaseApp, storageBucketUrl);
             if (!storage) throw Error("useFirebaseStorageSource Firebase not initialised");
-            const folderRef = ref(storage, path);
+            const folderRef = ref(storage, prefix);
             return await list(folderRef, {
                 maxResults: options?.maxResults,
                 pageToken: options?.pageToken
             });
         },
 
-        async deleteFile(path: string, bucket?: string): Promise<void> {
+        async deleteObject(path: string, bucket?: string): Promise<void> {
             if (!firebaseApp) throw Error("useFirebaseStorageSource Firebase not initialised");
             const storageBucketUrl = bucket ?? bucketUrl;
             const storage = getStorage(firebaseApp, storageBucketUrl);

package/src/hooks/useFirestoreDriver.ts

@@ -160,7 +160,7 @@ export function useFirestoreDriver({
             entityId,
             collection,
             onUpdate,
-            onError,
+            onError
         }: ListenEntityProps<M>): () => void => {
         if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
 
@@ -183,7 +183,7 @@ export function useFirestoreDriver({
         path,
         databaseId,
         searchString,
-        onUpdate,
+        onUpdate
     }: {
         path: string,
         databaseId?: string,
@@ -297,7 +297,7 @@ export function useFirestoreDriver({
             searchString,
             orderBy,
             order,
-            collection,
+            collection
         }: FetchCollectionProps<M>
         ): Promise<Entity<M>[]> => {
 
@@ -346,7 +346,7 @@ export function useFirestoreDriver({
                 order,
                 onUpdate,
                 onError,
-                collection,
+                collection
             }: ListenCollectionProps<M>
         ): () => void => {
 
@@ -372,7 +372,7 @@ export function useFirestoreDriver({
                     path,
                     searchString,
                     onUpdate,
-                    databaseId,
+                    databaseId
                 });
             }
 
@@ -404,7 +404,7 @@ export function useFirestoreDriver({
         fetchEntity: useCallback(<M extends Record<string, any>>({
             path,
             entityId,
-            collection,
+            collection
         }: FetchEntityProps<M>
         ): Promise<Entity<M> | undefined> => {
             const resolvedPath = path;
@@ -440,7 +440,7 @@ export function useFirestoreDriver({
                 entityId,
                 values: valuesProp,
                 collection,
-                status,
+                status
             }: SaveEntityProps<M>): Promise<Entity<M>> => {
 
             if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
@@ -482,7 +482,7 @@ export function useFirestoreDriver({
                     return {
                         id: documentReference.id,
                         path,
-                        values: firestoreToCMSModel(values),
+                        values: firestoreToCMSModel(values)
                     } as Entity<M>;
                 })
                 .catch((error) => {
@@ -548,7 +548,7 @@ export function useFirestoreDriver({
             filter,
             order,
             orderBy,
-            collection,
+            collection
         }: FetchCollectionProps<any>): Promise<number> => {
             if (!firebaseApp) throw Error("useFirestoreDriver Firebase not initialised");
             const databaseId = collection?.databaseId;
@@ -562,7 +562,7 @@ export function useFirestoreDriver({
             path,
             collection,
             filterValues,
-            sortBy,
+            sortBy
         }: {
             path: string,
             collection: EntityCollection<any>,
@@ -656,7 +656,8 @@ export function firestoreToCMSModel(data: any): any {
         return data; // already translated
     }
     if (data instanceof VectorValue || (typeof data === "object" && data !== null && typeof data.toArray === "function" && data.constructor?.name === "VectorValue")) {
-        return { __type__: "__vector__", value: data.toArray() };
+        return { __type__: "__vector__",
+value: data.toArray() };
     }
 
     if (data instanceof FirestoreGeoPoint) {
@@ -665,7 +666,9 @@ export function firestoreToCMSModel(data: any): any {
     if (data instanceof DocumentReference) {
         // @ts-ignore
         const databaseId = data?.firestore?._databaseId?.database;
-        return new EntityReference({ id: data.id, path: getCMSPathFromFirestorePath(data.path), databaseId });
+        return new EntityReference({ id: data.id,
+path: getCMSPathFromFirestorePath(data.path),
+databaseId });
     }
     if (Array.isArray(data)) {
         return data.map(firestoreToCMSModel).filter(v => v !== undefined);
@@ -703,6 +706,8 @@ export function cmsToFirestoreModel(data: any, firestore: Firestore, inArray = f
     } else if (data.isEntityReference && data.isEntityReference()) {
         const targetFirestore = data.databaseId ? getFirestore(firestore.app, data.databaseId) : firestore;
         return doc(targetFirestore, data.path, data.id);
+    } else if (data && typeof data === "object" && data.__type === "relation" && data.path && data.id) {
+        return doc(firestore, data.path, String(data.id));
     } else if (data instanceof GeoPoint) {
         return new FirestoreGeoPoint(data.latitude, data.longitude);
     } else if (data instanceof Date) {
@@ -718,7 +723,8 @@ export function cmsToFirestoreModel(data: any, firestore: Firestore, inArray = f
                 else
                     return {};
             })
-            .reduce((a, b) => ({ ...a, ...b }), {});
+            .reduce((a, b) => ({ ...a,
+...b }), {});
     }
     return data;
 }

package/src/utils/algolia.ts

@@ -14,7 +14,7 @@ export function performAlgoliaTextSearch(client: any, indexName: string, query:
 
     return client.searchSingleIndex({
         indexName,
-        searchParams: { query },
+        searchParams: { query }
     }).then(({ hits }: any) => {
         return hits.map((hit: any) => hit.objectID as string);
     })