@rebasepro/types 0.5.0 → 0.6.1

package/dist/types/backend_hooks.d.ts

@@ -1,4 +1,3 @@
-import type { AdminUser } from "../controllers/client";
 /**
  * Context passed to every backend hook.
  * Provides information about the request that triggered the hook.
@@ -13,57 +12,6 @@ export interface BackendHookContext {
     /** The HTTP method of the request */
     method: "GET" | "POST" | "PUT" | "DELETE";
 }
-/**
- * Hooks for intercepting Admin User data at the API boundary.
- *
- * These hooks run on the server after the database operation completes
- * but before the response is sent to the client.
- *
- * @group Backend Hooks
- */
-export interface UserHooks {
-    /**
-     * Transform a user record after it's read from the database,
-     * before it's returned to the client.
-     *
-     * Return the modified user, or `null` to filter it out entirely
-     * (the user won't appear in listings or individual fetches).
-     */
-    afterRead?(user: AdminUser, context: BackendHookContext): AdminUser | null | Promise<AdminUser | null>;
-    /**
-     * Transform user data before it's written to the database.
-     * Runs on POST (create) and PUT (update).
-     *
-     * Return the (possibly modified) data to proceed with the save.
-     * Throw an error to abort the operation.
-     */
-    beforeSave?(data: {
-        email?: string;
-        displayName?: string;
-        roles?: string[];
-    }, context: BackendHookContext): {
-        email?: string;
-        displayName?: string;
-        roles?: string[];
-    } | Promise<{
-        email?: string;
-        displayName?: string;
-        roles?: string[];
-    }>;
-    /**
-     * Called after a user is successfully created or updated.
-     * Useful for side-effects like sending notifications.
-     */
-    afterSave?(user: AdminUser, context: BackendHookContext): void | Promise<void>;
-    /**
-     * Called before a user is deleted. Throw to prevent deletion.
-     */
-    beforeDelete?(userId: string, context: BackendHookContext): void | Promise<void>;
-    /**
-     * Called after a user is successfully deleted.
-     */
-    afterDelete?(userId: string, context: BackendHookContext): void | Promise<void>;
-}
 /**
  * Hooks for intercepting collection entity data at the REST API boundary.
  *
@@ -133,9 +81,6 @@ export interface DataHooks {
  * These hooks run server-side after database operations complete and before
  * API responses are sent.
  *
- * - `users` — intercept admin user management endpoints
- * - `data` — intercept ALL collection entity data flowing through the REST API
- *
  * `data` hooks complement per-collection `EntityCallbacks`. Entity callbacks
  * run inside the DataDriver (close to the DB); data hooks run at the HTTP
  * boundary (close to the client). Use data hooks for cross-cutting concerns
@@ -152,12 +97,6 @@ export interface DataHooks {
  *             }
  *             return entity;
  *         }
- *     },
- *     users: {
- *         afterRead(user, ctx) {
- *             if (user.email.endsWith("@system.internal")) return null;
- *             return user;
- *         }
  *     }
  * };
  * ```
@@ -165,8 +104,6 @@ export interface DataHooks {
  * @group Backend Hooks
  */
 export interface BackendHooks {
-    /** Hooks for intercepting user management data */
-    users?: UserHooks;
     /** Hooks for intercepting ALL collection entity data via the REST API */
     data?: DataHooks;
 }

package/dist/types/breadcrumbs.d.ts

@@ -0,0 +1,26 @@
+export interface BreadcrumbEntry {
+    title: string;
+    url: string;
+    /**
+     * Optional entity count for collection breadcrumbs.
+     * - undefined: not applicable (e.g., entity breadcrumb, custom view)
+     * - null: loading
+     * - number: loaded count
+     */
+    count?: number | null;
+    /**
+     * Unique identifier for this breadcrumb (e.g., collection path).
+     * Used to update count without replacing entire breadcrumb array.
+     */
+    id?: string;
+}
+export interface BreadcrumbsController {
+    breadcrumbs: BreadcrumbEntry[];
+    set: (props: {
+        breadcrumbs: BreadcrumbEntry[];
+    }) => void;
+    /**
+     * Update the count for a specific breadcrumb by ID.
+     */
+    updateCount: (id: string, count: number | null | undefined) => void;
+}

