@marktiderman/genesis-core 1.3.0 → 1.5.0

package/dist/provider/index.d.ts

@@ -1,9 +1,12 @@
-import { D as DataProvider } from '../types-DUbRb8qV.js';
-export { A as ArrayFilter, B as BaseRecord, b as BulkChange, c as BulkResult, C as CreateParams, d as CreateResult, f as DeleteParams, g as DeleteResult, k as FilterParam, G as GetManyParams, l as GetManyResult, m as GetOneParams, n as GetOneResult, H as HistoryParams, I as Identifier, o as ImportParams, L as ListParams, p as ListResult, N as NullFilter, P as PaginationParam, R as RangeFilter, y as RowFailure, S as ScalarFilter, z as SortParam, U as UpdateParams, J as UpdateResult } from '../types-DUbRb8qV.js';
-export { D as DataWriteError, a as DataWriteErrorOptions, W as WriteOutcome, i as isDataWriteError } from '../write-outcome-aYToY3dK.js';
+import { D as DataProvider, I as Identifier, B as BaseRecord, j as InvalidationKey, W as WriteEvent } from '../types-Dsqqr9s7.js';
+export { A as ArrayFilter, a as BulkChange, b as BulkResult, C as CreateParams, c as CreateResult, d as DeleteParams, e as DeleteResult, F as FilterParam, G as GetManyParams, f as GetManyResult, g as GetOneParams, h as GetOneResult, H as HistoryParams, i as ImportParams, L as ListParams, k as ListResult, N as NullFilter, P as PaginationParam, R as RangeFilter, l as RowFailure, S as ScalarFilter, m as SortParam, U as UpdateParams, n as UpdateResult } from '../types-Dsqqr9s7.js';
+import { D as DataReadError, R as ReadOutcome, b as DataWriteError, W as WriteOutcome } from '../read-outcome-BQkYcV4t.js';
+export { a as DataReadErrorOptions, c as DataWriteErrorOptions, i as isDataReadError, d as isDataWriteError, r as readFailureMessage } from '../read-outcome-BQkYcV4t.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
 import { S as StorageAdapter } from '../types-DKcxHXxq.js';
