@standardbeagle/edit-db 0.4.494 → 0.4.583

package/dist/common/saved-objects.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Client for the server's `/_saved-objects` REST endpoint (list/get/put/delete of
+ * user-authored objects). A small REST helper — the GraphQL fetcher seam is
+ * GraphQL-only, so this is a sibling transport, not an extension of it. Paths are
+ * resolved against `baseUrl` (default `''` = the page origin, like the other
+ * `/api/*` REST clients).
+ *
+ * Types are declared here to keep this shipped stack self-contained; they mirror
+ * the canonical contract in `@bifrostql/types` (`SavedObject`) and the C# source of
+ * truth in `BifrostQL.Core/SavedObjects`.
+ */
+export type SavedObjectType = 'query' | 'form' | 'report' | 'dashboard';
+export interface SavedObject {
+    id: string;
+    type: SavedObjectType;
+    name: string;
+    folder?: string;
+    definition: unknown;
+    version: number;
+}
+/** Thrown when a `put` is rejected because the object was modified concurrently (HTTP 409). */
+export declare class SavedObjectConflictError extends Error {
+    constructor(message: string);
+}
+export interface SavedObjectsClient {
+    /**
+     * Lists stored objects, skipping any entry that does not parse so one corrupt
+     * record cannot take out the whole list. Skipped entries are reported through
+     * `onSkipped` rather than discarded silently — a caller that shows a list is
+     * expected to tell the user some of it could not be read.
+     */
+    list(type?: SavedObjectType, signal?: AbortSignal, onSkipped?: (skipped: number) => void): Promise<SavedObject[]>;
+    get(type: SavedObjectType, id: string, signal?: AbortSignal): Promise<SavedObject | null>;
+    put(object: SavedObject, signal?: AbortSignal): Promise<SavedObject>;
+    remove(type: SavedObjectType, id: string, signal?: AbortSignal): Promise<void>;
+}
+export declare const SAVED_OBJECTS_PATH = "/_saved-objects";
+export declare function createSavedObjectsClient(baseUrl?: string): SavedObjectsClient;
+/** Validates an unknown value as a {@link SavedObject}; returns null when it does not conform. */
+export declare function parseSavedObject(value: unknown): SavedObject | null;

package/dist/common/schema-queries.d.ts

@@ -0,0 +1 @@
+export declare const GET_DB_SCHEMA = "\nquery dbSchema {\n  _dbSchema {\n    dbName\n    graphQlName\n    labelColumn\n    primaryKeys\n    isEditable\n    metadata {\n      key\n      value\n    }\n    columns {\n      dbName\n      graphQlName\n      paramType\n      dbType\n      isPrimaryKey\n      isIdentity\n      isNullable\n      isReadOnly\n      isLargeValue\n      maxLength\n      minLength\n      min\n      max\n      step\n      precision\n      scale\n      pattern\n      patternMessage\n      inputType\n      defaultValue\n      enumValues\n      enumLabels\n      metadata {\n        key\n        value\n      }\n    }\n    multiJoins {\n      name\n      fieldName\n      sourceColumnNames\n      destinationTable\n      destinationColumnNames\n    }\n    singleJoins {\n      name\n      fieldName\n      sourceColumnNames\n      destinationTable\n      destinationColumnNames\n    }\n    manyToManyJoins {\n      name\n      targetTable\n      junctionTable\n      junctionTargetField\n      sourceColumnNames\n      junctionSourceColumnNames\n      junctionTargetColumnNames\n      targetColumnNames\n      hasPayload\n    }\n    indexes {\n      name\n      isUnique\n      isClustered\n      isPrimaryKey\n      columns\n    }\n  }\n}";

package/dist/components/bulk-edit-dialog.d.ts

