@rebasepro/types 0.4.0 → 0.6.0

package/src/types/collections.ts

@@ -11,6 +11,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.
@@ -158,6 +159,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     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;
 
 
     /**
@@ -399,7 +405,50 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     Actions?: ComponentRef<CollectionActionsProps>[];
 
+    /**
+     * The database table name for this collection.
+     * Automatically set for PostgreSQL collections.
+     * For non-SQL backends, this may be undefined.
+     */
+    table?: string;
+
+    /**
+     * Relations defined for this collection.
+     * Populated at normalization time from inline relation properties
+     * or explicit relation definitions.
+     */
+    relations?: Relation[];
+
+    /**
+     * Security rules for this collection (Row Level Security).
+     * 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;
 }
 
 // ── Driver-specific collection types ──────────────────────────────────
@@ -517,7 +566,10 @@ export type EntityCollection<M extends Record<string, unknown> = Record<string,
 // Use these after a `getDataSourceCapabilities()` guard to safely access
 // driver-specific fields without coupling to a concrete driver type.
 
-/** An EntityCollection that supports SQL-style relations (e.g. Postgres). */
+/**
+ * An EntityCollection that supports SQL-style relations (e.g. Postgres).
+ * @deprecated Use `EntityCollection` directly — `table`, `relations`, and `securityRules` are now on `BaseEntityCollection`.
+ */
 export type CollectionWithRelations<M extends Record<string, unknown> = Record<string, unknown>> =
     EntityCollection<M> & { table?: string; relations?: Relation[]; securityRules?: SecurityRule[] };
 
@@ -721,7 +773,6 @@ export interface FilterPreset<Key extends string = string> {
 }
 
 
-
 /**
  * Used to indicate valid filter combinations (e.g. created in Firestore)
  * If the user selects a specific filter/sort combination, the CMS checks if it's
@@ -1099,3 +1150,122 @@ 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/src/types/component_overrides.ts

@@ -0,0 +1,177 @@
+import type React from "react";
+
+// ── Scoped component name unions ──────────────────────────────────────
+
+/**
+ * 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 / Layout ──
+    | "Shell.AppBar"
+    | "Shell.Drawer"
+    | "Shell.DrawerNavigationItem"
+    | "Shell.DrawerNavigationGroup"
+
+    // ── Home Page ──
+    | "HomePage"
+    | "HomePage.CollectionCard"
+
+    // ── Auth ──
+    | "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.View"
+    | "Collection.Table"
+    | "Collection.Card"
+    | "Collection.EmptyState"
+    | "Collection.Actions"
+
+    // ── Entity / Form ──
+    | "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;
+
+// ── Override entry ────────────────────────────────────────────────────
+
+/**
+ * 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;
+}
+
+// ── Override maps by scope ────────────────────────────────────────────
+
+/**
+ * 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/src/types/database_adapter.ts

@@ -27,7 +27,7 @@ import type {
     DatabaseAdmin,
     InitializedDriver,
     RealtimeProvider,
-    BootstrappedAuth,
+    BootstrappedAuth
 } from "./backend";
 
 /**

package/src/types/entity_views.tsx

@@ -21,10 +21,19 @@ 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/src/types/index.ts

@@ -28,3 +28,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/src/types/plugins.tsx

@@ -6,7 +6,7 @@ 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";
 
@@ -136,10 +136,6 @@ export interface RebasePlugin {
      */
     views?: AppView[];
 
-    /**
-     * User management delegate from this plugin.
-     */
-    userManagement?: UserManagementDelegate;
 
     /**
      * Optional lifecycle hooks. Called by the Rebase runtime

package/src/types/properties.ts

@@ -745,15 +745,6 @@ export interface MapProperty extends BaseProperty {
      * Properties that are displayed when rendered as a preview
      */
     previewProperties?: string[];
-    /**
-     * Allow the user to add only some keys in this map.
-     * By default, all properties of the map have the corresponding field in
-     * the form view. Setting this flag to true allows to pick only some.
-     * Useful for map that can have a lot of sub-properties that may not be
-     * needed
-     */
-    pickOnlySomeKeys?: boolean;
-
     /**
      * Render this map as a key-value table that allows to use
      * arbitrary keys. You don't need to define the properties in this case.

package/src/types/translations.ts

@@ -130,6 +130,9 @@ export interface RebaseTranslations {
 
     // ─── Error states ─────────────────────────────────────────────
     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/src/types/user_management_delegate.ts

@@ -15,80 +15,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>;
-
-}