@rebasepro/app 0.13.1-canary.gef9608c → 0.14.0

package/dist/collections/property_presentation.d.ts

@@ -10,11 +10,26 @@
  * That last one is worth knowing about rather than assuming: the collection editor
  * has a whole Conditions UI, `serializable_utils` persists what it writes, and
  * `BaseProperty.conditions` documents itself as "evaluated at runtime like property
- * builders" — but the evaluator below is reached only from its own tests. The
- * declarative conditions feature is authored and stored, never applied. It lives
- * here now because here is where it would be called from once it is wired up.
+ * builders" — but the evaluator below is reached only from its own tests. It lives
+ * here because here is where it would be called from once it is wired up.
+ *
+ * The one part of `conditions` that *is* applied is the literal case:
+ * `hidden`/`readOnly`/`disabled` stated as a plain boolean rather than as a rule.
+ * A literal needs no context, so `isHidden`/`isReadOnly`/`isDisabled` can answer
+ * it directly, and those three gates are consulted everywhere a field is laid
+ * out. A *rule* still is not evaluated anywhere in production — the split is
+ * deliberate, not an oversight: it is the difference between a condition that
+ * needs an entity to be evaluated against and one that does not.
  */
 import type { ConditionContext, Property } from "@rebasepro/types";
 export declare function isReadOnly(property: Property): boolean;
 export declare function isHidden(property: Property): boolean;
+/**
+ * Whether the field is disabled by its own declaration, ignoring form state.
+ *
+ * The `admin.disabled` block and `conditions.disabled: true` say the same thing
+ * two ways, so every caller that gated on the first now asks here instead of
+ * growing a second check of its own.
+ */
+export declare function isDisabled(property: Property): boolean;
 export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;

package/dist/components/LoginView/oauth-redirect-flow.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The browser half of the OAuth authorization-code flow.
+ *
+ * The server only ever sees a `code` and a `redirectUri` taken from the
+ * request body, so `state`, PKCE and the binding between "this browser started
+ * a login" and "this code came back" are, by construction, the client's job.
+ * In the admin login they had been nobody's job: the authorize URL carried no
+ * `state`, and the return leg accepted any `?code=` as long as a localStorage
+ * marker naming the *provider* was set — a marker written on button click and
+ * removed only on a callback that carried a code, so abandoning the flow left
+ * it set indefinitely.
+ *
+ * Everything here is provider-agnostic on purpose. A button that wants a new
+ * provider calls {@link startOAuthRedirect} and gets state, expiry and PKCE
+ * without deciding anything, which is what stops the next provider shipping
+ * without them.
+ */
+export interface OAuthRedirectRequest {
+    /** Provider id, as mounted at `POST /auth/<id>`. */
+    provider: string;
+    /** The provider's authorization endpoint. */
+    authorizeUrl: string;
+    clientId: string;
+    scope: string;
+    /** Where the provider sends the browser back. Echoed to the token exchange. */
+    redirectUri: string;
+    /** Set when the provider implements PKCE. */
+    pkce?: boolean;
+    /** Extra authorize-endpoint parameters (`response_type`, and so on). */
+    params?: Record<string, string>;
+}
+/** What the browser remembers between leaving for the provider and coming back. */
+export interface PendingOAuthRedirect {
+    provider: string;
+    state: string;
+    codeVerifier?: string;
+    redirectUri: string;
+    startedAt: number;
+}
+export type OAuthCallbackResult = 
+/** No OAuth callback in this URL. */
+{
+    status: "none";
+}
+/** The provider reported a failure, or the user declined. */
+ | {
+    status: "error";
+    error: string;
+}
+/**
+ * A code arrived that this browser cannot account for: no pending
+ * authorization, an expired one, or a `state` that does not match. This is
+ * what a login-CSRF / code-injection attempt looks like.
+ */
+ | {
+    status: "mismatch";
+} | {
+    status: "ok";
+    provider: string;
+    code: string;
+    codeVerifier?: string;
+    redirectUri: string;
+};
+type Storage = Pick<globalThis.Storage, "getItem" | "setItem" | "removeItem">;
+export declare function readPendingOAuthRedirect(storage?: Storage | null): PendingOAuthRedirect | null;
+export declare function clearPendingOAuthRedirect(storage?: Storage | null): void;
+/**
+ * Build the authorize URL and the pending record that will validate its
+ * callback. Split out from {@link startOAuthRedirect} so it can be tested
+ * without navigating.
+ */
+export declare function buildOAuthAuthorization(request: OAuthRedirectRequest, now?: number): Promise<{
+    url: string;
+    pending: PendingOAuthRedirect;
+}>;
+/** Remember the authorization and send the browser to the provider. */
+export declare function startOAuthRedirect(request: OAuthRedirectRequest, storage?: Storage | null): Promise<void>;
+/**
+ * Interpret a return from the provider.
+ *
+ * Clears the pending record on **every** path that saw a callback — including
+ * `?error=` and a state mismatch — so a declined or abandoned consent screen
+ * cannot leave the browser primed to accept somebody else's code later.
+ */
+export declare function consumeOAuthCallback(search: string, storage?: Storage | null, now?: number): OAuthCallbackResult;
+export {};

