@rebasepro/types 0.6.1 → 0.8.0

package/src/types/collections.ts

@@ -2,16 +2,18 @@ import React, { Dispatch, SetStateAction } from "react";
 import type { Entity, EntityStatus, EntityValues } from "./entities";
 import type { EntityCallbacks } from "./entity_callbacks";
 
-import type { EnumValues, Properties } from "./properties";
+import type { EnumValues, Properties, PostgresProperties, FirebaseProperties, MongoProperties } from "./properties";
 import type { ExportConfig } from "./export_import";
-import type { EntityOverrides } from "./entity_overrides";
+
 import type { User } from "../users";
 import type { RebaseContext } from "../rebase_context";
 import type { Relation } from "./relations";
 import type { EntityCustomView, FormViewConfig } from "./entity_views";
 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";
 
 /**
  * Base interface containing all driver-agnostic collection properties.
@@ -58,34 +60,45 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
 
 
     /**
-     * Which driver handles this collection.
-     * Use this to route collections to different backends:
-     * - `"postgres"` - Route to PostgreSQL backend
-     * - `"firestore"` - Route to Firestore (client-side)
-     * - `"mongodb"` - Route to MongoDB backend
-     * - Custom IDs for your own driver implementations
+     * 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).
      *
-     * If not specified, the default driver `"(default)"` is used.
+     * If not specified, the default data source `"(default)"` is used, which
+     * for a standard Rebase app is the server-mediated Postgres backend.
      *
      * @example
-     * // Simple - no driver needed for default
+     * // Default data source (server-mediated Postgres)
      * { slug: "products" }
      *
-     * // Firestore collection (client-side real-time)
-     * { slug: "analytics", driver: "firestore" }
+     * // A direct-transport Firestore data source registered as "analytics"
+     * { slug: "events", dataSource: "analytics" }
+     */
+    dataSource?: string;
+
+    /**
+     * The database engine backing this collection (`"postgres"`, `"firestore"`,
+     * `"mongodb"`, or a custom id).
      *
-     * // Multiple databases within a driver
-     * { slug: "orders", driver: "postgres", databaseId: "orders_db" }
+     * On concrete collection types ({@link PostgresCollection},
+     * {@link FirebaseCollection}, {@link MongoDBCollection}) this is a literal
+     * discriminant. On the base type it is optional and gets stamped
+     * automatically during collection normalization from the registered
+     * {@link DataSourceDefinition}.
+     *
+     * Prefer setting {@link dataSource} and letting the engine be resolved.
      */
-    driver?: string;
+    engine?: string;
 
     /**
-     * Which database within the driver.
+     * Which database within the engine.
      * - For Firestore: The Firestore database ID (e.g., for multi-database projects)
      * - For PostgreSQL: Schema or database name
      * - For MongoDB: Database name
      *
-     * If not specified, the default database of the driver is used.
+     * If not specified, the default database of the engine is used. Resolved
+     * from the collection's {@link DataSourceDefinition} when omitted here.
      */
     databaseId?: string;
 
@@ -165,6 +178,26 @@ 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.
+     *
+     * 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.
+     *
+     * Defining your own write rule for an operation overrides the default for
+     * that operation. Set this flag to `true` to remove the default policies
+     * entirely and take full responsibility for the collection's RLS.
+     *
+     * @default false
+     */
+    disableDefaultAuthPolicies?: boolean;
+
 
     /**
      * Order in which the properties are displayed.
@@ -269,8 +302,8 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
 
     /**
      * Can the elements in this collection be edited inline in the collection
-     * view. If this flag is set to false but `permissions.edit` is `true`, entities
-     * can still be edited in the side panel
+     * view. Even when inline editing is disabled, entities can still be
+     * edited in the side panel (subject to `securityRules`).
      */
     inlineEditing?: boolean;
 
@@ -322,9 +355,11 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
     ownerId?: string;
 
     /**
-     * Overrides for the entity view, like the data source or the storage source.
+     * Arbitrary key-value metadata for external consumers.
+     * Not interpreted by Rebase — passed through serialization unchanged.
+     * Used by domain apps to store custom per-collection config.
      */
-    overrides?: EntityOverrides;
+    metadata?: Record<string, unknown>;
 
     /**
      * Width of the side dialog (in pixels) when opening an entity in this collection.
@@ -375,7 +410,7 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Possible values: "table", "cards", "kanban".
      * Defaults to all three: ["table", "cards", "kanban"].
      * Note: "kanban" will only be available if the collection has at least
-     * one string property with enumValues defined, regardless of this setting.
+     * one string property with `enum` defined, regardless of this setting.
      */
     enabledViews?: ViewMode[];
 