@@ -0,0 +1,18 @@
+import { Table } from '../types/schema';
+import { PkFilter } from '../lib/row-id';
+interface BulkEditDialogProps {
+    table: Table;
+    /** Primary-key filters of the selected rows (composite-safe, from pkFilterFor). */
+    pks: PkFilter[];
+    onClose: () => void;
+}
+/**
+ * Jira-style bulk edit: apply one shared set of field changes to every selected
+ * row, saved as ONE `delta: { updated }` document — one server transaction (a
+ * failure anywhere applies nothing) that rides the set-based bulk fast path at
+ * batch scale. Before saving, the selected rows are re-read fresh in a single
+ * query so echoed non-nullable columns reflect current server state (the grid's
+ * projection excludes large values and may be stale).
+ */
+export declare function BulkEditDialog({ table, pks, onClose }: BulkEditDialogProps): import("react").JSX.Element;
+export {};

package/dist/components/content-viewer.d.ts

@@ -2,6 +2,13 @@ interface ContentViewerProps {
     value: unknown;
     dbType?: string;
     onExpand?: () => void;
+    /**
+     * True when the column's value is deliberately NOT selected by the grid query
+     * (large-value/LOB columns, fetched on demand). A missing value then means
+     * "not fetched", which must not render as NULL — that would misreport real
+     * content as absent. Expanding fetches the actual value.
+     */
+    deferred?: boolean;
 }
-export declare function ContentViewer({ value, dbType, onExpand }: ContentViewerProps): import("react").JSX.Element;
+export declare function ContentViewer({ value, dbType, onExpand, deferred }: ContentViewerProps): import("react").JSX.Element;
 export {};

package/dist/components/data-table.d.ts

@@ -1,5 +1,8 @@
 import { ColumnDef, ColumnFiltersState, SortingState } from '@tanstack/react-table';
+import { ExportRunner } from '../lib/export';
 import { PkFilter } from '../lib/row-id';
+import { Column } from '../types/schema';
+import { GridGroupMemberRequest, GroupingRow, GroupingSort } from '../lib/grid-grouping';
 /**
  * Props for the DataTable component.
  * @interface DataTableProps
@@ -22,8 +25,14 @@ interface DataTableProps<TData> {
     sorting: SortingState;
     /** Active column filters */
     columnFilters: ColumnFiltersState;
-    /** Whether data is currently loading */
+    /** Whether data is currently loading (no rows to show yet) */
     loading?: boolean;
+    /**
+     * Whether a page/sort/filter refresh is in flight while the previous rows
+     * stay on screen. `loading` covers only the no-rows-yet case; without this
+     * flag a slow page turn gives zero feedback and reads as a dead click.
+     */
+    fetching?: boolean;
     /** Enable row selection checkboxes */
     selectable?: boolean;
     /**
@@ -51,6 +60,21 @@ interface DataTableProps<TData> {
     onDeleteRow?: (pk: PkFilter) => void;
     /** Callback when deleting multiple selected rows */
     onDeleteSelected?: (pks: PkFilter[]) => void;
+    /** Bulk edit of the selected rows — one shared change set, one delta transaction. */
+    onBulkEditSelected?: (pks: PkFilter[]) => void;
+    /** Column ids editable INLINE: double-click a cell to edit; Enter/blur commits into the staged set, Escape cancels. */
+    inlineEditableColumns?: ReadonlySet<string>;
+    /** Column ids whose inline editor is a boolean toggle instead of a text input. */
+    inlineBooleanColumns?: ReadonlySet<string>;
+    /** Staged (unsaved) cell edits keyed by row id; rendered dirty and shown in place of the stored value. */
+    pendingEdits?: ReadonlyMap<string, Record<string, unknown>>;
+    /** Commits one edited cell into the staged set (owned by the caller so edits survive refetches). */
+    onCellCommit?: (rowId: string, columnId: string, value: unknown) => void;
+    /** Save/discard the whole staged set — rendered in the toolbar with the unsaved count. */
+    onSaveAllEdits?: () => void;
+    onDiscardAllEdits?: () => void;
+    /** True while the staged set is being saved; locks the toolbar buttons. */
+    savingEdits?: boolean;
     /**
      * Whether parent/child drill-down ("stacking") mode is active. When the
      * companion `onToggleStacking` is supplied, a graphical toggle renders next
@@ -60,6 +84,29 @@ interface DataTableProps<TData> {
     stackingEnabled?: boolean;
     /** Toggle stacking mode on/off. When omitted, the toggle is not rendered. */
     onToggleStacking?: (next: boolean) => void;
