@rebasepro/firebase 0.17.3 → 0.18.1

package/src/hooks/useInitialiseFirebase.ts

@@ -1,132 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-
-import { deleteApp, FirebaseApp, getApps, initializeApp } from "firebase/app";
-
-/**
- * @group Firebase
- */
-export interface InitialiseFirebaseResult {
-    firebaseConfigLoading: boolean,
-    firebaseApp?: FirebaseApp;
-    configError?: string,
-    firebaseConfigError?: Error
-}
-
-const hostingError = "It seems like the provided Firebase config is not correct. If you \n" +
-    "are using the credentials provided automatically by Firebase \n" +
-    "Hosting, make sure you link your Firebase app to Firebase Hosting. \n";
-
-/**
- * Function used to initialise Firebase, either by using the provided config,
- * or by fetching it by Firebase Hosting, if not specified.
- *
- * It works as a hook that gives you the loading state and the used
- * configuration.
- *
- * You most likely only need to use this if you are developing a custom app. You can also not use this component
- * and initialise Firebase yourself.
- *
- * @param onFirebaseInit
- * @param firebaseConfig
- * @param fromUrl
- * @param name
- * @param authDomain
- * @group Firebase
- */
-export function useInitialiseFirebase({
-                                          firebaseConfig,
-                                          fromUrl,
-                                          onFirebaseInit,
-                                          name,
-                                          authDomain
-                                      }: {
-    firebaseConfig?: Record<string, unknown>,
-    fromUrl?: string | undefined,
-    onFirebaseInit?: ((config: object, firebaseApp: FirebaseApp) => void) | undefined,
-    name?: string;
-    authDomain?: string;
-}): InitialiseFirebaseResult {
-
-    const [firebaseApp, setFirebaseApp] = useState<FirebaseApp | undefined>();
-    const [firebaseConfigLoading, setFirebaseConfigLoading] = useState<boolean>(false);
-    const [configError, setConfigError] = useState<string>();
-
-    const initFirebase = useCallback((config: Record<string, unknown>) => {
-
-        if (config.projectId === firebaseApp?.options.projectId) {
-            console.debug("Firebase app already initialised with the same project ID. This should happen only in development mode.");
-            setConfigError(undefined);
-            setFirebaseConfigLoading(false);
-            return;
-        }
-
-        try {
-            const targetName = name ?? "[DEFAULT]";
-            const currentApps = getApps();
-            const existingApp = currentApps.find(app => app.name === targetName);
-            if (existingApp) {
-                deleteApp(existingApp);
-            }
-            const initialisedFirebaseApp = initializeApp(config, targetName);
-            setConfigError(undefined);
-            setFirebaseConfigLoading(false);
-            setFirebaseApp(initialisedFirebaseApp);
-        } catch (e: unknown) {
-            console.error("Error initialising Firebase", e);
-            setConfigError(hostingError + "\n" + (e instanceof Error ? e.message : JSON.stringify(e)));
-        }
-    }, [name]);
-
-    useEffect(() => {
-        if (onFirebaseInit && firebaseConfig && firebaseApp) {
-            onFirebaseInit(firebaseConfig, firebaseApp);
-        }
-    }, [firebaseApp]);
-
-    useEffect(() => {
-
-        setFirebaseConfigLoading(true);
-
-        function fetchFromUrl(url: string) {
-            fetch(url)
-                .then(async response => {
-                    console.debug("Firebase init response", response.status);
-                    if (response && response.status < 300) {
-                        const config = await response.json();
-                        if (authDomain) config.authDomain = authDomain;
-                        initFirebase(config);
-                    }
-                })
-                .catch(e => {
-                        setFirebaseConfigLoading(false);
-                        setConfigError(
-                            "Could not load Firebase configuration from Firebase hosting. " +
-                            "If the app is not deployed in Firebase hosting, you need to specify the configuration manually" +
-                            e.toString()
-                        );
-                    }
-                );
-        }
-
-        if (firebaseConfig) {
-            initFirebase(firebaseConfig);
-        } else {
-            if (fromUrl) {
-                fetchFromUrl(fromUrl);
-            } else if (process.env.NODE_ENV === "production") {
-                fetchFromUrl("/__/firebase/init.json");
-            } else {
-                setFirebaseConfigLoading(false);
-                setConfigError(
-                    "You need to deploy the app to Firebase hosting or specify a Firebase configuration object"
-                );
-            }
-        }
-    }, []);
-
-    return {
-        firebaseApp,
-        firebaseConfigLoading,
-        configError
-    };
-}