package/dist/types/collections.d.ts

@@ -10,6 +10,7 @@ import type { Relation } from "./relations";
 import type { EntityCustomView, FormViewConfig } from "./entity_views";
 import type { EntityAction } from "./entity_actions";
 import type { ComponentRef } from "./component_ref";
+import type { CollectionComponentOverrideMap } from "./component_overrides";
 /**
  * Base interface containing all driver-agnostic collection properties.
  * Use {@link PostgresCollection} or {@link FirebaseCollection} for
@@ -136,6 +137,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Prevent default actions from being displayed or executed on this collection.
      */
     disableDefaultActions?: ("edit" | "copy" | "delete")[];
+    /**
+     * Mark this collection as an authentication collection.
+     * When true, this collection is used for user management, login, password hashing, and invitation flows.
+     */
+    auth?: boolean | AuthCollectionConfig;
     /**
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
@@ -360,6 +366,30 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * When defined, the backend enforces access control policies.
      */
     securityRules?: SecurityRule[];
+    /**
+     * Collection-scoped component overrides. These take precedence over
+     * global overrides set on `<Rebase>`, but only within this collection's
+     * views (entity form, detail view, table, empty state, etc.).
+     *
+     * Only collection-scoped components (like `Entity.Form`, `Collection.EmptyState`,
+     * `Collection.Card`, etc.) can be overridden here. App-level components
+     * (like `Shell.AppBar`, `HomePage`) can only be overridden at the `<Rebase>` level.
+     *
+     * @example
+     * ```tsx
+     * const productsCollection: PostgresCollection = {
+     *     name: "Products",
+     *     slug: "products",
+     *     table: "products",
+     *     components: {
+     *         "Entity.Form": { Component: ProductCustomForm },
+     *         "Collection.Card": { Component: ProductCard },
+     *     },
+     *     properties: { ... }
+     * };
+     * ```
+     */
+    components?: CollectionComponentOverrideMap;
 }
 /**
  * A collection backed by PostgreSQL (or any SQL database).
@@ -959,3 +989,114 @@ export interface RolesOnlySecurityRule extends SecurityRuleBase {
     using?: never;
     withCheck?: never;
 }
+/**
+ * Configuration for authentication collections.
+ *
+ * Controls what happens when admins create users, reset passwords,
+ * and which entity actions are auto-injected.
+ *
+ * Use `auth: true` as sugar for `{ enabled: true }` with all defaults.
+ *
+ * @example Override user creation
+ * ```ts
+ * auth: {
+ *     enabled: true,
+ *     onCreateUser: async (values, ctx) => {
+ *         const hash = await ctx.hashPassword("welcome123");
+ *         return {
+ *             values: { ...values, passwordHash: hash, emailVerified: true },
+ *             temporaryPassword: "welcome123",
+ *         };
+ *     },
+ * }
+ * ```
+ *
+ * @example Disable the reset-password entity action
+ * ```ts
+ * auth: {
+ *     enabled: true,
+ *     actions: { resetPassword: false },
+ * }
+ * ```
+ *
+ * @group Models
+ */
+export interface AuthCollectionConfig {
+    /** Set to true to mark this collection as the authentication collection. */
+    enabled: boolean;
+    /**
+     * Called when an admin creates a user via the collection REST API.
+     *
+     * Default: generate password → hash → normalize email → save →
+     *          send invitation email (or return temp password if no email configured).
+     *
+     * Override to implement custom invitation flows, LDAP sync, etc.
+     */
+    onCreateUser?: (values: Record<string, unknown>, ctx: AuthCollectionContext) => Promise<AuthCollectionCreateResult>;
+    /**
+     * Called when an admin resets a user's password via the admin panel.
+     *
+     * Default: generate reset token → send email (or generate + return temp password).
+     * Override for custom reset flows.
+     */
+    onResetPassword?: (userId: string, ctx: AuthCollectionContext) => Promise<AuthCollectionResetResult>;
+    /**
+     * Control which auth-specific entity actions are auto-injected.
+     *
+     * Default: `{ resetPassword: true }` — the framework auto-injects
+     * the built-in `resetPasswordAction` into the collection's entity actions.
+     *
+     * Set to `false` to disable, or pass a custom `EntityAction` to replace the UI.
+     */
+    actions?: {
+        resetPassword?: boolean | EntityAction;
+    };
+}
+/**
+ * Context provided to collection-level auth hooks.
+ *
+ * This is a simplified facade over the server internals —
+ * it exposes only what's needed for custom auth flows without
+ * coupling collection config to internal interfaces.
+ *
+ * @group Models
+ */
+export interface AuthCollectionContext {
+    /** Hash a password using the configured algorithm (scrypt by default). */
+    hashPassword: (password: string) => Promise<string>;
+    /** Send an email. Only available when email service is configured. */
+    sendEmail?: (options: {
+        to: string;
+        subject: string;
+        html: string;
+        text?: string;
+    }) => Promise<void>;
+    /** Whether the email service is configured and available. */
+    emailConfigured: boolean;
+    /** The app name from email config (for templates). */
+    appName: string;
+    /** The base URL for password reset links. */
+    resetPasswordUrl: string;
+}
+/**
+ * Result of a collection-level `onCreateUser` hook.
+ * @group Models
+ */
+export interface AuthCollectionCreateResult {
+    /** Processed values to persist (must include passwordHash, NOT raw password). */
+    values: Record<string, unknown>;
+    /** If set, shown to the admin in the creation result dialog. */
+    temporaryPassword?: string;
+    /** Whether an invitation email was sent. */
+    invitationSent?: boolean;
+}
+/**
+ * Result of a collection-level `onResetPassword` hook.
+ * @group Models
+ */
+export interface AuthCollectionResetResult {
+    /** If set, shown to the admin. */
+    temporaryPassword?: string;
+    /** Whether a reset email was sent. */
+    invitationSent?: boolean;
+}

