@rebasepro/types 0.8.0 → 0.9.1-canary.09aaf62

package/src/types/collections.ts

@@ -1,6 +1,6 @@
 import React, { Dispatch, SetStateAction } from "react";
 import type { Entity, EntityStatus, EntityValues } from "./entities";
-import type { EntityCallbacks } from "./entity_callbacks";
+import type { CollectionCallbacks } from "./entity_callbacks";
 
 import type { EnumValues, Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
 import type { ExportConfig } from "./export_import";
@@ -13,17 +13,17 @@ import type { EntityAction } from "./entity_actions";
 import type { PolicyExpression } from "./policy";
 import type { ComponentRef } from "./component_ref";
 import type { CollectionComponentOverrideMap } from "./component_overrides";
-import type { WhereFilterOp, FilterValues, FilterPreset } from "./filter-operators";
+import type { WhereFilterOp, FilterValues, FilterPreset, OrderByTuple } from "./filter-operators";
 
 /**
  * Base interface containing all driver-agnostic collection properties.
- * Use {@link PostgresCollection} or {@link FirebaseCollection} for
- * driver-specific type safety, or {@link EntityCollection} when you
+ * Use {@link PostgresCollectionConfig} or {@link FirebaseCollectionConfig} for
+ * driver-specific type safety, or {@link CollectionConfig} when you
  * need to handle any collection regardless of backend.
  *
  * @group Models
  */
-export interface BaseEntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+export interface BaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
 
     /**
      * You can set an alias that will be used internally instead of the collection name.
@@ -56,14 +56,14 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      *
      * Custom drivers can set this directly to expose child collections to the UI.
      */
-    childCollections?: () => EntityCollection<Record<string, unknown>>[];
+    childCollections?: () => CollectionConfig<Record<string, unknown>>[];
 
 
     /**
      * The data source this collection belongs to — the routing key shared by
      * the frontend router and the backend driver registry. It points at a
      * {@link DataSourceDefinition} registered on `<Rebase dataSources>` (front)
-     * and `initRebase({ dataSources })` (back).
+     * and `initializeRebaseBackend({ dataSources })` (back).
      *
      * If not specified, the default data source `"(default)"` is used, which
      * for a standard Rebase app is the server-mediated Postgres backend.
@@ -81,8 +81,8 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * The database engine backing this collection (`"postgres"`, `"firestore"`,
      * `"mongodb"`, or a custom id).
      *
-     * On concrete collection types ({@link PostgresCollection},
-     * {@link FirebaseCollection}, {@link MongoDBCollection}) this is a literal
+     * On concrete collection types ({@link PostgresCollectionConfig},
+     * {@link FirebaseCollectionConfig}, {@link MongoDBCollectionConfig}) this is a literal
      * discriminant. On the base type it is optional and gets stamped
      * automatically during collection normalization from the registered
      * {@link DataSourceDefinition}.
@@ -103,7 +103,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     databaseId?: string;
 
     /**
-     * Set of properties that compose an entity
+     * Set of properties that compose a entity
      */
     properties: Properties;
 
@@ -145,13 +145,13 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     readonly titleProperty?: Extract<keyof M, string> | (string & {});
 
     /**
-     * When editing an entity, you can choose to open the entity in a side dialog
+     * When editing a entity, you can choose to open the entity in a side dialog
      * or in a full screen dialog. Defaults to `full_screen`.
      */
     openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
 
     /**
-     * Controls what happens when a user clicks on an entity in the collection view.
+     * Controls what happens when a user clicks on a entity in the collection view.
      * - `"edit"` (default): Opens the entity in the edit form.
      * - `"view"`: Opens a read-only detail view with an "Edit" button.
      */
@@ -179,24 +179,23 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     auth?: boolean | AuthCollectionConfig;
 
     /**
-     * Opt out of the framework's default Row Level Security policies for
-     * authentication collections.
+     * Opt out of the framework's default Row Level Security policies.
      *
-     * When a collection has `auth` enabled, the schema generator automatically
-     * injects an admin-only write policy (INSERT/UPDATE/DELETE require the
-     * `admin` role, or the trusted server context) for any write operation that
-     * the collection does not already cover with an explicit `securityRules`
-     * entry. This makes privileged columns such as `roles` safe by default — a
-     * non-admin cannot modify the user row through the data API regardless of
-     * which code path issues the write.
+     * The schema generator automatically injects, for every collection, a
+     * baseline SELECT policy granting the trusted server context and the
+     * `admin` role read access (reads run under a restricted role, so RLS
+     * default-denies without it). For auth collections it additionally injects
+     * a self-read policy (`id = auth.uid()`) and an admin-only write gate
+     * (INSERT/UPDATE/DELETE require the `admin` role or the trusted server
+     * context), making privileged columns such as `roles` safe by default.
      *
-     * Defining your own write rule for an operation overrides the default for
-     * that operation. Set this flag to `true` to remove the default policies
+     * Author-defined `securityRules` are permissive and broaden access on top
+     * of these defaults. Set this flag to `true` to remove the defaults
      * entirely and take full responsibility for the collection's RLS.
      *
      * @default false
      */
-    disableDefaultAuthPolicies?: boolean;
+    disableDefaultPolicies?: boolean;
 
 
     /**
@@ -204,19 +203,18 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * If you are specifying your collection as code, the order is the same as the
      * one you define in `properties`. Additional columns are added at the
      * end of the list, if the order is not specified.
+     *
      * You can use this prop to hide some properties from the table view.
      * Note that if you set this prop, other ways to hide fields, like
      * `hidden` in the property definition, will be ignored.
      * `propertiesOrder` has precedence over `hidden`.
-     *     - For properties use the property key.
-     *     - For additional fields use the field key.
-     *     - If you have subcollections, you get a column for each subcollection,
-     *       with the path (or alias) as the subcollection, prefixed with
-     *       `subcollection:`. e.g. `subcollection:orders`.
-     * You can use this prop to hide some properties from the table view.
-     * Note that if you set this prop, other ways to hide fields, like
-     * `hidden` in the property definition,will be ignored.
-     * `propertiesOrder` has precedence over `hidden`.
+     *
+     * Supported entry formats:
+     *     - For properties, use the property key.
+     *     - For additional fields, use the field key.
+     *     - Child collections (Firestore subcollections, or Postgres relations
+     *       with `many` cardinality) each get a column with id
+     *       `subcollection:<slug>`, e.g. `subcollection:orders`.
      */
     propertiesOrder?: (Extract<keyof M, string> | (string & {}) | string | `subcollection:${string}`)[];
 
@@ -233,11 +231,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     selectionEnabled?: boolean;
 
     /**
-     * This interface defines all the callbacks that can be used when an entity
+     * This interface defines all the callbacks that can be used when a entity
      * is being created, updated or deleted.
      * Useful for adding your own logic or blocking the execution of the operation.
      */
-    readonly callbacks?: EntityCallbacks<M, USER>;
+    readonly callbacks?: CollectionCallbacks<M, USER>;
 
     /**
      * Pass your own selection controller if you want to control selected
@@ -287,7 +285,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * applied in the collection.
      * e.g. `sort: ["order", "asc"]`
      */
-    readonly sort?: [Extract<keyof M, string> | (string & {}), "asc" | "desc"];
+    readonly sort?: OrderByTuple<Extract<keyof M, string> | (string & {})>;
 
     /**
      * You can add additional fields to the collection view by implementing
@@ -318,7 +316,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
 
     /**
      * If you want to open custom views or subcollections by default when opening the edit
-     * view of an entity, you can specify the path to the view here.
+     * view of a entity, you can specify the path to the view here.
      * The path is relative to the current collection. For example if you have a collection
      * that has a custom view as well as a subcollection that refers to another entity, you can
      * either specify the path to the custom view or the path to the subcollection.
@@ -362,7 +360,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     metadata?: Record<string, unknown>;
 
     /**
-     * Width of the side dialog (in pixels) when opening an entity in this collection.
+     * Width of the side dialog (in pixels) when opening a entity in this collection.
      */
     sideDialogWidth?: number | string;
 
@@ -384,12 +382,24 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      */
     history?: boolean;
 
+    /**
+     * Whether a write naming a field this collection does not declare is
+     * rejected with a 400. Defaults to `true`.
+     *
+     * Set to `false` to let unknown keys through to the database, which is what
+     * happened before this existed: a typo reached the INSERT and came back as
+     * a Postgres error about a column, or — where a column really does exist
+     * that the config never declared, populated by a trigger or a default —
+     * quietly worked. The second case is the reason for the escape hatch.
+     */
+    strictWrites?: boolean;
+
     /**
      * Should local changes be backed up in local storage, to prevent data loss on
      * accidental navigations.
-     * - `manual_apply`: When the user navigates back to an entity with local changes,
+     * - `manual_apply`: When the user navigates back to a entity with local changes,
      *   they will be prompted to restore the changes.
-     * - `auto_apply`: When the user navigates back to an entity with local changes,
+     * - `auto_apply`: When the user navigates back to a entity with local changes,
      *   the changes will be automatically applied.
      * - `false`: Local changes will not be backed up.
      * Defaults to `manual_apply`.
@@ -458,7 +468,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Security rules for this collection (Row Level Security).
      * When defined, the backend enforces access control policies.
      */
-    securityRules?: SecurityRule[];
+    securityRules?: readonly SecurityRule[];
 
     /**
      * Collection-scoped component overrides. These take precedence over
@@ -471,7 +481,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      *
      * @example
      * ```tsx
-     * const productsCollection: PostgresCollection = {
+     * const productsCollection: PostgresCollectionConfig = {
      *     name: "Products",
      *     slug: "products",
      *     table: "products",
@@ -492,13 +502,13 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
  * A collection backed by PostgreSQL (or any SQL database).
  * Adds support for SQL-style relations (JOINs) and Row Level Security.
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only SQL-relevant fields appear.
  *
  * @group Models
  */
-export interface PostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
-    extends BaseEntityCollection<M, USER> {
+export interface PostgresCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
+    extends BaseCollectionConfig<M, USER> {
     properties: PostgresProperties;
 
     /**
@@ -526,7 +536,7 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
     relations?: Relation[];
 
     /**
-     * Security rules for this collection (Supabase-style Row Level Security).
+     * Security rules for this collection (PostgreSQL Row Level Security).
      * When defined, the schema generator will enable RLS on the table and
      * create the corresponding PostgreSQL policies.
      *
@@ -540,27 +550,27 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
      * - `auth.roles()` — comma-separated app role IDs
      * - `auth.jwt()`   — full JWT claims as JSONB
      */
-    securityRules?: SecurityRule[];
+    securityRules?: readonly SecurityRule[];
 }
 
 /**
  * A collection backed by Firebase / Firestore.
  * Adds support for subcollections (nested document collections).
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only Firestore-relevant fields appear.
  *
  * @group Models
  */
-export interface FirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
-    extends BaseEntityCollection<M, USER> {
+export interface FirebaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
+    extends BaseCollectionConfig<M, USER> {
     /**
      * The database engine for this collection. Must be set to `"firestore"`.
      */
     engine: "firestore";
 
     /**
-     * Set of properties that compose an entity.
+     * Set of properties that compose a entity.
      * Firestore collections support `reference` properties but not `relation`.
      */
     properties: FirebaseProperties;
@@ -572,7 +582,7 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
      *
      * @example
      * ```typescript
-     * const fsCustomer: FirebaseCollection = {
+     * const fsCustomer: FirebaseCollectionConfig = {
      *     slug: "fs_customer",        // URL: /c/fs_customer
      *     path: "customer",           // Firestore path: customer
      *     name: "Customers (Firestore)",
@@ -586,21 +596,21 @@ export interface FirebaseCollection<M extends Record<string, unknown> = Record<s
     /**
      * You can add subcollections to your entity in the same way you define the root
      * collections. The collections added here will be displayed when opening
-     * the side dialog of an entity.
+     * the side dialog of a entity.
      */
-    subcollections?: () => EntityCollection<Record<string, unknown>>[];
+    subcollections?: () => CollectionConfig<Record<string, unknown>>[];
 }
 
 /**
  * A collection backed by MongoDB.
  *
- * Use this type instead of {@link EntityCollection} when you want
+ * Use this type instead of {@link CollectionConfig} when you want
  * compile-time safety that only MongoDB-relevant fields appear.
  *
  * @group Models
  */
-export interface MongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
-    extends BaseEntityCollection<M, USER> {
+export interface MongoDBCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
+    extends BaseCollectionConfig<M, USER> {
 
     /**
      * The database engine for this collection. Must be set to `"mongodb"`.
@@ -608,7 +618,7 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
     engine: "mongodb";
 
     /**
-     * Set of properties that compose an entity.
+     * Set of properties that compose a entity.
      * MongoDB collections support `reference` properties but not `relation`.
      */
     properties: MongoProperties;
@@ -620,7 +630,7 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
      *
      * @example
      * ```typescript
-     * const mongoCustomer: MongoDBCollection = {
+     * const mongoCustomer: MongoDBCollectionConfig = {
      *     slug: "mongo_customer",      // URL: /c/mongo_customer
      *     path: "customer",            // MongoDB collection: customer
      *     name: "Customers (MongoDB)",
@@ -634,25 +644,25 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
 
 /**
  * A collection backed by any data source.
- * This is a discriminated union — use {@link PostgresCollection},
- * {@link FirebaseCollection}, or {@link MongoDBCollection} for
+ * This is a discriminated union — use {@link PostgresCollectionConfig},
+ * {@link FirebaseCollectionConfig}, or {@link MongoDBCollectionConfig} for
  * driver-specific type safety.
  *
  * @group Models
  */
-export type EntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
-    | PostgresCollection<M, USER>
-    | FirebaseCollection<M, USER>
-    | MongoDBCollection<M, USER>;
+export type CollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> =
+    | PostgresCollectionConfig<M, USER>
+    | FirebaseCollectionConfig<M, USER>
+    | MongoDBCollectionConfig<M, USER>;
 
 /**
  * Type guard for PostgreSQL collections.
  * Returns true if the collection uses the Postgres engine (or the default engine).
  * @group Models
  */
-export function isPostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
-    collection: EntityCollection<M, USER>
-): collection is PostgresCollection<M, USER> {
+export function isPostgresCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
+    collection: CollectionConfig<M, USER>
+): collection is PostgresCollectionConfig<M, USER> {
     return !collection.engine || collection.engine === "postgres";
 }
 
@@ -660,9 +670,9 @@ export function isPostgresCollection<M extends Record<string, unknown> = Record<
  * Type guard for Firebase / Firestore collections.
  * @group Models
  */
-export function isFirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
-    collection: EntityCollection<M, USER>
-): collection is FirebaseCollection<M, USER> {
+export function isFirebaseCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
+    collection: CollectionConfig<M, USER>
+): collection is FirebaseCollectionConfig<M, USER> {
     return collection.engine === "firestore";
 }
 
@@ -670,9 +680,9 @@ export function isFirebaseCollection<M extends Record<string, unknown> = Record<
  * Type guard for MongoDB collections.
  * @group Models
  */
-export function isMongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
-    collection: EntityCollection<M, USER>
-): collection is MongoDBCollection<M, USER> {
+export function isMongoDBCollectionConfig<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
+    collection: CollectionConfig<M, USER>
+): collection is MongoDBCollectionConfig<M, USER> {
     return collection.engine === "mongodb";
 }
 
@@ -682,12 +692,12 @@ export function isMongoDBCollection<M extends Record<string, unknown> = Record<s
  * otherwise falls back to `slug`.
  */
 export function getCollectionDataPath<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
-    collection: EntityCollection<M, USER>
+    collection: CollectionConfig<M, USER>
 ): string {
-    if (isFirebaseCollection(collection) && collection.path) {
+    if (isFirebaseCollectionConfig(collection) && collection.path) {
         return collection.path;
     }
-    if (isMongoDBCollection(collection) && collection.path) {
+    if (isMongoDBCollectionConfig(collection) && collection.path) {
         return collection.path;
     }
     return collection.slug;
@@ -704,9 +714,9 @@ export function getCollectionDataPath<M extends Record<string, unknown> = Record
  * @group Models
  */
 export function getDeclaredSubcollections<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
-    collection: EntityCollection<M, USER>
-): (() => EntityCollection<Record<string, unknown>>[]) | undefined {
-    return (collection as FirebaseCollection<M, USER>).subcollections;
+    collection: CollectionConfig<M, USER>
+): (() => CollectionConfig<Record<string, unknown>>[]) | undefined {
+    return (collection as FirebaseCollectionConfig<M, USER>).subcollections;
 }
 
 
@@ -741,7 +751,7 @@ export type ViewMode = "list" | "table" | "cards" | "kanban";
  *
  * @group Models
  */
-export interface CollectionActionsProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User, EC extends EntityCollection<M> = EntityCollection<M>> {
+export interface CollectionActionsProps<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User, EC extends CollectionConfig<M> = CollectionConfig<M>> {
     /**
      * Full collection path of this entity. This is the full path, like
      * `users/1234/addresses`
@@ -807,7 +817,7 @@ export interface CollectionActionsProps<M extends Record<string, unknown> = Reco
 
 /**
  * Use this controller to retrieve the selected entities or modify them in
- * an {@link EntityCollection}
+ * an {@link CollectionConfig}
  * @group Models
  */
 export interface SelectionController<M extends Record<string, unknown> = Record<string, unknown>> {
@@ -894,16 +904,16 @@ export interface AdditionalFieldDelegate<M extends Record<string, unknown> = Rec
 }
 
 
-export type InferCollectionType<S extends EntityCollection> = S extends EntityCollection<infer M> ? M : never;
+export type InferCollectionConfigType<S extends CollectionConfig> = S extends CollectionConfig<infer M> ? M : never;
 
 /**
- * Used in the {@link EntityCollection#defaultSelectedView} to define the default
+ * Used in the {@link CollectionConfig#defaultSelectedView} to define the default
  * @group Models
  */
 export type DefaultSelectedViewBuilder = (params: DefaultSelectedViewParams) => string | undefined;
 
 /**
- * Used in the {@link EntityCollection#defaultSelectedView} to define the default
+ * Used in the {@link CollectionConfig#defaultSelectedView} to define the default
  * @group Models
  */
 export type DefaultSelectedViewParams = {
@@ -961,7 +971,7 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
 /**
  * Flexible Row Level Security rule for a collection.
  *
- * Inspired by Supabase's approach to PostgreSQL RLS. Rules can range from
+ * Built on PostgreSQL Row Level Security. Rules can range from
  * simple convenience shortcuts to fully custom SQL expressions, giving you the
  * full power of PostgreSQL Row Level Security.
  *
@@ -974,7 +984,7 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
  *
  * **How rules combine:** PostgreSQL evaluates all matching policies for an
  * operation. Permissive rules are OR'd together (any one passing is enough).
- * Restrictive rules are AND'd (all must pass). This mirrors Supabase behavior.
+ * Restrictive rules are AND'd (all must pass). This is standard PostgreSQL RLS behavior.
  *
  * **Mutual exclusivity:** `ownerField`, `access`, structured `condition`, and
  * raw SQL (`using`/`withCheck`) cannot be combined. The type system enforces
@@ -1041,7 +1051,7 @@ export interface SecurityRuleBase {
      * // Equivalent to operation: "all"
      * { operations: ["all"], ownerField: "user_id" }
      */
-    operations?: SecurityOperation[];
+    operations?: readonly SecurityOperation[];
 
     /**
      * Whether this policy is `"permissive"` (default) or `"restrictive"`.
@@ -1051,7 +1061,7 @@ export interface SecurityRuleBase {
      * - **restrictive**: Restrictive policies are AND'd with all permissive
      *   policies — they act as additional gates that *must* also pass.
      *
-     * This is the same model as PostgreSQL / Supabase.
+     * This is the standard PostgreSQL RLS model.
      *
      * @default "permissive"
      */
@@ -1084,7 +1094,7 @@ export interface SecurityRuleBase {
      * // Admins have unfiltered read access to all rows
      * { operation: "select", roles: ["admin"], using: "true" }
      */
-    roles?: string[];
+    roles?: readonly string[];
 
     // ── Advanced: native PostgreSQL role targeting ───────────────────────
 
@@ -1109,7 +1119,7 @@ export interface SecurityRuleBase {
      * // Only apply this policy when connected as `app_role`
      * { operation: "select", access: "public", pgRoles: ["app_role"] }
      */
-    pgRoles?: string[];
+    pgRoles?: readonly string[];
 }
 
 /**

package/src/types/component_overrides.ts

@@ -1,4 +1,6 @@
 import type React from "react";
+import type { Property } from "./properties";
+import type { WhereFilterOp } from "./filter-operators";
 
 // ── Scoped component name unions ──────────────────────────────────────
 
@@ -43,13 +45,14 @@ export type CollectionComponentName =
     | "Collection.Card"
     | "Collection.EmptyState"
     | "Collection.Actions"
+    | "Collection.FilterField"
 
     // ── Entity / Form ──
     | "Entity.Form"
-    | "Entity.FormActions"
-    | "Entity.DetailView"
+    | "EditView.FormActions"
+    | "DetailView"
     | "Entity.SidePanel"
-    | "Entity.Preview"
+    | "EntityPreview"
     | "Entity.MissingReference";
 
 /**
@@ -58,6 +61,70 @@ export type CollectionComponentName =
  */
 export type OverridableComponentName = AppComponentName | CollectionComponentName;
 
+/**
+ * Props received by a filter field component — whether it is a built-in
+ * per-type field, a property-level replacement (`property.ui.Filter`), or a
+ * `"Collection.FilterField"` override.
+ *
+ * The `operators` list is **already resolved**: it is the intersection of the
+ * engine's {@link DataSourceCapabilities.filterOperators}, the property-type
+ * defaults, and any `property.ui.filterOperators` narrowing. A custom field
+ * should only offer operators from this list — anything else may throw at
+ * query time on engines that cannot execute it.
+ *
+ * @example
+ * ```tsx
+ * function MyStatusFilter({ value, setValue, operators }: FilterFieldBindingProps) {
+ *     return (
+ *         <select
+ *             value={value?.[1] as string ?? ""}
+ *             onChange={e => setValue(e.target.value ? ["==", e.target.value] : undefined)}>
+ *             <option value="">Any</option>
+ *             <option value="active">Active</option>
+ *             <option value="archived">Archived</option>
+ *         </select>
+ *     );
+ * }
+ * ```
+ *
+ * @group Component Overrides
+ */
+export interface FilterFieldBindingProps {
+    /** Key of the property being filtered (the column id). */
+    propertyKey: string;
+
+    /**
+     * The resolved property. For array properties this is the **item**
+     * property (`property.of`), with `isArray` set to true.
+     */
+    property: Property;
+
+    /** True when the underlying property is an array of `property`. */
+    isArray: boolean;
+
+    /**
+     * Operators this field may offer, already narrowed by engine
+     * capabilities, property-type defaults, and `property.ui.filterOperators`.
+     */
+    operators: readonly WhereFilterOp[];
+
+    /** Current filter condition for this property, if any. */
+    value?: [WhereFilterOp, unknown];
+
+    /** Set (or clear, with `undefined`) the filter condition. */
+    setValue: (value?: [WhereFilterOp, unknown]) => void;
+
+    /** Display title for the field (usually the property name). */
+    title?: string;
+
+    /**
+     * Coordination flags used by fields that open their own dialogs
+     * (e.g. the reference picker hides the parent filters dialog).
+     */
+    hidden?: boolean;
+    setHidden?: (hidden: boolean) => void;
+}
+
 // ── Override entry ────────────────────────────────────────────────────
 
 /**
@@ -89,7 +156,7 @@ export type OverridableComponentName = AppComponentName | CollectionComponentNam
  *
  * @group Component Overrides
  */
-export interface ComponentOverride<P = any> {
+export interface ComponentOverride<P = Record<string, unknown>> {
     /**
      * The replacement component. Receives the same props as the built-in
      * component it replaces.
@@ -161,7 +228,7 @@ export type CollectionComponentOverrideMap = {
  *         "HomePage": { Component: MyDashboard },
  *
  *         // Collection defaults: apply to ALL collections
- *         "Entity.FormActions": {
+ *         "EditView.FormActions": {
  *             Component: MyFormActions,
  *             wrap: true
  *         },

package/src/types/cron.ts

@@ -4,7 +4,7 @@ import type { RebaseClient } from "../controllers/client";
  * Cron Job type definitions for Rebase.
  *
  * These types define the shape of cron job definitions, their runtime
- * status, and execution log entries — used across server-core, client,
+ * status, and execution log entries — used across server, client,
  * and studio packages.
  */
 
@@ -60,7 +60,16 @@ export interface CronJobContext {
     /** A simple logger scoped to this job run. */
     log: (...args: unknown[]) => void;
 
-    /** The RebaseClient instance to interact with the database. */
+    /**
+     * The server-side {@link RebaseClient}. This is the **same singleton**
+     * exposed as `rebase` (imported from `@rebasepro/server`) and as
+     * `context` in collection callbacks — it is only named `client` here.
+     *
+     * Its data plane (`client.data`) runs with **admin privileges and bypasses
+     * RLS** (`{ uid: "service", roles: ["admin"] }`). There is no per-request
+     * user in a cron, so treat every query as fully trusted and scope your own
+     * filters explicitly.
+     */
     client: RebaseClient;
 }