+    /**
+     * Full-result-set export runner (pages every matching row for the current
+     * filters/sort). When supplied, an Export control renders in the toolbar.
+     */
+    exportRows?: ExportRunner;
+    /** Total matching rows — drives the export's above-cap confirmation. */
+    totalRows?: number;
+    /** Opens a chart prefilled from this table and its schema-aware filters. */
+    onVisualize?: () => void;
+    /** Schema columns offered by the URL-backed server grouping selector. */
+    groupableColumns?: readonly Column[];
+    grouping?: {
+        column: Column;
+        sumColumn: Column | null;
+        rows: GroupingRow[];
+        loading: boolean;
+        error: Error | null;
+        sort: GroupingSort;
+        onSortChange: (sort: GroupingSort) => void;
+        memberRequest: (value: unknown) => GridGroupMemberRequest;
+    } | null;
+    onGroupingChange?: (columnName: string | null) => void;
+    onGroupingSumChange?: (columnName: string | null) => void;
 }
 /**
  * DataTable component - A comprehensive data table with sorting, filtering,
@@ -89,5 +136,5 @@ interface DataTableProps<TData> {
  * @param props - DataTable configuration props
  * @returns React element containing the data table interface
  */
-export declare function DataTable<TData>({ columns, data, tableName, pageCount, pageIndex, pageSize, sorting, columnFilters, loading, selectable, primaryKeys, selectedRowId, onRowSelect, onSortingChange, onColumnFiltersChange, onPageIndexChange, onPageSizeChange, onEditRow, onDeleteRow, onDeleteSelected, stackingEnabled, onToggleStacking, }: DataTableProps<TData>): import("react").JSX.Element;
+export declare function DataTable<TData>({ columns, data, tableName, pageCount, pageIndex, pageSize, sorting, columnFilters, loading, fetching, selectable, primaryKeys, selectedRowId, onRowSelect, onSortingChange, onColumnFiltersChange, onPageIndexChange, onPageSizeChange, onEditRow, onDeleteRow, onDeleteSelected, onBulkEditSelected, inlineEditableColumns, inlineBooleanColumns, pendingEdits, onCellCommit, onSaveAllEdits, onDiscardAllEdits, savingEdits, stackingEnabled, onToggleStacking, exportRows, totalRows, onVisualize, groupableColumns, grouping, onGroupingChange, onGroupingSumChange, }: DataTableProps<TData>): import("react").JSX.Element;
 export {};

package/dist/components/detail-panel.d.ts

@@ -1,10 +1,10 @@
 import { Table } from '../types/schema';
-import { ColumnPanel } from '../data-panel';
+import { DrillFrame } from '../lib/drill-stack';
 interface DetailPanelProps {
     parentTable: Table;
     selectedRowId: string;
     onClose?: () => void;
-    onOpenColumn?: (panel: ColumnPanel) => void;
+    onOpenColumn?: (panel: DrillFrame) => void;
 }
 export declare function DetailPanel({ parentTable, selectedRowId, onClose, onOpenColumn }: DetailPanelProps): import("react").JSX.Element | null;
 export {};

package/dist/components/export-button.d.ts

@@ -0,0 +1,19 @@
+import { ExportRunner } from '../lib/export';
+interface ExportButtonProps {
+    /** Bound runner that pages the full filtered/sorted result set. */
+    exportRows: ExportRunner;
+    /** Total matching rows — drives the above-cap confirmation. */
+    total: number;
+    /** Base name for the downloaded file. */
+    tableName: string;
+    /** Above this many rows the export prompts for confirmation. */
+    rowCap?: number;
+}
+/**
+ * Toolbar control that exports the full result set through the shared export
+ * util. Above `rowCap` it confirms first; while running it swaps to a Cancel
+ * button that aborts paging (leaving no file). Cancellation is silent — no error
+ * toast — since the user asked for it.
+ */
+export declare function ExportButton({ exportRows, total, tableName, rowCap, }: ExportButtonProps): import("react").JSX.Element;
+export {};