package/src/hooks/useRecaptcha.tsx

@@ -1,28 +0,0 @@
-import { useEffect } from "react";
-import { getAuth, RecaptchaVerifier } from "firebase/auth";
-
-declare global {
-    interface Window {
-        recaptchaVerifier: RecaptchaVerifier;
-    }
-}
-
-export const RECAPTCHA_CONTAINER_ID = "recaptcha-container" as const;
-
-export function useRecaptcha() {
-    useEffect(() => {
-        if (!window || window?.recaptchaVerifier) return;
-
-        const auth = getAuth();
-
-        window.recaptchaVerifier = new RecaptchaVerifier(
-            auth,
-            RECAPTCHA_CONTAINER_ID,
-            {
-                size: "invisible"
-            }
-        );
-    }, []);
-
-    return null;
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./hooks";
-export * from "./types";
-export * from "./utils";
-export * from "./components";

package/src/types/appcheck.ts

@@ -1,11 +0,0 @@
-import { CustomProvider, ReCaptchaEnterpriseProvider, ReCaptchaV3Provider } from "firebase/app-check";
-
-/**
- * @group Firebase
- */
-export interface AppCheckOptions {
-    provider: CustomProvider | ReCaptchaV3Provider | ReCaptchaEnterpriseProvider;
-    isTokenAutoRefreshEnabled?: boolean;
-    debugToken?: string;
-    forceRefresh?: boolean;
-}

package/src/types/auth.tsx

@@ -1,75 +0,0 @@
-import { ApplicationVerifier, ConfirmationResult, User as FirebaseUser } from "firebase/auth";
-
-import type { User } from "@rebasepro/types";
-import type { AuthController } from "@rebasepro/cms-types";
-
-/**
- * @group Firebase
- */
-export type FirebaseSignInProvider =
-    | "password"
-    | "phone"
-    | "anonymous"
-    | "google.com"
-    | "facebook.com"
-    | "github.com"
-    | "twitter.com"
-    | "microsoft.com"
-    | "apple.com";
-
-/**
- * @group Firebase
- */
-export type FirebaseSignInOption = {
-    provider: FirebaseSignInProvider;
-    scopes?: string[];
-    customParameters?: Record<string, string>;
-}
-
-export type FirebaseUserWrapper = User & FirebaseUser & {
-    firebaseUser: FirebaseUser | null;
-}
-
-/**
- * @group Firebase
- */
-export type FirebaseAuthController<USER extends User = FirebaseUserWrapper, ExtraData = any> =
-    AuthController<USER, ExtraData>
-    & {
-
-        confirmationResult?: ConfirmationResult;
-
-        googleLogin: () => void;
-
-        anonymousLogin: () => void;
-
-        appleLogin: () => void;
-
-        facebookLogin: () => void;
-
-        githubLogin: () => void;
-
-        microsoftLogin: () => void;
-
-        twitterLogin: () => void;
-
-        emailPasswordLogin: (email: string, password: string) => void;
-
-        fetchSignInMethodsForEmail: (email: string) => Promise<string[]>;
-
-        createUserWithEmailAndPassword: (email: string, password: string) => void;
-
-        sendPasswordResetEmail: (email: string) => Promise<void>;
-
-        phoneLogin: (phone: string, applicationVerifier: ApplicationVerifier) => void;
-
-        /**
-         * Skip login
-         */
-        skipLogin: () => void;
-
-        setUser: (user: USER | null) => void;
-
-        setUserRoles: (roles: string[]) => void;
-
-    };

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from "./auth";
-export * from "./text_search";
-export * from "./appcheck";

package/src/types/text_search.ts

@@ -1,42 +0,0 @@
-import { User as FirebaseUser } from "firebase/auth";
-import { FirebaseApp } from "firebase/app";
-import { CollectionConfig } from "@rebasepro/types";
-
-export type FirestoreTextSearchControllerBuilder = (props: {
-    firebaseApp: FirebaseApp;
-}) => FirestoreTextSearchController;
-
-/**
- * Use this controller to return a list of ids from a search index, given a
- * `path` and a `searchString`.
- * Firestore does not support text search directly, so we need to rely on an external
- * index, such as Algolia.
- * Note that you will get text search requests for collections that have the
- * `textSearchEnabled` flag set to `true`.
- * @see performAlgoliaTextSearch
- * @group Firebase
- */
-export type FirestoreTextSearchController = {
-    /**
-     * This method is called when a search delegate is ready to be used.
-     * Return true if this path can be handled by this controller.
-     * @param props
-     */
-    init: (props: {
-        path: string,
-        databaseId?: string,
-        collection?: CollectionConfig
-    }) => Promise<boolean>,
-    /**
-     * Do the search and return a list of ids.
-     * @param props
-     */
-    search: (props: {
-        searchString: string,
-        path: string,
-        currentUser?: FirebaseUser,
-        databaseId?: string,
-        collection?: CollectionConfig
-    }) => (Promise<readonly string[] | undefined>),
-
-};

package/src/utils/algolia.ts

@@ -1,27 +0,0 @@
-import { buildExternalSearchController } from "./text_search_controller";
-
-/**
- * Utility function to perform a text search in an algolia index,
- * returning the ids of the entities.
- * @param client The algolia client
- * @param indexName
- * @param query
- * @group Firebase
- */
-export function performAlgoliaTextSearch(client: { searchSingleIndex: (params: Record<string, unknown>) => Promise<{ hits: Array<{ objectID: string }> }> }, indexName: string, query: string): Promise<readonly string[]> {
-
-    console.debug("Performing Algolia query", client, query);
-
-    return client.searchSingleIndex({
-        indexName,
-        searchParams: { query }
-    }).then(({ hits }) => {
-        return hits.map((hit) => hit.objectID);
-    })
-        .catch((err: unknown) => {
-            console.error(err);
-            return [];
-        });
-}
-
-

package/src/utils/collections_firestore.ts

@@ -1,150 +0,0 @@
-import { deleteField, DocumentSnapshot } from "firebase/firestore";
-import { CollectionConfig, FirebaseCollectionConfig, Properties, Property } from "@rebasepro/types";
-import { COLLECTION_PATH_SEPARATOR, sortProperties, stripCollectionPath } from "@rebasepro/common";
-
-export function buildCollectionId(idOrPath: string, parentCollectionSlugs?: string[], parentEntityIds?: string[]): string {
-    if (!parentCollectionSlugs)
-        return stripCollectionPath(idOrPath);
-    return [...parentCollectionSlugs.map(stripCollectionPath), stripCollectionPath(idOrPath)].join(COLLECTION_PATH_SEPARATOR);
-}
-
-
-export const docsToCollectionTree = (docs: DocumentSnapshot[]): CollectionConfig[] => {
-
-    const collectionsMap = docs.map((doc) => {
-        const id: string = doc.id;
-        const collection = docToCollection(doc);
-        return { [id]: collection };
-    }).reduce((a, b) => ({ ...a,
-...b }), {});
-
-    const orderedKeys = Object.keys(collectionsMap).sort((a, b) => b.split(COLLECTION_PATH_SEPARATOR).length - a.split(COLLECTION_PATH_SEPARATOR).length);
-
-    orderedKeys.forEach((id) => {
-        const collection = collectionsMap[id];
-        if (id.includes(COLLECTION_PATH_SEPARATOR)) {
-            const parentId = id.split(COLLECTION_PATH_SEPARATOR).slice(0, -1).join(COLLECTION_PATH_SEPARATOR);
-            const parentCollection = collectionsMap[parentId];
-            if (parentCollection)
-                (parentCollection as FirebaseCollectionConfig).subcollections = () => [...((parentCollection as FirebaseCollectionConfig).subcollections?.() ?? []), collection];
-            delete collectionsMap[id];
-        }
-    });
-
-    return Object.values(collectionsMap);
-}
-
-export const docToCollection = (doc: DocumentSnapshot): CollectionConfig => {
-    const data = doc.data();
-    if (!data)
-        throw Error("Entity collection has not been persisted correctly");
-    const propertiesOrder = data.propertiesOrder;
-    const properties = data.properties as Properties ?? {};
-
-    // Normalize enum values from object format to array format (sorted alphabetically)
-    const normalizedProperties = normalizePropertiesEnumValues(properties, true);
-    const sortedProperties = sortProperties(normalizedProperties, propertiesOrder);
-    return {
-        ...data,
-        properties: sortedProperties,
-        slug: data.id ?? data.alias ?? data.slug
-    } as CollectionConfig;
-}
-
-
-/**
- * Converts enum values from object format to array format.
- * Firestore doesn't preserve object key order, so we must use arrays.
- * When enum values are already stored as an array, their order is preserved
- * (this is intentional - users can reorder columns in Kanban view).
- * Only sort alphabetically when converting from legacy object format.
- * @param enumValues - The enum values (object or array format)
- * @param sortObjectFormat - If true, sort by id alphabetically when converting from object format
- * @returns Array of EnumValueConfig objects
- */
-function normalizeEnumValuesToArray(
-    enumValues: unknown,
-    sortObjectFormat = false
-): unknown[] {
-    if (Array.isArray(enumValues)) {
-        // Already an array - preserve order! This order is intentional
-        // (e.g., user reordered Kanban columns)
-        return enumValues;
-    } else if (typeof enumValues === "object" && enumValues !== null) {
-        // Convert object to array format
-        // Object keys don't have guaranteed order in Firestore, so we sort alphabetically
-        const entries = Object.entries(enumValues).map(([id, value]) =>
-            typeof value === "string"
-                ? {
-                    id,
-                    label: value
-                }
-                : {
-                    ...(value as object),
-                    id
-                }
-        );
-        // Sort alphabetically by id when loading from Firestore object format
-        // This is the only case where sorting makes sense, since object key order is not preserved
-        if (sortObjectFormat) {
-            entries.sort((a, b) => String(a.id).localeCompare(String(b.id)));
-        }
-        return entries;
-    }
-    return [];
-}
-
-/**
- * Normalizes all enum values in a properties object.
- * @param properties - The properties object to normalize
- * @param sortObjectFormat - If true, sort enum values alphabetically when converting from object format
- * @returns Properties with normalized enum values
- */
-function normalizePropertiesEnumValues(
-    properties: Properties,
-    sortObjectFormat = false
-): Properties {
-    const result: Properties = {};
-    Object.entries(properties).forEach(([key, property]) => {
-        if (typeof property === "object" && property !== null) {
-            const normalizedProperty = { ...property } as Record<string, unknown>;
-
-            // Handle direct enum values
-            if (normalizedProperty.enum) {
-                normalizedProperty.enum = normalizeEnumValuesToArray(
-                    normalizedProperty.enum,
-                    sortObjectFormat
-                );
-            }
-
-            const propType = normalizedProperty.type ?? normalizedProperty.dataType;
-
-            // Handle array properties with enum values in "of"
-            if (propType === "array" && typeof normalizedProperty.of === "object" && normalizedProperty.of !== null) {
-                const ofProp = normalizedProperty.of as Record<string, unknown>;
-                if (ofProp.enum) {
-                    normalizedProperty.of = {
-                        ...ofProp,
-                        enum: normalizeEnumValuesToArray(
-                            ofProp.enum,
-                            sortObjectFormat
-                        )
-                    };
-                }
-            }
-
-            // Handle map properties recursively
-            if (propType === "map" && normalizedProperty.properties) {
-                normalizedProperty.properties = normalizePropertiesEnumValues(
-                    normalizedProperty.properties as Properties,
-                    sortObjectFormat
-                );
-            }
-
-            result[key] = normalizedProperty as unknown as Property;
-        } else {
-            result[key] = property;
-        }
-    });
-    return result;
-}

package/src/utils/database.ts

@@ -1,39 +0,0 @@
-import { FirebaseApp } from "firebase/app";
-import {
-    collection,
-    getDocs,
-    getFirestore,
-    limit as limitClause,
-    query,
-    QueryDocumentSnapshot
-} from "firebase/firestore";
-
-export async function getFirestoreDataInPath(firebaseApp: FirebaseApp, path: string, parentPaths: string[], limit: number): Promise<object[]> {
-    const firestore = getFirestore(firebaseApp);
-    if (!parentPaths || parentPaths.length === 0) {
-        const q = query(collection(firestore, path), limitClause(limit));
-        return getDocs(q).then((queryEntity) => {
-            return queryEntity.docs.map(doc => doc.data());
-        });
-    } else {
-        let currentDocs: QueryDocumentSnapshot[] | undefined = undefined;
-        let index = 0;
-        const allPaths = parentPaths;
-        allPaths.push(path);
-        let parentPath: string | undefined = allPaths[0];
-        while (parentPath) {
-            if (currentDocs) {
-                currentDocs = (await Promise.all(currentDocs.map(async (doc) => {
-                    const q = query(collection(firestore, doc.ref.path, parentPath as string), limitClause(5));
-                    return (await getDocs(q)).docs;
-                }))).flat();
-            } else {
-                const q = query(collection(firestore, parentPath), limitClause(5));
-                currentDocs = (await getDocs(q)).docs;
-            }
-            index++;
-            parentPath = index < allPaths.length ? allPaths[index] : undefined;
-        }
-        return currentDocs ? currentDocs.map(doc => doc.data()) : [];
-    }
-}

package/src/utils/index.ts

@@ -1,7 +0,0 @@
-export * from "./collections_firestore";
-export * from "./database";
-export * from "./algolia";
-export * from "./pinecone";
-export * from "./text_search_controller";
-export * from "./local_text_search_controller";
-export * from "./rebase_search_controller";

package/src/utils/local_text_search_controller.ts

@@ -1,143 +0,0 @@
-import { collection, getFirestore, onSnapshot, query } from "firebase/firestore";
-import Fuse from "fuse.js"
-
-import { FirebaseApp } from "firebase/app";
-import { CollectionConfig } from "@rebasepro/types";
-import { FirestoreTextSearchController, FirestoreTextSearchControllerBuilder } from "../types";
-
-const MAX_SEARCH_RESULTS = 80;
-
-export const localSearchControllerBuilder: FirestoreTextSearchControllerBuilder = ({
-    firebaseApp
-}: {
-
-    firebaseApp: FirebaseApp,
-}): FirestoreTextSearchController => {
-
-    let currentPath: string | undefined;
-    const indexes: Record<string, Fuse<object & { id: string }>> = {};
-    const listeners: Record<string, () => void> = {};
-
-    const destroyListener = (path: string) => {
-        if (listeners[path]) {
-            listeners[path]();
-            delete listeners[path];
-            delete indexes[path];
-        }
-    }
-
-    const init = ({
-        path,
-        collection: collectionProp,
-        databaseId
-    }: {
-        path: string,
-        collection?: CollectionConfig,
-        databaseId?: string
-    }): Promise<boolean> => {
-
-        if (currentPath && path !== currentPath) {
-            destroyListener(currentPath)
-        }
-
-        currentPath = path;
-
-        return new Promise((resolve, reject) => {
-            if (collectionProp) {
-                console.debug("Init local search controller", path);
-                const firestore = databaseId ? getFirestore(firebaseApp, databaseId) : getFirestore(firebaseApp);
-                const col = collection(firestore, path);
-                listeners[path] = onSnapshot(query(col),
-                    {
-                        next: (entity) => {
-                            if (entity.metadata.fromCache && entity.metadata.hasPendingWrites) {
-                                return;
-                            }
-                            const docs = entity.docs.map(doc => ({
-                                id: doc.id,
-                                ...doc.data()
-                            }));
-
-                            indexes[path] = buildIndex(docs, collectionProp);
-                            console.debug("Added docs to index", path, docs.length);
-                            resolve(true);
-                        },
-                        error: (e) => {
-                            console.error("Error initializing local search controller", path);
-                            console.error(e);
-                            reject(e);
-                        }
-                    }
-                );
-            }
-        });
-    }
-
-    const search = async ({
-        searchString,
-        path
-    }: {
-        searchString: string,
-        path: string,
-        databaseId?: string
-    }) => {
-        console.debug("Searching local index", path, searchString);
-        const index = indexes[path];
-        if (!index) {
-            throw new Error(`Index not found for path ${path}`);
-        }
-        let searchResult = index.search(searchString);
-        searchResult = searchResult.splice(0, MAX_SEARCH_RESULTS);
-        searchResult = searchResult.sort((a, b) => {
-            // Check if item A is an exact match
-            const aExactMatch = a.item.id === searchString;
-            // Check if item B is an exact match
-            const bExactMatch = b.item.id === searchString;
-
-            if (aExactMatch && !bExactMatch) {
-                return -1; // Prioritize item A
-            } else if (!aExactMatch && bExactMatch) {
-                return 1; // Prioritize item B
-            } else {
-                // If both are exact matches or both are not, sort by Fuse's original score
-                return (a.score ?? 0) - (b.score ?? 0);
-            }
-        });
-        return searchResult.map((e) => e.item.id);
-    };
-
-    return {
-        init,
-        search
-    }
-}
-
-function buildIndex(list: (object & { id: string })[], collection: CollectionConfig) {
-
-    const keys = ["id", ...Object.keys(collection.properties)];
-
-    const fuseOptions = {
-        // isCaseSensitive: false,
-        // includeScore: false,
-        // shouldSort: true,
-        // includeMatches: false,
-        // findAllMatches: false,
-        // minMatchCharLength: 1,
-        // location: 0,
-        threshold: 0.6,
-        // distance: 100,
-        // useExtendedSearch: false,
-        // ignoreLocation: false,
-        // ignoreFieldNorm: false,
-        // fieldNormWeight: 1,
-        includeScore: true,
-        keys: [{
-            name: "title",
-            weight: 1.0
-        }, ...keys.map(key => ({
-            name: key,
-            weight: 0.5
-        }))]
-    };
-    return new Fuse<object & { id: string }>(list, fuseOptions);
-}