@@ -464,13 +499,13 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
  */
 export interface PostgresCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
     extends BaseEntityCollection<M, USER> {
-    properties: Properties;
+    properties: PostgresProperties;
 
     /**
-     * The driver for this collection. For Postgres collections this
+     * The database engine for this collection. For Postgres collections this
      * can be omitted (Postgres is the default) or set to `"postgres"`.
      */
-    driver?: "postgres" | undefined;
+    engine?: "postgres" | undefined;
 
     /**
      * The PostgreSQL table name for this collection.
@@ -520,9 +555,33 @@ export interface PostgresCollection<M extends Record<string, unknown> = Record<s
 export interface FirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>
     extends BaseEntityCollection<M, USER> {
     /**
-     * The driver for this collection. Must be set to `"firestore"`.
+     * The database engine for this collection. Must be set to `"firestore"`.
      */
-    driver: "firestore";
+    engine: "firestore";
+
+    /**
+     * Set of properties that compose an entity.
+     * Firestore collections support `reference` properties but not `relation`.
+     */
+    properties: FirebaseProperties;
+
+    /**
+     * The Firestore collection path to query. Defaults to `slug` if not set.
+     * Use this when the Firestore path differs from the slug
+     * (e.g., when a PostgreSQL collection already uses the same slug).
+     *
+     * @example
+     * ```typescript
+     * const fsCustomer: FirebaseCollection = {
+     *     slug: "fs_customer",        // URL: /c/fs_customer
+     *     path: "customer",           // Firestore path: customer
+     *     name: "Customers (Firestore)",
+     *     engine: "firestore",
+     *     properties: { ... }
+     * };
+     * ```
+     */
+    path?: string;
 
     /**
      * You can add subcollections to your entity in the same way you define the root
@@ -544,9 +603,33 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
     extends BaseEntityCollection<M, USER> {
 
     /**
-     * The driver for this collection. Must be set to `"mongodb"`.
+     * The database engine for this collection. Must be set to `"mongodb"`.
+     */
+    engine: "mongodb";
+
+    /**
+     * Set of properties that compose an entity.
+     * MongoDB collections support `reference` properties but not `relation`.
      */
-    driver: "mongodb";
+    properties: MongoProperties;
+
+    /**
+     * The MongoDB collection name to use. Defaults to `slug` if not set.
+     * Use this when the MongoDB collection name differs from the slug
+     * (e.g., when a PostgreSQL collection already uses the same slug).
+     *
+     * @example
+     * ```typescript
+     * const mongoCustomer: MongoDBCollection = {
+     *     slug: "mongo_customer",      // URL: /c/mongo_customer
+     *     path: "customer",            // MongoDB collection: customer
+     *     name: "Customers (MongoDB)",
+     *     engine: "mongodb",
+     *     properties: { ... }
+     * };
+     * ```
+     */
+    path?: string;
 }
 
 /**
@@ -562,33 +645,15 @@ export type EntityCollection<M extends Record<string, unknown> = Record<string,
     | FirebaseCollection<M, USER>
     | MongoDBCollection<M, USER>;
 
-// ── Capability intersection types ─────────────────────────────────────
-// Use these after a `getDataSourceCapabilities()` guard to safely access
-// driver-specific fields without coupling to a concrete driver type.
-
-/**
- * An EntityCollection that supports SQL-style relations (e.g. Postgres).
- * @deprecated Use `EntityCollection` directly — `table`, `relations`, and `securityRules` are now on `BaseEntityCollection`.
- */
-export type CollectionWithRelations<M extends Record<string, unknown> = Record<string, unknown>> =
-    EntityCollection<M> & { table?: string; relations?: Relation[]; securityRules?: SecurityRule[] };
-
-/** An EntityCollection that supports subcollections (e.g. Firestore). */
-export type CollectionWithSubcollections<M extends Record<string, unknown> = Record<string, unknown>> =
-    EntityCollection<M> & { subcollections?: () => EntityCollection<Record<string, unknown>>[] };
-
-
-// ── Type guards ───────────────────────────────────────────────────────
-
 /**
  * Type guard for PostgreSQL collections.
- * Returns true if the collection uses the Postgres driver (or the default driver).
+ * 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> {
-    return !collection.driver || collection.driver === "postgres";
+    return !collection.engine || collection.engine === "postgres";
 }
 
 /**
@@ -598,7 +663,7 @@ export function isPostgresCollection<M extends Record<string, unknown> = Record<
 export function isFirebaseCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
     collection: EntityCollection<M, USER>
 ): collection is FirebaseCollection<M, USER> {
-    return collection.driver === "firestore";
+    return collection.engine === "firestore";
 }
 
 /**
@@ -608,7 +673,40 @@ export function isFirebaseCollection<M extends Record<string, unknown> = Record<
 export function isMongoDBCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
     collection: EntityCollection<M, USER>
 ): collection is MongoDBCollection<M, USER> {
-    return collection.driver === "mongodb";
+    return collection.engine === "mongodb";
+}
+
+/**
+ * Returns the data path for a collection.
+ * For Firestore or MongoDB collections with a `path`, returns that value;
+ * otherwise falls back to `slug`.
+ */
+export function getCollectionDataPath<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(
+    collection: EntityCollection<M, USER>
+): string {
+    if (isFirebaseCollection(collection) && collection.path) {
+        return collection.path;
+    }
+    if (isMongoDBCollection(collection) && collection.path) {
+        return collection.path;
+    }
+    return collection.slug;
+}
+
+/**
+ * Reads a collection's driver-declared subcollections thunk (the `subcollections`
+ * field) independent of engine identity, so engine-agnostic code doesn't have to
+ * type-guard against a specific driver. Returns `undefined` when the collection
+ * declares none.
+ *
+ * Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
+ * whether the engine honours subcollections at all before reading them.
+ * @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;
 }
 
 
@@ -619,9 +717,9 @@ export function isMongoDBCollection<M extends Record<string, unknown> = Record<s
 export interface KanbanConfig<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Property key to use for Kanban board columns.
-     * Must reference a string property with enumValues defined.
+     * Must reference a string property with `enum` values defined.
      * Entities will be grouped into columns based on this property's value.
-     * The column order is determined by the order of enumValues in the property.
+     * The column order is determined by the order of `enum` values in the property.
      */
     columnProperty: Extract<keyof M, string> | (string & {});
 }