package/dist/components/export-button.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/filters/number-filter.d.ts

@@ -2,6 +2,13 @@ import { Column } from '@tanstack/react-table';
 interface NumberFilterProps<TData, TValue> {
     column: Column<TData, TValue>;
 }
-export declare function parseNumeric(raw: string, isInt: boolean): number | null;
+/**
+ * Validates the typed text and returns the value to filter by: the digits
+ * unchanged for a bigint/decimal column (a JS number would round them), otherwise
+ * a number. Null means the text is not (yet) a complete numeric literal, which the
+ * caller reads as "no filter". Thin wrapper over the shared classifier so the
+ * filter, the edit form and the write path all agree on what a column accepts.
+ */
+export declare function parseNumeric(raw: string, paramType: string): number | string | null;
 export declare function NumberFilter<TData, TValue>({ column }: NumberFilterProps<TData, TValue>): import("react").JSX.Element | null;
 export {};

package/dist/components/fk-cell-popover.d.ts

@@ -2,16 +2,16 @@ import { ReactNode } from 'react';
 import { Column, Join, Table } from '../types/schema';
 interface FkCellPopoverProps {
     tableName: string;
-    recordId: string | number;
+    fkValue: string | number;
     /**
-     * The column on `tableName` whose value is `recordId`. Callers pass the FK target
+     * The column on `tableName` whose value is `fkValue`. Callers pass the FK target
      * column from the join metadata (`destinationColumnNames[0]`). Using the target's
      * "primary key" column here is wrong for composite-PK and denormalized-FK targets.
      */
     filterColumn: string;
     /**
      * The full join descriptor. When the join is composite, the popover ignores
-     * `recordId`/`filterColumn` and builds an `{and: [...]}` filter from every
+     * `fkValue`/`filterColumn` and builds an `{and: [...]}` filter from every
      * `sourceColumnNames` value on `sourceRow`. Single-FK callers can omit this.
      */
     join?: Join;
@@ -28,6 +28,6 @@ interface PreviewPlan {
     cacheKey: unknown;
 }
 /** Exported for tests: pure query-plan derivation with no React/query dependencies. */
-export declare function buildPreviewPlan(tableName: string, destTable: Table, previewColumns: Column[], join: Join | undefined, sourceRow: Record<string, unknown> | undefined, recordId: string | number, filterColumn: string): PreviewPlan | null;
-export declare function FkCellPopover({ tableName, recordId, filterColumn, join, sourceRow, children }: FkCellPopoverProps): import("react").JSX.Element;
+export declare function buildPreviewPlan(tableName: string, destTable: Table, previewColumns: Column[], join: Join | undefined, sourceRow: Record<string, unknown> | undefined, fkValue: string | number, filterColumn: string): PreviewPlan | null;
+export declare function FkCellPopover({ tableName, fkValue, filterColumn, join, sourceRow, children }: FkCellPopoverProps): import("react").JSX.Element;
 export {};

package/dist/components/form-runner-host.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLFetcher } from '../common/fetcher';
+import { FormDefinition } from '../lib/form-definition';
+import { FieldWidgetHint } from '../lib/form-widget';
+interface FormRunnerHostProps {
+    /** The GraphQL fetcher every read/write routes through (transport-agnostic). */
+    fetcher: GraphQLFetcher;
+    /** The saved form definition to render. */
+    definition: FormDefinition;
+    /** Optional app-metadata widget hints keyed by column name. */
+    fieldMetadata?: Record<string, FieldWidgetHint>;
+    onClose?: () => void;
+}
+export declare function FormRunnerHost({ fetcher, definition, fieldMetadata, onClose }: FormRunnerHostProps): import("react").JSX.Element;
+export {};

