cogsbox-shape 0.5.209 → 0.5.211

package/cogsbox-shape-state/dist/plugin.d.ts

@@ -1,11 +1,23 @@
+import { type ChainMethodContext } from "cogsbox-state";
 import { z } from "zod";
 /** Minimal shape of a createSchemaBox entry — matches journalSchemaBox.journalTechnical etc. */
 export type ShapeRefineInfo = {
     fieldToGroup: Record<string, number[]>;
     groups: {
-        deps: string[] | null;
+        deps: readonly string[] | null;
     }[];
 };
+export type ShapeIssue = {
+    path: string[];
+    message: string;
+    code?: string;
+};
+export type ShapeErrorGroup = {
+    hasErrors: boolean;
+    message: string;
+    issues: ShapeIssue[];
+};
+export type ShapeErrorGroups = Record<string, ShapeErrorGroup>;
 export type ShapeSchemaBoxEntry = {
     /** Field-key → value map from DeriveStateType (not z.infer on a flattened client object). */
     stateType: Record<string, unknown>;
@@ -13,6 +25,9 @@ export type ShapeSchemaBoxEntry = {
     schemas: {
         client: z.ZodTypeAny;
     };
+    validators?: {
+        client: z.ZodTypeAny;
+    };
     refineInfo?: ShapeRefineInfo;
 };
 export type ShapeSchemaBox = Record<string, ShapeSchemaBoxEntry>;
@@ -42,11 +57,25 @@ type FormUpdateParams = {
         code?: string;
     }>) => void;
     clearZodErrors: (paths: string[][]) => void;
+    setErrorGroups?: (parentPath: string[], groups: ShapeErrorGroups) => void;
 };
+type MutableTuple<T> = T extends readonly [...infer TItems] ? TItems : never;
+type ExtractShapeRefineGroupFields<TEntry> = TEntry extends {
+    refineInfo?: {
+        groups: readonly (infer TGroup)[];
+    };
+} ? TGroup extends {
+    deps: infer TDeps;
+} ? TDeps extends readonly string[] ? MutableTuple<TDeps> : never : never : never;
+type ShapeRefineGroupFields<TBox extends ShapeSchemaBox> = [
+    ExtractShapeRefineGroupFields<TBox[keyof TBox]>
+] extends [never] ? string[] : ExtractShapeRefineGroupFields<TBox[keyof TBox]>;
 export declare function wireShapeValidationOptions(box: ShapeSchemaBox, params: TransformStateParams): void;
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */
 export declare function validateShapeRefines(box: ShapeSchemaBox, params: FormUpdateParams): void;
 export declare function createShapePlugin<const TBox extends ShapeSchemaBox>(box: TBox): import("cogsbox-state").CogsPluginBuilder<"shape", {
     logs: boolean | undefined;
-}, unknown, unknown, never, {}, true, false, true, false, false, true, InferShapeBoxState<TBox>>;
+}, unknown, unknown, never, {
+    $errorGroups: import("cogsbox-state").ChainMethodDefinition<(_ctx: ChainMethodContext, ...fields: ShapeRefineGroupFields<TBox>) => ShapeErrorGroup>;
+}, true, false, true, true, false, true, InferShapeBoxState<TBox>>;
 export {};

package/cogsbox-shape-state/dist/plugin.js

@@ -1,8 +1,19 @@
 import { createPluginContext } from "cogsbox-state";
 import { z } from "zod";
+const emptyErrorGroup = {
+    hasErrors: false,
+    message: "",
+    issues: [],
+};
 function pathKey(path) {
     return path.join("\0");
 }
