@rebasepro/app 0.11.1-canary.gfd39654 → 0.12.1-canary.g181d0fe

package/README.md

@@ -8,7 +8,7 @@ Framework-agnostic runtime for data-driven admin panels — React hooks, provide
 pnpm add @rebasepro/app
 ```
 
-**Peer dependencies:** `react >= 19`, `react-dom >= 19`, `react-router ^7`, `react-router-dom ^7`
+**Peer dependencies:** `react >= 19.2.7`, `react-dom >= 19.2.7`, `react-router ^8`
 
 ## What This Package Does
 

package/dist/auth/api.d.ts

@@ -59,7 +59,9 @@ export declare function createAuthConfigCache(): AuthConfigCache;
  * Concurrent calls are deduplicated: only one network request is made
  * and all callers share the same promise.
  */
-export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache): Promise<AuthConfigResponse>;
+export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache, 
+/** The backend's `basePath`; only needed if it is not the default. */
+apiPath?: string): Promise<AuthConfigResponse>;
 /**
  * Clear the cached auth config (e.g. on logout or for testing).
  */

package/dist/collections/filter-operator-resolution.d.ts

@@ -1,4 +1,28 @@
 import { Property, WhereFilterOp } from "@rebasepro/types";
+/**
+ * Whether a relation is one the collection's engine can compile into a
+ * `WHERE`.
+ *
+ * Which kinds those are is the *driver's* answer, not this function's, so it
+ * comes from {@link DataSourceCapabilities.filterableRelationKinds}. The admin
+ * is one UI over Postgres, MongoDB, Firestore and whatever a developer
+ * registers, and "a many-to-many compiles to an `EXISTS` over the junction" is
+ * a fact about the Postgres driver — true today, and not the sort of thing to
+ * assert on an engine's behalf.
+ *
+ * Offering an uncompilable filter is not a cosmetic bug. The Postgres driver
+ * used to drop a filter key it could not resolve, which *widened* the result
+ * set — filtering a many-to-many column returned every row instead of none.
+ * That now fails closed with a 400, which is correct for a real schema drift
+ * and wrong as the answer to a control the admin itself put on screen.
+ *
+ * A relation whose kind cannot be determined at all — no inline `relation`
+ * block and no stamped `resolvedRelation` — stays filterable. The server
+ * resolves relations before the config reaches the admin, so this is the
+ * hand-built-property case, and silently dropping a working filter there would
+ * be its own regression.
+ */
+export declare function isFilterableRelation(property: Property, engine?: string): boolean;
 export interface ResolveFilterOperatorsParams {
     /**
      * The property to filter on. For array properties, pass the **item**
@@ -24,8 +48,9 @@ export interface ResolveFilterOperatorsParams {
  * 2. what makes sense for the property type (e.g. no `>` on booleans);
  * 3. the developer's optional narrowing — `property.admin.filterOperators`.
  *
- * Returns an empty array when the property is not filterable (either by
- * type, or because the developer disabled it with `filterOperators: []`).
+ * Returns an empty array when the property is not filterable — by type, by
+ * developer narrowing (`filterOperators: []`), or because it is a relation the
+ * query layer has no column for (see {@link isFilterableRelation}).
  *
  * @group Models
  */

package/dist/components/LoginView/LoginView.d.ts

@@ -104,10 +104,18 @@ export interface LoginViewProps {
      * Pre-fill the password field (e.g. for demo or testing environments).
      */
     defaultPassword?: string;
+    /**
+     * When set, the email/password forms render a "Join the newsletter"
+     * opt-in checkbox. Called with the address that just authenticated —
+     * sign-in or registration — if the box was ticked. Wire it to whatever
+     * stores the subscription; failures are the callback's problem, the
+     * login flow never waits on it.
+     */
+    onNewsletterOptIn?: (email: string) => void;
 }
 /**
  * Generic login view component that works with any AuthControllerExtended.
  * Feature-detects capabilities to show/hide login methods.
  * @group Core
  */
-export declare function LoginView({ logo, authController, noUserComponent, disableSignupScreen, disabled, notAllowedError, googleClientId, githubClientId, linkedinClientId, title, subtitle, needsSetup, registrationEnabled, additionalComponent, topComponent, defaultEmail, defaultPassword }: LoginViewProps): React.JSX.Element;
+export declare function LoginView({ logo, authController, noUserComponent, disableSignupScreen, disabled, notAllowedError, googleClientId, githubClientId, linkedinClientId, title, subtitle, needsSetup, registrationEnabled, additionalComponent, topComponent, defaultEmail, defaultPassword, onNewsletterOptIn }: LoginViewProps): React.JSX.Element;

package/dist/components/RebaseAuth.d.ts

@@ -1,10 +1,10 @@
-import type { RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseAuthViewConfig } from "@rebasepro/admin-types";
 /**
  * Declarative component to configure authentication in Rebase.
  * Renders nothing — purely registers config into the RebaseRegistry.
  *
  * This is a framework-level component that lives in core since
- * authentication is cross-cutting (CMS, Studio, any app area).
+ * authentication is cross-cutting (admin, Studio, any app area).
  * @group Core
  */
-export declare function RebaseAuth({ loginView }: RebaseAuthConfig): null;
+export declare function RebaseAuth({ loginView }: RebaseAuthViewConfig): null;

package/dist/core/Rebase.d.ts

@@ -2,7 +2,7 @@ import type { RebaseProps } from "./RebaseProps";
 import React from "react";
 import { User } from "@rebasepro/types";
 /**
- * If you are using independent components of the CMS
+ * If you are using independent components of the admin
  * you need to wrap them with this main component, so the internal hooks work.
  *
  * This is the main component of Rebase. It acts as the provider of all the

package/dist/core/RebaseProps.d.ts

@@ -43,10 +43,8 @@ type DeepPartial<T> = T extends object ? {
  * Controller to simulate different roles when dev mode is active.
  * @group Models
  */
-export interface EffectiveRoleController {
-    effectiveRole: string | null;
-    setEffectiveRole: (role: string | null) => void;
-}
+export type { EffectiveRoleController } from "@rebasepro/types";
+import type { EffectiveRoleController } from "@rebasepro/types";
 /**
  * Props for the main {@link Rebase} component.
  *
@@ -116,7 +114,7 @@ export type RebaseProps<USER extends User> = {
      */
     basePath?: string;
     /**
-     * Optional base path for the CMS collections.
+     * Optional base path for the admin collections.
      * Defaults to "/c"
      */
     baseCollectionPath?: string;
@@ -127,12 +125,12 @@ export type RebaseProps<USER extends User> = {
      */
     apiUrl?: string;
     /**
-     * Format of the dates in the CMS.
+     * Format of the dates in the admin.
      * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
      */
     dateTimeFormat?: string;
     /**
-     * Locale of the CMS, currently only affecting dates
+     * Locale of the admin, currently only affecting dates
      */
     locale?: Locale;
     /**
@@ -228,7 +226,7 @@ export type RebaseProps<USER extends User> = {
      */
     userConfigPersistence?: UserConfigurationPersistence;
     /**
-     * Callback used to get analytics events from the CMS
+     * Callback used to get analytics events from the admin
      */
     onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
     /**
@@ -237,11 +235,11 @@ export type RebaseProps<USER extends User> = {
      */
     entityLinkBuilder?: EntityLinkBuilder;
     /**
-     * Plugins loaded in the CMS
+     * Plugins loaded in the admin
      */
     plugins?: RebasePlugin[];
     /**
-     * Extra slots for the CMS
+     * Extra slots for the admin
      */
     slots?: SlotContribution[];
     /**
@@ -289,4 +287,3 @@ export type RebaseProps<USER extends User> = {
      */
     components?: ComponentOverrideMap;
 };
-export {};

package/dist/hooks/ApiConfigContext.d.ts

@@ -8,17 +8,51 @@ import React from "react";
  */
 export interface ApiConfig {
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under, appended to {@link apiUrl}.
+     *
+     * `"/api"` by default, which is the server's default `basePath`. It is
+     * carried here because a good deal of UI builds request URLs by hand
+     * instead of going through the client's typed methods, and every one of
+     * those sites used to write `/api` as a literal — so a backend configured
+     * with any other `basePath` served an admin panel whose auth-provider
+     * discovery, storage browser, history panel, user picker and Studio tools
+     * all requested paths that did not exist.
+     */
+    apiPath: string;
     getAuthToken?: () => Promise<string | null>;
 }
+/** What the server uses when `basePath` is not configured. */
+export declare const DEFAULT_API_PATH = "/api";
 /**
  * Read the API config from context. Returns `undefined` if no provider is present,
  * allowing hooks to fall back to their own props.
  */
 export declare function useApiConfig(): ApiConfig | undefined;
 /**
- * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * `apiUrl` and `apiPath` joined, with no trailing slash — the prefix to build a
+ * request URL from.
+ *
+ * Returns `undefined` when there is no provider, so a caller can keep its own
+ * fallback rather than silently requesting a relative path.
+ */
+export declare function useApiBase(): string | undefined;
+/**
+ * The same prefix, derived from a client rather than from context.
+ *
+ * For the code that holds a `RebaseClient` but sits outside (or above) an
+ * `ApiConfigProvider`. Returns `undefined` when the client has no base URL,
+ * which is the signal every caller already treats as "cannot build a request".
+ */
+export declare function apiBaseOf(client?: {
+    baseUrl?: string;
+    apiPath?: string;
+}): string | undefined;
+/**
+ * Provide API configuration (apiUrl, apiPath, getAuthToken) to the entire subtree.
  * Typically rendered inside `<Rebase>` or at the app root.
  */
-export declare function ApiConfigProvider({ apiUrl, getAuthToken, children }: ApiConfig & {
+export declare function ApiConfigProvider({ apiUrl, apiPath, getAuthToken, children }: Omit<ApiConfig, "apiPath"> & {
+    apiPath?: string;
     children: React.ReactNode;
 }): React.JSX.Element;

package/dist/hooks/useBackendStorageSource.d.ts

@@ -7,6 +7,11 @@ export interface BackendStorageSourceProps {
      * Backend API URL (e.g., 'http://localhost:3001')
      */
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under. Defaults to the server's own
+     * default; pass the backend's `basePath` if it was configured otherwise.
+     */
+    apiPath?: string;
     /**
      * Function to get the current auth token
      */
@@ -27,4 +32,4 @@ export interface BackendStorageSourceProps {
  * <Rebase storageSource={storageSource} ... />
  * ```
  */
