@rebasepro/types 0.13.0 → 0.13.1-canary.g249daa1

package/src/controllers/data.ts

@@ -1,3 +1,5 @@
+import type { VectorSearchParams } from "./data_driver";
+import type { ComputedSortField, SearchMatch } from "../types/search";
 import { Entity, EntityValues } from "../types/entities";
 import { WhereFilterOp, FieldPath, FilterValues, OrderByTuple } from "../types/filter-operators";
 
@@ -38,13 +40,19 @@ export interface FilterCondition {
  *
  * `limit`/`offset` and `page` describe the same window two ways. If **both
  * `offset` and `page` are provided, `page` wins** — the backend computes
- * `offset = (page - 1) * (limit ?? 20)` and ignores the explicit `offset`.
- * Pick one style per query.
+ * `offset = (page - 1) * (limit ?? DEFAULT_LIST_LIMIT)` and ignores the
+ * explicit `offset`. Pick one style per query.
  *
  * @group Data
  */
 export interface FindParams<M extends Record<string, unknown> = Record<string, unknown>> {
-    /** Maximum number of items to return (default: 20). */
+    /**
+     * Maximum number of items to return.
+     *
+     * Defaults to {@link DEFAULT_LIST_LIMIT}, and is clamped to
+     * {@link MAX_LIST_LIMIT}. Both bounds are applied by the backend, so a
+     * read is never unbounded whether or not a limit was asked for.
+     */
     limit?: number;
     /**
      * Number of items to skip. Ignored when {@link FindParams.page} is also
@@ -53,7 +61,7 @@ export interface FindParams<M extends Record<string, unknown> = Record<string, u
     offset?: number;
     /**
      * Page number (1-indexed), alternative to {@link FindParams.offset}.
-     * When set, overrides `offset` as `(page - 1) * (limit ?? 20)`.
+     * When set, overrides `offset` as `(page - 1) * (limit ?? DEFAULT_LIST_LIMIT)`.
      */
     page?: number;
     /**
@@ -80,7 +88,7 @@ export interface FindParams<M extends Record<string, unknown> = Record<string, u
      * Sort order as a `[field, direction]` tuple.
      * @example orderBy: ["created_at", "desc"]
      */
-    orderBy?: OrderByTuple<FieldPath<M>>;
+    orderBy?: OrderByTuple<FieldPath<M> | ComputedSortField>;
     /**
      * Relations to include in the response.
      *
@@ -90,11 +98,47 @@ export interface FindParams<M extends Record<string, unknown> = Record<string, u
      */
     include?: string[];
     /**
-     * Full-text search string. Matched (OR-ed) across the collection's
-     * searchable columns, then AND-ed with `where`/`logical`. This is the
-     * value behind the query builder's `.search()` method.
+     * Text search string, AND-ed with `where`/`logical`. This is the value
+     * behind the query builder's `.search()` method.
+     *
+     * What it compiles to depends on the collection. By default — matching
+     * every collection that has not said otherwise — it is a case-insensitive
+     * substring match OR-ed across the collection's top-level `string`
+     * properties: it does not reach inside `map` or `array` properties, it does
+     * not stem or rank, and it cannot use an index.
+     *
+     * A Postgres collection that declares a `search` block instead gets a
+     * ranked full-text match over exactly the fields it named, and rows come
+     * back with a {@link FindParams.orderBy}-able `_score`.
      */
     searchString?: string;
+
+    /**
+     * Nearest-neighbour search over a `vector` property.
+     *
+     * Postgres only, and only for a collection that declares a property of
+     * type `vector`. Rows come back ordered by distance, closest first, each
+     * carrying a `_distance`. Combines with `where` and `logical`, which are
+     * applied as filters before the ordering — so this is "the nearest rows
+     * that also match", not "the nearest rows, then filtered".
+     *
+     * Supplying the query vector is the caller's job: rebase stores and
+     * searches embeddings, it does not compute them.
+     */
+    vectorSearch?: VectorSearchParams;
+
+    /**
+     * Ask each returned row to explain itself: which declared search fields
+     * matched, with a highlighted snippet from each. Populates `_matches`.
+     *
+     * Off by default because it is not free — one `ts_headline` per declared
+     * field per returned row, and `ts_headline` re-parses the document rather
+     * than reading the index. Fine for a page of results, not for an export.
+     *
+     * Ignored unless the collection declares a `search` block and the query
+     * carries a `searchString`; there is nothing to explain otherwise.
+     */
+    searchExplain?: boolean;
 }
 
 /**
@@ -116,35 +160,50 @@ export interface FindResponse<M extends Record<string, unknown> = Record<string,
 
 
 /**
- * Fluent query builder for the **admin admin** — resolves to `FindResponse<M>`
+ * Fluent query builder for the **admin panel** — resolves to `FindResponse<M>`
  * (Snapshot-wrapped rows).
  *
  * @internal App developers should use {@link SDKQueryBuilderInterface}
  * (flat rows, returned by `client.data.*` / `context.data.*`). This
- * Snapshot-flavored variant backs the admin admin internals only.
+ * Snapshot-flavored variant backs the admin panel internals only.
  *
  * @group Data
  */
 export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
     where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): this;
     where(logicalCondition: LogicalCondition): this;
