@standards/schema 0.0.0-stage → 1.0.0-alpha.382

package/dist/index-Bu9xF5Nq.d.ts

@@ -0,0 +1,278 @@
+
+import { J as ImageShape, u as RecordAppearance } from "./objects-B4DgFZ82.js";
+import { i as AttributeType, n as Attribute } from "./attributes-kAhQzg8-.js";
+import { z as z$1 } from "zod";
+import { ColorId, IconName } from "@standards/constants";
+//#region src/types/mutations.d.ts
+interface AddAttributeInput {
+  name: string;
+  label: string;
+  type: AttributeType;
+  required?: boolean;
+  unique?: boolean;
+  description?: string;
+  placeholder?: string;
+  icon?: IconName;
+  defaultValue?: unknown;
+  metadata?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+interface CreateCustomObjectInput {
+  name: string;
+  label: string;
+  pluralLabel?: string;
+  labelExpression: string;
+  embeddingExpression?: string;
+  description?: string;
+  icon?: IconName;
+  color?: ColorId;
+  imageShape?: ImageShape;
+  attributes?: (Attribute | {
+    build: () => Attribute;
+  })[];
+  metadata?: Record<string, unknown>;
+}
+interface UpdateObjectInput {
+  label?: string;
+  pluralLabel?: string;
+  description?: string;
+  icon?: IconName;
+  /** `null` clears it: the colour then derives from the object name. */
+  color?: ColorId | null;
+  /** `null` clears it: record images then crop to a square. */
+  imageShape?: ImageShape | null;
+  labelExpression?: string;
+  embeddingExpression?: string;
+  metadata?: Record<string, unknown>;
+}
+interface RelationOption {
+  id: string;
+  objectId: string;
+  objectName: string;
+  objectLabel: string;
+  objectIcon?: string;
+  objectColor?: ColorId;
+  objectImageShape?: ImageShape;
+  /** The target record's own icon / image; absent when it has neither. */
+  appearance?: RecordAppearance;
+  label: string;
+}
+interface RelationOptionsResponse {
+  options: RelationOption[];
+  hasMore: boolean;
+  total: number;
+  nextOffset?: number;
+}
+//#endregion
+//#region src/validation/config/schemas.d.ts
+/**
+ * `baseConfigSchema`'s keys — the model never sets these directly, and the
+ * prompt (`attribute-reference.ts`'s `BASE_CONFIG_KEYS`) already hides them
+ * from every `<attribute_types>` line. `ADD_ATTRIBUTE_WIRE` omits them from
+ * each per-type wire config for the same reason, so the wire never offers a
+ * key the model was never told about — and never exposes `metadata`, the one
+ * genuine open record among them, on the wire. Single source: the runtime
+ * prompt imports this instead of keeping its own copy.
+ */
+declare const WIRE_OMITTED_CONFIG_KEYS: readonly ["placeholder", "description", "defaultValue", "icon", "order", "hidden", "archived", "deprecated", "metadata"];
+/**
+ * The omitted base keys one attribute type's wire offers back, each with the
+ * wire schema it is validated by. Karl's ruling on #4537 (2026-09-27, «
+ * Relations seulement »): a relation field takes its own icon, a catalogue
+ * name the agent finds with `search_icons`, exactly as an object icon; every
+ * other type keeps `icon` omitted. Single source for the wire
+ * (`ADD_ATTRIBUTE_WIRE`) and the prompt (`attribute-reference.ts`), so the
+ * key the model is told about is the key the wire accepts.
+ */
+declare const WIRE_OFFERED_BASE_CONFIG: Partial<Record<AttributeType, Partial<Record<(typeof WIRE_OMITTED_CONFIG_KEYS)[number], z$1.ZodType>>>>;
+/** The keys hidden from `attributeType`'s wire config and its prompt line. */
+declare function wireOmittedConfigKeysFor(attributeType: AttributeType): readonly string[];
+/** `omit()` mask of the type keys hidden from `attributeType`'s wire. */
+declare function wireHiddenTypeConfigMask(attributeType: AttributeType): Record<string, true>;
+/**
+ * Builds the `superRefine` that refuses a key belonging to a DIFFERENT type
+ * than the one sent.
+ *
+ * Two wire shapes merge several types into one member for size — the nine
+ * simple attribute types of `ADD_ATTRIBUTE_WIRE`, and the seven simple
+ * qualified-property types below — so a merged member structurally accepts
+ * every merged type's keys. Without this, a `text`-only `format` sent on a
+ * `number` parses and is then silently `.strip()`-ped at store: a key lost
+ * with no feedback. Checked against the SENT type, and the message names the
+ * keys that type does accept so the next call is right. One factory rather
+ * than two near-identical loops — the second one drifted first.
+ */
+declare function refuseForeignKeys<T extends string>(keysByType: Readonly<Record<T, ReadonlySet<string>>>, noun: string, alwaysAllowed?: readonly string[]): (type: T, subject: Record<string, unknown> | undefined, ctx: z$1.RefinementCtx, path?: readonly string[]) => void;
+declare const statusGroupSchema: z$1.ZodEnum<{
+  idle: "idle";
+  in_progress: "in_progress";
+  finished: "finished";
+}>;
+declare const selectOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+}, z$1.core.$strict>;
+declare const multiselectOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+}, z$1.core.$strict>;
+declare const statusOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+  group: z$1.ZodEnum<{
+    idle: "idle";
+    in_progress: "in_progress";
+    finished: "finished";
+  }>;
+}, z$1.core.$strict>;
+/**
+ * Drops, from every option of an attribute config or body, the keys
+ * `optionSchema` does not know — typically an `id` the code builder accepted
+ * without complaint (#4356). Sync stores options through it, and the schema
+ * state reads them through it, so one stale key no longer 400s the whole state.
+ * The options of a `relation()`/`document()`'s `.qualifyWith()` properties are
+ * validated by the same schema, so each property definition goes through it too.
+ *
+ * Order is kept, and a config with nothing to drop is returned as is. A list
+ * or option that is not the expected shape is left for strict validation to
+ * refuse.
+ */
+declare function withoutUnknownOptionKeys<T extends object>(config: T): T;
+/**
+ * Property types whose config differs from `baseConfigSchema` only by
+ * independent optional scalars — no options array, no relation targets. Same
+ * shape as `SIMPLE_ATTRIBUTE_TYPES` in `architect/operations/schema.ts` minus
+ * `richtext`/`user` (not valid property types) — none of these seven types'
+ * keys collide, proven by `tests/validation/config/property-config.test.ts`.
+ * Merged into one wire member for the same reason `ADD_ATTRIBUTE_WIRE` merges
+ * its nine: the model reads one shape instead of seven near-identical ones,
+ * and this is also what keeps a qualified relation/document's `add_attribute`
+ * leaf under its wire-size cap (`tests/architect/wire-schema-size.test.ts`) —
+ * ten separate members, each paying its own JSON Schema object/`$defs`
+ * boilerplate, blew the budget even after the base config keys were omitted.
+ */
+declare const SIMPLE_PROPERTY_TYPES: readonly ["text", "number", "checkbox", "date", "phone", "currency", "location"];
+declare const propertyAttributeSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>[]], "type">;
+declare const propertySchemaSchema: z$1.ZodObject<{
+  definitions: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>[]], "type">>;
+}, z$1.core.$strip>;
+/**
+ * The wire-facing property union, derived from the stored one: the same seven
+ * simple types merged into one member, the option-carrying types alongside,
+ * everything the model never sets omitted, and `.strict()` so an invented key
+ * is refused by name instead of silently stripped at store.
+ */
+declare const propertyAttributeWireSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>[]], "type">;
+declare const propertySchemaWireSchema: z$1.ZodObject<{
+  definitions: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>[]], "type">>;
+}, z$1.core.$strict>;
+/**
+ * A month or a year has no time of day and no range end to pair with in this
+ * slice (#5325): `precision` narrower than a day is refused beside
+ * `includeTime` or `endDate`, on the attribute and on each date property it
+ * qualifies an edge with.
+ */
+declare function datePrecisionIssues(type: string, config: Record<string, unknown>, path?: PropertyKey[]): {
+  path: PropertyKey[];
+  message: string;
+}[];
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z$1.ZodObject<z$1.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z$1.ZodObject<z$1.ZodRawShape>;
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * The config contract as a WRITE applies it: the stored schema plus the
+ * stricter option and icon rules newly written values must satisfy.
+ */
+declare function getAttributeConfigWriteSchema(type: AttributeType): z$1.ZodObject<z$1.ZodRawShape>;
+/**
+ * Strict parser for newly created attribute definitions.
+ *
+ * Top-level config remains strip-compatible with the historical config
+ * contract, while newly written icons and select-like option objects are
+ * validated strictly.
+ */
+declare function parseAttributeConfigForCreate(type: AttributeType, input: unknown): Record<string, unknown>;
+/**
+ * Patch-aware parser for persisted attributes.
+ *
+ * An explicit options patch owns and strictly validates the complete new
+ * list. Omission means the stored legacy list is preserved without
+ * reconstruction, including options that predate required colours/groups.
+ */
+declare function parseAttributeConfigForUpdate(stored: Attribute, patch: Partial<AddAttributeInput>): Record<string, unknown>;
+//#endregion
+export { AddAttributeInput as C, UpdateObjectInput as D, RelationOptionsResponse as E, withoutUnknownOptionKeys as S, RelationOption as T, selectOptionWriteSchema as _, datePrecisionIssues as a, wireHiddenTypeConfigMask as b, multiselectOptionWriteSchema as c, parseAttributeConfigForUpdate as d, propertyAttributeSchema as f, refuseForeignKeys as g, propertySchemaWireSchema as h, attributeConfigSchemas as i, parseAttributeConfig as l, propertySchemaSchema as m, WIRE_OFFERED_BASE_CONFIG as n, getAttributeConfigSchema as o, propertyAttributeWireSchema as p, WIRE_OMITTED_CONFIG_KEYS as r, getAttributeConfigWriteSchema as s, SIMPLE_PROPERTY_TYPES as t, parseAttributeConfigForCreate as u, statusGroupSchema as v, CreateCustomObjectInput as w, wireOmittedConfigKeysFor as x, statusOptionWriteSchema as y };