+function errorGroupStorageKey(stateKey, parentPath) {
+    return [stateKey, ...parentPath].join("\0");
+}
+function groupKey(fields) {
+    return fields.join("+");
+}
 function resolveRelatedPaths(blurPath, relatedFields) {
     const parent = blurPath.slice(0, -1);
     return [...relatedFields].map((field) => [...parent, field]);
@@ -32,13 +43,30 @@ function issueMatchesRelatedFields(issue, relatedFields) {
     const leaf = String(issue.path.at(-1) ?? "");
     return relatedFields.has(leaf);
 }
+function buildShapeErrorGroups(entry, groupIndexes, fallbackField, issues) {
+    const groups = {};
+    for (const index of groupIndexes) {
+        const deps = entry.refineInfo?.groups[index]?.deps ?? [fallbackField];
+        const relatedFields = new Set(deps);
+        const mapped = mapZodIssues(issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields)));
+        groups[groupKey(deps)] =
+            mapped.length > 0
+                ? {
+                    hasErrors: true,
+                    message: mapped[0]?.message ?? "",
+                    issues: mapped,
+                }
+                : emptyErrorGroup;
+    }
+    return groups;
+}
 export function wireShapeValidationOptions(box, params) {
     const entry = box[params.stateKey];
     if (!entry)
         return;
     params.setOptions({
         validation: {
-            zodSchemaV4: entry.schemas.client,
+            zodSchemaV4: entry.validators?.client ?? entry.schemas.client,
             onBlur: "error",
         },
     });
@@ -48,21 +76,25 @@ export function validateShapeRefines(box, params) {
     if (params.event.activityType !== "blur")
         return;
     const entry = box[params.stateKey];
-    const clientSchema = entry?.schemas.client;
+    const clientSchema = entry?.validators?.client ?? entry?.schemas.client;
     if (!entry || !clientSchema)
         return;
     const field = params.path.at(-1);
     if (!field)
         return;
+    const groupIndexes = entry.refineInfo?.fieldToGroup[field];
     const relatedFields = getRelatedFields(entry, field);
     if (!relatedFields)
         return;
     const relatedPaths = resolveRelatedPaths(params.path, relatedFields);
     const result = clientSchema.safeParse(params.getState());
+    const parentPath = params.path.slice(0, -1);
     if (result.success) {
+        params.setErrorGroups?.(parentPath, buildShapeErrorGroups(entry, groupIndexes ?? [], field, []));
         params.clearZodErrors(relatedPaths);
         return;
     }
+    params.setErrorGroups?.(parentPath, buildShapeErrorGroups(entry, groupIndexes ?? [], field, result.error.issues));
     const issues = result.error.issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields));
     const mapped = mapZodIssues(issues);
     const activeKeys = new Set(mapped.map((entry) => pathKey(entry.path)));
@@ -91,6 +123,14 @@ const { createPlugin } = createPluginContext({
     }),
 });
 export function createShapePlugin(box) {
+    const errorGroupsByPath = new Map();
+    const setErrorGroups = (stateKey, parentPath, groups) => {
+        const key = errorGroupStorageKey(stateKey, parentPath);
+        errorGroupsByPath.set(key, {
+            ...errorGroupsByPath.get(key),
+            ...groups,
+        });
+    };
     return createPlugin("shape")
         .initialState(() => buildInitialState(box))
         .transformState((params) => wireShapeValidationOptions(box, params))
@@ -98,6 +138,15 @@ export function createShapePlugin(box) {
         if (params.options?.logs) {
             console.log("[shape]", params.stateKey, params.path, params.event.activityType);
         }
-        validateShapeRefines(box, params);
-    });
+        validateShapeRefines(box, {
+            ...params,
+            setErrorGroups: (parentPath, groups) => setErrorGroups(params.stateKey, parentPath, groups),
+        });
+    })
+        .methods(({ object }) => ({
+        $errorGroups: object((_ctx, ...fields) => {
+            const key = errorGroupStorageKey(_ctx.stateKey, _ctx.path);
+            return (errorGroupsByPath.get(key)?.[groupKey(fields)] ?? emptyErrorGroup);
+        }),
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.209",
+  "version": "0.5.211",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",