-export declare function useBackendStorageSource({ apiUrl, getAuthToken }: BackendStorageSourceProps): StorageSource;
+export declare function useBackendStorageSource({ apiUrl, apiPath, getAuthToken }: BackendStorageSourceProps): StorageSource;

package/dist/hooks/useBuildModeController.d.ts

@@ -1,6 +1,6 @@
 import type { ModeController } from "./useModeController";
 /**
  * Use this hook to build a color mode controller that determines
- * the theme of the CMS
+ * the theme of the admin
  */
 export declare function useBuildModeController(): ModeController;

package/dist/hooks/useCustomizationController.d.ts

@@ -2,7 +2,7 @@ import type { CustomizationController } from "@rebasepro/admin-types";
 /**
  * Use this hook to retrieve the customization controller.
  * This hook includes all the customization options that can be used
- * to customize the CMS.
+ * to customize the admin.
  *
  * You will likely not need to use this hook directly.
  *

package/dist/hooks/useNavigationBlocker.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { Blocker, BlockerFunction } from "react-router-dom";
+import { Blocker, BlockerFunction } from "react-router";
 /**
  * Owns the single React Router blocker for the whole app.
  *

package/dist/hooks/useRebaseRegistry.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthConfig } from "@rebasepro/admin-types";
+import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthViewConfig } from "@rebasepro/admin-types";
 /**
  * Split into two contexts to prevent infinite re-render loops:
  * - DispatchContext: stable register/unregister functions (never changes identity)
@@ -10,11 +10,11 @@ import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, R
  * RebaseShell consumes state context to read the collected configs.
  */
 interface RegistryDispatch {
-    registerCMS: (config: RebaseAdminConfig) => void;
-    unregisterCMS: () => void;
+    registerAdmin: (config: RebaseAdminConfig) => void;
+    unregisterAdmin: () => void;
     registerStudio: (config: RebaseStudioConfig) => void;
     unregisterStudio: () => void;
-    registerAuth: (config: RebaseAuthConfig) => void;
+    registerAuth: (config: RebaseAuthViewConfig) => void;
     unregisterAuth: () => void;
 }
 export declare function RebaseRegistryProvider({ children }: {

package/dist/hooks/useStudioBridge.d.ts

@@ -3,9 +3,9 @@ import type { CollectionRegistryController } from "@rebasepro/types";
 import type { SidePanelController, UrlController, NavigationStateController, BreadcrumbEntry, BreadcrumbsController } from "@rebasepro/admin-types";
 export type { BreadcrumbEntry, BreadcrumbsController };
 /**
- * StudioBridge provides optional CMS capabilities to Studio components.
- * When CMS is present, a bridge provider injects real implementations.
- * When CMS is absent, noop defaults ensure Studio works standalone.
+ * StudioBridge provides optional admin capabilities to Studio components.
+ * When the admin is present, a bridge provider injects real implementations.
+ * When the admin is absent, noop defaults ensure Studio works standalone.
  */
 export interface StudioBridge {
     collectionRegistry: CollectionRegistryController;
@@ -13,13 +13,38 @@ export interface StudioBridge {
     urlController: UrlController;
     navigationState: NavigationStateController;
     breadcrumbs: BreadcrumbsController;
+    capabilities: StudioCapabilities;
+}
+/**
+ * What the *host* of these tools can do, as opposed to what the backend can.
+ *
+ * Studio is mounted in two very different places. In a project's own admin
+ * panel it runs next to the collection source files and can edit them through
+ * the schema-editor routes. In the hosted console it runs against somebody
+ * else's deployed container: there is no source to edit — the container is
+ * rebuilt from the customer's repository on every deploy — and the routes that
+ * would edit it are not mounted at all, because the framework switches the
+ * schema editor off under `NODE_ENV=production`.
+ *
+ * Tools that would otherwise offer a write into the codebase read this to
+ * decide whether that write is even meaningful.
+ */
+export interface StudioCapabilities {
+    /**
+     * Whether the host has the project's collection source at hand and can
+     * write to it.
+     *
+     * Defaults to `true`, which is what an admin panel running beside its own
+     * `collectionsDir` has always assumed.
+     */
+    codebase: boolean;
 }
 export declare const StudioBridgeContext: React.Context<StudioBridge>;
 /**
- * Provider that injects CMS capabilities into Studio.
+ * Provider that injects admin capabilities into Studio.
  * Accepts partial overrides — any field not provided falls back to noop.
  *
- * Usage (in app wiring, when CMS is present):
+ * Usage (in app wiring, when the admin is present):
  * ```tsx
  * <StudioBridgeProvider value={{
  *     collectionRegistry: useCollectionRegistryController(),
@@ -36,16 +61,18 @@ export declare function StudioBridgeProvider({ value, children }: {
     value: Partial<StudioBridge>;
     children: React.ReactNode;
 }): React.JSX.Element;
-/** Collection registry — returns noop if CMS is not present. */
+/** Collection registry — returns noop if the admin is not present. */
 export declare function useStudioCollectionRegistry(): CollectionRegistryController;
-/** Side panel controller — returns noop if CMS is not present. */
+/** Side panel controller — returns noop if the admin is not present. */
 export declare function useStudioSidePanelController(): SidePanelController;
-/** URL controller — returns noop if CMS is not present. */
+/** URL controller — returns noop if the admin is not present. */
 export declare function useStudioUrlController(): UrlController;
-/** Navigation state — returns noop if CMS is not present. */
+/** Navigation state — returns noop if the admin is not present. */
 export declare function useStudioNavigationState(): NavigationStateController;
-/** Breadcrumbs controller — returns noop if CMS is not present. */
+/** Breadcrumbs controller — returns noop if the admin is not present. */
 export declare function useStudioBreadcrumbs(): BreadcrumbsController;
+/** What the host can do — see {@link StudioCapabilities}. */
+export declare function useStudioCapabilities(): StudioCapabilities;
 /**
  * Registry that controllers use to self-register their implementations
  * into the Studio bridge. Each controller calls `register(key, value)`