@rebasepro/firebase 0.0.1-canary.2 → 0.0.1-canary.eb08332

package/README.md

@@ -1,4 +1,98 @@
-# Rebase Firebase
+# @rebasepro/firebase
 
-This library provides a set of utilities to integrate [Rebase](https://rebase.pro) with 
-[Firebase](https://firebase.google.com/).
+Firebase client adapter for Rebase — connects the Rebase admin panel to Firebase (Firestore, Auth, Storage).
+
+## Installation
+
+```bash
+pnpm add @rebasepro/firebase
+```
+
+**Peer dependencies:** `firebase ^10.12.2 || ^11.0.0 || ^12.0.0`, `react >= 19.0.0`, `react-dom >= 19.0.0`, `typesense ^1.8.0` (optional)
+
+## What This Package Does
+
+This package provides the full Firebase integration layer for Rebase. It includes:
+
+- A top-level `RebaseFirebaseApp` component that wires up Firebase Auth, Firestore, and Storage into a complete admin app with login, routing, and data management.
+- React hooks for each Firebase service (auth, Firestore, storage, App Check, user management).
+- Text search adapters (Algolia, Pinecone, Typesense, local, Rebase-hosted).
+- Firebase login view with configurable sign-in providers.
+
+## Key Exports
+
+### Components
+
+| Export | Description |
+|---|---|
+| `RebaseFirebaseApp` | Full-featured Rebase app component backed by Firebase. Handles init, auth, routing, and rendering |
+| `RebaseFirebaseAppProps` | Props type for `RebaseFirebaseApp` — name, logo, collections, views, signInOptions, plugins, etc. |
+| `FirebaseLoginView` | Standalone Firebase login view with social sign-in buttons |
+
+### Hooks
+
+| Export | Description |
+|---|---|
+| `useInitialiseFirebase` | Initializes the Firebase app from config |
+| `useFirebaseAuthController` | Manages Firebase Auth state (sign-in, sign-out, user) |
+| `useFirestoreDriver` | Creates a Firestore-backed `DataDriver` for CRUD and realtime listeners |
+| `useFirebaseStorageSource` | Provides file upload/download via Firebase Storage |
+| `useAppCheck` | Enables Firebase App Check verification |
+| `useRecaptcha` | reCAPTCHA integration for App Check |
+| `useBuildUserManagement` | Builds a user/role management delegate from Firestore |
+| `useFirebaseAccessGate` | Evaluates whether the current user can access the admin panel |
+| `useFirebaseRealTimeDBDelegate` | Realtime Database integration |
+
+### Utils
+
+| Export | Description |
+|---|---|
+| `buildAlgoliaSearchController` | Algolia text search adapter |
+| `buildPineconeSearchController` | Pinecone text search adapter |
+| `buildRebaseSearchController` | Rebase-hosted search adapter |
+| `buildLocalTextSearchController` | Client-side fuzzy search (Fuse.js) |
+| `buildTextSearchController` | Generic text search adapter builder |
+| `buildCollectionsFromFirestore` | Auto-generate collection configs by introspecting Firestore data |
+
+### Types
+
+| Export | Description |
+|---|---|
+| `FirebaseSignInProvider` | Provider ID strings (`google.com`, `github.com`, etc.) |
+| `FirebaseSignInOption` | Sign-in config with scopes and custom parameters |
+| `FirebaseAuthController` | Extended auth controller type for Firebase |
+| `FirebaseUserWrapper` | Rebase user wrapper around Firebase User |
+| `FirestoreTextSearchControllerBuilder` | Builder type for text search controllers |
+| `AppCheckOptions` | App Check configuration type |
+
+## Quick Start
+
+```tsx
+import { RebaseFirebaseApp } from "@rebasepro/firebase";
+
+const firebaseConfig = {
+    apiKey: "...",
+    authDomain: "...",
+    projectId: "...",
+    storageBucket: "...",
+};
+
+export default function App() {
+    return (
+        <RebaseFirebaseApp
+            name="My Admin"
+            firebaseConfig={firebaseConfig}
+            collections={[/* your collections */]}
+            signInOptions={["google.com"]}
+        />
+    );
+}
+```
+
+## Related Packages
+
+- `@rebasepro/admin` — Admin panel UI (Scaffold, Drawer, SideDialogs)
+- `@rebasepro/app` — Core framework (Rebase provider, routing)
+- `@rebasepro/common` — Shared data utilities
+- `@rebasepro/types` — Shared type definitions
+- `@rebasepro/ui` — UI component library

package/dist/components/FirebaseLoginView.d.ts

@@ -54,7 +54,7 @@ export interface FirebaseLoginViewProps {
      * You may want to use it in conjunction with the `disabled` prop.
      */
     additionalComponent?: ReactNode;
-    notAllowedError?: any;
+    notAllowedError?: string | Error;
     className?: string;
 }
 /**
@@ -63,10 +63,10 @@ export interface FirebaseLoginViewProps {
 
  * @category Firebase
  */
-export declare function FirebaseLoginView({ children, allowSkipLogin, logo, signInOptions, firebaseApp, authController, noUserComponent, disableSignupScreen, disableResetPassword, disabled, additionalComponent, notAllowedError, className }: FirebaseLoginViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function FirebaseLoginView({ children, allowSkipLogin, logo, signInOptions, firebaseApp, authController, noUserComponent, disableSignupScreen, disableResetPassword, disabled, additionalComponent, notAllowedError, className }: FirebaseLoginViewProps): React.JSX.Element;
 export declare function LoginButton({ icon, onClick, text, disabled }: {
     icon: React.ReactNode;
     onClick: () => void;
     text: string;
     disabled?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/dist/components/RebaseFirebaseApp.d.ts

@@ -1,3 +1,4 @@
+import React from "react";
 import { RebaseFirebaseAppProps } from "./RebaseFirebaseAppProps";
 /**
  * This is the default implementation of a Rebase app using the Firebase services
@@ -16,4 +17,4 @@ import { RebaseFirebaseAppProps } from "./RebaseFirebaseAppProps";
 
  * @category Firebase
  */
-export declare function RebaseFirebaseApp({ name, logo, logoDark, authenticator, collections, views, adminViews, textSearchControllerBuilder, allowSkipLogin, signInOptions, firebaseConfig, onFirebaseInit, appCheckOptions, dateTimeFormat, locale, basePath, baseCollectionPath, onAnalyticsEvent, propertyConfigs: propertyConfigsProp, plugins, autoOpenDrawer, firestoreIndexesBuilder, components, localTextSearchEnabled, userManagement }: RebaseFirebaseAppProps): import("react/jsx-runtime").JSX.Element;
+export declare function RebaseFirebaseApp({ name, logo, logoDark, accessGate, collections, views, adminViews, textSearchControllerBuilder, allowSkipLogin, signInOptions, firebaseConfig, onFirebaseInit, appCheckOptions, dateTimeFormat, locale, basePath, baseCollectionPath, onAnalyticsEvent, propertyConfigs: propertyConfigsProp, plugins, autoOpenDrawer, firestoreIndexesBuilder, components, localTextSearchEnabled }: RebaseFirebaseAppProps): React.JSX.Element;

package/dist/components/RebaseFirebaseAppProps.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
-import { Authenticator, CMSAnalyticsEvent, CMSView, CMSViewsBuilder, EntityCollection, EntityCollectionsBuilder, RebasePlugin, Locale, PropertyConfig } from "@rebasepro/core";
-import { UserManagementDelegate } from "@rebasepro/types";
+import { AnalyticsEvent, AppView, AppViewsBuilder, CollectionConfig, CollectionConfigsBuilder, RebasePlugin, Locale, PropertyConfig } from "@rebasepro/types";
+import { FirebaseAccessGate } from "../hooks/useFirebaseAccessGate";
 import { FirebaseApp } from "@firebase/app";
 import { FirebaseLoginViewProps } from "./FirebaseLoginView";
 import { AppCheckOptions, FirebaseSignInOption, FirebaseSignInProvider, FirebaseUserWrapper, FirestoreTextSearchControllerBuilder } from "../types";
@@ -29,17 +29,17 @@ export type RebaseFirebaseAppProps = {
      * Each of the navigation entries in this field
      * generates an entry in the main menu.
      */
-    collections?: EntityCollection[] | EntityCollectionsBuilder;
+    collections?: CollectionConfig[] | CollectionConfigsBuilder;
     /**
      * Custom additional views created by the developer, added to the main
      * navigation
      */
-    views?: CMSView[] | CMSViewsBuilder;
+    views?: AppView[] | AppViewsBuilder;
     /**
      * Custom additional views created by the developer, added to the admin
      * navigation
      */
-    adminViews?: CMSView[] | CMSViewsBuilder;
+    adminViews?: AppView[] | AppViewsBuilder;
     /**
      * Record of custom form fields to be used in the CMS.
      * You can use the key to reference the custom field in
@@ -48,12 +48,12 @@ export type RebaseFirebaseAppProps = {
     propertyConfigs?: PropertyConfig[];
     /**
      * Do the users need to log in to access the CMS.
-     * You can specify an Authenticator function to discriminate which users can
-     * access the CMS or not.
+     * You can specify a {@link FirebaseAccessGate} function to discriminate
+     * which users can access the CMS or not.
      * If not specified, authentication is enabled but no user restrictions
      * apply
      */
-    authenticator?: boolean | Authenticator<FirebaseUserWrapper>;
+    accessGate?: boolean | FirebaseAccessGate<FirebaseUserWrapper>;
     /**
      * List of sign in options that will be displayed in the login
      * view if `authentication` is enabled. You can pass Firebase providers strings,
@@ -109,7 +109,7 @@ export type RebaseFirebaseAppProps = {
     /**
      * Callback used to get analytics events from the CMS
      */
-    onAnalyticsEvent?: (event: CMSAnalyticsEvent, data?: object) => void;
+    onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
     /**
      * Use plugins to modify the behaviour of the CMS.
      * Currently, in ALPHA, and likely subject to change.
@@ -127,10 +127,6 @@ export type RebaseFirebaseAppProps = {
     firestoreIndexesBuilder?: FirestoreIndexesBuilder;
     localTextSearchEnabled?: boolean;
     components?: ComponentsRegistry;
-    /**
-     * Delegate for user and role management. Provides the admin views if specified.
-     */
-    userManagement?: UserManagementDelegate;
 };
 export type ComponentsRegistry = {
     /**

package/dist/components/social_icons.d.ts

@@ -1,6 +1,6 @@
-export declare const googleIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
-export declare const appleIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
-export declare const githubIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
-export declare const facebookIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
-export declare const microsoftIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
-export declare const twitterIcon: (mode: "light" | "dark") => import("react/jsx-runtime").JSX.Element;
+export declare const googleIcon: (mode: "light" | "dark") => import("react").JSX.Element;
+export declare const appleIcon: (mode: "light" | "dark") => import("react").JSX.Element;
+export declare const githubIcon: (mode: "light" | "dark") => import("react").JSX.Element;
+export declare const facebookIcon: (mode: "light" | "dark") => import("react").JSX.Element;
+export declare const microsoftIcon: (mode: "light" | "dark") => import("react").JSX.Element;
+export declare const twitterIcon: (mode: "light" | "dark") => import("react").JSX.Element;

package/dist/hooks/index.d.ts

@@ -2,6 +2,8 @@ export * from "./useFirebaseAuthController";
 export * from "./useFirebaseStorageSource";
 export * from "./useInitialiseFirebase";
 export * from "./useAppCheck";
-export * from "./useFirestoreDataSource";
+export * from "./useFirestoreDriver";
 export * from "./useFirebaseRealTimeDBDelegate";
 export * from "./useRecaptcha";
+export * from "./useBuildUserManagement";
+export * from "./useFirebaseAccessGate";

package/dist/hooks/useAppCheck.d.ts

@@ -10,11 +10,11 @@ export interface InitializeAppCheckProps {
 export interface InitializeAppCheckResult {
     loading: boolean;
     appCheckVerified?: boolean;
-    error?: any;
+    error?: unknown;
 }
 /**
  * Function used to initialise Firebase App Check.
  *
  * @group Firebase
  */
-export declare function useAppCheck({ firebaseApp, options, }: InitializeAppCheckProps): InitializeAppCheckResult;
+export declare function useAppCheck({ firebaseApp, options }: InitializeAppCheckProps): InitializeAppCheckResult;

package/dist/hooks/useBuildUserManagement.d.ts

@@ -0,0 +1,78 @@
+import { AuthController, DataDriver, User } from "@rebasepro/types";
+import { FirebaseAccessGate } from "./useFirebaseAccessGate";
+export interface Role {
+    id: string;
+    name: string;
+    isAdmin?: boolean;
+}
+export interface UserManagementDelegateParams<CONTROLLER extends AuthController<User> = AuthController<User>> {
+    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;
+}
+/**
+ * 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
+ */
+export declare function useBuildUserManagement<CONTROLLER extends AuthController<User> = AuthController<User>, USER extends User = CONTROLLER extends AuthController<infer U> ? U : User>({ authController, dataSourceDelegate, roles: rolesProp, usersPath, rolesPath, allowDefaultRolesCreation }: UserManagementDelegateParams<CONTROLLER>): {
+    loading: boolean;
+    roles: Role[];
+    users: USER[];
+    saveUser: (user: USER) => Promise<USER>;
+    saveRole: (role: Role) => Promise<void>;
+    rolesError: Error | undefined;
+    deleteUser: (user: User) => Promise<void>;
+    deleteRole: (role: Role) => Promise<void>;
+    usersError: Error | undefined;
+    isAdmin: boolean;
+    allowDefaultRolesCreation: boolean;
+    defineRolesFor: (user: User) => string[] | undefined;
+    accessGate: FirebaseAccessGate<USER>;
+} & CONTROLLER & {
+    initialLoading: boolean;
+    userRoles: string[] | undefined;
+    getUser: (uid: string) => USER | null;
+    user: {
+        roles: string[] | undefined;
+        uid: string;
+        displayName: string | null;
+        email: string | null;
+        photoURL: string | null;
+        providerId: string;
+        isAnonymous: boolean;
+        emailVerified?: boolean;
+        createdAt?: Date | string | null;
+        metadata?: Record<string, any>;
+        getIdToken?: (forceRefresh?: boolean) => Promise<string>;
+    } | null;
+};

package/dist/hooks/useFirebaseAccessGate.d.ts

@@ -0,0 +1,44 @@
+import { AuthController, RebaseData, StorageSource, User } from "@rebasepro/types";
+/**
+ * Client-side gate that decides whether a Firebase-authenticated user
+ * is allowed to access the CMS UI.
+ *
+ * Return `true` to allow access or `false` / throw to deny.
+ * @group Firebase
+ */
+export type FirebaseAccessGate<USER extends User = User> = (props: {
+    /**
+     * Logged-in user or null
+     */
+    user: USER | null;
+    /**
+     * AuthController
+     */
+    authController: AuthController<USER>;
+    /**
+     * Unified data access API
+     */
+    data: RebaseData;
+    /**
+     * Used storage implementation
+     */
+    storageSource: StorageSource;
+}) => boolean | Promise<boolean>;
+/**
+ * Hook that evaluates a {@link FirebaseAccessGate} callback after
+ * the user logs in and gates access to the main CMS view.
+ *
+ * @group Firebase
+ */
+export declare function useFirebaseAccessGate<USER extends User = User>({ disabled, authController, accessGate, storageSource, data }: {
+    disabled?: boolean;
+    authController: AuthController<USER>;
+    accessGate?: boolean | FirebaseAccessGate<USER>;
+    data: RebaseData;
+    storageSource: StorageSource;
+}): {
+    canAccessMainView: boolean;
+    authLoading: boolean;
+    notAllowedError: unknown;
+    authVerified: boolean;
+};

package/dist/hooks/useFirebaseAuthController.d.ts

@@ -1,12 +1,12 @@
 import { FirebaseApp } from "@firebase/app";
 import { FirebaseAuthController, FirebaseSignInOption, FirebaseSignInProvider, FirebaseUserWrapper } from "../types";
-import { Role, User } from "@rebasepro/core";
+import type { User } from "@rebasepro/types";
 export interface FirebaseAuthControllerProps {
     loading?: boolean;
     firebaseApp?: FirebaseApp;
     signInOptions?: Array<FirebaseSignInProvider | FirebaseSignInOption>;
     onSignOut?: () => void;
-    defineRolesFor?: (user: User) => Promise<Role[] | undefined> | Role[] | undefined;
+    defineRolesFor?: (user: User) => Promise<string[] | undefined> | string[] | undefined;
 }
 /**
  * Use this hook to build an {@link AuthController} based on Firebase Auth

package/dist/hooks/useFirebaseRealTimeDBDelegate.d.ts

@@ -1,5 +1,5 @@
 import { FirebaseApp } from "@firebase/app";
-import { DataSource } from "@rebasepro/core";
+import { DataDriver } from "@rebasepro/types";
 export declare function useFirebaseRTDBDelegate({ firebaseApp }: {
     firebaseApp?: FirebaseApp;
-}): DataSource;
+}): DataDriver;

package/dist/hooks/useFirebaseStorageSource.d.ts

@@ -1,5 +1,5 @@
 import { FirebaseApp } from "@firebase/app";
-import { StorageSource } from "@rebasepro/core";
+import { StorageSource } from "@rebasepro/types";
 /**
  * @group Firebase
  */

package/dist/hooks/{useFirestoreDataSource.d.ts → useFirestoreDriver.d.ts}

@@ -1,11 +1,11 @@
-import { DataSource, EntityCollection, FilterCombination } from "@rebasepro/core";
+import { DataDriver, CollectionConfig, FilterCombination } from "@rebasepro/types";
 import { Firestore } from "@firebase/firestore";
 import { FirebaseApp } from "@firebase/app";
 import { FirestoreTextSearchControllerBuilder } from "../types/text_search";
 /**
  * @group Firebase
  */
-export interface FirestoreDataSourceProps {
+export interface FirestoreDataDriverProps {
     firebaseApp?: FirebaseApp;
     /**
      * You can use this controller to return a list of ids from a search index, given a
@@ -26,22 +26,22 @@ export interface FirestoreDataSourceProps {
 }
 export type FirestoreIndexesBuilder = (params: {
     path: string;
-    collection: EntityCollection<any>;
+    collection: CollectionConfig<any>;
 }) => FilterCombination<string>[] | undefined;
-export type FirestoreDataSource = DataSource & {
+export type FirestoreDataDriver = DataDriver & {
     initTextSearch: (props: {
         path: string;
         databaseId?: string;
-        collection?: EntityCollection;
+        collection?: CollectionConfig;
     }) => Promise<boolean>;
 };
 /**
- * Use this hook to build a {@link DataSource} based on Firestore
+ * Use this hook to build a {@link DataDriver} based on Firestore
  * @param firebaseApp
  * @param textSearchControllerBuilder
  * @group Firebase
  */
-export declare function useFirestoreDataSource({ firebaseApp, textSearchControllerBuilder, firestoreIndexesBuilder, localTextSearchEnabled }: FirestoreDataSourceProps): FirestoreDataSource;
+export declare function useFirestoreDriver({ firebaseApp, textSearchControllerBuilder, firestoreIndexesBuilder, localTextSearchEnabled }: FirestoreDataDriverProps): FirestoreDataDriver;
 /**
  * Recursive function that converts Firestore data types into CMS or plain
  * JS types.
@@ -52,5 +52,5 @@ export declare function useFirestoreDataSource({ firebaseApp, textSearchControll
  * @param data
  * @group Firestore
  */
-export declare function firestoreToCMSModel(data: any): any;
-export declare function cmsToFirestoreModel(data: any, firestore: Firestore, inArray?: boolean): any;
+export declare function firestoreToCMSModel(data: unknown): unknown;
+export declare function cmsToFirestoreModel(data: unknown, firestore: Firestore, inArray?: boolean): unknown;