package/dist/types/component_overrides.d.ts

@@ -0,0 +1,138 @@
+import type React from "react";
+/**
+ * Components that can only be overridden at the **app level** via the
+ * `components` prop on `<Rebase>`.
+ *
+ * These are shell-level / global components that exist outside of any
+ * specific collection context.
+ *
+ * @group Component Overrides
+ */
+export type AppComponentName = "Shell.AppBar" | "Shell.Drawer" | "Shell.DrawerNavigationItem" | "Shell.DrawerNavigationGroup" | "HomePage" | "HomePage.CollectionCard" | "Auth.LoginView";
+/**
+ * Components that can be overridden at the **collection level**
+ * (on an individual collection definition) or at the **app level**
+ * (as a default for all collections).
+ *
+ * When set at the app level, these act as defaults. When set on a
+ * specific collection, they override the app-level default for that
+ * collection only.
+ *
+ * @group Component Overrides
+ */
+export type CollectionComponentName = "Collection.View" | "Collection.Table" | "Collection.Card" | "Collection.EmptyState" | "Collection.Actions" | "Entity.Form" | "Entity.FormActions" | "Entity.DetailView" | "Entity.SidePanel" | "Entity.Preview" | "Entity.MissingReference";
+/**
+ * All overridable component names across all scopes.
+ * @group Component Overrides
+ */
+export type OverridableComponentName = AppComponentName | CollectionComponentName;
+/**
+ * A single component override entry.
+ *
+ * - **Eject mode** (default): Your component fully replaces the built-in one.
+ *   It receives the same props as the original.
+ *
+ * - **Wrap mode** (`wrap: true`): Your component wraps the original. The
+ *   built-in component is passed as `OriginalComponent` in props, so you can
+ *   render it inside your custom layout/logic.
+ *
+ * @example
+ * ```tsx
+ * // Eject — full replacement
+ * { Component: MyCustomAppBar }
+ *
+ * // Wrap — augment the original
+ * {
+ *     Component: ({ OriginalComponent, ...props }) => (
+ *         <div>
+ *             <MyBanner />
+ *             <OriginalComponent {...props} />
+ *         </div>
+ *     ),
+ *     wrap: true
+ * }
+ * ```
+ *
+ * @group Component Overrides
+ */
+export interface ComponentOverride<P = any> {
+    /**
+     * The replacement component. Receives the same props as the built-in
+     * component it replaces.
+     *
+     * When `wrap` is true, an additional `OriginalComponent` prop is injected
+     * containing the default component, allowing you to render it within
+     * your custom wrapper.
+     */
+    Component: React.ComponentType<P>;
+    /**
+     * When true, the original default component is injected as the
+     * `OriginalComponent` prop into your Component, enabling the
+     * wrapping pattern (similar to Docusaurus's `--wrap` swizzle mode).
+     *
+     * When false or omitted, your component fully replaces the default
+     * (similar to Docusaurus's `--eject` swizzle mode).
+     *
+     * @default false
+     */
+    wrap?: boolean;
+}
+/**
+ * Collection-scoped overrides. Only collection-level components
+ * can be overridden here.
+ *
+ * Set on a collection's `components` field to customize
+ * components for that specific collection.
+ *
+ * @example
+ * ```tsx
+ * const productsCollection = {
+ *     name: "Products",
+ *     slug: "products",
+ *     components: {
+ *         "Entity.Form": { Component: ProductForm },
+ *         "Collection.EmptyState": { Component: ProductsEmptyState },
+ *         "Collection.Card": { Component: ProductCard },
+ *     }
+ * };
+ * ```
+ *
+ * @group Component Overrides
+ */
+export type CollectionComponentOverrideMap = {
+    [K in CollectionComponentName]?: ComponentOverride;
+};
+/**
+ * App-level overrides. Includes both app-only components (Shell, HomePage, Auth)
+ * and collection-level components (as defaults for all collections).
+ *
+ * Pass this to the `components` prop on `<Rebase>`.
+ *
+ * Collection-level components set here act as **defaults** — they apply to all
+ * collections unless a specific collection overrides them in its own
+ * `components`.
+ *
+ * @example
+ * ```tsx
+ * <Rebase
+ *     client={client}
+ *     components={{
+ *         // App-level: only available here
+ *         "Shell.AppBar": { Component: MyAppBar },
+ *         "HomePage": { Component: MyDashboard },
+ *
+ *         // Collection defaults: apply to ALL collections
+ *         "Entity.FormActions": {
+ *             Component: MyFormActions,
+ *             wrap: true
+ *         },
+ *         "Collection.EmptyState": { Component: MyEmptyState },
+ *     }}
+ * />
+ * ```
+ *
+ * @group Component Overrides
+ */
+export type ComponentOverrideMap = {
+    [K in OverridableComponentName]?: ComponentOverride;
+};

