@rebasepro/cms 0.20.0 → 0.21.0

package/dist/selection/SelectionMenu.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import { Entity } from "@rebasepro/types";
+import { SelectionController, SelectionQuery } from "@rebasepro/cms-types";
+export interface SelectionMenuProps<M extends Record<string, unknown>> {
+    selectionController: SelectionController<M>;
+    /** The rows the view is holding right now. */
+    loadedEntities: Entity<M>[];
+    /** The view's live query — what "all matching" stands for. */
+    query: SelectionQuery<M>;
+    /** The view's filtered count. `undefined` while loading, or where the accessor has none. */
+    collectionEntitiesCount?: number;
+    collectionName: string;
+}
+/**
+ * The whole of selecting rows, in one control: a checkbox for the common case
+ * and a caret for everything else.
+ *
+ * The escalation from "the rows on screen" to "every row that matches" lived in
+ * a strip under the toolbar, which was wrong in a way that only shows up in
+ * use: it appears the moment you tick a single checkbox, and the list you were
+ * reading jumps down by its height. A control that punishes the first click is
+ * not worth whatever the strip was explaining.
+ *
+ * So the escalation is a menu item — clicked deliberately, costing no layout,
+ * and in the place you already go to select everything.
+ */
+export declare function SelectionMenu<M extends Record<string, unknown>>({ selectionController, loadedEntities, query, collectionEntitiesCount, collectionName }: SelectionMenuProps<M>): React.JSX.Element;

package/dist/selection/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./resolve_selection.js";
+export * from "./SelectionMenu.js";

package/dist/selection/resolve_selection.d.ts

@@ -0,0 +1,62 @@
+import { Entity, FindParams } from "@rebasepro/types";
+import { EntitySelection, SelectionQuery } from "@rebasepro/cms-types";
+import { EntityPageAccessor } from "../util/entity_pages.js";
+/**
+ * Rows asked for per request while resolving a query selection.
+ *
+ * Same ceiling as the export walk, and for the same reason: the server refuses
+ * a `limit` above its `MAX_LIST_LIMIT` rather than clamping it.
+ */
+export declare const SELECTION_PAGE_SIZE = 500;
+/**
+ * Most rows one query selection will resolve to ids for.
+ *
+ * The write path is per-row — `deleteMany` loops the single-row delete server
+ * side so hooks and row-level security still run for each — so this is a
+ * genuine ceiling on the work, not just on memory. Going over it **throws**
+ * rather than acting on a prefix, which is the failure that cannot be seen:
+ * "deleted 12,480 rows" reads identically whether it was all of them or the
+ * first page.
+ */
+export declare const MAX_SELECTION_ROWS = 20000;
+/**
+ * A stable string for a selection query, for comparing the query a selection
+ * was made against with the one the view is showing now.
+ *
+ * Filter keys are sorted: `filterValues` is rebuilt on most renders and its key
+ * order follows whatever order the user touched the columns in, so a plain
+ * `JSON.stringify` would report the same filter as a different one and drop a
+ * selection the moment anything re-rendered.
+ */
+export declare function serializeSelectionQuery<M extends Record<string, unknown>>(query: SelectionQuery<M>): string;
+/** Turn a captured selection query into the `find` params that reproduce it. */
+export declare function selectionQueryToFindParams<M extends Record<string, unknown>>(query: SelectionQuery<M>): Omit<FindParams<M>, "limit" | "offset" | "page">;
+export interface ResolveSelectionParams<M extends Record<string, unknown>> {
+    selection: EntitySelection<M>;
+    /**
+     * Reads the rows a query selection stands for. Only consulted in query
+     * mode — an entities selection is already resolved and never hits the
+     * network.
+     */
+    accessor: EntityPageAccessor<M>;
+    pageSize?: number;
+    maxRows?: number;
+    /** Called after every page, so a long resolve can show where it is. */
+    onProgress?: (loaded: number, total: number | undefined) => void;
+    /** Checked between pages; aborting returns the rows read so far. */
+    signal?: {
+        aborted: boolean;
+    };
+}
+/**
+ * The rows a selection covers.
+ *
+ * This is the *only* way to get rows out of a query selection, and it is why
+ * {@link EntitySelection} is a union: a bulk action has to call it, which means
+ * it has to deal with the wait, the ceiling and the failure. The array this
+ * replaced let the same code path read whatever the view had scrolled — 50 rows
+ * of 12,480 — and report success.
+ *
+ * @throws When the query matches more than `maxRows` rows.
+ */
+export declare function resolveSelection<M extends Record<string, unknown>>({ selection, accessor, pageSize, maxRows, onProgress, signal }: ResolveSelectionParams<M>): Promise<Entity<M>[]>;