package/dist/components/form-runner.d.ts

@@ -0,0 +1,43 @@
+import { SchemaContextValue, Table } from '../types/schema';
+import { FormDefinition } from '../lib/form-definition';
+import { FieldWidgetHint } from '../lib/form-widget';
+/**
+ * Resolves the definition's bound table against the introspected schema. The
+ * builder may store a qualified "schema.name" while the schema keys on the
+ * GraphQL name, so match on either form. Returns undefined when the table is no
+ * longer in the published schema.
+ */
+export declare function resolveDefinitionTable(schema: SchemaContextValue, tableId: string): Table | undefined;
+interface FormRunnerViewProps {
+    table: Table;
+    definition: FormDefinition;
+    /** App-metadata widget hints keyed by column name (widget / visible / readOnly). */
+    fieldMetadata?: Record<string, FieldWidgetHint>;
+    onClose?: () => void;
+    schema?: SchemaContextValue;
+    /** Values fixed by a containing form when creating a related record. */
+    initialValues?: Record<string, unknown>;
+    /** Fields supplied by a containing form; retain them in mutations but do not render inputs. */
+    hiddenFields?: readonly string[];
+    /** Opens the runner directly in create mode for a related-record action. */
+    startInNewMode?: boolean;
+    /** Opens the runner on this row for a related-record edit action. */
+    initialPkRoute?: string;
+}
+/**
+ * The bound runtime for a resolved table. Split from {@link FormRunner} so it can
+ * be exercised directly with a `Table` and a fetcher, without a schema fetch.
+ */
+export declare function FormRunnerView({ table, definition, fieldMetadata, onClose, schema, initialValues, hiddenFields, startInNewMode, initialPkRoute }: FormRunnerViewProps): import("react").JSX.Element;
+interface FormRunnerProps {
+    definition: FormDefinition;
+    fieldMetadata?: Record<string, FieldWidgetHint>;
+    onClose?: () => void;
+}
+/**
+ * Top-level form runner: resolves the definition's table from the introspected
+ * schema, then hands off to {@link FormRunnerView}. Renders loading / error /
+ * not-found states so a stale definition cannot crash the tree.
+ */
+export declare function FormRunner({ definition, fieldMetadata, onClose }: FormRunnerProps): import("react").JSX.Element;
+export {};

package/dist/components/form-subform.d.ts

@@ -0,0 +1,11 @@
+import { Table } from '../types/schema';
+import { FormSubform } from '../lib/form-definition';
+interface Props {
+    parent: Table;
+    child: Table;
+    subform: FormSubform;
+    row: Record<string, unknown>;
+}
+/** Related child rows in a form. The selected parent values are always passed as GraphQL variables. */
+export declare function FormSubformPanel({ parent, child, subform, row }: Props): import("react").JSX.Element;
+export {};

package/dist/components/grouped-grid-summary.d.ts

@@ -0,0 +1,17 @@
+import { GridGroupMemberRequest, GroupingRow, GroupingSort } from '../lib/grid-grouping';
+interface GroupedGridSummaryProps {
+    label: string;
+    rows: readonly GroupingRow[];
+    loading?: boolean;
+    error?: Error | null;
+    sumLabel?: string;
+    /** Uses the active grid page-size preference, not an unrelated constant. */
+    pageSize: number;
+    /** Aggregate bucket order; member rows retain the active flat-grid order. */
+    sort: GroupingSort;
+    onSortChange: (sort: GroupingSort) => void;
+    memberRequest: (value: unknown) => GridGroupMemberRequest;
+}
+/** Server aggregate groups with local group paging and one expandable, server-filtered member bucket. */
+export declare function GroupedGridSummary({ label, rows, loading, error, sumLabel, pageSize, sort, onSortChange, memberRequest }: GroupedGridSummaryProps): import("react").JSX.Element;
+export {};

package/dist/components/m2m-panel.d.ts