package/dist/components/common/useColumnsIds.d.ts

@@ -5,6 +5,28 @@ export type PropertyColumnConfig = {
     disabled: boolean;
 };
 export declare function getSubcollectionColumnId(collection: AdminCollection<any>): string;
+/**
+ * The jump-to-tab columns a collection table does not need, because the relation
+ * behind them already has a column of its own.
+ *
+ * Every child view gets a 200px button column that opens its tab. For a relation
+ * declared in `relations` that button is the relation's only presence in the
+ * table. For one declared as a property it is the second: the property's own
+ * column is already there, hydrated by the list fetch's `include: ["*"]`, showing
+ * the child rows themselves — and carrying the *same heading*, because the tab
+ * takes its name from the declaring property. Two columns called "Applications",
+ * one of them a button, and nothing in the header to tell them apart.
+ *
+ * The property column wins: it shows what the children are, and each chip in it
+ * opens one. The tab stays reachable by opening the record, which is what the
+ * rest of the table's rows do anyway.
+ *
+ * Unless the author hid that column — `hideFromCollection` on the property, or a
+ * `propertiesOrder` that omits it, is a statement about the column and not about
+ * the relation, so the button comes back rather than the relation dropping out
+ * of the table altogether.
+ */
+export declare function getRedundantChildViewColumnIds<M extends Record<string, any>>(collection: AdminCollection<M>): Set<string>;
 export declare function useColumnIds<M extends Record<string, any>>(collection: AdminCollection<M>, includeSubcollections: boolean): PropertyColumnConfig[];
 export declare function getColumnKeysForProperty(property: Property, key: string, disabled?: boolean): PropertyColumnConfig[];
 export declare function getFormFieldKeys(collection: AdminCollection): string[];

package/dist/core/Rebase.d.ts

@@ -12,4 +12,4 @@ import { User } from "@rebasepro/types";
  *
  * @group Core
  */
-export declare function Rebase<USER extends User>(props: RebaseProps<USER>): React.JSX.Element;
+export declare function Rebase<USER extends User, DB = unknown>(props: RebaseProps<USER, DB>): React.JSX.Element;

package/dist/core/RebaseProps.d.ts

@@ -99,7 +99,7 @@ import type { EffectiveRoleController } from "@rebasepro/types";
  *
  * @group Models
  */