package/dist/types/entity_views.d.ts

@@ -17,9 +17,17 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
      */
     setFieldValue: (key: string, value: unknown, shouldValidate?: boolean) => void;
     /**
-     * Save the entity.
+     * Quietly persist the entity to the database without any UI feedback
+     * (no validation, no snackbar, no form reset).
+     * Use this for programmatic/background saves from custom views.
      */
     save: (values: M) => void;
+    /**
+     * Submit the form — validates, saves, resets the form, and shows
+     * a success snackbar. This is what the Save button calls.
+     * Use this from custom views when you want the full "user saved" experience.
+     */
+    submit: () => void;
     /**
      * Collection of the entity being modified
      */

package/dist/types/index.d.ts

@@ -26,3 +26,5 @@ export * from "./backend_hooks";
 export * from "./component_ref";
 export * from "./auth_adapter";
 export * from "./database_adapter";
+export * from "./breadcrumbs";
+export * from "./component_overrides";

package/dist/types/plugins.d.ts

@@ -5,7 +5,6 @@ import type { InferPropertyType, Property } from "./properties";
 import type { FormContext } from "./entity_views";
 import type { RebaseContext } from "../rebase_context";
 import type { NavigationGroupMapping, AppView } from "../controllers/navigation";
-import type { UserManagementDelegate } from "./user_management_delegate";
 import type { User } from "../users";
 import type { SlotContribution } from "./slots";
 /**
@@ -101,10 +100,6 @@ export interface RebasePlugin {
      * Views to be automatically added to the navigation.
      */
     views?: AppView[];