-    orderBy(column: keyof M & string, direction?: "asc" | "desc"): this;
+    orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc"): this;
     limit(count: number): this;
     offset(count: number): this;
-    search(searchString: string): this;
+    search(searchString: string, options?: { explain?: boolean }): this;
+
+    /**
+     * Order rows by nearest-neighbour distance to `vector`, closest first.
+     *
+     * Postgres only, over a property declared as `type: "vector"`. Each row
+     * comes back with a `_distance`. Any `where` on the same query filters
+     * before the ordering; distance decides the order.
+     *
+     * The query embedding is the caller's to produce.
+     */
+    vectorSearch(
+        property: string,
+        vector: number[],
+        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+    ): this;
     include(...relations: string[]): this;
     find(): Promise<FindResponse<M>>;
     listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
 }
 
 /**
- * A single collection's CRUD accessor for the **admin admin** — every method
+ * A single collection's CRUD accessor for the **admin panel** — every method
  * resolves to `Snapshot`-wrapped rows (`FindResponse<M>` / `Snapshot<M>`).
  *
  * @internal App developers do **not** use this. The public, symmetric surface
  * is {@link SDKCollectionClient} (flat rows), exposed as `client.data.products`
  * in the SDK and `context.data.products` in framework callbacks. This
- * Snapshot-flavored accessor backs the admin admin view-model only.
+ * Snapshot-flavored accessor backs the admin panel view-model only.
  *
  * @group Data
  */
@@ -181,6 +240,20 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      */
     update(id: string | number, data: Partial<EntityValues<M>>): Promise<Entity<M>>;
 
+    /**
+     * Update many records in a single transaction.
+     *
+     * See {@link SDKCollectionClient.updateMany}. Optional, as `createMany` is.
+     */
+    updateMany?(updates: { id: string | number; data: Partial<EntityValues<M>> }[]): Promise<Entity<M>[]>;
+
+    /**
+     * Delete many records in a single transaction.
+     *
+     * See {@link SDKCollectionClient.deleteMany}. Optional, as `createMany` is.
+     */
+    deleteMany?(ids: (string | number)[]): Promise<void>;
+
     /**
      * Delete a record by ID.
      */
@@ -200,16 +273,37 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
 
     /**
      * Count the number of records matching the given filter.
+     *
+     * Optional on this contract because a data source need not support it, and
+     * required on `CollectionClient` — the HTTP implementation always has it.
+     * So `client.data.posts.count()` compiles in the browser while the same
+     * call through a `context.data` accessor needs `count?.()`, which is the
+     * one place the two halves of this API are not interchangeable.
      */
     count?(params?: FindParams<M>): Promise<number>;
 
     // Fluent Query Builder
     where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): QueryBuilderInterface<M>;
     where(logicalCondition: LogicalCondition): QueryBuilderInterface<M>;
-    orderBy(column: keyof M & string, direction?: "asc" | "desc"): QueryBuilderInterface<M>;
+    orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc"): QueryBuilderInterface<M>;
     limit(count: number): QueryBuilderInterface<M>;
     offset(count: number): QueryBuilderInterface<M>;
