cogsbox-shape 0.5.193 → 0.5.194

package/dist/vitest/fullSchema.test.js

@@ -0,0 +1,1367 @@
+import { expect, describe, it } from "vitest";
+import { expectTypeOf } from "expect-type";
+// Import the new primary method for schema creation
+import { s, schema, createSchemaBox } from "../schema.js";
+import z from "zod";
+/*
+================================================================
+SECTION A: TYPE-LEVEL TESTS (Using the new pattern)
+================================================================
+*/
+describe("Schema Builder Type Tests (with expect-type)", () => {
+    describe("Basic Field Definitions", () => {
+        it("should correctly type a simple varchar field", () => {
+            const nameField = s.sqlite({ type: "varchar" });
+            expectTypeOf(nameField.config.zodSqlSchema).toEqualTypeOf();
+        });
+        it("should correctly type a nullable integer field", () => {
+            const ageField = s.sqlite({ type: "int", nullable: true });
+            expectTypeOf(ageField.config.zodClientSchema).toEqualTypeOf();
+        });
+        it("should correctly type a primary key field", () => {
+            const idField = s.sqlite({ type: "int", pk: true });
+            expectTypeOf(idField.config.zodSqlSchema).toEqualTypeOf();
+        });
+        it("should correctly type an enum field", () => {
+            const statusField = s.sqlite({
+                type: "enum",
+                values: ["draft", "published", "archived"],
+            });
+            expectTypeOf().toEqualTypeOf();
+            expect(statusField.config.zodSqlSchema.parse("draft")).toBe("draft");
+            expect(() => statusField.config.zodSqlSchema.parse("deleted")).toThrow();
+        });
+    });
+    describe("Chainable Methods", () => {
+        it("should create a union type when .client provides a different type", () => {
+            const idField = s.sqlite({ type: "int", pk: true }).clientInput({
+                value: () => "temp-uuid-123",
+                schema: z.literal("temp-uuid-123"),
+            });
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("should NOT create a union type when .client provides the same type", () => {
+            const countField = s
+                .sqlite({ type: "int" })
+                .clientInput({ value: () => 0, schema: z.number() });
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("should correctly override the client schema with .clientInput()", () => {
+            const statusField = s
+                .sqlite({ type: "int" })
+                .clientInput(() => z.boolean());
+            expectTypeOf().toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("should add validation to client schema with .client()", () => {
+            const nameField = s
+                .sqlite({ type: "varchar" })
+                .clientInput({ value: "John" })
+                .client((tools) => tools.clientInput.min(3));
+            expectTypeOf().toEqualTypeOf();
+        });
+        it("should chain .clientInput().client().server() correctly", () => {
+            const nameField = s
+                .sqlite({ type: "varchar" })
+                .clientInput({ value: "" })
+                .client((tools) => tools.clientInput.min(3))
+                .server((tools) => tools.clientInput.min(5));
+            expectTypeOf().toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+    describe("`createSchemaBoxRegistry` Integration with Relations", () => {
+        // 1. Define schemas with placeholders
+        const users = schema({
+            _tableName: "users",
+            id: s.sqlite({ type: "int", pk: true }).clientInput({
+                value: () => "new-user",
+                schema: z.literal("new-user"),
+            }),
+            posts: s.hasMany(),
+        });
+        const posts = schema({
+            _tableName: "posts",
+            id: s.sqlite({ type: "int", pk: true }),
+            isPublished: s.sqlite({ type: "int" }).clientInput(() => z.boolean()),
+            authorId: s.reference(() => users.id),
+        });
+        // 2. Create the registry and resolve relations
+        const box = createSchemaBox({ users, posts }, {
+            users: {
+                posts: { fromKey: "id", toKey: posts.authorId },
+            },
+        });
+        const finalPostResult = box.posts.schemas;
+        it("should correctly handle reference types", () => {
+            // The authorId should be a union of the DB type (number) and the initial state of the referenced field
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+});
+/*
+================================================================
+SECTION B: RUNTIME BEHAVIOR TESTS (Using the new pattern)
+================================================================
+*/
+describe("Schema Builder Runtime Behavior", () => {
+    describe("Default Value Generation", () => {
+        // Define the schema using the new builder syntax
+        const defaultsSchema = schema({
+            _tableName: "defaults",
+            fromInitialState: s.sqlite({ type: "varchar" }).clientInput({
+                value: () => "from-initial-state",
+                schema: z.string(),
+            }),
+            fromSqlDefault: s.sqlite({ type: "int", default: 99 }),
+            isNullable: s.sqlite({ type: "boolean", nullable: true }),
+            hasNoDefault: s.sqlite({ type: "int" }),
+        });
+        // Process it with the registry
+        const box = createSchemaBox({ defaults: defaultsSchema }, {
+            defaults: {},
+        });
+        const defaults = box.defaults.defaults;
+        it("should get default from .clientInput()", () => {
+            expect(defaults.fromInitialState).toBe("from-initial-state");
+        });
+        it("should get default from SQL config", () => {
+            expect(defaults.fromSqlDefault).toBe(99);
+        });
+        it("should default a nullable field to null", () => {
+            expect(defaults.isNullable).toBeNull();
+        });
+        it("should use the generated default (e.g., 0 for int) when none is provided", () => {
+            expect(defaults.hasNoDefault).toBe(0);
+        });
+    });
+    describe("Schema Parsing, Validation, and Transformation", () => {
+        const complexSchemaDef = schema({
+            _tableName: "complex",
+            id: s.sqlite({ type: "int", pk: true }),
+            status: s
+                .sqlite({ type: "int" }) // DB: 0=Inactive, 1=Active
+                .clientInput(() => z.enum(["inactive", "active"])) // Client: "inactive" | "active"
+                .transform({
+                toClient: (dbValue) => (dbValue === 1 ? "active" : "inactive"),
+                toDb: (clientValue) => (clientValue === "active" ? 1 : 0),
+            }),
+            name: s
+                .sqlite({ type: "varchar" })
+                .server(({ sql }) => sql.min(3, "Name is too short")),
+        });
+        // Use the new registry to process the schema
+        const box = createSchemaBox({ complex: complexSchemaDef }, {
+            complex: {},
+        });
+        const { client, sql, server } = box.complex.schemas;
+        const { toClient, toDb } = box.complex.transforms;
+        it("should correctly transform a DB object to a Client object", () => {
+            const dbData = { id: 1, status: 1, name: "Test" };
+            const clientResult = toClient(dbData);
+            expect(clientResult.status).toBe("active");
+            expect(() => client.parse(clientResult)).not.toThrow();
+        });
+        it("should correctly transform a Client object to a DB object", () => {
+            const clientData = { id: 1, status: "inactive", name: "Test" };
+            const dbResult = toDb(clientData);
+            expect(dbResult.status).toBe(0);
+            expect(() => sql.parse(dbResult)).not.toThrow();
+        });
+        it("should still use the validationSchema for pure validation", () => {
+            const invalidClientData = { id: 1, status: "inactive", name: "ab" };
+            const result = server.safeParse(invalidClientData);
+            expect(result.success).toBe(false);
+            if (!result.success) {
+                expect(result.error.issues[0].message).toBe("Name is too short");
+            }
+        });
+    });
+});
+describe("Tools params are actual Zod schemas at runtime", () => {
+    it("should provide actual Zod schemas as tools in .client()", () => {
+        let capturedTools;
+        s.sqlite({ type: "varchar" })
+            .clientInput({ value: "test" })
+            .client((tools) => {
+            capturedTools = {
+                sql: tools.sql,
+                clientInput: tools.clientInput,
+                client: tools.client,
+            };
+            return tools.clientInput;
+        });
+        expect(capturedTools).toBeDefined();
+        expect(capturedTools.sql).toBeInstanceOf(z.ZodType);
+        expect(typeof capturedTools.sql.parse).toBe("function");
+        expect(typeof capturedTools.sql.safeParse).toBe("function");
+        expect(capturedTools.clientInput).toBeInstanceOf(z.ZodType);
+        expect(typeof capturedTools.clientInput.parse).toBe("function");
+        expect(capturedTools.client).toBeInstanceOf(z.ZodType);
+        expect(typeof capturedTools.client.parse).toBe("function");
+    });
+    it("should provide actual Zod schemas as tools in .server()", () => {
+        let capturedTools;
+        s.sqlite({ type: "varchar" })
+            .clientInput({ value: "test" })
+            .client((tools) => tools.clientInput)
+            .server((tools) => {
+            capturedTools = {
+                sql: tools.sql,
+                clientInput: tools.clientInput,
+                client: tools.client,
+            };
+            return tools.clientInput;
+        });
+        expect(capturedTools).toBeDefined();
+        expect(capturedTools.sql).toBeInstanceOf(z.ZodType);
+        expect(capturedTools.clientInput).toBeInstanceOf(z.ZodType);
+        expect(capturedTools.client).toBeInstanceOf(z.ZodType);
+    });
+    it("should allow calling Zod methods on tools params in .client()", () => {
+        let clientInputSchema;
+        s.sqlite({ type: "varchar" })
+            .clientInput({ value: "" })
+            .client((tools) => {
+            clientInputSchema = tools.clientInput;
+            const validated = tools.clientInput.min(3);
+            expect(validated.safeParse("ab").success).toBe(false);
+            expect(validated.safeParse("abc").success).toBe(true);
+            return validated;
+        });
+        expect(clientInputSchema).toBeInstanceOf(z.ZodString);
+    });
+    it("should allow calling Zod methods on tools params in .server()", () => {
+        let serverClientInput;
+        s.sqlite({ type: "varchar" })
+            .clientInput({ value: "" })
+            .client((tools) => tools.clientInput.min(3))
+            .server((tools) => {
+            serverClientInput = tools.clientInput;
+            const validated = tools.clientInput.min(5);
+            expect(validated.safeParse("abcd").success).toBe(false);
+            expect(validated.safeParse("abcde").success).toBe(true);
+            return validated;
+        });
+        expect(serverClientInput).toBeInstanceOf(z.ZodString);
+    });
+    it("should provide correct Zod types for numeric fields in tools", () => {
+        let capturedSql;
+        let capturedInput;
+        s.sqlite({ type: "int" })
+            .clientInput({ value: 0 })
+            .client((tools) => {
+            capturedSql = tools.sql;
+            capturedInput = tools.clientInput;
+            return tools.clientInput;
+        });
+        expect(capturedSql).toBeInstanceOf(z.ZodNumber);
+        expect(capturedSql.parse(42)).toBe(42);
+        expect(capturedInput).toBeInstanceOf(z.ZodNumber);
+        expect(capturedInput.parse(0)).toBe(0);
+    });
+    it("should provide correct Zod types for boolean fields in tools", () => {
+        let capturedInput;
+        s.sqlite({ type: "int" })
+            .clientInput(() => z.boolean())
+            .client((tools) => {
+            capturedInput = tools.clientInput;
+            return tools.clientInput;
+        });
+        expect(capturedInput).toBeInstanceOf(z.ZodBoolean);
+        expect(capturedInput.parse(true)).toBe(true);
+        expect(capturedInput.safeParse("not bool").success).toBe(false);
+    });
+    it("should allow nullable() and other modifiers on tools params", () => {
+        let capturedInput;
+        s.sqlite({ type: "varchar", nullable: true })
+            .clientInput({ value: null, schema: z.string().nullable() })
+            .client((tools) => {
+            capturedInput = tools.clientInput;
+            expect(tools.clientInput.safeParse(null).success).toBe(true);
+            expect(tools.clientInput.safeParse("hello").success).toBe(true);
+            return tools.clientInput;
+        });
+        expect(capturedInput).toBeInstanceOf(z.ZodNullable);
+    });
+});
+describe("New Session Features - Base Schema Without Relations", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s
+            .sqlite({ type: "int", pk: true })
+            .clientInput({ value: () => "user-123", schema: z.string() }),
+        petId: s.reference(() => pets.id),
+        pets: s.hasMany(),
+    });
+    const pets = schema({
+        _tableName: "pets",
+        id: s.sqlite({ type: "int", pk: true }),
+        userId: s.reference(() => users.id),
+        owner: s.hasOne(),
+    });
+    const box = createSchemaBox({ users, pets }, {
+        users: {
+            pets: { fromKey: "id", toKey: pets.userId },
+        },
+        pets: {
+            owner: { fromKey: "userId", toKey: users.id },
+        },
+    });
+    describe("Base Schema Excludes Relations", () => {
+        it("should exclude relations from base client schema", () => {
+            expectTypeOf().toEqualTypeOf();
+            // Runtime check - the schema shape should not include 'pets'
+            const clientShape = box.users.schemas.client.shape;
+            expect(clientShape).not.toHaveProperty("pets");
+            expect(clientShape).toHaveProperty("id");
+            expect(clientShape).toHaveProperty("petId");
+        });
+        it("should exclude relations from default values", () => {
+            const defaults = box.pets.defaults;
+            // Runtime check
+            expect(defaults).not.toHaveProperty("owner");
+            expect(defaults).toHaveProperty("id");
+            expect(defaults).toHaveProperty("userId");
+        });
+    });
+    describe("View Creation", () => {
+        it("should include only selected relations in view", () => {
+            const userView = box.users.createView({
+                pets: true,
+            });
+            expectTypeOf().toEqualTypeOf();
+            // Runtime check
+            const viewShape = userView.schemas.client.shape;
+            expect(viewShape).toHaveProperty("pets");
+            expect(viewShape.pets).toBeInstanceOf(z.ZodArray);
+        });
+        it("should handle nested relations correctly", () => {
+            const userViewNested = box.users.createView({
+                pets: { owner: true },
+            });
+            expectTypeOf().toEqualTypeOf();
+            // Runtime check - owner should not have pets
+            const shape = userViewNested.schemas.client.shape;
+            if (shape.pets instanceof z.ZodArray) {
+                const petSchema = shape.pets.element;
+                if (petSchema instanceof z.ZodObject) {
+                    const petShape = petSchema.shape;
+                    expect(petShape).toHaveProperty("owner");
+                    // Check that owner is optional
+                    expect(petShape.owner).toBeInstanceOf(z.ZodNullable);
+                    // Check that owner doesn't include pets
+                    if (petShape.owner instanceof z.ZodNullable) {
+                        const ownerSchema = petShape.owner._def.innerType;
+                        if (ownerSchema instanceof z.ZodObject) {
+                            expect(ownerSchema.shape).not.toHaveProperty("pets");
+                        }
+                    }
+                }
+            }
+        });
+    });
+    it("should provide type-safe navigation", () => {
+        expectTypeOf().not.toBeNever();
+        // Runtime test - nav proxy should return nested proxies
+        expect(box.users.nav).toBeDefined();
+        expect(box.users.nav.pets).toBeDefined();
+        expect(box.users.nav.pets.owner).toBeDefined();
+    });
+    describe("Default Values Accessibility", () => {
+        it("should expose default values at top level", () => {
+            expect(box.users.defaults).toBeDefined();
+            expect(box.users.defaults.id).toBe("user-123");
+            expect(box.pets.defaults.id).toBe(0);
+            expect(box.pets.defaults.userId).toBe("user-123");
+        });
+    });
+    describe("Reference Resolution", () => {
+        it("should correctly resolve reference types", () => {
+            expectTypeOf().toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
+        });
+    });
+});
+describe("Relation Defaults in Views", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s
+            .sqlite({ type: "int", pk: true })
+            .clientInput({ value: () => "user-123", schema: z.string() }),
+        name: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        posts: s.hasMany({ count: 2 }), // Should generate 2 posts
+        comments: s.hasMany([]), // Should be empty array
+        profile: s.hasOne(true), // Changed from {} to true
+        settings: s.hasOne(null), // Should be null
+        followers: s.hasMany(undefined), // Should not be included
+    });
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        title: s.sqlite({ type: "varchar" }).clientInput({ value: "Default Post" }),
+        authorId: s.reference(() => users.id),
+        user: s.hasOne(true),
+    });
+    const comments = schema({
+        _tableName: "comments",
+        id: s.sqlite({ type: "int", pk: true }),
+        text: s
+            .sqlite({ type: "varchar" })
+            .clientInput({ value: "Default Comment" }),
+        userId: s.reference(() => users.id),
+        user: s.hasOne(true),
+    });
+    const profiles = schema({
+        _tableName: "profiles",
+        id: s.sqlite({ type: "int", pk: true }),
+        bio: s.sqlite({ type: "varchar" }).clientInput({ value: "Default Bio" }),
+        userId: s.reference(() => users.id),
+        user: s.hasOne(true),
+    });
+    const box = createSchemaBox({ users, posts, comments, profiles }, {
+        users: {
+            posts: { fromKey: "id", toKey: posts.authorId },
+            comments: { fromKey: "id", toKey: comments.userId },
+            profile: { fromKey: "id", toKey: profiles.userId },
+            settings: { fromKey: "id", toKey: profiles.userId },
+            followers: { fromKey: "id", toKey: users.id },
+        },
+        posts: {
+            user: { fromKey: "id", toKey: users.id },
+        },
+        comments: {
+            user: { fromKey: "id", toKey: users.id },
+        },
+        profiles: {
+            user: { fromKey: "id", toKey: users.id },
+        },
+    });
+    it("should generate correct defaults based on relation config", () => {
+        const view = box.users.createView({
+            posts: true,
+            comments: true,
+            profile: true,
+            settings: true,
+            followers: true,
+        });
+        const defaults = view.defaults();
+        // Base fields
+        expect(defaults.id).toBe("user-123");
+        expect(defaults.name).toBe("John");
+        // posts with count: 2
+        expect(defaults.posts).toHaveLength(2);
+        expect(defaults.posts?.[0]).toEqual({
+            id: 0,
+            title: "Default Post",
+            authorId: "user-123",
+        });
+        expect(defaults.posts?.[1]).toEqual({
+            id: 0,
+            title: "Default Post",
+            authorId: "user-123",
+        });
+        // comments with []
+        expect(defaults.comments).toEqual([]);
+        // profile with {}
+        expect(defaults.profile).toEqual({
+            id: 0,
+            bio: "Default Bio",
+            userId: "user-123",
+        });
+        // settings with null
+        expect(defaults.settings).toBeNull();
+        // followers with undefined - should not exist
+        expect(defaults).not.toHaveProperty("followers");
+    });
+    it("should handle nested relation defaults", () => {
+        const nestedView = box.users.createView({
+            posts: {},
+        });
+        const defaults = nestedView.defaults();
+        expect(defaults.posts).toHaveLength(2);
+        expect(defaults.posts?.[0]).not.toHaveProperty("author"); // Relation not selected
+    });
+});
+describe("Transform affects defaults", () => {
+    const userSchema = schema({
+        _tableName: "users",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => `temp_${Math.random().toString(36).substr(2, 9)}`,
+            schema: z.string(),
+        }),
+        email: s
+            .sqlite({ type: "varchar", length: 255 })
+            .server(() => z.email("Invalid email address")),
+        isActive: s
+            .sqlite({ type: "int" })
+            .clientInput(() => z.boolean())
+            .transform({
+            toClient: (val) => val === 1,
+            toDb: (val) => (val ? 1 : 0),
+        }),
+        role: s.sqlite({ type: "varchar" }).clientInput({
+            value: "user",
+            schema: z.enum(["user", "admin"]),
+        }),
+    });
+    const box = createSchemaBox({ users: userSchema }, { users: {} });
+    const { transforms } = box.users;
+    const defaults = box.users.generateDefaults();
+    it("should have defaults with correct runtime values", () => {
+        expect(defaults.isActive).toBe(false);
+        expect(typeof defaults.isActive).toBe("boolean");
+    });
+    it("should correctly transform defaults to db format", () => {
+        const dbVersion = transforms.toDb(defaults);
+        expect(dbVersion.isActive).toBe(0);
+        expect(typeof dbVersion.isActive).toBe("number");
+        const clientVersion = transforms.toClient(dbVersion);
+        expect(clientVersion.isActive).toBe(false);
+        expect(typeof clientVersion.isActive).toBe("boolean");
+    });
+});
+describe("UUID generation in initialState", () => {
+    it("should call value function with uuid tool", () => {
+        const field = s.sqlite({ type: "int", pk: true }).clientInput({
+            value: ({ uuid }) => uuid(),
+            schema: z.string(),
+            clientPk: true,
+        });
+        expect(typeof field.config.initialValue).toBe("function");
+        const result = field.config.initialValue({
+            uuid: () => "test-uuid",
+        });
+        expect(typeof result).toBe("string");
+        expect(result.length).toBeGreaterThan(0);
+    });
+});
+describe("Missing properties - parseForDb, parseFromDb, pk, clientPk, isClientRecord", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: ({ uuid }) => uuid(),
+            schema: z.string(),
+            clientPk: true,
+        }),
+        name: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        isActive: s
+            .sqlite({ type: "int" })
+            .clientInput(() => z.boolean())
+            .transform({
+            toClient: (val) => val === 1,
+            toDb: (val) => (val ? 1 : 0),
+        }),
+        email: s.sqlite({ type: "varchar", field: "email_address" }),
+        posts: s.hasMany({ count: 1 }),
+    });
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        title: s.sqlite({ type: "varchar" }).clientInput({ value: "Untitled" }),
+        authorId: s.reference(() => users.id),
+    });
+    const box = createSchemaBox({ users, posts }, {
+        users: {
+            posts: { fromKey: "id", toKey: posts.authorId },
+        },
+    });
+    describe("DB Field Key Mapping (field property)", () => {
+        it("should correctly map 'field' property to sqlSchema types and runtime shapes", () => {
+            expectTypeOf().toHaveProperty("email_address");
+            expectTypeOf().not.toHaveProperty("email");
+            expectTypeOf().toHaveProperty("email");
+            expectTypeOf().not.toHaveProperty("email_address");
+            const sqlKeys = Object.keys(box.users.schemas.sql.shape);
+            expect(sqlKeys).toContain("email_address");
+            expect(sqlKeys).not.toContain("email");
+            const clientKeys = Object.keys(box.users.schemas.client.shape);
+            expect(clientKeys).toContain("email");
+            expect(clientKeys).not.toContain("email_address");
+        });
+        it("parseForDb should return an object with the DB keys typed correctly", () => {
+            const clientData = {
+                id: 1,
+                name: "Alice",
+                isActive: true,
+                email: "alice@test.com",
+            };
+            const dbData = box.users.transforms.parseForDb(clientData);
+            expectTypeOf(dbData).toHaveProperty("email_address");
+            expectTypeOf(dbData).not.toHaveProperty("email");
+            expect(dbData.email_address).toBe("alice@test.com");
+            expect(dbData.email).toBeUndefined();
+        });
+    });
+    describe("pk and clientPk", () => {
+        it("should expose pk array on base schema", () => {
+            expect(box.users.pk).toEqual(["id"]);
+            expect(box.posts.pk).toEqual(["id"]);
+        });
+        it("should expose clientPk array for fields with clientPk: true", () => {
+            expect(box.users.clientPk).toEqual(["id"]);
+        });
+        it("should inherit clientPk on reference fields", () => {
+            expect(box.posts.clientPk).toEqual(["authorId"]);
+        });
+    });
+    describe("isClientRecord", () => {
+        it("should auto-detect client records when clientPk is string but sql is int", () => {
+            expect(box.users.isClientRecord).toBeDefined();
+            expect(typeof box.users.isClientRecord).toBe("function");
+            expect(box.users.isClientRecord({ id: "some-uuid", name: "Test" })).toBe(true);
+            expect(box.users.isClientRecord({ id: 42, name: "Test" })).toBe(false);
+        });
+        it("should also have isClientRecord on posts due to inherited clientPk from reference", () => {
+            expect(box.posts.isClientRecord).toBeDefined();
+            expect(typeof box.posts.isClientRecord).toBe("function");
+        });
+    });
+    describe("parseFromDb and parseForDb", () => {
+        it("should map DB column names to client keys on parseFromDb", () => {
+            const dbRow = {
+                id: 1,
+                name: "Alice",
+                isActive: 1,
+                email_address: "a@b.com",
+            };
+            const result = box.users.transforms.parseFromDb(dbRow);
+            expect(result.email).toBe("a@b.com");
+            expect(result.isActive).toBe(true);
+        });
+        it("should map client keys to DB column names on parseForDb", () => {
+            const clientData = {
+                id: 1,
+                name: "Alice",
+                isActive: true,
+                email: "a@b.com",
+            };
+            const result = box.users.transforms.parseForDb(clientData);
+            expect(result.isActive).toBe(1);
+            expect(result.email_address).toBe("a@b.com");
+        });
+    });
+});
+// =======================================================
+// NEW TEST SUITE: Smart ClientPK & Mapped DB Keys Logic
+// =======================================================
+describe("Smart clientPk and isClientRecord logic", () => {
+    const smartSchema = schema({
+        _tableName: "smart_table",
+        // 1. Auto-detect function execution
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: ({ uuid }) => uuid(),
+            schema: z.string(),
+            clientPk: true, // Should auto-detect by dummy-executing the uuid factory
+        }),
+        // 2. Custom function + mapped db key
+        mappedId: s.sqlite({ type: "int", field: "db_mapped_id" }).clientInput({
+            value: "temp_999",
+            schema: z.string(),
+            clientPk: (val) => typeof val === "string" && val.startsWith("temp_"),
+        }),
+    });
+    const smartBox = createSchemaBox({ smart: smartSchema }, {
+        smart: {},
+    });
+    it("should auto-detect client records by dummy-executing the factory function", () => {
+        // Because value: ({ uuid }) => uuid() returns a string, the system should auto-infer `typeof val === "string"`
+        expect(smartBox.smart.isClientRecord({ id: "some-uuid-123" })).toBe(true);
+        expect(smartBox.smart.isClientRecord({ id: 1 })).toBe(false);
+    });
+    it("should use a custom checker function if provided to clientPk", () => {
+        // Valid custom format
+        expect(smartBox.smart.isClientRecord({ mappedId: "temp_abc" })).toBe(true);
+        // Invalid custom format (doesn't start with temp_)
+        expect(smartBox.smart.isClientRecord({ mappedId: "invalid_abc" })).toBe(false);
+        // Integer is not a client record
+        expect(smartBox.smart.isClientRecord({ mappedId: 42 })).toBe(false);
+    });
+    it("should safely check BOTH the client key and the db key at runtime", () => {
+        // Provide ONLY the client key
+        expect(smartBox.smart.isClientRecord({ mappedId: "temp_client" })).toBe(true);
+        // Provide ONLY the db key (how it might look coming straight from a SQL query)
+        expect(smartBox.smart.isClientRecord({ db_mapped_id: "temp_db" })).toBe(true);
+        // Ensure failures correctly resolve when testing either key
+        expect(smartBox.smart.isClientRecord({ mappedId: 100 })).toBe(false);
+        expect(smartBox.smart.isClientRecord({ db_mapped_id: 100 })).toBe(false);
+    });
+});
+describe("Nested relations with transforms", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s
+            .sqlite({ type: "int", pk: true })
+            .clientInput({ value: () => "user-123", schema: z.string() }),
+        name: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        posts: s.hasMany({ count: 1 }),
+    });
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        title: s.sqlite({ type: "varchar" }).clientInput({ value: "Default Post" }),
+        isPublished: s
+            .sqlite({ type: "int" })
+            .clientInput(() => z.boolean())
+            .transform({
+            toClient: (val) => val === 1,
+            toDb: (val) => (val ? 1 : 0),
+        }),
+        authorId: s.reference(() => users.id),
+        comments: s.hasMany({ count: 1 }),
+    });
+    const comments = schema({
+        _tableName: "comments",
+        id: s.sqlite({ type: "int", pk: true }),
+        text: s.sqlite({ type: "varchar" }).clientInput({ value: "Comment" }),
+        isDeleted: s
+            .sqlite({ type: "int" })
+            .clientInput(() => z.boolean())
+            .transform({
+            toClient: (val) => val === 1,
+            toDb: (val) => (val ? 1 : 0),
+        }),
+        postId: s.reference(() => posts.id),
+    });
+    const box = createSchemaBox({ users, posts, comments }, {
+        users: {
+            posts: { fromKey: "id", toKey: posts.authorId },
+        },
+        posts: {
+            comments: { fromKey: "id", toKey: comments.postId },
+        },
+    });
+    it("should transform nested relation fields in defaults", () => {
+        const view = box.users.createView({
+            posts: { comments: true },
+        });
+        const defaults = view.defaults();
+        expect(defaults.posts).toHaveLength(1);
+        const post = defaults.posts?.[0];
+        expect(post).toBeDefined();
+        expect(post.isPublished).toBe(false);
+        expect(typeof post.isPublished).toBe("boolean");
+        expect(post.comments).toHaveLength(1);
+        const comment = post.comments?.[0];
+        expect(comment.isDeleted).toBe(false);
+        expect(typeof comment.isDeleted).toBe("boolean");
+    });
+    it("should transform nested relation fields in toClient", () => {
+        const view = box.users.createView({
+            posts: { comments: true },
+        });
+        const { toClient } = view.transforms;
+        const dbData = {
+            id: 1,
+            name: "John",
+            posts: [
+                {
+                    id: 10,
+                    title: "My Post",
+                    isPublished: 1,
+                    authorId: 1,
+                    comments: [
+                        {
+                            id: 100,
+                            text: "Comment text",
+                            isDeleted: 0,
+                            postId: 10,
+                        },
+                    ],
+                },
+            ],
+        };
+        const clientData = toClient(dbData);
+        expect(clientData.posts[0].isPublished).toBe(true);
+        expect(typeof clientData.posts[0].isPublished).toBe("boolean");
+        expect(clientData.posts[0].comments[0].isDeleted).toBe(false);
+        expect(typeof clientData.posts[0].comments[0].isDeleted).toBe("boolean");
+    });
+    it("should transform nested relation fields in toDb", () => {
+        const view = box.users.createView({
+            posts: { comments: true },
+        });
+        const { toDb } = view.transforms;
+        const clientData = {
+            id: "user-123",
+            name: "John",
+            posts: [
+                {
+                    id: 10,
+                    title: "My Post",
+                    isPublished: true,
+                    authorId: "user-123",
+                    comments: [
+                        {
+                            id: 100,
+                            text: "Comment text",
+                            isDeleted: true,
+                            postId: 10,
+                        },
+                    ],
+                },
+            ],
+        };
+        const dbData = toDb(clientData);
+        expect(dbData.posts[0].isPublished).toBe(1);
+        expect(typeof dbData.posts[0].isPublished).toBe("number");
+        expect(dbData.posts[0].comments[0].isDeleted).toBe(1);
+        expect(typeof dbData.posts[0].comments[0].isDeleted).toBe("number");
+    });
+    it("should work with parseFromDb and parseForDb", () => {
+        const view = box.users.createView({
+            posts: { comments: true },
+        });
+        const { parseFromDb, parseForDb } = view.transforms;
+        const dbRow = {
+            id: 1,
+            name: "John",
+            posts: [
+                {
+                    id: 10,
+                    title: "My Post",
+                    isPublished: 1,
+                    authorId: 1,
+                    comments: [
+                        {
+                            id: 100,
+                            text: "Comment text",
+                            isDeleted: 0,
+                            postId: 10,
+                        },
+                    ],
+                },
+            ],
+        };
+        const clientResult = parseFromDb(dbRow);
+        expect(clientResult.id).toBe(1);
+        expect(clientResult.posts[0].isPublished).toBe(true);
+        expect(clientResult.posts[0].comments[0].isDeleted).toBe(false);
+    });
+});
+describe("sqlOnly fields", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => "user-123",
+            schema: z.string(),
+        }),
+        name: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        internalToken: s.sqlite({ type: "varchar", sqlOnly: true }),
+    });
+    const box = createSchemaBox({ users }, { users: {} });
+    it("should exclude sqlOnly fields from client schema", () => {
+        expectTypeOf().not.toHaveProperty("internalToken");
+        const clientKeys = Object.keys(box.users.schemas.client.shape);
+        expect(clientKeys).not.toContain("internalToken");
+    });
+    it("should include sqlOnly fields in sql schema", () => {
+        expectTypeOf().toHaveProperty("internalToken");
+        const sqlKeys = Object.keys(box.users.schemas.sql.shape);
+        expect(sqlKeys).toContain("internalToken");
+    });
+    it("should exclude sqlOnly fields from defaults", () => {
+        const defaults = box.users.defaults;
+        expect(defaults).not.toHaveProperty("internalToken");
+    });
+    it("should exclude sqlOnly fields from toClient output", () => {
+        const { toClient } = box.users.transforms;
+        const dbData = { id: 1, name: "John", internalToken: "secret" };
+        const result = toClient(dbData);
+        expect(result).not.toHaveProperty("internalToken");
+    });
+    it("should NOT include sqlOnly fields in toDb output", () => {
+        const { toDb } = box.users.transforms;
+        const clientData = { id: 1, name: "John" };
+        const result = toDb(clientData);
+        expect(result).not.toHaveProperty("internalToken");
+    });
+});
+describe("SQL enum fields", () => {
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        status: s.sqlite({
+            type: "enum",
+            values: ["draft", "published", "archived"],
+            default: "draft",
+        }),
+        nullableStatus: s.sqlite({
+            type: "enum",
+            values: ["draft", "published"],
+            nullable: true,
+        }),
+    });
+    const box = createSchemaBox({ posts }, { posts: {} });
+    it("should validate enum values in sql, client, and server schemas", () => {
+        expect(box.posts.schemas.sql.shape.status.parse("published")).toBe("published");
+        expect(box.posts.schemas.client.shape.status.parse("archived")).toBe("archived");
+        expect(box.posts.schemas.server.shape.status.parse("draft")).toBe("draft");
+        expect(() => box.posts.schemas.server.shape.status.parse("deleted")).toThrow();
+    });
+    it("should use enum defaults and nullable enum defaults", () => {
+        expect(box.posts.defaults.status).toBe("draft");
+        expect(box.posts.defaults.nullableStatus).toBeNull();
+    });
+    it("should parse enum data for db writes", () => {
+        expect(box.posts.transforms.parseForDb({
+            id: 1,
+            status: "published",
+            nullableStatus: null,
+        })).toEqual({ id: 1, status: "published", nullableStatus: null });
+    });
+});
+describe("derive - computed fields", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s.sqlite({ type: "int", pk: true }),
+        fullName: s.clientInput(""),
+        firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
+    }).derive({
+        forClient: {
+            fullName: (row) => `${row.firstName} ${row.lastName}`,
+        },
+    });
+    const box = createSchemaBox({ users }, { users: {} });
+    it("should add derived fields to defaults", () => {
+        const defaults = box.users.defaults;
+        expect(defaults.fullName).toBe("John Doe");
+    });
+    it("should compute derived fields in toClient", () => {
+        const { toClient } = box.users.transforms;
+        const dbData = { id: 1, firstName: "Jane", lastName: "Smith" };
+        const result = toClient(dbData);
+        expect(result.fullName).toBe("Jane Smith");
+    });
+    it("should NOT include derived fields in sql schema", () => {
+        const sqlKeys = Object.keys(box.users.schemas.sql.shape);
+        expect(sqlKeys).not.toContain("fullName");
+    });
+    it("should include derived fields in client schema", () => {
+        expectTypeOf().toHaveProperty("fullName");
+    });
+    it("should work with multiple derived fields", () => {
+        const products = schema({
+            _tableName: "products",
+            id: s.sqlite({ type: "int", pk: true }),
+            price: s.sqlite({ type: "int" }).clientInput({ value: 100 }),
+            quantity: s.sqlite({ type: "int" }).clientInput({ value: 5 }),
+            total: s.clientInput(0),
+            formattedPrice: s.clientInput(""),
+        }).derive({
+            forClient: {
+                total: (row) => row.price * row.quantity,
+                formattedPrice: (row) => `$${row.price}`,
+            },
+        });
+        const box = createSchemaBox({ products }, { products: {} });
+        const defaults = box.products.defaults;
+        expect(defaults.total).toBe(500);
+        expect(defaults.formattedPrice).toBe("$100");
+    });
+    it("should track dependencies for forDb derived fields", () => {
+        const contacts = schema({
+            _tableName: "contacts",
+            id: s.sqlite({ type: "int", pk: true }),
+            firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+            lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
+            searchName: s.sqlite({ type: "varchar", sqlOnly: true }),
+        }).derive({
+            forDb: {
+                searchName: (row) => `${row.firstName} ${row.lastName}`.trim().toLowerCase(),
+            },
+        });
+        const contactBox = createSchemaBox({ contacts }, { contacts: {} });
+        expect(contactBox.contacts.deriveDependencies.searchName).toEqual([
+            "firstName",
+            "lastName",
+        ]);
+        expect(contactBox.contacts.transforms.parseForDb({
+            id: 1,
+            firstName: "Ada",
+            lastName: "Lovelace",
+        })).toMatchObject({ searchName: "ada lovelace" });
+    });
+    it("should allow forDb derived fields on visible DB columns", () => {
+        const contacts = schema({
+            _tableName: "contacts",
+            id: s.sqlite({ type: "int", pk: true }),
+            firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+            lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "Doe" }),
+            fullName: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+        }).derive({
+            forDb: {
+                fullName: (row) => `${row.firstName} ${row.lastName}`.trim(),
+            },
+        });
+        const contactBox = createSchemaBox({ contacts }, { contacts: {} });
+        expect(contactBox.contacts.transforms.parseForDb({
+            id: 1,
+            firstName: "Ada",
+            lastName: "Lovelace",
+            fullName: "stale",
+        })).toMatchObject({ fullName: "Ada Lovelace" });
+    });
+});
+describe("refine", () => {
+    it("should run server refinement on parseForDb", () => {
+        const events = schema({
+            _tableName: "events",
+            id: s.sqlite({ type: "int", pk: true }),
+            startDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            endDate: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            content: s.sqlite({ type: "varchar", nullable: true }).clientInput({
+                value: null,
+                schema: z.string().nullable(),
+            }),
+            isPublished: s.sqlite({ type: "boolean" }).clientInput({ value: false }),
+        }).refine({
+            server: (row) => {
+                const errors = [];
+                if (row.startDate && row.endDate && row.startDate > row.endDate) {
+                    errors.push({
+                        path: ["endDate"],
+                        message: "End date must be after start date",
+                    });
+                }
+                if (row.isPublished && !row.content) {
+                    errors.push({
+                        path: ["content"],
+                        message: "Published events must have content",
+                    });
+                }
+                return errors.length > 0 ? errors : undefined;
+            },
+        });
+        const box = createSchemaBox({ events }, { events: {} });
+        expect(() => box.events.transforms.parseForDb({
+            id: 1,
+            startDate: "2024-12-31",
+            endDate: "2024-01-01",
+            content: null,
+            isPublished: false,
+        })).toThrow("End date must be after start date");
+        expect(() => box.events.transforms.parseForDb({
+            id: 1,
+            startDate: "2024-01-01",
+            endDate: "2024-12-31",
+            content: null,
+            isPublished: true,
+        })).toThrow("Published events must have content");
+        const valid = box.events.transforms.parseForDb({
+            id: 1,
+            startDate: "2024-01-01",
+            endDate: "2024-12-31",
+            content: "Event details",
+            isPublished: true,
+        });
+        expect(valid).toMatchObject({
+            startDate: "2024-01-01",
+            endDate: "2024-12-31",
+            content: "Event details",
+            isPublished: true,
+        });
+    });
+    it("should run client refinement on client input", () => {
+        const forms = schema({
+            _tableName: "forms",
+            id: s.sqlite({ type: "int", pk: true }),
+            password: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            confirmPassword: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+        }).refine({
+            client: (row) => {
+                if (row.password !== row.confirmPassword) {
+                    return {
+                        path: ["confirmPassword"],
+                        message: "Passwords must match",
+                    };
+                }
+                return undefined;
+            },
+        });
+        const box = createSchemaBox({ forms }, { forms: {} });
+        const result = box.forms.schemas.clientInput.safeParse({
+            id: 1,
+            password: "secret",
+            confirmPassword: "different",
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error.issues[0].message).toBe("Passwords must match");
+        }
+        const validResult = box.forms.schemas.clientInput.safeParse({
+            id: 1,
+            password: "secret",
+            confirmPassword: "secret",
+        });
+        expect(validResult.success).toBe(true);
+    });
+    it("should track refinement dependencies", () => {
+        const items = schema({
+            _tableName: "items",
+            id: s.sqlite({ type: "int", pk: true }),
+            min: s.sqlite({ type: "int" }).clientInput({ value: 0 }),
+            max: s.sqlite({ type: "int" }).clientInput({ value: 100 }),
+        }).refine({
+            server: (row) => {
+                if (row.min > row.max) {
+                    return { path: ["max"], message: "Max must be >= min" };
+                }
+                return undefined;
+            },
+        });
+        const box = createSchemaBox({ items }, { items: {} });
+        expect(box.items.refineDependencies.server).toEqual(["min", "max"]);
+        expect(box.items.refineDependencies.client).toEqual([]);
+    });
+    it("should support chaining derive and refine", () => {
+        const records = schema({
+            _tableName: "records",
+            id: s.sqlite({ type: "int", pk: true }),
+            firstName: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            lastName: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            fullName: s.sqlite({ type: "varchar", sqlOnly: true }),
+        })
+            .derive({
+            forDb: {
+                fullName: (row) => `${row.firstName} ${row.lastName}`.trim(),
+            },
+        })
+            .refine({
+            server: (row) => {
+                if (!row.firstName && !row.lastName) {
+                    return { path: ["firstName"], message: "Name is required" };
+                }
+                return undefined;
+            },
+        });
+        const box = createSchemaBox({ records }, { records: {} });
+        expect(box.records.deriveDependencies.fullName).toEqual([
+            "firstName",
+            "lastName",
+        ]);
+        expect(box.records.refineDependencies.server).toEqual([
+            "firstName",
+            "lastName",
+        ]);
+        const result = box.records.transforms.parseForDb({
+            id: 1,
+            firstName: "John",
+            lastName: "Doe",
+        });
+        expect(result).toMatchObject({ fullName: "John Doe" });
+    });
+});
+describe("client-only fields", () => {
+    it("should exclude client-only fields from database transforms", () => {
+        const tasks = schema({
+            _tableName: "tasks",
+            id: s.sqlite({ type: "int", pk: true }),
+            title: s.sqlite({ type: "varchar" }).clientInput({ value: "" }),
+            statusLabel: s.clientInput(""),
+        });
+        const taskBox = createSchemaBox({ tasks }, { tasks: {} });
+        expect(taskBox.tasks.transforms.parseForDb({
+            id: 1,
+            title: "Ship it",
+            statusLabel: "Local only",
+        })).toEqual({ id: 1, title: "Ship it" });
+        expect(taskBox.tasks.transforms.parsePatchForDb({
+            statusLabel: "Still local only",
+        })).toEqual({});
+    });
+});
+describe("sqlOnly with derive in relations", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => "user-123",
+            schema: z.string(),
+        }),
+        internalScore: s.sqlite({ type: "int", sqlOnly: true }),
+        posts: s.hasMany({ count: 1 }),
+    });
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        title: s.sqlite({ type: "varchar" }).clientInput({ value: "Post" }),
+        authorId: s.reference(() => users.id),
+        preview: s.clientInput(""),
+    }).derive({
+        forClient: {
+            preview: (row) => row.title.substring(0, 5),
+        },
+    });
+    const box = createSchemaBox({ users, posts }, {
+        users: { posts: { fromKey: "id", toKey: posts.authorId } },
+    });
+    it("should exclude sqlOnly fields from view but include derived", () => {
+        const view = box.users.createView({ posts: true });
+        const viewClientKeys = Object.keys(view.schemas.client.shape);
+        expect(viewClientKeys).not.toContain("internalScore");
+        expect(viewClientKeys).toContain("id");
+        expect(viewClientKeys).toContain("posts");
+    });
+    it("should include derived fields in view", () => {
+        const view = box.posts.createView({});
+        const defaults = view.defaults();
+        expect(defaults.preview).toBe("Post");
+    });
+    it("should apply toClient transforms correctly with derived", () => {
+        const view = box.users.createView({ posts: true });
+        const { toClient } = view.transforms;
+        const dbData = {
+            id: 1,
+            internalScore: 99,
+            posts: [{ id: 10, title: "Hello World", authorId: 1 }],
+        };
+        const result = toClient(dbData);
+        expect(result.internalScore).toBeUndefined();
+        expect(result.posts[0].preview).toBe("Hello");
+    });
+});
+describe("defaultsDefinition", () => {
+    const users = schema({
+        _tableName: "users",
+        id: s
+            .sqlite({ type: "int", pk: true })
+            .clientInput({ value: "user-123", schema: z.string() }),
+        name: s.sqlite({ type: "varchar" }).clientInput({ value: "John" }),
+        posts: s.hasMany({ count: 2 }),
+        profile: s.hasOne(true),
+    });
+    const posts = schema({
+        _tableName: "posts",
+        id: s.sqlite({ type: "int", pk: true }),
+        title: s.sqlite({ type: "varchar" }).clientInput({ value: "Default Post" }),
+        authorId: s.reference(() => users.id),
+        user: s.hasOne(true),
+    });
+    const box = createSchemaBox({ users, posts }, {
+        users: { posts: { fromKey: "id", toKey: posts.authorId } },
+        posts: { user: { fromKey: "id", toKey: users.id } },
+    });
+    it("should have defaultsDefinition on schema box", () => {
+        const def = box.users.defaultsDefinition;
+        expect(def).toBeDefined();
+        expect(def.id).toBe("user-123");
+        expect(def.name).toBe("John");
+        // Check array relation logic
+        expect(def.posts).toBeInstanceOf(Array);
+        expect(def.posts).toHaveLength(2);
+        expect(def.posts[0].title).toBe("Default Post");
+        // Check __def__ single-element logic
+        expect(def.__def__posts).toBeDefined();
+        expect(Array.isArray(def.__def__posts)).toBe(false);
+        expect(def.__def__posts.title).toBe("Default Post");
+    });
+    it("should have defaultsDefinition on views", () => {
+        const view = box.users.createView({
+            posts: { user: true },
+        });
+        const def = view.defaultsDefinition();
+        expect(def).toBeDefined();
+        expect(def.posts).toBeInstanceOf(Array);
+        expect(def.posts).toHaveLength(2);
+        // Nested relation array test
+        expect(def.posts[0].user).toBeDefined();
+        expect(def.posts[0].user?.name).toBe("John");
+        // Nested __def__ single-element logic
+        expect(def.__def__posts).toBeDefined();
+        expect(Array.isArray(def.__def__posts)).toBe(false);
+        expect(def.__def__posts.title).toBe("Default Post");
+        expect(def.__def__posts.user).toBeDefined();
+        expect(def.__def__posts.user?.name).toBe("John");
+    });
+});
+describe("dynamic value functions re-run on each view.defaults() call", () => {
+    const factory = schema({
+        _tableName: "factories",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => `temp_${Math.random().toString(36).substr(2, 8)}`,
+            schema: z.string(),
+            clientPk: true,
+        }),
+        name: s
+            .sqlite({ type: "varchar", length: 100 })
+            .clientInput({ value: "MyFactory" }),
+        boxes: s.hasMany({ count: 2 }),
+    });
+    const box = schema({
+        _tableName: "boxes",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => `box_${Math.random().toString(36).substr(2, 8)}`,
+            schema: z.string(),
+            clientPk: true,
+        }),
+        factoryId: s.reference(() => factory.id),
+        variant: s.hasOne(true),
+    });
+    const boxVariant = schema({
+        _tableName: "box_variants",
+        id: s.sqlite({ type: "int", pk: true }).clientInput({
+            value: () => `var_${Math.random().toString(36).substr(2, 8)}`,
+            schema: z.string(),
+            clientPk: true,
+        }),
+        boxId: s.reference(() => box.id),
+        label: s
+            .sqlite({ type: "varchar", length: 50 })
+            .clientInput({ value: "Standard" }),
+    });
+    const box_ = createSchemaBox({ factory, box, boxVariant }, {
+        factory: {
+            boxes: { fromKey: "id", toKey: box.factoryId },
+        },
+        box: {
+            variant: { fromKey: "id", toKey: boxVariant.boxId },
+        },
+        boxVariant: {},
+    });
+    it("should generate unique top-level defaults on each call", () => {
+        const view = box_.factory.createView({ boxes: { variant: true } });
+        const first = view.defaults();
+        const second = view.defaults();
+        expect(first.id).not.toBe(second.id);
+        expect(first.name).toBe("MyFactory");
+    });
+    it("should generate unique nested relation defaults on each call", () => {
+        const view = box_.factory.createView({ boxes: { variant: true } });
+        const first = view.defaults();
+        const second = view.defaults();
+        expect(first.boxes).toHaveLength(2);
+        expect(second.boxes).toHaveLength(2);
+        first.boxes.forEach((b, i) => {
+            expect(b.id).not.toBe(second.boxes[i].id);
+        });
+    });
+    it("should generate unique deeply nested defaults on each call", () => {
+        const view = box_.factory.createView({ boxes: { variant: true } });
+        const first = view.defaults();
+        const second = view.defaults();
+        first.boxes.forEach((b, i) => {
+            const firstVariant = b.variant;
+            const secondVariant = second.boxes[i].variant;
+            expect(firstVariant.id).not.toBe(secondVariant.id);
+        });
+    });
+    it("should generate unique values within the same defaults call", () => {
+        const view = box_.factory.createView({ boxes: { variant: true } });
+        const defaults = view.defaults();
+        const ids = new Set([
+            defaults.id,
+            ...(defaults.boxes?.map((b) => b.id) ?? []),
+            ...(defaults.boxes?.flatMap((b) => b.variant ? [b.variant.id] : []) ?? []),
+        ]);
+        expect(ids.size).toBe(5);
+    });
+    it("should generate unique values across defaultsDefinition calls", () => {
+        const view = box_.factory.createView({ boxes: { variant: true } });
+        const first = view.defaultsDefinition();
+        const second = view.defaultsDefinition();
+        expect(first.id).not.toBe(second.id);
+        expect(first.boxes[0].variant.id).not.toBe(second.boxes[0].variant.id);
+    });
+});