cogsbox-shape 0.5.203 → 0.5.205

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

@@ -1 +1 @@
-export { createShapePlugin, validateShapeFormUpdate, type InferShapeBoxState, type ShapeRefineInfo, type ShapeSchemaBox, type ShapeSchemaBoxEntry, } from "./plugin.js";
+export { createShapePlugin, validateShapeRefines, wireShapeValidationOptions, type InferShapeBoxState, type ShapeRefineInfo, type ShapeSchemaBox, type ShapeSchemaBoxEntry, } from "./plugin.js";

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

@@ -1 +1 @@
-export { createShapePlugin, validateShapeFormUpdate, } from "./plugin.js";
+export { createShapePlugin, validateShapeRefines, wireShapeValidationOptions, } from "./plugin.js";

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

@@ -20,6 +20,15 @@ export type ShapeSchemaBox = Record<string, ShapeSchemaBoxEntry>;
 export type InferShapeBoxState<TBox extends ShapeSchemaBox> = {
     [K in keyof TBox]: TBox[K]["stateType"];
 };
+type TransformStateParams = {
+    stateKey: string;
+    setOptions: (options: {
+        validation?: {
+            zodSchemaV4?: z.ZodTypeAny;
+            onBlur?: "error" | "warning";
+        };
+    }) => void;
+};
 type FormUpdateParams = {
     stateKey: string;
     path: string[];
@@ -32,9 +41,12 @@ type FormUpdateParams = {
         message: string;
         code?: string;
     }>) => void;
+    clearZodErrors: (paths: string[][]) => void;
 };
-export declare function validateShapeFormUpdate(box: ShapeSchemaBox, params: FormUpdateParams): void;
+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, {}, false, false, true, false, false, true, InferShapeBoxState<TBox>>;
+}, unknown, unknown, never, {}, true, false, true, false, false, true, InferShapeBoxState<TBox>>;
 export {};

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

@@ -1,21 +1,24 @@
 import { createPluginContext } from "cogsbox-state";
 import { z } from "zod";