@@ -720,57 +818,8 @@ export interface SelectionController<M extends Record<string, unknown> = Record<
     toggleEntitySelection(entity: Entity<M>, newSelectedState?: boolean): void;
 }
 
-/**
- * Filter conditions in a `Query.where()` clause are specified using the
- * strings `<`, `<=`, `==`, `>=`, `>`, `array-contains`, `in`, and `array-contains-any`.
- * @group Models
- */
-export type WhereFilterOp =
-    | "<"
-    | "<="
-    | "=="
-    | "!="
-    | ">="
-    | ">"
-    | "array-contains"
-    | "in"
-    | "not-in"
-    | "array-contains-any";
-
-/**
- * Used to define filters applied in collections
- *
- * e.g. `{ age: [">=", 18] }`
- *
- * @group Models
- */
-export type FilterValues<Key extends string> =
-    Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
-
-/**
- * A pre-defined filter preset for quick access in the collection toolbar.
- * Users can select a preset to instantly apply a set of filters and
- * optionally a sort order.
- *
- * @group Models
- */
-export interface FilterPreset<Key extends string = string> {
-    /**
-     * Display label shown in the preset menu.
-     * If omitted, a summary is auto-generated from the filter keys.
-     */
-    label?: string;
-
-    /**
-     * The filter values to apply when this preset is selected.
-     */
-    filterValues: FilterValues<Key>;
-
-    /**
-     * Optional sort override to apply alongside the filter values.
-     */
-    sort?: [Key, "asc" | "desc"];
-}
+// Canonical filter types — re-exported from the single source-of-truth.
+export type { WhereFilterOp, FilterValues, WireFilterValues, FilterPreset } from "./filter-operators";
 
 
 /**
@@ -927,13 +976,26 @@ export type SecurityOperation = "select" | "insert" | "update" | "delete" | "all
  * operation. Permissive rules are OR'd together (any one passing is enough).
  * Restrictive rules are AND'd (all must pass). This mirrors Supabase behavior.
  *
- * **Mutual exclusivity:** `ownerField`, `access`, and raw SQL (`using`/`withCheck`)
- * cannot be combined. The type system enforces this — attempting to set
- * conflicting fields will produce a compile-time error.
+ * **Mutual exclusivity:** `ownerField`, `access`, structured `condition`, and
+ * raw SQL (`using`/`withCheck`) cannot be combined. The type system enforces
+ * this — attempting to set conflicting fields will produce a compile-time
+ * error.
+ *
+ * **Which form to reach for:** prefer the structured {@link StructuredSecurityRule}
+ * (`condition`/`check`) or the shortcuts (`ownerField`, `access`, `roles`). These
+ * are engine-agnostic and evaluated identically by the database and the admin UI,
+ * so the UI never shows an action the database will reject. Raw SQL
+ * ({@link RawSQLSecurityRule}) keeps full PostgreSQL power but is Postgres-only
+ * and server-authoritative (the UI cannot evaluate arbitrary SQL locally).
  *
  * @group Models
  */
