@stonecrop/schema 0.31.0 → 0.32.0

package/dist/src/field.d.ts

@@ -1,423 +0,0 @@
-import { z } from 'zod';
-import type { ColumnSchema } from './column-schema';
-import { flattenFields } from './flatten';
-import type { InteractionMode } from './mode';
-import { TableViewConfig } from './table';
-export { flattenFields };
-/**
- * Field options - flexible bag for type-specific configuration.
- *
- * Usage:
- * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
- * - Select with badges: \{ choices: [...], badges: \{ Open: "warning", ... \} \} or bare map
- * - Decimal: config object (\{ precision: 10, scale: 2 \})
- * - Code: config object (\{ language: "python" \})
- *
- * Deliberately *not* a bare string: a string once meant "link target", which made the value's
- * shape encode its meaning. That job belongs to `ValueField.doctype`, leaving this a plain
- * choices-or-config bag.
- *
- * @public
- */
-export declare const FieldOptions: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
-/**
- * Field options type inferred from Zod schema
- * @public
- */
-export type FieldOptions = z.infer<typeof FieldOptions>;
-/**
- * Validation configuration for form fields
- * @public
- */
-export declare const FieldValidation: z.ZodObject<{
-    errorMessage: z.ZodString;
-}, z.core.$loose>;
-/**
- * Field validation type inferred from Zod schema
- * @public
- */
-export type FieldValidation = z.infer<typeof FieldValidation>;
-/**
- * A field that holds a scalar value, a link to another record, or a select choice.
- * The most common kind of field. `component` determines how it renders; the attributes below
- * carry everything else that is not a rendering concern.
- * @public
- */
-export interface ValueField {
-    /** Discriminator — identifies this as a value-holding field */
-    kind: 'field';
-    /** Unique identifier for this field within its doctype */
-    fieldname: string;
-    /**
-     * Vue component that renders this field — the primary (and only) rendering axis. Required:
-     * there is nothing left to derive it from, and a field without one has nothing to render it.
-     * Any string is valid; naming a custom component is how an app renders a field Stonecrop
-     * ships no widget for. See `CANONICAL_COMPONENTS` for the set Stonecrop provides.
-     */
-    component: string;
-    /** True for the field that identifies the record's primary-key column. */
-    primaryKey?: boolean;
-    /** True for a computed/display field with no backing DB column — excluded from SQL SELECT. */
-    computed?: boolean;
-    /** Editor language for code fields (e.g. `'json'`, `'typescript'`) — the only thing distinguishing
-     *  a JSON editor from a code editor, since both render with `ACodeEditor`. */
-    language?: string;
-    /**
-     * Target doctype slug. Presence is what makes a field a link.
-     *
-     * How it renders is decided by `component`, not by this: `AFormLink` renders an
-     * inline id-picker, while `AForm`/`ATable` expand the target (see `linkRenderMode`). Expansion
-     * metadata — backlink, fetch strategy, authoritative cardinality — lives in the doctype's
-     * `links` map, which is additive and never required for a plain foreign key.
-     */
-    doctype?: string;
-    /** Human-readable label */
-    label?: string;
-    /** CSS width (e.g. `"40ch"`, `"200px"`) */
-    width?: string;
-    /** CSS height (e.g. `"100%"`, `"40vh"`) — used by full-viewport fields such as Planner */
-    height?: string;
-    /** Text alignment */
-    align?: 'left' | 'center' | 'right' | 'start' | 'end';
-    /** Whether the field is editable in table cell context */
-    edit?: boolean;
-    /** Input mask pattern or serialized function */
-    mask?: string;
-    /** Serialized display formatter — distinct from `mask` (input). Spreads through
-     *  `schemaToColumns` to `ColumnSchema.format`; deserialized at render time by ATable's
-     *  `getFormattedValue`. Returns a plain string, HTML, or a {@link BadgeDescriptor} for badge
-     *  cells. When a descriptor is returned it wins over any badge map on `options`. */
-    format?: string;
-    /** Per-field interaction mode override */
-    mode?: InteractionMode;
-    /** Type-specific options: Select choices, Decimal precision config, etc. A link's target is not
-     *  here — it is `doctype`. */
-    options?: FieldOptions;
-    /** Whether the field is required */
-    required?: boolean;
-    /** Whether the field is read-only */
-    readOnly?: boolean;
-    /** Whether the field is hidden from the UI */
-    hidden?: boolean;
-    /** Default value for new records */
-    default?: unknown;
-    /** Validation configuration */
-    validation?: FieldValidation;
-    /** Cardinality for Link fields — authoritative value on LinkDeclaration takes precedence */
-    cardinality?: 'atMostOne' | 'one' | 'noneOrMany' | 'atLeastOne';
-    /**
-     * Provenance marker — stamped only by the GraphQL converter; absence means hand-authored.
-     * When present, the docbuilder freezes the field's identity set (`fieldname`, `primaryKey`,
-     * `required`, `options`, `cardinality`, `doctype`), since `fieldname` is the GraphQL/column
-     * binding and `doctype` is the FK's target. `component` is deliberately **not** frozen: it
-     * chooses the widget, which is an authoring decision the database has no opinion about.
-     */
-    source?: 'introspected';
-}
-/**
- * A layout container that groups other fields. Resolves to a nested AForm.
- * @public
- */
-export interface FieldsetField {
-    /** Discriminator — identifies this as a fieldset container */
-    kind: 'fieldset';
-    /** Unique identifier for this fieldset within its doctype */
-    fieldname: string;
-    /** Vue component to render this fieldset. Defaults to `'AFieldset'` in resolveSchema. */
-    component?: string;
-    /** Human-readable label for the fieldset legend */
-    label?: string;
-    /** Whether the fieldset can be collapsed */
-    collapsible?: boolean;
-    /** Interaction mode for all children inside this fieldset */
-    mode?: InteractionMode;
-    /** Nested field definitions — resolved recursively by resolveSchema */
-    schema: DoctypeField[];
-}
-/**
- * An inline table whose columns are defined directly in the schema (no linked doctype).
- * Use when the table data does not warrant a separate doctype.
- * @public
- */
-export interface TableField {
-    /** Discriminator — identifies this as an inline table */
-    kind: 'table';
-    /** Unique identifier for this table within its doctype */
-    fieldname: string;
-    /** Vue component to render this table. Defaults to `'ATable'` in resolveSchema. */
-    component?: string;
-    /** Human-readable label */
-    label?: string;
-    /** Column definitions — use ColumnSchema (fieldname key) from \@stonecrop/schema */
-    columns: ColumnSchema[];
-    /** View configuration — defaults to `{ view: 'list' }` in resolveSchema when absent */
-    config?: TableViewConfig;
-    /** Interaction mode for all cells inside this table */
-    mode?: InteractionMode;
-}
-/**
- * Union of all authoring-time field variants.
- * Use `kind` to discriminate: `'field'` | `'fieldset'` | `'table'`.
- * @public
- */
-export type DoctypeField = ValueField | FieldsetField | TableField;
-/**
- * Which of the three field shapes an entry has, read from the entry's own structure.
- *
- * The single definition of that question. It had three copies before this — the parser's
- * `injectKind`, {@link stripFieldKind}'s agreement check, and the docbuilder's own
- * `isValueField` in another package — each free to drift, and drift here re-types a field rather
- * than throwing: a value field read as a fieldset loses its column, a fieldset read as a value
- * field loses every child.
- *
- * Deliberately **shape-only**: a declared `kind` is ignored. Two callers depend on that. The
- * stripper compares this against the declaration to decide whether removing it is lossless, which
- * it cannot do if this honours it. The docbuilder reads raw JSON off disk and classifies entries to
- * decide which to render as editable rows — and `kind` is Stonecrop's own discriminant, not
- * something a doctype author writes, so a tool reading a file has no business consulting it.
- *
- * `injectKind` is the one place a declaration still wins, and only to leave an already-parsed
- * object untouched on its way back through.
- *
- * @param field - a field entry, authored or parsed
- * @returns the kind its shape implies
- * @public
- */
-export declare function inferFieldKind(field: unknown): DoctypeField['kind'];
-/**
- * Recursively injects the `kind` discriminant into a raw field object and, for fieldsets,
- * into each of its nested `schema` children — mirroring exactly what Zod's `preprocess`
- * does at every level of the discriminated union.
- *
- * Table `columns` are {@link ColumnSchema} entries, not `DoctypeField`s, so they are left
- * untouched — the Zod table schema validates them with a plain passthrough and never injects
- * `kind` there either.
- *
- * Needed because `Doctype.fromObject` constructs a Doctype without running Zod, yet the
- * registry's `resolveFields` gates link and fieldset handling on `field.kind`. Without this,
- * a JSON-authored link resolves to a flat scalar and a fieldset's children are dropped.
- *
- * @public
- */
-export declare function normalizeFieldKind(field: unknown): unknown;
-/**
- * Remove the `kind` discriminant from a field, recursing into a fieldset's children.
- *
- * The outbound half of the boundary {@link normalizeFieldKind} owns inbound. `kind` is a
- * discriminated-union tag the parser synthesizes, not something an author writes, so nothing that
- * *writes* a doctype should put it on disk — the generator and the docbuilder's save both call
- * this. Without it the two round-trip asymmetrically: every save adds a key the file never had.
- *
- * Strips only when `injectKind` would restore exactly what was removed. A fieldset carrying no
- * `schema` re-infers as a plain field, so its `kind` is kept rather than silently re-typing the
- * document; `DoctypeMeta` requires `schema` on a fieldset, so that shape is already invalid and
- * belongs to the load gate, not here.
- *
- * Table `columns` are {@link ColumnSchema} entries rather than `DoctypeField`s and never carry an
- * injected `kind`, so they are passed through untouched — the same asymmetry `injectKind` has.
- *
- * @param field - a field object, as held in memory after parsing
- * @returns the field without `kind`, safe to serialize
- * @public
- */
-export declare function stripFieldKind(field: unknown): unknown;
-/**
- * The field properties a `source: 'introspected'` marker freezes — the ones the database owns.
- *
- * This is the single definition of the identity set. The docbuilder greys these inputs on an
- * introspected field, and the converter's merge refuses to rewrite them. Stating it twice is how
- * the two drift, so both read this constant.
- *
- * Everything absent from this list is author-owned, `component` most importantly: it chooses the
- * widget, which is an authoring decision the database has no opinion about.
- *
- * @public
- */
-export declare const INTROSPECTED_IDENTITY_PROPS: readonly ["fieldname", "primaryKey", "required", "options", "cardinality", "doctype"];
-/**
- * Find the field a doctype marks as its primary key, or `undefined` when none is marked.
- *
- * This is the single definition of "which field identifies a record". Both sides depend on it:
- * the middleware builds the SQL identity predicate from it, and the client resolves a record's
- * route/store key from it. Call this; never re-derive the rule at the call site, or the two will
- * drift and the client will key records by a column the server never queried.
- *
- * Two deliberate rules, both matching the shape `primaryKey` actually has:
- * - Fieldset children are **included**, via {@link flattenFields}. A fieldset is layout, not
- *   scope: its children are fields of the doctype with columns of their own, which is why the
- *   adapter's SELECT already descends and why `getDisplayField` does too. Scanning top level only
- *   did not *refuse* a nested declaration — it ignored one, so an author marked identity and
- *   nothing honoured it and nothing said so.
- * - The **first** match in document order wins. Identity is single-valued by design — a doctype
- *   describes the API surface, and mapping a composite database key onto one identity there is the
- *   adapter's job — so a doctype declaring several is malformed rather than composite.
- *   `DoctypeMeta` rejects that at the load gate; this stays total for callers holding fields that
- *   never went through it.
- *
- * @param fields - the doctype's fields; fieldset children are descended into
- * @returns the primary-key field, or `undefined` for a PK-less doctype
- * @public
- */
-export declare function getPrimaryKeyField(fields: readonly DoctypeField[]): ValueField | undefined;
-/**
- * Resolve the field a doctype nominates as its display text, or `undefined` when the nomination
- * does not name a readable column.
- *
- * This is the single definition of "is this a usable `displayField`". Both sides depend on it:
- * `DoctypeMeta` refuses a bad nomination at the load gate, and the adapter builds a SELECT from
- * the field it returns. Call this; never re-derive the rule, or the gate and the query will
- * disagree about which nominations are legal — which they did, in both directions at once.
- *
- * Two things disqualify a nomination, and both are the doctype saying so itself:
- * - it names no field at all, fieldset children included
- * - it names a `computed` field, which is declared precisely to state it has no column, so a
- *   SELECT built from it would reference a column the database does not have
- *
- * @param fields - the doctype's top-level fields
- * @param displayField - the nominated fieldname
- * @returns the nominated field, or `undefined` when it is not a readable column
- * @public
- */
-export declare function getDisplayField(fields: readonly DoctypeField[], displayField: string | undefined): ValueField | undefined;
-/**
- * The name of the field a record is identified by: the declared `primaryKey`, or `id` when the
- * doctype declares none.
- *
- * The `id` fallback is load-bearing, not defensive — a surrogate-key doctype carries an `id`
- * column and marks no primary key, so "nothing declared" means `id`, not "no identity".
- *
- * This exists because that one-line rule had been restated at four sites — the client's
- * `Doctype.recordIdField`, both nuxt hosts' `recordLookupField`, and the Postgres adapter — and
- * the fourth had omitted the fallback, so a doctype the client keyed by `id` was one the adapter
- * could not look up at all. Call this; a fifth restatement is how they diverge again.
- *
- * The returned name is not guaranteed to be a declared field: a doctype that declares no
- * `primaryKey` and no `id` yields `'id'` regardless. An adapter that must build a SQL predicate
- * from it has to confirm the field exists and say so when it does not, because selecting a column
- * the doctype never declared returns nothing rather than failing.
- *
- * @param fields - the doctype's top-level fields
- * @returns the identifying fieldname
- * @public
- */
-export declare function getRecordIdField(fields: readonly DoctypeField[]): string;
-/**
- * Resolve a record's identity value using the doctype's declared primary key.
- *
- * Falls back to `record.id` when the doctype declares no `primaryKey`. That fallback is
- * load-bearing, not defensive: surrogate-key doctypes carry an `id` column and never mark a
- * primary key, and PostGraphile renames a single-column `id` PK to `rowId` — so the declared
- * field and `id` are both real sources, in that order.
- *
- * @param fields - the doctype's top-level fields
- * @param record - the record to read the identity from
- * @returns the identity as a string, or `undefined` when neither source yields a usable value
- * @public
- */
-export declare function getRecordIdentity(fields: readonly DoctypeField[], record: Record<string, unknown>): string | undefined;
-/**
- * Zod runtime validation schema for ValueField.
- * @public
- */
-export declare const ValueFieldSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"field">;
-    fieldname: z.ZodString;
-    component: z.ZodString;
-    primaryKey: z.ZodOptional<z.ZodBoolean>;
-    computed: z.ZodOptional<z.ZodBoolean>;
-    language: z.ZodOptional<z.ZodString>;
-    doctype: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    width: z.ZodOptional<z.ZodString>;
-    height: z.ZodOptional<z.ZodString>;
-    align: z.ZodOptional<z.ZodEnum<{
-        left: "left";
-        right: "right";
-        center: "center";
-        start: "start";
-        end: "end";
-    }>>;
-    edit: z.ZodOptional<z.ZodBoolean>;
-    mask: z.ZodOptional<z.ZodString>;
-    format: z.ZodOptional<z.ZodString>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        edit: "edit";
-        read: "read";
-        display: "display";
-    }>>;
-    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    readOnly: z.ZodOptional<z.ZodBoolean>;
-    hidden: z.ZodOptional<z.ZodBoolean>;
-    default: z.ZodOptional<z.ZodUnknown>;
-    validation: z.ZodOptional<z.ZodObject<{
-        errorMessage: z.ZodString;
-    }, z.core.$loose>>;
-    cardinality: z.ZodOptional<z.ZodEnum<{
-        atMostOne: "atMostOne";
-        one: "one";
-        noneOrMany: "noneOrMany";
-        atLeastOne: "atLeastOne";
-    }>>;
-    source: z.ZodOptional<z.ZodLiteral<"introspected">>;
-}, z.core.$strip>;
-/**
- * Zod runtime validation schema for FieldsetField.
- * Recursive — FieldsetField.schema is validated against DoctypeFieldSchema.
- * @public
- */
-export declare const FieldsetFieldSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"fieldset">;
-    fieldname: z.ZodString;
-    component: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    collapsible: z.ZodOptional<z.ZodBoolean>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        edit: "edit";
-        read: "read";
-        display: "display";
-    }>>;
-    schema: z.ZodLazy<z.ZodArray<z.ZodType<DoctypeField, unknown, z.core.$ZodTypeInternals<DoctypeField, unknown>>>>;
-}, z.core.$strip>;
-/**
- * Zod runtime validation schema for TableField.
- * @public
- */
-export declare const TableFieldSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"table">;
-    fieldname: z.ZodString;
-    component: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    columns: z.ZodArray<z.ZodObject<{
-        fieldname: z.ZodString;
-    }, z.core.$loose>>;
-    config: z.ZodOptional<z.ZodObject<{
-        view: z.ZodOptional<z.ZodEnum<{
-            list: "list";
-            uncounted: "uncounted";
-            "list-expansion": "list-expansion";
-            tree: "tree";
-            gantt: "gantt";
-            "tree-gantt": "tree-gantt";
-        }>>;
-        fullWidth: z.ZodOptional<z.ZodBoolean>;
-        defaultTreeExpansion: z.ZodOptional<z.ZodEnum<{
-            root: "root";
-            branch: "branch";
-            leaf: "leaf";
-        }>>;
-        dependencyGraph: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        edit: "edit";
-        read: "read";
-        display: "display";
-    }>>;
-}, z.core.$strip>;
-/**
- * Zod runtime validation schema for the DoctypeField discriminated union.
- * Validates all three field variants: `'field'`, `'fieldset'`, `'table'`.
- * @public
- */
-export declare const DoctypeFieldSchema: z.ZodType<DoctypeField, unknown, z.core.$ZodTypeInternals<DoctypeField, unknown>>;
-//# sourceMappingURL=field.d.ts.map

package/dist/src/field.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field.ts"],"names":[],"mappings":"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"}