@@ -1,10 +1,9 @@
-import { ManyToManyJoin, Table } from '../types/schema';
-import { ColumnPanel } from '../data-panel';
+import { ManyToManyJoin } from '../types/schema';
+import { DrillFrame } from '../lib/drill-stack';
 interface M2mPanelProps {
-    parentTable: Table;
     m2m: ManyToManyJoin;
     parentRowId: string;
-    onOpenColumn?: (panel: ColumnPanel) => void;
+    onOpenColumn?: (panel: DrillFrame) => void;
 }
 /**
  * One detail tab for a many-to-many relationship. The junction is skipped for
@@ -13,5 +12,5 @@ interface M2mPanelProps {
  * (insert a junction row) and detached (delete the junction row by its primary
  * key).
  */
-export declare function M2mPanel({ parentTable, m2m, parentRowId, onOpenColumn }: M2mPanelProps): import("react").JSX.Element;
+export declare function M2mPanel({ m2m, parentRowId, onOpenColumn }: M2mPanelProps): import("react").JSX.Element;
 export {};

package/dist/components/ui/table.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data-edit.d.ts

@@ -1,4 +1,5 @@
 import { ReactElement } from 'react';
+import { Column } from './types/schema';
 export declare const NONE_VALUE = "__none__";
 /**
  * Maps a form value to the Radix `<Select>` control value. Radix shows the
@@ -7,6 +8,18 @@ export declare const NONE_VALUE = "__none__";
  * indistinguishable from never having picked one.
  */
 export declare function selectControlValue(value: unknown, offersNone: boolean): string;
+/**
+ * Radix's Select emits onValueChange('') when the item matching the current
+ * value UNMOUNTS — which happens legitimately here whenever an FK select swaps
+ * its fallback "raw key" item for the freshly-fetched window item, or the
+ * option window reloads. That emission is never a user action (a user picks a
+ * real value or the NONE_VALUE sentinel), but handled as one it silently
+ * cleared the stored FK to '' and the dialog showed the placeholder over a row
+ * that HAS a value — then Save failed "required". Drop it.
+ */
+export declare function guardSelectClear(onChange: (val: string) => void): (val: string) => void;
+export type FkRole = 'none' | 'anchor-single' | 'anchor-composite' | 'member-composite';
+export declare function isFkOrEnumColumn(column: Column, fkRole: FkRole): boolean;
 /**
  * DataEdit component - Form interface for creating and editing database records.
  *
@@ -16,7 +29,7 @@ export declare function selectControlValue(value: unknown, offersNone: boolean):
  * @example
  * ```tsx
  * // Used within the router context
- * <Route path="/:table/edit/:editid" element={<DataEdit />} />
+ * <Route path="/:table/edit/:editId" element={<DataEdit />} />
  * ```
  *
  * @returns React element containing the edit form dialog
@@ -26,10 +39,10 @@ export declare function DataEdit(): ReactElement;
  * Prop-driven edit dialog. Use this to edit a record in place — from a grid at
  * any nesting depth — without changing the route, so the surrounding drill
  * context (parent → child → grandchild, side columns) is preserved. `table` is
- * the table's `graphQlName`; `editid` is the encoded PK route ('' to insert).
+ * the table's `graphQlName`; `editId` is the encoded PK route ('' to insert).
  */
-export declare function DataEditDialog({ table, editid, onClose }: {
+export declare function DataEditDialog({ table, editId, onClose }: {
     table: string;
-    editid: string;
+    editId: string;
     onClose: () => void;
 }): ReactElement;

package/dist/data-panel.d.ts

@@ -1,12 +1 @@
-/**
- * A side-panel drill frame. `filterTable` + `filterId` + `filterColumn`
- * describe the FK scoping applied to `tableName`'s rows — they're optional so
- * the same shape can also represent a simple "open table X" panel.
- */
-export interface ColumnPanel {
-    tableName: string;
-    filterTable?: string;
-    filterId?: string;
-    filterColumn?: string;
-}
 export declare function DataPanel(): import("react").JSX.Element;