cogsbox-shape 0.5.204 → 0.5.205

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

@@ -41,6 +41,7 @@ type FormUpdateParams = {
         message: string;
         code?: string;
     }>) => void;
+    clearZodErrors: (paths: string[][]) => void;
 };
 export declare function wireShapeValidationOptions(box: ShapeSchemaBox, params: TransformStateParams): void;
 /** Cross-field refine errors only — field rules are handled by state via setOptions. */

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

@@ -1,5 +1,12 @@
 import { createPluginContext } from "cogsbox-state";
 import { z } from "zod";
+function pathKey(path) {
+    return path.join("\0");
+}
+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),
@@ -21,6 +28,10 @@ function getRelatedFields(entry, field) {
     }
     return related;
 }
+function issueMatchesRelatedFields(issue, relatedFields) {
+    const leaf = String(issue.path.at(-1) ?? "");
+    return relatedFields.has(leaf);
+}
 export function wireShapeValidationOptions(box, params) {
     const entry = box[params.stateKey];
     if (!entry)
@@ -46,12 +57,21 @@ export function validateShapeRefines(box, params) {
     const relatedFields = getRelatedFields(entry, field);
     if (!relatedFields)
         return;
+    const relatedPaths = resolveRelatedPaths(params.path, relatedFields);
     const result = clientSchema.safeParse(params.getState());
-    if (result.success)
+    if (result.success) {
+        params.clearZodErrors(relatedPaths);
         return;
-    const issues = result.error.issues.filter((issue) => relatedFields.has(String(issue.path[0])));
-    if (issues.length > 0) {
-        params.addZodErrors(mapZodIssues(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)));
+    const stalePaths = relatedPaths.filter((targetPath) => !activeKeys.has(pathKey(targetPath)));
+    if (stalePaths.length > 0) {
+        params.clearZodErrors(stalePaths);
+    }
+    if (mapped.length > 0) {
+        params.addZodErrors(mapped);
     }
 }
 function buildInitialState(box) {

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.204",
+  "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",