package/dist/index-CiTBL4gH.d.ts

@@ -0,0 +1,101 @@
+
+import { i as ObjectDefinition } from "./objects-B4DgFZ82.js";
+import { n as Attribute } from "./attributes-kAhQzg8-.js";
+import { i as ValidationResult, r as ValidationMessages } from "./index-DLO8JpnY.js";
+import { z as z$1 } from "zod";
+//#region src/validation/object/attribute-factory.d.ts
+/**
+ * Create a Zod schema for any attribute type.
+ * Returns a strict validator that does NOT handle optional fields.
+ * Use createFormAttributeValidator for form validation with optional support.
+ *
+ * @param attr - The attribute to create a validator for
+ * @param messages - Custom validation messages for i18n support
+ */
+declare function createAttributeValidator(attr: Attribute, messages?: ValidationMessages): z$1.ZodTypeAny;
+/**
+ * Create a Zod schema for form validation.
+ * - Normalizes empty values (empty strings, empty objects) to null for optional fields
+ * - Accepts custom messages for i18n support
+ *
+ * Use this in UI forms where optional fields may have null/undefined values.
+ *
+ * @param attr - The attribute to create a validator for
+ * @param messages - Custom validation messages for i18n support
+ */
+declare function createFormAttributeValidator(attr: Attribute, messages?: ValidationMessages): z$1.ZodTypeAny;
+//#endregion
+//#region src/validation/object/object-validator.d.ts
+/**
+ * Create a Zod schema for an entire object
+ *
+ * Uses passthrough mode to allow computed fields (formula, rollup) that may be
+ * present in record data but are not part of the mutable schema.
+ *
+ * Result is cached per ObjectDefinition instance — safe because ObjectDefinitions
+ * are stable after module load and never mutated at runtime.
+ */
+declare function createObjectValidator(objectDef: ObjectDefinition): z$1.ZodType<Record<string, unknown>>;
+/**
+ * Create a Zod schema for draft validation.
+ * All attributes become optional, but provided values are still validated.
+ *
+ * Uses passthrough mode to allow computed fields (formula, rollup) that may be
+ * present in record data but are not part of the mutable schema.
+ *
+ * Result is cached per ObjectDefinition instance — safe because ObjectDefinitions
+ * are stable after module load and never mutated at runtime.
+ */
+declare function createDraftValidator(objectDef: ObjectDefinition): z$1.ZodType<Record<string, unknown>>;
+//#endregion
+//#region src/validation/object/helpers.d.ts
+/**
+ * Validate data against an attribute schema
+ */
+declare function validateAttribute(attr: Attribute, value: unknown): ValidationResult;
+/**
+ * Validate data against an object schema
+ */
+declare function validateObject(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate and throw if invalid.
+ *
+ * Throws `ValidationError` (code `SCHEMA_VALIDATION_FAILED`) on failure so HTTP
+ * adapters can map it to 400. Generic `Error` would bubble up to a 500.
+ */
+declare function validateObjectOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Validate data in draft mode.
+ * - All attributes are treated as optional (no required validation)
+ * - Provided values are still validated for format/type correctness
+ */
+declare function validateDraft(objectDef: ObjectDefinition, data: Record<string, unknown>): ValidationResult;
+/**
+ * Validate draft data and throw if format validation fails.
+ *
+ * Same contract as `validateObjectOrThrow` but skips `required()` checks.
+ * Throws `ValidationError` so HTTP adapters map it to 400.
+ */
+declare function validateDraftOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Throw a `ValidationError` when `data` contains keys that do not correspond
+ * to any attribute declared on `objectDef`.
+ *
+ * Call this on **client-supplied input** before Zod validation so the error
+ * message clearly names every offending key.  Do NOT call on merged data that
+ * includes existing record values — older records may legitimately carry stale
+ * keys that predate this guard (see issue #658).
+ *
+ * Maps to HTTP 400 via `SchemaExceptionFilter` (code SCHEMA_VALIDATION_FAILED).
+ */
+declare function rejectUnknownAttributesOrThrow(objectDef: ObjectDefinition, data: Record<string, unknown>): void;
+/**
+ * Get the list of required attributes that are missing values.
+ */
+declare function getMissingRequiredAttributes(objectDef: ObjectDefinition, data: Record<string, unknown>): Attribute[];
+/**
+ * Check if a record is complete (all required attributes have valid values).
+ */
+declare function isRecordComplete(objectDef: ObjectDefinition, data: Record<string, unknown>): boolean;
+//#endregion
+export { validateDraft as a, validateObjectOrThrow as c, createAttributeValidator as d, createFormAttributeValidator as f, validateAttribute as i, createDraftValidator as l, isRecordComplete as n, validateDraftOrThrow as o, rejectUnknownAttributesOrThrow as r, validateObject as s, getMissingRequiredAttributes as t, createObjectValidator as u };