@stndrds/schema 1.0.0-alpha.328 → 1.0.0-alpha.330

package/dist/index-Uwy7CTKo.d.ts

@@ -0,0 +1,254 @@
+
+import { Y as Attribute, Z as AttributeType } from "./exceptions-DGCzCc9t.js";
+import { z as z$1 } from "zod";
+import { IconName } from "@stndrds/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;
+  attributes?: (Attribute | {
+    build: () => Attribute;
+  })[];
+  metadata?: Record<string, unknown>;
+}
+interface UpdateObjectInput {
+  label?: string;
+  pluralLabel?: string;
+  description?: string;
+  icon?: IconName;
+  labelExpression?: string;
+  embeddingExpression?: string;
+  metadata?: Record<string, unknown>;
+}
+interface RelationOption {
+  id: string;
+  objectId: string;
+  objectName: string;
+  objectLabel: string;
+  objectIcon?: string;
+  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"];
+/**
+ * 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<{
+    gray: "gray";
+    slate: "slate";
+    blue: "blue";
+    sky: "sky";
+    indigo: "indigo";
+    green: "green";
+    emerald: "emerald";
+    teal: "teal";
+    red: "red";
+    rose: "rose";
+    yellow: "yellow";
+    amber: "amber";
+    orange: "orange";
+    purple: "purple";
+    violet: "violet";
+    fuchsia: "fuchsia";
+    pink: "pink";
+    cyan: "cyan";
+    lime: "lime";
+  }>;
+}, 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<{
+    gray: "gray";
+    slate: "slate";
+    blue: "blue";
+    sky: "sky";
+    indigo: "indigo";
+    green: "green";
+    emerald: "emerald";
+    teal: "teal";
+    red: "red";
+    rose: "rose";
+    yellow: "yellow";
+    amber: "amber";
+    orange: "orange";
+    purple: "purple";
+    violet: "violet";
+    fuchsia: "fuchsia";
+    pink: "pink";
+    cyan: "cyan";
+    lime: "lime";
+  }>;
+}, 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<{
+    gray: "gray";
+    slate: "slate";
+    blue: "blue";
+    sky: "sky";
+    indigo: "indigo";
+    green: "green";
+    emerald: "emerald";
+    teal: "teal";
+    red: "red";
+    rose: "rose";
+    yellow: "yellow";
+    amber: "amber";
+    orange: "orange";
+    purple: "purple";
+    violet: "violet";
+    fuchsia: "fuchsia";
+    pink: "pink";
+    cyan: "cyan";
+    lime: "lime";
+  }>;
+  group: z$1.ZodEnum<{
+    idle: "idle";
+    in_progress: "in_progress";
+    finished: "finished";
+  }>;
+}, z$1.core.$strict>;
+/**
+ * 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>;
+/**
+ * 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 { UpdateObjectInput as S, statusOptionWriteSchema as _, getAttributeConfigWriteSchema as a, RelationOption as b, parseAttributeConfigForCreate as c, propertyAttributeWireSchema as d, propertySchemaSchema as f, statusGroupSchema as g, selectOptionWriteSchema as h, getAttributeConfigSchema as i, parseAttributeConfigForUpdate as l, refuseForeignKeys as m, WIRE_OMITTED_CONFIG_KEYS as n, multiselectOptionWriteSchema as o, propertySchemaWireSchema as p, attributeConfigSchemas as r, parseAttributeConfig as s, SIMPLE_PROPERTY_TYPES as t, propertyAttributeSchema as u, AddAttributeInput as v, RelationOptionsResponse as x, CreateCustomObjectInput as y };

package/dist/index-XtmC-C7J.d.mts

@@ -0,0 +1,53 @@
+
+import { Y as Attribute } from "./exceptions-DGCzCc9t.mjs";
+import { z as z$1 } from "zod";
+//#region src/validation/core/types.d.ts
+/**
+ * Validation messages for Zod validators.
+ * All functions receive the full Attribute to access label, type, etc.
+ * Can be customized for i18n support.
+ */
+interface ValidationMessages {
+  required: (attr: Attribute) => string;
+  invalidType: (attr: Attribute, expected: string) => string;
+  minLength: (attr: Attribute, min: number) => string;
+  maxLength: (attr: Attribute, max: number) => string;
+  invalidPattern: (attr: Attribute) => string;
+  minValue: (attr: Attribute, min: number) => string;
+  maxValue: (attr: Attribute, max: number) => string;
+  mustBeInteger: (attr: Attribute) => string;
+  invalidDate: (attr: Attribute) => string;
+  invalidOption: (attr: Attribute, options: string[]) => string;
+  invalidId: (attr: Attribute) => string;
+  maxItems: (attr: Attribute, max: number) => string;
+  invalidRichtext: (attr: Attribute) => string;
+  invalidPhone: (attr: Attribute) => string;
+  invalidCurrency: (attr: Attribute) => string;
+  invalidLocation: (attr: Attribute) => string;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+  success: boolean;
+  data?: Record<string, unknown>;
+  errors?: Array<{
+    path: string[];
+    message: string;
+  }>;
+}
+//#endregion
+//#region src/validation/core/messages.d.ts
+declare const DEFAULT_VALIDATION_MESSAGES: ValidationMessages;
+//#endregion
+//#region src/validation/core/errors.d.ts
+/**
+ * Format Zod validation errors into a consistent structure.
+ * This eliminates code duplication across multiple validation functions.
+ */
+declare function formatZodErrors(error: z$1.ZodError): Array<{
+  path: string[];
+  message: string;
+}>;
+//#endregion
+export { ValidationResult as i, DEFAULT_VALIDATION_MESSAGES as n, ValidationMessages as r, formatZodErrors as t };