+import '../types-C5bjsbxz.js';
 import '../form-types.js';
 
 interface MockProviderOptions {
@@ -70,8 +73,195 @@ interface SupabaseClient {
 interface SupabaseClientInput {
     from(table: string): unknown;
 }
-declare function createSupabaseProvider(client: SupabaseClientInput): DataProvider;
+/** What a write hook is told about the write it is part of. */
+interface SupabaseWriteContext {
+    resource: string;
+    action: "create" | "update";
+    /** The row's id, for an update. */
+    id?: Identifier;
+}
+/** Per-resource rules for `createSupabaseProvider`. Every field is optional. */
+interface SupabaseResourceConfig {
+    /** Singular noun for failure messages, e.g. "project". Defaults to "record". */
+    noun?: string;
+    /** Plural for list messages, when it isn't `noun` + "s" ("categories"). */
+    nounPlural?: string;
+    /**
+     * The columns a search covers. `[]` means the resource can't be searched,
+     * and `capabilities(resource).search` reports false so a UI hides the box.
+     * Set, they replace the caller's `search.fields`; omitted, those are used
+     * as given.
+     */
+    searchFields?: readonly string[];
+    /**
+     * The column a sorted list orders by last, so rows with equal sort values
+     * keep one order from page to page (none repeats, none is skipped).
+     * Default `"id"`; `false` for a table or view without one. With the
+     * default, a view that turns out to have no `id` column is read as before
+     * (without the key order) and a development warning suggests setting this.
+     */
+    orderKey?: string | false;
+    /**
+     * `"bin"` for a table whose delete trigger moves the row to a recycle bin
+     * instead of removing it (see `SupabaseProviderOptions.binTables`).
+     * `"hard"` forces a plain delete even when `binTables` lists the table.
+     */
+    deleteMode?: "hard" | "bin";
+    /**
+     * Turns submitted values into the row to write: trim, drop read-only keys,
+     * validate. Runs before every create and update, including the `create`
+     * and `update` overrides. Throw (ideally `DataWriteError("invalid", ...)`)
+     * to refuse the write; nothing is sent.
+     */
+    prepare?: (values: Record<string, unknown>, context: SupabaseWriteContext) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    /**
+     * Creates the row some other way than an insert, e.g. a security-definer
+     * RPC. Return the new row, or its id and the provider reads the row back
+     * (if the read-back fails, the create is still reported as saved, with
+     * just the id, so the user does not retry and make a second one). Throw to
+     * fail; a Supabase `{ message, code }` error is mapped like any other.
+     */
+    create?: (row: Record<string, unknown>) => Promise<BaseRecord | Identifier>;
+    /**
+     * Updates the row some other way than an update, e.g. an RPC. Return the
+     * updated row, or its id (or `true`) and the provider reads it back.
+     * Returning nothing (`undefined`/`null`/`false`) means no row changed: the provider then reads the
+     * row to say why (`forbidden` or `gone`), exactly as for a plain update,
+     * so a function that silently skips a row never reports a save.
+     */
+    update?: (id: Identifier, row: Record<string, unknown>) => Promise<BaseRecord | Identifier | boolean | null | undefined | void>;
+    /** Maps a stored row to edit-form values; see `DataProvider.toFormValues`. */
+    toFormValues?: (record: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Other cache keys a committed write to this resource makes stale, e.g.
+     * `[["staff"], ["me"]]`. Served through `DataProvider.invalidates`, which
+     * `useResource` and `useResourceForm` invalidate after their writes.
+     */
+    invalidates?: InvalidationKey[] | ((event: WriteEvent) => InvalidationKey[]);
+}
+/** Options for `createSupabaseProvider`. All optional; none changes reads. */
+interface SupabaseProviderOptions {
+    /**
+     * Recycle-bin tables: their delete trigger turns a delete into a "binned"
+     * mark and the binned row drops out of the caller's view (RLS or a view
+     * filter). The database reports such a delete as zero rows, so for these
+     * the provider checks the row is visible, deletes it, and reads it back:
+     * gone from view is success, still visible is `forbidden`. A row that was
+     * not visible beforehand is `gone`.
+     */
+    binTables?: readonly string[] | ((resource: string) => boolean);
+    /** Per-resource rules, keyed by resource (table) name. */
+    resources?: Record<string, SupabaseResourceConfig>;
+    /**
+     * Called after every committed create, update and delete, e.g. to
+     * invalidate caches the Genesis hooks don't know about. Awaited, but a
+     * failure is logged and never turns a committed write into a failed one.
+     */
+    onWrite?: (event: WriteEvent) => void | Promise<void>;
+    /**
+     * The most rows one list page may ask for (PostgREST's `max-rows` caps
+     * reads anyway; default 1000). A larger request is refused with an
+     * `invalid` `DataReadError` (its `cause` says why) rather than cut short,
+     * so page boundaries never disagree with the caller's `perPage`.
+     * `capabilities().maxPerPage` reports it.
+     */
+    maxPerPage?: number;
+    /**
+     * Called with every failed read, before it is thrown. The thrown
+     * `DataReadError` carries a plain message for users; the store's own
+     * error (its raw text and code) is its `cause`, for logging here.
+     */
+    onReadError?: (error: DataReadError, context: {
+        resource: string;
+        operation: "getList" | "getOne" | "getMany";
+    }) => void | Promise<void>;
+}
+/**
+ * The Supabase data provider. Reads and writes go through the client you
+ * pass, under that client's session and RLS.
+ *
+ * Writes never report a save that did not happen:
+ * - `update` and `deleteOne` ask for the affected rows. Zero rows is a
+ *   `DataWriteError`: the row is read back, and still visible means
+ *   `forbidden` (RLS or a trigger refused the change), no longer visible
+ *   means `gone`.
+ * - Database errors on writes are thrown as `DataWriteError` with the
+ *   outcome their code means (`writeOutcomeFromCode`) and the code kept on
+ *   `error.code`.
+ * - Recycle-bin tables (`binTables`) succeed when the row leaves the
+ *   caller's view.
+ *
+ * Reads are unchanged: errors are thrown as an `Error` carrying `code`.
+ */
+declare function createSupabaseProvider(client: SupabaseClientInput, options?: SupabaseProviderOptions): DataProvider;
 
+/**
+ * Maps a store error code to the read outcome it means: the write mapping,
+ * with `22***` and PostgREST request errors (`PGRST1**` other than PGRST116,
+ * `42703` unknown column, `42P01` unknown table) read as `invalid`.
+ */
+declare function readOutcomeFromCode(code: string | null | undefined): ReadOutcome;
+/**
+ * Maps a Postgres SQLSTATE or PostgREST error code to the write outcome it
+ * means. Anything not listed is `error`: a code is only read as a refusal or
+ * a bad value when it says so.
+ *
+ * - `42501` (insufficient privilege, including "new row violates row-level
+ *   security policy") → `forbidden`
+ * - `22***` (data exception: bad type, out of range) and `23***` (integrity
+ *   constraint: `23505` unique, `23503` foreign key, `23502` not null,
+ *   `23514` check) → `invalid`
+ * - `PGRST301`–`PGRST303` (JWT missing, expired or rejected), `28000`,
+ *   `28P01` → `unauthenticated`
+ * - `PGRST116` (one row was asked for and none came back) → `gone`
+ */
+declare function writeOutcomeFromCode(code: string | null | undefined): WriteOutcome;
+/** Field errors read from a store error, with the safe sentence that sums them up. */
+interface PostgrestFieldErrors {
+    /** Column name → safe message for that input. */
+    fields: Record<string, string>;
+    /** One safe sentence for the whole error, to replace the store's raw text. */
+    message: string;
+}
+/**
+ * Reads which columns a Postgres constraint error is about, from PostgREST's
+ * `message` / `details`, and gives safe messages for them. Only plain column
+ * names are taken from the store's text; the values it echoes are never
+ * used. Returns `undefined` when nothing can be mapped safely.
+ *
+ * - `23505` unique violation, `Key (email)=(…) already exists.` → each
+ *   column: "This value is already in use." (several columns: "This
+ *   combination is already in use.")
+ * - `23502` not-null, `null value in column "title" …` → "This field is
+ *   required."
+ * - `23503` foreign key on insert/update, `Key (owner_id)=(…) is not present
+ *   in table …` → "The selected item doesn't exist."
+ */
+declare function fieldErrorsFromPostgrest(error: {
+    code?: unknown;
+    message?: unknown;
+    details?: unknown;
+}): PostgrestFieldErrors | undefined;
+/**
+ * Turns anything a write threw, or the `{ message, code }` error a Supabase
+ * client returned, into a `DataWriteError`. A `DataWriteError` passes through
+ * unchanged; anything else keeps its message and `code`, and is kept as the
+ * `cause`.
+ *
+ * When the error names the columns it is about (`fieldErrorsFromPostgrest`:
+ * unique, not-null and foreign-key violations), the result carries `fields`
+ * and its message is replaced with a safe sentence; the raw text stays on
+ * the `cause`.
+ */
+declare function toDataWriteError(error: unknown): DataWriteError;
+
+/**
+ * Puts a `DataProvider` in context, and nothing else. Mount it inside your
+ * app's own `QueryClientProvider` and the Genesis hooks share that cache:
+ * the same query keys (`[resource, "list", params]`,
+ * `[resource, "detail", id, select]`), so invalidating `[resource]` from app
+ * code refreshes Genesis lists too, and vice versa.
+ */
 interface DataProviderRootProps {
     provider: DataProvider;
     children: ReactNode;
@@ -87,6 +277,14 @@ type GenesisProviderProps = {
     mock?: never;
     /** Platform-specific storage adapter. Defaults to localStorage (SSR-safe). */
     storage?: StorageAdapter;
+    /**
+     * The TanStack Query client to use. Without it, GenesisProvider creates
+     * its OWN client — a second cache beside any the app already has, so app
+     * queries and Genesis queries would not see each other's invalidations.
+     * An app with a `QueryClientProvider` should pass its client here, or
+     * use `DataProviderRoot` inside that provider instead.
+     */
+    queryClient?: QueryClient;
 } | {
     children: ReactNode;
     provider?: never;
@@ -97,7 +295,15 @@ type GenesisProviderProps = {
     };
     /** Platform-specific storage adapter. Defaults to localStorage (SSR-safe). */
     storage?: StorageAdapter;
+    /** See the `provider` variant. */
+    queryClient?: QueryClient;
 };
-declare function GenesisProvider({ children, provider, mock, storage, }: GenesisProviderProps): react.JSX.Element;
+/**
+ * Convenience root: a `QueryClientProvider`, storage, and a data provider
+ * (yours, or a mock built from datasets). It creates its own `QueryClient`
+ * unless you pass `queryClient`; an app that already has one should pass it,
+ * or mount `DataProviderRoot` inside its existing `QueryClientProvider`.
+ */
+declare function GenesisProvider({ children, provider, mock, storage, queryClient: queryClientProp, }: GenesisProviderProps): react.JSX.Element;
 
-export { DataProvider, DataProviderRoot, type DataProviderRootProps, GenesisProvider, type GenesisProviderProps, type MockProviderOptions, type SupabaseClient, type SupabaseClientInput, createMockProvider, createSupabaseProvider, useDataProvider, useStorage };
+export { BaseRecord, DataProvider, DataProviderRoot, type DataProviderRootProps, DataReadError, DataWriteError, GenesisProvider, type GenesisProviderProps, Identifier, InvalidationKey, type MockProviderOptions, type PostgrestFieldErrors, ReadOutcome, type SupabaseClient, type SupabaseClientInput, type SupabaseProviderOptions, type SupabaseResourceConfig, type SupabaseWriteContext, WriteEvent, WriteOutcome, createMockProvider, createSupabaseProvider, fieldErrorsFromPostgrest, readOutcomeFromCode, toDataWriteError, useDataProvider, useStorage, writeOutcomeFromCode };

package/dist/provider/index.js

@@ -1,6 +1,8 @@
-export { createSupabaseProvider } from '../chunk-6AA4ISUA.js';
-export { DataWriteError, isDataWriteError } from '../chunk-4W4W7F4I.js';
-export { DataProviderRoot, GenesisProvider, createMockProvider, useDataProvider, useStorage } from '../chunk-6V2TIN3G.js';
+export { createSupabaseProvider, fieldErrorsFromPostgrest, readOutcomeFromCode, toDataWriteError, writeOutcomeFromCode } from '../chunk-RLY7TZUY.js';
+export { DataReadError, isDataReadError, readFailureMessage } from '../chunk-HUNGCTRA.js';
+export { DataWriteError, isDataWriteError } from '../chunk-5NHR6ZXS.js';
+import '../chunk-RYEXWQFD.js';
+export { DataProviderRoot, GenesisProvider, createMockProvider, useDataProvider, useStorage } from '../chunk-GGSXSI6Z.js';
 import '../chunk-ZYJUEJ4Z.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/read-outcome-BQkYcV4t.d.ts

@@ -0,0 +1,88 @@
+import { D as DataRow } from './types-C5bjsbxz.js';
+
+/**
+ * - `conflict`: someone else changed the row since it was read. `current`
+ *   carries the row as it is now.
+ * - `gone`: the row was deleted, or is no longer visible to this user. The
+ *   two cannot be told apart without a privileged look at the table, which
+ *   would show this user a fact about a row they cannot see.
+ * - `forbidden`: the row is visible and unchanged, but the app or the
+ *   database does not let this user make this change. Only reported when
+ *   that is proven, never assumed from "zero rows changed".
+ * - `invalid`: the store rejected the value (type, constraint, not-null).
+ * - `audit_failed`: the audit entry could not be written, so the edit was
+ *   rolled back with it.
+ * - `unauthenticated`: no signed-in user, or the session expired.
+ * - `error`: anything else. The edit did not commit.
+ */
+type WriteOutcome = "conflict" | "gone" | "forbidden" | "invalid" | "audit_failed" | "unauthenticated" | "error";
+interface DataWriteErrorOptions {
+    /** The row as it is now, for a `conflict`. Only fields the user may read. */
+    current?: DataRow;
+    /** The row's current version token, for a `conflict`. */
+    currentVersion?: string | null;
+    /**
+     * The store's own error code, when it gave one (a Postgres SQLSTATE such as
+     * `23505`, or a PostgREST code such as `PGRST301`).
+     */
+    code?: string;
+    /**
+     * Per-field messages, keyed by field (column) name, for a write the store
+     * rejected because of particular values. Each message is safe to show next
+     * to its input: plain words, never the store's raw text or the value.
+     * `useResourceForm` puts each one on its field.
+     */
+    fields?: Record<string, string>;
+    /** The underlying error, kept for logging. */
+    cause?: unknown;
+}
+/** Thrown by a provider when a write did not commit. */
+declare class DataWriteError extends Error {
+    readonly outcome: WriteOutcome;
+    readonly current?: DataRow;
+    readonly currentVersion?: string | null;
+    /** The store's own error code, when it gave one. */
+    readonly code?: string;
+    /**
+     * Per-field messages (field name → safe message), when the store said which
+     * values it rejected. See `DataWriteErrorOptions.fields`.
+     */
+    readonly fields?: Readonly<Record<string, string>>;
+    constructor(outcome: WriteOutcome, message: string, options?: DataWriteErrorOptions);
+}
+/**
+ * `instanceof` fails when two copies of this package are installed, so check
+ * the shape instead.
+ */
+declare function isDataWriteError(error: unknown): error is DataWriteError;
+
+/**
+ * - `unauthenticated`: no signed-in user, or the session expired.
+ * - `forbidden`: this user may not read these records.
+ * - `gone`: the one record asked for doesn't exist, or isn't visible.
+ * - `invalid`: the request itself was wrong (an unknown column, a bad value).
+ * - `error`: anything else.
+ */
+type ReadOutcome = "unauthenticated" | "forbidden" | "gone" | "invalid" | "error";
+interface DataReadErrorOptions {
+    /** The store's own error code (a Postgres SQLSTATE or PostgREST code). */
+    code?: string;
+    /** The underlying error, with its raw text, kept for logging. */
+    cause?: unknown;
+}
+/** Thrown by a provider when a read failed. Its `message` is safe to show. */
+declare class DataReadError extends Error {
+    readonly outcome: ReadOutcome;
+    /** The store's own error code, when it gave one. */
+    readonly code?: string;
+    constructor(outcome: ReadOutcome, message: string, options?: DataReadErrorOptions);
+}
+/**
+ * `instanceof` fails when two copies of this package are installed, so check
+ * the shape instead.
+ */
+declare function isDataReadError(error: unknown): error is DataReadError;
+/** The plain sentence for a failed read of `noun` records (one, or a list). */
+declare function readFailureMessage(outcome: ReadOutcome, noun: string, one: boolean, plural?: string): string;
+
+export { DataReadError as D, type ReadOutcome as R, type WriteOutcome as W, type DataReadErrorOptions as a, DataWriteError as b, type DataWriteErrorOptions as c, isDataWriteError as d, isDataReadError as i, readFailureMessage as r };

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
-import { t as ResourceContract, I as Identifier, e as DataRow } from '../types-DUbRb8qV.js';
-export { a as AuditEntry, F as FieldPermissions, h as FieldReference, i as FieldSchema, j as FilterOperator, q as ProviderCapabilities, r as RecordComment, s as ResourceAccess, u as ResourceRelation, v as ResourceSchema, w as ResourceSummary, x as RowAction, E as StorageType, V as VersionField } from '../types-DUbRb8qV.js';
-export { D as DataWriteError, a as DataWriteErrorOptions, W as WriteOutcome, i as isDataWriteError } from '../write-outcome-aYToY3dK.js';
+import { e as ResourceContract, D as DataRow } from '../types-C5bjsbxz.js';
+export { A as AuditEntry, F as FieldPermissions, a as FieldReference, b as FieldSchema, c as FilterOperator, P as ProviderCapabilities, R as RecordComment, d as ResourceAccess, f as ResourceRelation, g as ResourceSchema, h as ResourceSummary, i as RowAction, S as StorageType, V as VersionField } from '../types-C5bjsbxz.js';
+import { I as Identifier } from '../types-Dsqqr9s7.js';
+export { D as DataReadError, a as DataReadErrorOptions, b as DataWriteError, c as DataWriteErrorOptions, R as ReadOutcome, W as WriteOutcome, i as isDataReadError, d as isDataWriteError, r as readFailureMessage } from '../read-outcome-BQkYcV4t.js';
 export { FieldType as WidgetHint } from '../form-types.js';
 
 /** The key of a contract as a list, whichever form `key` was declared in. */

package/dist/schema/index.js

@@ -1,4 +1,5 @@
 export { decodeRecordKey, encodeRecordKey, keyFields } from '../chunk-KV2HW4G4.js';
-export { DataWriteError, isDataWriteError } from '../chunk-4W4W7F4I.js';
+export { DataReadError, isDataReadError, readFailureMessage } from '../chunk-HUNGCTRA.js';
+export { DataWriteError, isDataWriteError } from '../chunk-5NHR6ZXS.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{types-DUbRb8qV.d.ts → types-C5bjsbxz.d.ts}

@@ -70,7 +70,7 @@ interface FieldSchema {
  * One declaration of a resource: its fields and its identity.
  *
  * `key` names the identity field, or several for a composite key (a junction
- * table keyed on `(coach_id, client_id)`). Use {@link keyFields} to read it as
+ * table keyed on `(team_id, user_id)`). Use {@link keyFields} to read it as
  * a list without caring which form it took.
  */
 interface ResourceContract<Row extends DataRow = DataRow> {
@@ -239,6 +239,17 @@ interface ProviderCapabilities {
     readonly actions?: boolean;
     /** `comments` and `addComment` are served. */
     readonly comments?: boolean;
+    /**
+     * The most rows one `getList` page may ask for. A request for more is
+     * refused (it is not cut short, which would shift later page boundaries),
+     * so a client that wants every row must page at this size or less.
+     */
+    readonly maxPerPage?: number;
+    /**
+     * A delete moves the record to a recycle bin (it can be restored) instead
+     * of removing it. Asked per resource: `capabilities(resource)`.
+     */
+    readonly softDelete?: boolean;
 }
 /** One audit record, as committed alongside the edit it describes. */
 interface AuditEntry {
@@ -260,257 +271,4 @@ interface AuditEntry {
     readonly after: DataRow | null;
 }
 
-/** Record identifier — supports both string UUIDs and numeric auto-increment IDs. */
-type Identifier = string | number;
-/** Base record type — all resources must have an id. */
-type BaseRecord = {
-    id: Identifier;
-    [key: string]: unknown;
-};
-/** Pagination parameters (offset-based, with optional cursor for future use). */
-interface PaginationParam {
-    page: number;
-    perPage: number;
-    cursor?: string;
-}
-/** Sort direction for a single field. */
-interface SortParam {
-    field: string;
-    order: "asc" | "desc";
-}
-/**
- * Filter expressions — discriminated union by operator.
- * Filters are AND-ed together in queries.
- */
-/** Operators that compare a field against a single scalar value. */
-interface ScalarFilter {
-    field: string;
-    operator: "eq" | "neq" | "gt" | "lt" | "gte" | "lte" | "contains";
-    value: string | number | boolean;
-}
-/** Operator that checks field membership in a list. */
-interface ArrayFilter {
-    field: string;
-    operator: "in";
-    value: (string | number | boolean)[];
-}
-/** Operator that checks field is within a range. */
-interface RangeFilter {
-    field: string;
-    operator: "between";
-    value: [string | number, string | number];
-}
-/** Operators that check for null/non-null — no value needed. */
-interface NullFilter {
-    field: string;
-    operator: "is_null" | "is_not_null";
-}
-type FilterParam = ScalarFilter | ArrayFilter | RangeFilter | NullFilter;
-/** Parameters for `getList`. */
-interface ListParams {
-    pagination?: PaginationParam;
-    sort?: SortParam;
-    /**
-     * Sort by several fields, first one first. Wins over `sort` on a provider
-     * whose capabilities report `multiSort`; others use only `sort`.
-     */
-    sorts?: SortParam[];
-    filters?: FilterParam[];
-    /** Supabase select syntax, e.g. "*, author:profiles(name)". Mock provider ignores this. */
-    select?: string;
-    /** Multi-field text search (case-insensitive). */
-    search?: {
-        query: string;
-        fields: string[];
-    };
-}
-/** Result of `getList`. */
-interface ListResult<T> {
-    data: T[];
-    total: number;
-}
-/** Parameters for `getOne`. */
-interface GetOneParams {
-    id: Identifier;
-    /** Supabase select syntax, e.g. "*, author:profiles(name)". Defaults to "*". */
-    select?: string;
-}
-/** Result of `getOne`. */
-interface GetOneResult<T> {
-    data: T;
-}
-/** Parameters for `getMany`. */
-interface GetManyParams {
-    ids: Identifier[];
-}
-/** Result of `getMany`. */
-interface GetManyResult<T> {
-    data: T[];
-}
-/** Parameters for `create`. */
-interface CreateParams<T> {
-    data: Partial<T>;
-}
-/** Result of `create`. */
-interface CreateResult<T> {
-    data: T;
-    /** The audit entry committed with the new row, from a provider that audits. */
-    audit?: AuditEntry;
-}
-/** Parameters for `update`. */
-interface UpdateParams<T> {
-    /**
-     * The record's identifier. For a composite key, the canonical string from
-     * `encodeRecordKey` (`@marktiderman/genesis-core/schema`).
-     */
-    id: Identifier;
-    data: Partial<T>;
-    /**
-     * The version token the caller read the row at. A provider that reports
-     * `versionedWrites` in its capabilities rejects the update with a
-     * `DataWriteError` (`conflict`) when the row has moved on since, instead of
-     * overwriting someone else's edit. Providers without versioned writes
-     * ignore it.
-     */
-    expectedVersion?: string | null;
-}
-/** Result of `update`. */
-interface UpdateResult<T> {
-    data: T;
-    /** The row's new version token, from a provider with versioned writes. */
-    version?: string | null;
-    /** The audit entry committed with the edit, from a provider that audits. */
-    audit?: AuditEntry;
-}
-/** Parameters for `deleteOne`. */
-interface DeleteParams {
-    id: Identifier;
-    /** The version token the row was read at; see `UpdateParams.expectedVersion`. */
-    expectedVersion?: string | null;
-}
-/** Result of `deleteOne`. */
-interface DeleteResult {
-    data: {
-        id: Identifier;
-    };
-    /** The audit entry committed with the deletion, from a provider that audits. */
-    audit?: AuditEntry;
-}
-/** One row's change in a bulk update. */
-interface BulkChange {
-    id: Identifier;
-    data: Record<string, unknown>;
-    /** The version token the row was read at. */
-    expectedVersion?: string | null;
-}
-/** Why one row of a bulk write or import didn't go through. */
-interface RowFailure {
-    /** The row's position in the request, from 0. */
-    index: number;
-    id?: Identifier;
-    outcome: string;
-    message: string;
-}
-/** Result of a bulk write: every row changed, or none did. */
-interface BulkResult {
-    /** Rows changed; always the number requested when `ok`. */
-    count: number;
-    ok: boolean;
-    /** Present when `ok` is false: every row that failed, so the caller can fix them all at once. */
-    failures?: RowFailure[];
-    /** One audit entry per row changed. */
-    audit?: AuditEntry[];
-}
-/** Parameters for `importRows`. */
-interface ImportParams {
-    rows: Record<string, unknown>[];
-    /** Check every row against the database and change nothing. */
-    dryRun: boolean;
-}
-/** Parameters for `history`. */
-interface HistoryParams {
-    id: Identifier;
-    /** Most recent first; default and maximum are the provider's. */
-    limit?: number;
-}
-interface DataProvider {
-    getList<T extends BaseRecord = BaseRecord>(resource: string, params: ListParams): Promise<ListResult<T>>;
-    getOne<T extends BaseRecord = BaseRecord>(resource: string, params: GetOneParams): Promise<GetOneResult<T>>;
-    getMany<T extends BaseRecord = BaseRecord>(resource: string, params: GetManyParams): Promise<GetManyResult<T>>;
-    create<T extends BaseRecord = BaseRecord>(resource: string, params: CreateParams<T>): Promise<CreateResult<T>>;
-    update<T extends BaseRecord = BaseRecord>(resource: string, params: UpdateParams<T>): Promise<UpdateResult<T>>;
-    deleteOne(resource: string, params: DeleteParams): Promise<DeleteResult>;
-    /**
-     * The resource's real shape for the CURRENT user: fields, key, version
-     * field, and per-field read and update rights. Fields the user may not read
-     * are omitted entirely.
-     */
-    describe?(resource: string): Promise<ResourceSchema>;
-    /** Every resource this user may see, for a sidebar or a picker. */
-    listResources?(): Promise<ResourceSummary[]>;
-    /**
-     * What this provider can do, optionally for one resource. A UI hides the
-     * controls a provider cannot serve instead of letting them error.
-     */
-    capabilities?(resource?: string): Promise<ProviderCapabilities>;
-    /**
-     * A record's audit history, most recent first, limited to the fields this
-     * user may read.
-     */
-    history?(resource: string, params: HistoryParams): Promise<AuditEntry[]>;
-    /**
-     * Update many rows in ONE transaction. All of them change or none do: a
-     * single conflict, refusal or invalid value rolls back the rest, and the
-     * result lists every row that failed.
-     */
-    updateMany?(resource: string, params: {
-        changes: BulkChange[];
-    }): Promise<BulkResult>;
-    /** Delete many rows in one transaction, all or none, each at its version. */
-    deleteMany?(resource: string, params: {
-        items: {
-            id: Identifier;
-            expectedVersion?: string | null;
-        }[];
-    }): Promise<BulkResult>;
-    /**
-     * Add rows from an import. With `dryRun`, every row is tried against the
-     * database and nothing is kept, so the result lists every row that would
-     * fail; without it, all rows are added in one transaction or none are.
-     */
-    importRows?(resource: string, params: ImportParams): Promise<BulkResult>;
-    /**
-     * Undo one audited change with a compensating write: put the changed
-     * fields back, remove an added row, or restore a deleted one. Refused when
-     * the row has changed since.
-     */
-    undo?(resource: string, params: {
-        auditId: string;
-    }): Promise<{
-        audit?: AuditEntry;
-    }>;
-    /**
-     * Run one of the resource's row actions (`ResourceSchema.actions`) on a
-     * row, at the version it was read. The app's function does the work; the
-     * row's change is audited.
-     */
-    runAction?(resource: string, params: {
-        id: Identifier;
-        action: string;
-        expectedVersion?: string | null;
-    }): Promise<{
-        data: Record<string, unknown> | null;
-        audit?: AuditEntry;
-    }>;
-    /** A record's comments, oldest first. */
-    comments?(resource: string, params: {
-        id: Identifier;
-    }): Promise<RecordComment[]>;
-    /** Add a comment to a record, as the signed-in user. */
-    addComment?(resource: string, params: {
-        id: Identifier;
-        body: string;
-    }): Promise<RecordComment>;
-}
-
-export type { ArrayFilter as A, BaseRecord as B, CreateParams as C, DataProvider as D, StorageType as E, FieldPermissions as F, GetManyParams as G, HistoryParams as H, Identifier as I, UpdateResult as J, ListParams as L, NullFilter as N, PaginationParam as P, RangeFilter as R, ScalarFilter as S, UpdateParams as U, VersionField as V, AuditEntry as a, BulkChange as b, BulkResult as c, CreateResult as d, DataRow as e, DeleteParams as f, DeleteResult as g, FieldReference as h, FieldSchema as i, FilterOperator as j, FilterParam as k, GetManyResult as l, GetOneParams as m, GetOneResult as n, ImportParams as o, ListResult as p, ProviderCapabilities as q, RecordComment as r, ResourceAccess as s, ResourceContract as t, ResourceRelation as u, ResourceSchema as v, ResourceSummary as w, RowAction as x, RowFailure as y, SortParam as z };
+export type { AuditEntry as A, DataRow as D, FieldPermissions as F, ProviderCapabilities as P, RecordComment as R, StorageType as S, VersionField as V, FieldReference as a, FieldSchema as b, FilterOperator as c, ResourceAccess as d, ResourceContract as e, ResourceRelation as f, ResourceSchema as g, ResourceSummary as h, RowAction as i };