@rebasepro/types 0.14.0 → 0.14.1-canary.g932d14c

package/dist/controllers/data.d.ts

@@ -1,7 +1,7 @@
 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";
+import { WhereFilterOp, FieldPath, FilterValues, OrderBySpec } from "../types/filter-operators";
 /**
  * Operator-blind filter value: whatever the column holds, a list of it, or null.
  *
@@ -145,10 +145,13 @@ export interface FindParams<M extends Record<string, unknown> = Record<string, u
      */
     logical?: LogicalCondition;
     /**
-     * Sort order as a `[field, direction]` tuple.
+     * Sort order as a `[field, direction]` tuple, or a list of them applied in
+     * order of significance — the second key breaks ties on the first, and so on.
+     *
      * @example orderBy: ["created_at", "desc"]
+     * @example orderBy: [["roles", "asc"], ["created_at", "desc"]]
      */
-    orderBy?: OrderByTuple<FieldPath<M> | ComputedSortField>;
+    orderBy?: OrderBySpec<FieldPath<M> | ComputedSortField>;
     /**
      * Relations to include in the response.
      *

package/dist/controllers/data_driver.d.ts

@@ -1,6 +1,7 @@
 import { RebaseApiError } from "../errors";
 import type { EntityStatus, EntityValues } from "../types/entities";
 import type { CollectionConfig, FilterValues } from "../types/collections";
+import type { OrderByTuple } from "../types/filter-operators";
 import type { RebaseCallContext } from "../call_context";
 import type { LogicalCondition } from "./data";
 /**
@@ -98,10 +99,25 @@ export interface FetchCollectionProps<M extends Record<string, unknown> = Record
     limit?: number;
     offset?: number;
     startAfter?: unknown;
-    orderBy?: string;
+    /**
+     * The sort, in either of two spellings:
+     *
+     * - a field name, whose direction is the separate `order` below — the
+     *   original single-column contract, which every existing driver reads;
+     * - a list of `[field, direction]` tuples applied in order of significance,
+     *   which carries a multi-column sort and ignores `order` entirely.
+     *
+     * `normalizeDriverOrderBy` in `@rebasepro/common` collapses the pair to the
+     * list form. A driver that has not been taught the list form should read it
+     * through that helper rather than assume a string: handed an array, `String()`
+     * would produce a field name like `roles,asc` and the sort would 400 (or,
+     * with unknown-field warnings on, silently vanish).
+     */
+    orderBy?: string | OrderByTuple[];
     searchString?: string;
     /** Ask each row which declared search field matched — populates `_matches`. */
     searchExplain?: boolean;
+    /** Direction for the string form of `orderBy`. Ignored when `orderBy` is a list. */
     order?: "desc" | "asc";
     /** Vector similarity search configuration */
     vectorSearch?: VectorSearchParams;
@@ -393,7 +409,8 @@ export interface RestFetchService {
         filter?: FilterValues<string>;
         /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
         logical?: LogicalCondition;
-        orderBy?: string;
+        /** See `FetchCollectionProps.orderBy`: a field name plus `order`, or a list of tuples. */
+        orderBy?: string | OrderByTuple[];
         order?: "desc" | "asc";
         limit?: number;
         offset?: number;
@@ -404,6 +421,31 @@ export interface RestFetchService {
         databaseId?: string;
         vectorSearch?: VectorSearchParams;
     }, include?: string[]): Promise<Record<string, unknown>[]>;
+    /**
+     * `count`/`sum`/`avg`/`min`/`max` over the rows a filter selects,
+     * optionally grouped.
+     *
+     * Optional, and the REST route answers 501 where a driver does not
+     * implement it — an aggregate is not a thing to approximate, and an empty
+     * result set would read as "nothing matched".
+     *
+     * Any implementation **must apply the same row-level authorization as a
+     * read**. An aggregate is an efficient way to learn about rows you cannot
+     * select, and `count(*)` over a table whose policies would return nothing
+     * has to be zero.
+     */
+    aggregate?(collectionPath: string, options: {
+        aggregates: {
+            fn: "count" | "sum" | "avg" | "min" | "max";
+            field?: string;
+            alias: string;
+        }[];
+        groupBy?: string[];
+        filter?: FilterValues<string>;
+        logical?: LogicalCondition;
+        searchString?: string;
+        limit?: number;
+    }): Promise<Record<string, unknown>[]>;
     /**
      * Fetch a single flattened entity with optional relation includes.
      */