-export type RebaseProps<USER extends User> = {
+export type RebaseProps<USER extends User, DB = unknown> = {
     /**
      * The root components of your application. Use RebaseAdmin, RebaseStudio, and RebaseShell.
      * Alternatively, pass a render function that receives { context, loading }.
@@ -140,8 +140,16 @@ export type RebaseProps<USER extends User> = {
      * entry keyed `"(default)"` carries a driver.
      * `client.auth` is subscribed unless `authController` is provided.
      * `client.storage` is used unless `storageSource` is provided.
+     *
+     * `DB` is inferred from whatever is passed, and defaults to `unknown` for
+     * an untyped client. It has to be a parameter rather than a fixed
+     * `RebaseClient`: `RebaseClient<unknown>` is not a supertype of
+     * `RebaseClient<Database>` — the dynamic branch of `RebaseSdkData` is an
+     * index signature that no concrete instantiation satisfies — so pinning it
+     * here rejected the client of every project that generates a `Database`
+     * type, which is the whole typed-SDK path.
      */
-    client?: RebaseClient;
+    client?: RebaseClient<DB>;
     /**
      * The data sources of the app. Each entry pairs a
      * {@link DataSourceDefinition} (key, engine, transport) with an optional

package/dist/hooks/data/collectionQuery.d.ts

@@ -0,0 +1,45 @@
+import type { FindParams, FilterValues, LogicalCondition } from "@rebasepro/types";
+/**
+ * The one place a collection read's parameters are assembled.
+ *
+ * ## Why this exists
+ *
+ * Four call sites used to build this object by hand — `useCollection` and
+ * `useDataTableController`, each in both their `listen` and `find` branches.
+ * Every one of them listed the fields it forwarded, so adding an option to
+ * `FindParams` meant remembering four places, and forgetting one failed
+ * silently: the option simply never reached the server, and the feature it
+ * enabled looked broken for reasons nowhere near the code that dropped it.
+ *
+ * That is not hypothetical. `searchExplain` was added to three of the four and
+ * the miss was found by intercepting a WebSocket frame, because nothing else
+ * could see it.
+ *
+ * A field added here reaches every read. `toFindParams` returns `FindParams`
+ * itself, so the compiler checks the shape rather than a hand-copied list.
+ */
+export interface CollectionQueryInput<M extends Record<string, unknown>> {
+    where?: FilterValues<Extract<keyof M, string>>;
+    logical?: LogicalCondition;
+    /**
+     * Loosened from `FindParams["orderBy"]` on purpose: callers hold the sort
+     * as a plain `[string, direction]` read off user config or a URL, where the
+     * column is not statically known. Narrowing it here would push a cast onto
+     * every call site, which is the kind of friction that sends people back to
+     * hand-building the object this exists to replace.
+     */
+    orderBy?: [string, "asc" | "desc"];
+    limit?: number;
+    offset?: number;
+    page?: number;
+    searchString?: string;
+    include?: string[];
+}
+/**
+ * Build the parameters for one collection read.
+ *
+ * Derived options live here rather than at the call sites, so they cannot
+ * disagree: `searchExplain` rides along exactly when there is a search string
+ * to explain, which is also the only time it costs anything.
+ */
+export declare function toFindParams<M extends Record<string, unknown>>(input: CollectionQueryInput<M>): FindParams<M>;

package/dist/hooks/data/useRelationSelector.d.ts

@@ -36,6 +36,17 @@ export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
      * Property name to use as the secondary display field
      */
     descriptionProperty?: keyof M;
+    /**
+     * Whether the list should be fetched at all. Defaults to `true`.
+     *
+     * A picker that is mounted is not a picker that is open, and the two used
+     * to be the same thing here: the fetch ran on mount, so a collection table
+     * with a relation column paid for one query — or one realtime subscription
+     * — per rendered row before anyone clicked a cell. Pass `false` until the
+     * list is actually needed and nothing is requested; flipping it to `true`
+     * fetches once, and it never goes back.
+     */
+    enabled?: boolean;
 }
 export interface RelationSelectorController {
     items: RelationItem[];
@@ -49,4 +60,4 @@ export interface RelationSelectorController {
 /**
  * Hook to manage relation selection with data fetching from Rebase data source
  */
-export declare function useRelationSelector<M extends Record<string, any> = any>({ path, collection, fixedFilter, pageSize, getLabelFromEntity, getDescriptionFromEntity, descriptionProperty }: UseRelationSelectorProps<M>): RelationSelectorController;
+export declare function useRelationSelector<M extends Record<string, any> = any>({ path, collection, fixedFilter, pageSize, getLabelFromEntity, getDescriptionFromEntity, descriptionProperty, enabled }: UseRelationSelectorProps<M>): RelationSelectorController;