-export type SecurityRule = OwnerSecurityRule | PublicSecurityRule | RawSQLSecurityRule | RolesOnlySecurityRule;
+export type SecurityRule =
+    | OwnerSecurityRule
+    | PublicSecurityRule
+    | StructuredSecurityRule
+    | RawSQLSecurityRule
+    | RolesOnlySecurityRule;
 
 /**
  * Shared fields for all SecurityRule variants.
@@ -1003,11 +1065,16 @@ export interface SecurityRuleBase {
      * application roles managed by Rebase, stored in the `rebase.user_roles`
      * table, and injected into each transaction via `auth.roles()`.
      *
-     * Generates a condition like:
-     *   `auth.roles() ~ '<role1>|<role2>'`
+     * Generates a safe array-overlap condition — the user passes if they hold
+     * *any* of the listed roles:
+     *   `string_to_array(auth.roles(), ',') && ARRAY['<role1>', '<role2>']`
      *
-     * Can be combined with `ownerField`, `access`, or raw `using`/`withCheck`.
-     * When combined, the role check is AND'd with the other condition.
+     * (Note: this is a true set intersection, NOT a regex/substring match, so
+     * a role named `admin` never matches `nonadmin` or `superadmin`.)
+     *
+     * Can be combined with `ownerField`, `access`, `condition`, or raw
+     * `using`/`withCheck`. When combined, the role check is AND'd with the
+     * other condition.
      *
      * @example
      * // Only admins can delete
@@ -1062,6 +1129,8 @@ export interface OwnerSecurityRule extends SecurityRuleBase {
     access?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
 }
 
 /**
@@ -1086,12 +1155,61 @@ export interface PublicSecurityRule extends SecurityRuleBase {
     ownerField?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
+}
+
+/**
+ * Security rule expressed as a structured, engine-agnostic
+ * {@link PolicyExpression}. This is the **recommended** way to write a
+ * non-trivial condition: it compiles to PostgreSQL `USING`/`WITH CHECK` SQL
+ * *and* is evaluated identically by the admin UI, so the UI can never show an
+ * action the database will reject.
+ *
+ * Cannot be combined with `ownerField`, `access`, or raw `using`/`withCheck`.
+ *
+ * @example
+ * // Owner, or any user holding the `moderator` role
+ * {
+ *   operation: "update",
+ *   condition: policy.or(
+ *       policy.compare(policy.field("user_id"), "eq", policy.authUid()),
+ *       policy.rolesOverlap(["moderator"])
+ *   )
+ * }
+ *
+ * @group Models
+ */
+export interface StructuredSecurityRule extends SecurityRuleBase {
+    /**
+     * Structured condition for the `USING` clause — which *existing* rows are
+     * visible / can be modified / deleted (SELECT, UPDATE, DELETE).
+     */
+    condition: PolicyExpression;
+
+    /**
+     * Structured condition for the `WITH CHECK` clause — which *new/updated*
+     * row values are allowed (INSERT, UPDATE). Defaults to `condition` when
+     * omitted, mirroring PostgreSQL's own behavior.
+     */
+    check?: PolicyExpression;
+
+    ownerField?: never;
+    access?: never;
+    using?: never;
+    withCheck?: never;
 }
 
 /**
  * Security rule using raw SQL expressions for full PostgreSQL RLS power.
  *
- * Cannot be combined with `ownerField` or `access`.
+ * **Postgres-only and server-authoritative.** Arbitrary SQL cannot be
+ * evaluated by the admin UI, so a rule using this form is treated as *unknown*
+ * client-side (never silently allowed) and its effect on visible actions is
+ * reflected from the server. For conditions that should also drive the UI
+ * precisely, prefer the structured {@link StructuredSecurityRule}.
+ *
+ * Cannot be combined with `ownerField`, `access`, or structured `condition`.
  *
  * You can reference columns via `{column_name}` which will be resolved to
  * `table.column_name` in the generated Drizzle code.
@@ -1129,6 +1247,8 @@ export interface RawSQLSecurityRule extends SecurityRuleBase {
 
     ownerField?: never;
     access?: never;
+    condition?: never;
+    check?: never;
 }
 
 /**
@@ -1149,6 +1269,8 @@ export interface RolesOnlySecurityRule extends SecurityRuleBase {
     access?: never;
     using?: never;
     withCheck?: never;
+    condition?: never;
+    check?: never;
 }
 
 /**

package/src/types/data_source.ts

@@ -53,6 +53,90 @@ export interface DataSourceCapabilities {
  */
 export type DataSourceFeatures = Omit<DataSourceCapabilities, "key" | "label">;
 