-    search(searchString: string): QueryBuilderInterface<M>;
+    search(searchString: string, options?: { explain?: boolean }): QueryBuilderInterface<M>;
+
+    /**
+     * Order rows by nearest-neighbour distance to `vector`, closest first.
+     *
+     * Postgres only, over a property declared as `type: "vector"`. Each row
+     * comes back with a `_distance`. Any `where` on the same query filters
+     * before the ordering; distance decides the order.
+     *
+     * The query embedding is the caller's to produce.
+     */
+    vectorSearch(
+        property: string,
+        vector: number[],
+        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+    ): QueryBuilderInterface<M>;
     include(...relations: string[]): QueryBuilderInterface<M>;
 }
 
@@ -240,12 +334,55 @@ export interface PaginationMeta {
  * @group Data
  */
 export interface FindResult<M extends Record<string, unknown> = Record<string, unknown>> {
-    /** Array of flat rows matching the query */
-    data: M[];
+    /**
+     * Flat rows matching the query, each carrying whatever the query computed
+     * for it — see {@link QueryComputedFields}.
+     */
+    data: (M & QueryComputedFields)[];
     /** Pagination metadata */
     meta: PaginationMeta;
 }
 
+/**
+ * Values a query attaches to a row that are not columns of it.
+ *
+ * Both are absent unless the query asked for the thing that produces them, so
+ * both are optional — and reading one on a query that did not ask returns
+ * `undefined` rather than a wrong number.
+ *
+ * They live here rather than on the row type because a generated row type
+ * describes a *table*, and neither of these is in one. Without this, a caller
+ * who sorted by relevance could not then read the relevance.
+ *
+ * A `type` alias, deliberately, not an `interface`. TypeScript grants an
+ * implicit index signature to a type alias and withholds it from an interface,
+ * so `Row & QueryComputedFields` stops being assignable to
+ * `Record<string, unknown>` the moment this becomes an interface. Seven casts
+ * in one downstream app broke on exactly that.
+ *
+ * @group Data
+ */
+export type QueryComputedFields = {
+    /**
+     * Relevance, when the collection declares a {@link SearchConfig} and the
+     * query carried a search string. Higher is better; the scale is not
+     * comparable between two different search strings.
+     */
+    _score?: number;
+    /**
+     * Which declared fields matched, and the text around each hit. Present only
+     * when the query asked for it — `.search(term, { explain: true })` — because
+     * it costs a `ts_headline` per field per row.
+     */
+    _matches?: SearchMatch[];
+    /**
+     * Distance to the query vector, when the query used
+     * {@link FindParams.vectorSearch}. Lower is closer, and the rows are
+     * already ordered by it.
+     */
+    _distance?: number;
+};
+
 /**
  * Which column an iteration seeks on, for keyset ("seek") pagination.
  *
@@ -340,10 +477,25 @@ export type FindAllParams<M extends Record<string, unknown> = Record<string, unk
 export interface SDKQueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
     where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): this;
     where(logicalCondition: LogicalCondition): this;
-    orderBy(column: keyof M & string, direction?: "asc" | "desc"): this;
+    orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc"): this;
     limit(count: number): this;
     offset(count: number): this;
-    search(searchString: string): this;
+    search(searchString: string, options?: { explain?: boolean }): this;
+
+    /**
+     * Order rows by nearest-neighbour distance to `vector`, closest first.
+     *
+     * Postgres only, over a property declared as `type: "vector"`. Each row
+     * comes back with a `_distance`. Any `where` on the same query filters
+     * before the ordering; distance decides the order.
+     *
+     * The query embedding is the caller's to produce.
+     */
+    vectorSearch(
+        property: string,
+        vector: number[],
+        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+    ): this;
     include(...relations: string[]): this;
     find(): Promise<FindResult<M>>;
     count(): Promise<number>;
@@ -501,6 +653,12 @@ export interface SDKCollectionClient<
      * Batches are capped server-side (1000 rows by default) because one batch
      * holds its locks for the whole transaction — chunk larger jobs.
      *
+     * Pass {@link WriteOptions.idempotencyKey} on anything that may be retried.
+     * A client that never sees the response cannot know whether the batch
+     * committed, and without a key the server cannot tell the retry from a
+     * second genuine import — so it performs it again, duplicating every row in
+     * the batch rather than just one.
+     *
      * @returns The written rows, in the order given.
      *
      * @example
@@ -510,7 +668,7 @@ export interface SDKCollectionClient<
      * }
      * ```
      */
-    createMany(data: I[], options?: { upsert?: boolean }): Promise<M[]>;
+    createMany(data: I[], options?: { upsert?: boolean } & WriteOptions): Promise<M[]>;
 
     /**
      * Update an existing record by ID.
@@ -520,6 +678,46 @@ export interface SDKCollectionClient<
      */
     update(id: string | number, data: U): Promise<M>;
 
+    /**
+     * Update many records in a single request and a single transaction.
+     *
+     * The counterpart to {@link createMany}, and the reason it exists is the
+     * same: one call per row means one HTTP round trip and one transaction per
+     * row. Every record still runs the normal pipeline — callbacks, relations,
+     * row-level security — and the batch is all-or-nothing, so a rejected
+     * record leaves none of them written and the error names the offending
+     * index.
+     *
+     * Each entry is `{ id, data }` rather than a flat row carrying its own key.
+     * That is deliberate: on a table keyed on something other than `id` — a
+     * `sku`, a composite key — a flat row cannot say whether a column is the
+     * address or a value to write. Naming the address separately mirrors
+     * single-row `update(id, data)` exactly and leaves nothing to infer.
+     *
+     * An id that matches no row fails the batch with a 404 rather than being
+     * skipped, for the same reason `update()` does: silently updating four of
+     * five rows is worse than updating none.
+     *
+     * Batches share `createMany`'s server-side cap (1000 rows by default),
+     * because one batch holds its locks for the whole transaction.
+     *
+     * Pass {@link WriteOptions.idempotencyKey} on anything that may be retried.
+     * An update replayed in full is naturally idempotent, but one interleaved
+     * with another writer's is not — the key is what stops a lost ACK from
+     * re-applying a stale batch over newer data.
+     *
+     * @returns The updated rows, in the order given.
+     *
+     * @example
+     * ```ts
+     * await client.data.orders.updateMany([
+     *     { id: "o-1", data: { status: "shipped" } },
+     *     { id: "o-2", data: { status: "shipped" } }
+     * ]);
+     * ```
+     */
+    updateMany(updates: { id: string | number; data: U }[], options?: WriteOptions): Promise<M[]>;
+
     /**
      * Delete a record by ID.
      * @throws {RebaseApiError} with status 404 when the record does not exist.
@@ -527,13 +725,48 @@ export interface SDKCollectionClient<
     delete(id: string | number): Promise<void>;
 
     /**
-     * Subscribe to a collection for real-time updates.
+     * Delete many records in a single request and a single transaction.
+     *
+     * Takes ids, not a filter. A filter-shaped bulk delete is a different and
+     * far more dangerous operation — the failure mode is an omitted or
+     * mistyped condition emptying a table, and it cannot be reviewed at the
+     * call site the way an explicit list can. Read first, then pass the ids you
+     * meant.
+     *
+     * `beforeDelete` and `afterDelete` fire per row, exactly as they do for
+     * single deletes, and returning `false` from `beforeDelete` fails the batch
+     * rather than quietly dropping one row from it. All-or-nothing, so an id
+     * that matches no row 404s the whole call.
+     *
+     * Shares `createMany`'s row cap.
+     *
+     * @example
+     * ```ts
+     * const stale = await client.data.sessions.findAll({
+     *     where: { expires_at: ["<", cutoff] }
+     * });
+     * await client.data.sessions.deleteMany(stale.map(s => s.id as string));
+     * ```
      */
-    listen?(params: FindParams<M> | undefined, onUpdate: (response: FindResult<M>) => void, onError?: (error: Error) => void): () => void;
+    deleteMany(ids: (string | number)[], options?: WriteOptions): Promise<void>;
 
     /**
-     * Subscribe to a single record for real-time updates.
+     * The low-level realtime subscription: raw server pushes, nothing else.
+     *
+     * **Prefer `observe()`** on a client from `@rebasepro/client`, which wraps
+     * this one and is what a UI actually wants — it emits from the local
+     * database first when offline is enabled, re-emits on local writes and
+     * rollbacks, and de-duplicates emissions so a refresh that changes nothing
+     * does not call back. `listen` does none of that; it forwards what the
+     * socket sends.
+     *
+     * Optional because it is only present when realtime is enabled. `observe()`
+     * is not — it degrades to a single fetch — which is the other reason to
+     * reach for it instead.
      */
+    listen?(params: FindParams<M> | undefined, onUpdate: (response: FindResult<M>) => void, onError?: (error: Error) => void): () => void;
+
+    /** {@link listen} for a single row. Prefer `observeById()`. */
     listenById?(id: string | number, onUpdate: (row: M | undefined) => void, onError?: (error: Error) => void): () => void;
 
     /**
@@ -544,15 +777,25 @@ export interface SDKCollectionClient<
     // Fluent Query Builder
     where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): SDKQueryBuilderInterface<M>;
     where(logicalCondition: LogicalCondition): SDKQueryBuilderInterface<M>;
-    orderBy(column: keyof M & string, direction?: "asc" | "desc"): SDKQueryBuilderInterface<M>;
+    orderBy(column: (keyof M & string) | ComputedSortField, direction?: "asc" | "desc"): SDKQueryBuilderInterface<M>;
     limit(count: number): SDKQueryBuilderInterface<M>;
     offset(count: number): SDKQueryBuilderInterface<M>;
-    search(searchString: string): SDKQueryBuilderInterface<M>;
+    search(searchString: string, options?: { explain?: boolean }): SDKQueryBuilderInterface<M>;
+    /**
+     * Order rows by nearest-neighbour distance to `vector`, closest first.
+     * Postgres only, over a `type: "vector"` property. See
+     * {@link SDKQueryBuilderInterface.vectorSearch}.
+     */
+    vectorSearch(
+        property: string,
+        vector: number[],
+        options?: { distance?: "cosine" | "l2" | "inner_product"; threshold?: number }
+    ): SDKQueryBuilderInterface<M>;
     include(...relations: string[]): SDKQueryBuilderInterface<M>;
 }
 
 /**
- * The unified data access object for the **admin admin** (Entity-shaped).
+ * The unified data access object for the **admin panel** (Entity-shaped).
  *
  * Access collections as dynamic properties: `data.products.find(...)`. Each
  * accessor returns `Entity`-wrapped records (`{ id, path, values }`) — the
@@ -561,7 +804,7 @@ export interface SDKCollectionClient<
  *
  * @internal App developers do **not** use this — they use
  * {@link RebaseSdkData} (flat rows), which is what the SDK client and backend
- * `context.data` expose. This Entity-shaped map backs the admin admin only.
+ * `context.data` expose. This Entity-shaped map backs the admin panel only.
  *
  * @group Data
  */
@@ -584,10 +827,15 @@ export type RebaseData<DB = unknown> = {
              * Dynamic collection accessor.
              * Access any collection by its slug as a property.
              *
+             * The index signature is `CollectionAccessor` alone, for the reason
+             * spelled out on {@link RebaseSdkData}: unioning in the `collection`
+             * method's own signature is unnecessary across an intersection, and it
+             * costs `data.products.find()` — the access this `@example` documents.
+             *
              * @example
              * data.products.find({ where: { status: ["==", "published"] } })
              */
-            [collectionSlug: string]: CollectionAccessor | ((slug: string) => CollectionAccessor);
+            [collectionSlug: string]: CollectionAccessor;
         }
 );
 
@@ -639,6 +887,26 @@ export type InsertOf<T> = T extends { Insert: infer I extends Record<string, unk
  */
 export type UpdateOf<T> = T extends { Update: infer U extends Record<string, unknown> } ? U : Partial<RowOf<T>>;
 
+/**
+ * Note on the untyped branch below: its index signature is
+ * `SDKCollectionClient`, NOT `SDKCollectionClient | ((slug: string) => …)`.
+ *
+ * The union looks like it is needed so `collection` — a method on this same
+ * object — satisfies the index signature. It is not, because `collection` is
+ * declared in a *separate* member of the intersection, and TypeScript only
+ * requires named properties to be assignable to an index signature declared
+ * alongside them. Including the function arm cost the documented accessor:
+ *
+ *     rebase.dataAsAdmin.projects.find()
+ *     //                          ^ Property 'find' does not exist on type
+ *     //                            'SDKCollectionClient | ((slug: string) => …)'
+ *
+ * Every project without a generated `Database` type lands on this branch, so
+ * property-style access — the form used by the `@example` below, by the
+ * scaffolded function template, and by the 0.13 migration note — did not
+ * compile for any of them. Do not restore the arm; use `collection(slug)` if a
+ * caller genuinely needs the by-slug function.
+ */
 export type RebaseSdkData<DB = unknown> = {
     /**
      * Get a flat collection accessor by slug.
@@ -659,6 +927,6 @@ export type RebaseSdkData<DB = unknown> = {
              * @example
              * data.products.find({ where: { status: ["==", "published"] } })
              */
-            [collectionSlug: string]: SDKCollectionClient | ((slug: string) => SDKCollectionClient);
+            [collectionSlug: string]: SDKCollectionClient;
         }
 );

package/src/controllers/data_driver.ts

@@ -117,6 +117,8 @@ export interface FetchCollectionProps<M extends Record<string, unknown> = Record
     startAfter?: unknown;
     orderBy?: string;
     searchString?: string;
+    /** Ask each row which declared search field matched — populates `_matches`. */
+    searchExplain?: boolean;
     order?: "desc" | "asc";
     /** Vector similarity search configuration */
     vectorSearch?: VectorSearchParams;
@@ -169,6 +171,23 @@ export interface SaveManyProps<M extends Record<string, unknown> = Record<string
     upsert?: boolean;
 }
 
+/**
+ * @internal
+ */
+export interface UpdateManyProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    path: string;
+    /**
+     * The rows to update, each named by its address.
+     *
+     * Distinct from {@link SaveManyProps.rows}, which carries keys *inside* the
+     * values and is insert-shaped — `saveMany` passes `status: "new"` and no
+     * `id`, so it cannot express "update exactly this row". This can, and it is
+     * why bulk update is a separate driver method rather than a flag on that one.
+     */
+    updates: { id: string | number; values: Partial<EntityValues<M>> }[];
+    collection?: CollectionConfig<M>;
+}
+
 /**
  * @internal
  */
@@ -177,6 +196,15 @@ export interface DeleteProps<M extends Record<string, unknown> = Record<string,
     collection?: CollectionConfig<M>;
 }
 
+/**
+ * @internal
+ */
+export interface DeleteManyProps<M extends Record<string, unknown> = Record<string, unknown>> {
+    path: string;
+    ids: (string | number)[];
+    collection?: CollectionConfig<M>;
+}
+
 export type FilterCombinationValidProps = {
     path: string;
     databaseId?: string;
@@ -258,6 +286,17 @@ export interface DataDriver {
      */
     saveMany?<M extends Record<string, unknown> = Record<string, unknown>>(props: SaveManyProps<M>): Promise<Record<string, unknown>[]>;
 
+    /**
+     * Update many rows in one transaction, each addressed by id.
+     *
+     * Optional for the same reason `saveMany` is: a driver that cannot make the
+     * batch atomic should not pretend to. The REST layer reports
+     * `BULK_UNSUPPORTED` rather than silently falling back to a loop of single
+     * writes, which would be neither atomic nor one round trip — the two things
+     * a caller reaches for a batch to get.
+     */
+    updateMany?<M extends Record<string, unknown> = Record<string, unknown>>(props: UpdateManyProps<M>): Promise<Record<string, unknown>[]>;
+
     /**
      * Delete a entity
      * @param props
@@ -271,6 +310,14 @@ export interface DataDriver {
      */
     deleteAll?(path: string): Promise<void>;
 
+    /**
+     * Delete many rows in one transaction, addressed by id.
+     *
+     * Ids rather than a filter, deliberately — see
+     * {@link SDKCollectionClient.deleteMany}. Optional, as `saveMany` is.
+     */
+    deleteMany?<M extends Record<string, unknown> = Record<string, unknown>>(props: DeleteManyProps<M>): Promise<void>;
+
     /**
      * Check if the given property is unique in the given collection
      * @param path Collection path
@@ -383,6 +430,8 @@ export interface RestFetchService {
             offset?: number;
             startAfter?: Record<string, unknown>;
             searchString?: string;
+            /** Ask each row which declared search fields matched — populates `_matches`. */
+            searchExplain?: boolean;
             databaseId?: string;
             vectorSearch?: VectorSearchParams;
         },

package/src/errors.ts

@@ -1,3 +1,42 @@
+/**
+ * The error codes every route can produce, as `RebaseApiError.code`.
+ *
+ * These are the defaults on `ApiError`'s static constructors server-side, so
+ * any endpoint can answer with one. They are **not** the complete set: routes
+ * pass their own more specific codes too (`EMAIL_EXISTS`, `TOKEN_EXPIRED`,
+ * `INVALID_BULK_BODY`, …), and auth alone defines a couple of dozen.
+ *
+ * Hence the union is deliberately open rather than closed. It exists to give
+ * autocomplete and to catch a typo in the common cases — `code` was a bare
+ * `string`, so `e.code === "NOT_FOUND"` and `e.code === "NOTFOUND"` were
+ * equally valid and only one of them worked. Closing it would be a lie that
+ * broke the moment a route added a code.
+ *
+ * @example
+ * if (e instanceof RebaseApiError) {
+ *   switch (e.code) {
+ *     case "NOT_FOUND": return null;          // completed
+ *     case "FORBIDDEN": return redirect();
+ *     default: throw e;                       // routes' own codes land here
+ *   }
+ * }
+ *
+ * @group Errors
+ */
+export type RebaseErrorCode =
+    | "BAD_REQUEST"
+    | "UNAUTHORIZED"
+    | "FORBIDDEN"
+    | "NOT_FOUND"
+    | "CONFLICT"
+    | "INTERNAL_ERROR"
+    | "SERVICE_UNAVAILABLE"
+    | "DB_PERMISSION_DENIED"
+    | "SCHEMA_DRIFT"
+    // `string & {}` keeps the union open while preserving completion on the
+    // literals above — a bare `| string` would collapse them and offer nothing.
+    | (string & {});
+
 /**
  * Structured initializer for {@link RebaseApiError}.
  *
@@ -10,8 +49,8 @@ export interface RebaseErrorInit {
      * logic errors that have no HTTP status.
      */
     status?: number;
-    /** Stable, machine-readable error code (e.g. `"NOT_FOUND"`, `"BAD_REQUEST"`). */
-    code?: string;
+    /** Stable, machine-readable error code. See {@link RebaseErrorCode}. */
+    code?: RebaseErrorCode;
     /** Structured error payload returned by the server, when present. */
     details?: unknown;
     /** The underlying error this one wraps, if any. */
@@ -45,8 +84,8 @@ export interface RebaseErrorInit {
 export class RebaseApiError extends Error {
     /** HTTP status code, or `undefined` for non-HTTP errors. */
     readonly status?: number;
-    /** Stable machine-readable error code, when the server supplied one. */
-    readonly code?: string;
+    /** Stable machine-readable error code, when the server supplied one. See {@link RebaseErrorCode}. */
+    readonly code?: RebaseErrorCode;
     /** Structured error payload from the server, when present. */
     readonly details?: unknown;
 

package/src/types/admin_block.ts

@@ -41,6 +41,7 @@ export const ADMIN_COLLECTION_KEYS = [
     "defaultSize",
     "defaultViewMode",
     "disableDefaultActions",
+    "display",
     "enabledViews",
     "entityActions",
     "entityViews",
@@ -51,6 +52,7 @@ export const ADMIN_COLLECTION_KEYS = [
     "formAutoSave",
     "formView",
     "group",
+    "hideFromEntityViews",
     "hideFromNavigation",
     "hideIdFromCollection",
     "hideIdFromForm",