-    /**
-     * User management delegate from this plugin.
-     */
-    userManagement?: UserManagementDelegate;
     /**
      * Optional lifecycle hooks. Called by the Rebase runtime
      * at appropriate points in the app lifecycle.

package/dist/types/translations.d.ts

@@ -112,6 +112,9 @@ export interface RebaseTranslations {
     /** Aria label for the user menu trigger in the drawer footer */
     user_menu?: string;
     error: string;
+    error_loading_data?: string;
+    error_check_server_logs?: string;
+    error_technical_details?: string;
     error_uploading_file: string;
     error_deleting: string;
     error_before_delete: string;

package/dist/types/user_management_delegate.d.ts

@@ -14,73 +14,3 @@ export interface UserCreationResult<USER extends User = User> {
      */
     temporaryPassword?: string;
 }
-/**
- * Delegate to manage auth-specific user operations.
- *
- * This interface allows the CMS to be agnostic of the underlying
- * authentication provider or backend. User/role CRUD is now handled
- * by the collection system; this delegate only exposes auth-specific
- * operations (password hashing, invitations, bootstrap).
- *
- * @group Models
- */
-export interface UserManagementDelegate<USER extends User = User> {
-    /**
-     * Are auth-related operations currently loading?
-     */
-    loading: boolean;
-    /**
-     * In-memory list of users (used for client-side filtering fallback).
-     */
-    users?: USER[];
-    /**
-     * Error from fetching the users list, if any.
-     */
-    usersError?: Error;
-    /**
-     * Look up a single user by UID from the in-memory cache.
-     */
-    getUser?: (uid: string) => USER | null;
-    /**
-     * Server-side user search with pagination.
-     */
-    searchUsers?: (params: {
-        search?: string;
-        limit?: number;
-        offset?: number;
-    }) => Promise<{
-        users: USER[];
-        total: number;
-    }>;
-    /**
-     * Create a new user with invitation/password generation support.
-     * Returns additional info about how the credentials were delivered.
-     */
-    createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Reset the password for an existing user.
-     * Returns a temporary password if no email service is configured,
-     * or a flag indicating an email invitation was sent.
-     */
-    resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Is the currently logged in user an admin?
-     */
-    isAdmin?: boolean;
-    /**
-     * Optionally define roles for a given user. This is useful when the roles
-     * are coming from a separate provider than the one issuing the tokens.
-     */
-    defineRolesFor?: (user: USER) => Promise<string[] | undefined> | string[] | undefined;
-    /**
-     * Whether any admin users exist. Used by the bootstrap banner to decide
-     * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`
-     * query) instead of loading all users.
-     */
-    hasAdminUsers?: boolean;
-    /**
-     * Optional function to bootstrap an admin user.
-     * Often used when the database is empty.
-     */
-    bootstrapAdmin?: () => Promise<void>;
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/types",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Rebase type definitions — shared interfaces and controller types",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -39,18 +39,18 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "@types/node": "^20.19.41",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.3",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^19.2.15",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@types/react-measure": "^2.0.12",
-    "@vitejs/plugin-react": "^4.7.0",
-    "hono": "^4.12.21",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.4.10",
-    "typescript": "^5.9.3",
-    "vite": "^5.4.21"
+    "@vitejs/plugin-react": "^6.0.2",
+    "hono": "^4.12.25",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.11",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16"
   },
   "peerDependencies": {
     "hono": "^4.12.21"