+/**
+ * The default data-source key, used when a collection does not name a
+ * `dataSource`. Shared by the frontend router and the backend driver
+ * registry so both agree on "the default database".
+ * @group Models
+ */
+export const DEFAULT_DATA_SOURCE_KEY = "(default)";
+
+/**
+ * How the *frontend* reaches a data source.
+ *
+ * - `"server"` — through the Rebase backend (the `RebaseClient`). The backend
+ *   holds the actual database adapter and routes by data-source key. This is
+ *   the default and covers Postgres, MongoDB, and any other server-mediated
+ *   engine.
+ * - `"direct"` — straight from the client to the external backend via its own
+ *   SDK driver (e.g. Firestore). The Rebase backend is not in the data path.
+ * - `"custom"` — a developer-supplied {@link DataDriver}, transport unspecified.
+ *
+ * @group Models
+ */
+export type DataSourceTransport = "server" | "direct" | "custom";
+
+/**
+ * Declarative definition of a data source — a named place data lives.
+ *
+ * Declared once and shared front and back: the frontend uses it to decide
+ * transport (client vs direct driver), the backend uses the same `key` to
+ * resolve a database adapter, and the editor derives capabilities from
+ * `engine`. Collections reference a definition by its `key` via
+ * `collection.dataSource`.
+ *
+ * @group Models
+ */
+export interface DataSourceDefinition {
+    /**
+     * Unique identifier for this data source. Collections point at it via
+     * `dataSource`. Defaults to {@link DEFAULT_DATA_SOURCE_KEY}.
+     */
+    key: string;
+
+    /**
+     * The engine backing this data source (e.g. `"postgres"`, `"mongodb"`,
+     * `"firestore"`, or a custom id). Determines the
+     * {@link DataSourceCapabilities} surfaced in the editor.
+     */
+    engine: string;
+
+    /**
+     * How the frontend reaches this source. Defaults to `"server"`.
+     */
+    transport: DataSourceTransport;
+
+    /**
+     * The physical database/schema/Firestore-database within the engine.
+     * Threaded to drivers/adapters as the existing `databaseId` runtime
+     * parameter. Defaults to the engine's own default.
+     */
+    databaseId?: string;
+
+    /** Human-readable label for the UI. */
+    label?: string;
+}
+
+/**
+ * The resolved data source for a collection: the single source of truth that
+ * the frontend router, backend registry, and editor all derive from.
+ * Produced by `resolveDataSource(collection, registry)`.
+ *
+ * @group Models
+ */
+export interface ResolvedDataSource {
+    /** Data-source key (routing key, shared front + back). */
+    key: string;
+    /** Engine backing the source (drives capabilities). */
+    engine: string;
+    /** Frontend transport. */
+    transport: DataSourceTransport;
+    /** Within-engine instance, if any (the `databaseId` runtime param). */
+    databaseId?: string;
+    /** Capabilities derived from {@link engine}. */
+    capabilities: DataSourceCapabilities;
+}
+
 // ── Built-in driver capabilities ─────────────────────────────────────
 
 /** @group Models */
@@ -127,13 +211,13 @@ const CAPABILITIES_REGISTRY: Record<string, DataSourceCapabilities> = {
 };
 
 /**
- * Look up capabilities for a given driver key.
- * If `driver` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+ * Look up capabilities for a given engine key.
+ * If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
  * @group Models
  */
-export function getDataSourceCapabilities(driver?: string): DataSourceCapabilities {
-    if (!driver) return POSTGRES_CAPABILITIES; // postgres is the default driver
-    return CAPABILITIES_REGISTRY[driver] ?? DEFAULT_CAPABILITIES;
+export function getDataSourceCapabilities(engine?: string): DataSourceCapabilities {
+    if (!engine) return POSTGRES_CAPABILITIES; // postgres is the default engine
+    return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
 }
 
 /**

package/src/types/entity_actions.tsx

@@ -69,7 +69,7 @@ export interface EntityAction<M extends Record<string, unknown> = Record<string,
 
 export type EntityActionClickProps<M extends Record<string, unknown>, USER extends User = User> = {
     entity?: Entity<M>;
-    context: RebaseContext<USER>;
+    context?: RebaseContext<USER>;
 
     path?: string;
     collection?: EntityCollection<M>;
@@ -93,7 +93,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     /**
      * If the action is rendered in the form, is it open in a side panel or full screen?
      */
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
 
     /**
      * Optional selection controller, present if the action is being called from a collection view