-function getValueAtPath(state, path) {
-    return path.reduce((current, key) => {
-        if (current !== null && typeof current === "object") {
-            return current[key];
-        }
-        return undefined;
-    }, state);
+function pathKey(path) {
+    return path.join("\0");
 }
-function getClientFieldSchema(clientSchema, field) {
-    const shape = clientSchema
-        .shape;
-    return shape?.[field];
+function resolveRelatedPaths(blurPath, relatedFields) {
+    const parent = blurPath.slice(0, -1);
+    return [...relatedFields].map((field) => [...parent, field]);
+}
+function mapZodIssues(issues) {
+    return issues.map((issue) => ({
+        path: issue.path.map(String),
+        message: issue.message,
+        code: issue.code,
+    }));
 }
 function getRelatedFields(entry, field) {
+    const groupIndexes = entry.refineInfo?.fieldToGroup[field];
+    if (!groupIndexes?.length)
+        return null;
     const related = new Set([field]);
-    const groupIndexes = entry.refineInfo?.fieldToGroup[field] ?? [];
     for (const index of groupIndexes) {
         const deps = entry.refineInfo?.groups[index]?.deps;
         if (!deps)
@@ -25,42 +28,50 @@ function getRelatedFields(entry, field) {
     }
     return related;
 }
-function mapZodIssues(issues, pathPrefix = []) {
-    return issues.map((issue) => ({
-        path: [...pathPrefix, ...issue.path.map(String)],
-        message: issue.message,
-        code: issue.code,
-    }));
+function issueMatchesRelatedFields(issue, relatedFields) {
+    const leaf = String(issue.path.at(-1) ?? "");
+    return relatedFields.has(leaf);
 }
-export function validateShapeFormUpdate(box, params) {
+export function wireShapeValidationOptions(box, params) {
+    const entry = box[params.stateKey];
+    if (!entry)
+        return;
+    params.setOptions({
+        validation: {
+            zodSchemaV4: entry.schemas.client,
+            onBlur: "error",
+        },
+    });
+}
+/** Cross-field refine errors only — field rules are handled by state via setOptions. */
+export function validateShapeRefines(box, params) {
+    if (params.event.activityType !== "blur")
+        return;
     const entry = box[params.stateKey];
     const clientSchema = entry?.schemas.client;
     if (!entry || !clientSchema)
         return;
-    const state = params.getState();
     const field = params.path.at(-1);
     if (!field)
         return;
-    if (params.event.activityType === "blur") {
-        const result = clientSchema.safeParse(state);
-        if (result.success)
-            return;
-        const relatedFields = getRelatedFields(entry, field);
-        const issues = result.error.issues.filter((issue) => relatedFields.has(String(issue.path[0])));
-        if (issues.length > 0) {
-            params.addZodErrors(mapZodIssues(issues));
-        }
+    const relatedFields = getRelatedFields(entry, field);
+    if (!relatedFields)
         return;
+    const relatedPaths = resolveRelatedPaths(params.path, relatedFields);
+    const result = clientSchema.safeParse(params.getState());
+    if (result.success) {
+        params.clearZodErrors(relatedPaths);
+        return;
+    }
+    const issues = result.error.issues.filter((issue) => issueMatchesRelatedFields(issue, relatedFields));
+    const mapped = mapZodIssues(issues);
+    const activeKeys = new Set(mapped.map((entry) => pathKey(entry.path)));
+    const stalePaths = relatedPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
+    if (stalePaths.length > 0) {
+        params.clearZodErrors(stalePaths);
     }
-    if (params.event.activityType === "input") {
-        const fieldSchema = getClientFieldSchema(clientSchema, field);
-        if (!fieldSchema)
-            return;
-        const value = getValueAtPath(state, params.path);
-        const result = fieldSchema.safeParse(value);
-        if (result.success)
-            return;
-        params.addZodErrors(mapZodIssues(result.error.issues, params.path));
+    if (mapped.length > 0) {
+        params.addZodErrors(mapped);
     }
 }
 function buildInitialState(box) {
@@ -82,10 +93,11 @@ const { createPlugin } = createPluginContext({
 export function createShapePlugin(box) {
     return createPlugin("shape")
         .initialState(() => buildInitialState(box))
+        .transformState((params) => wireShapeValidationOptions(box, params))
         .onFormUpdate((params) => {
         if (params.options?.logs) {
             console.log("[shape]", params.stateKey, params.path, params.event.activityType);
         }
-        validateShapeFormUpdate(box, params);
+        validateShapeRefines(box, params);
     });
 }

package/dist/schema.js

@@ -832,7 +832,7 @@ function createViewObject(initialRegistryKey, selection, registry, tableNameToRe
                 : registryEntry.zodSchemas.clientSchema;
         const primitiveShape = baseSchema.shape;
         if (subSelection === true) {
-            return z.object(primitiveShape);
+            return baseSchema;
         }
         const selectedRelationShapes = {};
         if (typeof subSelection === "object") {

package/dist/vitest/refineRuntime.test.js

@@ -85,4 +85,36 @@ describe("refine runtime behavior", () => {
         const good = box.rules.schemas.clientInput.safeParse({ id: 1, min: 10, max: 1 });
         expect(good.success).toBe(true);
     });
+    it("view keeps leaf refines and prefixes issue paths", () => {
+        const rules = schema({
+            _tableName: "rules",
+            id: s.sqlite({ type: "int", pk: true }),
+            min: s.sqlite({ type: "int" }).clientInput({ value: 0 }),
+            max: s.sqlite({ type: "int" }).clientInput({ value: 0 }),
+        }).refine((r) => [
+            r("client", (row) => row.min >= row.max
+                ? { path: ["max"], message: "Max must be > min" }
+                : undefined, ["min", "max"]),
+        ]);
+        const journal = schema({
+            _tableName: "journal",
+            id: s.sqlite({ type: "int", pk: true }),
+            rules: s.hasOne(true),
+        });
+        const box = createSchemaBox({ rules, journal }, {
+            journal: { rules: { fromKey: "id", toKey: rules.id } },
+        });
+        const view = box.journal.createView({ rules: true });
+        const bad = view.schemas.client.safeParse({
+            id: 1,
+            rules: { id: 1, min: 10, max: 1 },
+        });
+        expect(bad.success).toBe(false);
+        if (!bad.success) {
+            expect(bad.error.issues[0]).toMatchObject({
+                path: ["rules", "max"],
+                message: "Max must be > min",
+            });
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.203",
+  "version": "0.5.205",
   "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",