package/dist/types/components/EntityFormProps.d.ts

@@ -36,7 +36,20 @@ export type EntityFormProps<M extends Record<string, unknown>> = {
     showDefaultActions?: boolean;
     EntityFormActionsComponent?: React.FC<EntityFormActionsProps>;
     navigateBack?: () => void;
+    /**
+     * Rendered in place of the generated fields, inside this form — so it is
+     * handed this form's live {@link FormContext}, and Save, validation and the
+     * unsaved-changes guard all see what it writes. A collection's
+     * `formView.Builder` and an entity view declared with `includeActions` both
+     * arrive here.
+     */
     Builder?: React.ComponentType<EntityCustomViewParams<M>>;
+    /**
+     * Passed through to {@link Builder}: the path of parents above this record,
+     * which every entity view receives. The form itself does not read them.
+     */
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
     children?: React.ReactNode;
     /**
      * Called on form submit with the values to save.

package/dist/util/entity_pages.d.ts

@@ -0,0 +1,36 @@
+import { Entity, FindParams, FindResponse } from "@rebasepro/types";
+/** The slice of a collection accessor a page walk needs. */
+export interface EntityPageAccessor<M extends Record<string, unknown>> {
+    find(params?: FindParams<M>): Promise<FindResponse<M>>;
+}
+export interface WalkEntityPagesParams<M extends Record<string, unknown>> {
+    accessor: EntityPageAccessor<M>;
+    /** Query to walk. The window (`limit` / `offset` / `page`) is owned by the walk. */
+    params?: Omit<FindParams<M>, "limit" | "offset" | "page">;
+    pageSize: number;
+    /** Walking past this many rows throws, with `onCeiling`'s message. */
+    maxRows: number;
+    onCeiling: (maxRows: number) => string;
+    /** Called after every page with the rows so far, and the total when the server reports one. */
+    onProgress?: (loaded: number, total: number | undefined) => void;
+    /** Checked between pages. When it aborts, what has been read so far is returned. */
+    signal?: {
+        aborted: boolean;
+    };
+}
+/**
+ * Read **every** row matching a query, one page at a time.
+ *
+ * `find({})` sends no `limit`, and an absent limit is resolved server-side to
+ * `DEFAULT_LIST_LIMIT` — 50 rows. Anything that means "all of them" and asks
+ * once gets 50 back, with nothing to say that is what happened.
+ *
+ * Termination is driven by the server's `meta.hasMore` where it is reported and
+ * by an empty page otherwise — never by comparing a page's length against the
+ * requested limit, since a final page that happens to be exactly full is
+ * indistinguishable that way and a walk that stops there drops rows.
+ *
+ * @throws When more than `maxRows` rows match. A truncated answer is worse than
+ * no answer: it is indistinguishable from a complete one.
+ */
+export declare function walkEntityPages<M extends Record<string, unknown>>({ accessor, params, pageSize, maxRows, onCeiling, onProgress, signal }: WalkEntityPagesParams<M>): Promise<Entity<M>[]>;

package/dist/util/map_with_concurrency.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Run `task` over every item, at most `concurrency` at a time, and return the
+ * results in the order the items were given.
+ *
+ * The bulk delete used to be `Promise.all(entities.map(performDelete))`. That is
+ * fine for the handful of rows anyone could tick by hand, and it is the reason
+ * a "select all matching" over a real collection could not simply be poured
+ * into the existing dialog: twelve thousand entries in that array is twelve
+ * thousand simultaneous requests, which the browser queues and the server takes
+ * as a burst.
+ *
+ * Rejections are not swallowed and do not cancel: every task is run, and the
+ * first rejection is thrown once they have all settled, so a bulk action cannot
+ * half-apply and then report the failure as if nothing had happened.
+ */
+export declare function mapWithConcurrency<T, R>(items: readonly T[], concurrency: number, task: (item: T, index: number) => Promise<R>, onSettled?: (completed: number, total: number) => void): Promise<R[]>;