cogsbox-shape 0.5.178 → 0.5.180

package/README.md

@@ -33,18 +33,18 @@ Traditional approaches require defining these layers separately, leading to type
 Define a field by chaining methods. Each step is optional — use only what you need.
 
 ```
-s.sql()  →  .client()  →  .server()  →  .transform()
-        →  .derive()   →  .sqlOnly()
+s.sql()  →  .clientInput()  →  .client()  →  .server()  →  .transform()
 ```
 
-| Method                                       | Purpose                                                        |
-| -------------------------------------------- | -------------------------------------------------------------- |
-| `s.sql({ type })`                            | Database column type. The starting point for every field.      |
-| `.client({ value, schema })`                 | Client-side validation and default value for new records.      |
-| `.server(fn)`                                | Server-side validation. Stricter rules before database writes. |
-| `.transform({ toClient, toDb })`              | Converts between database and client representations.          |
-| `.derive({ field: (row) => computedValue })` | Adds computed fields based on other field values.              |
-| `.sqlOnly`                                   | Marks a field as server-only (not sent to client).             |
+| Method                            | Purpose                                                        |
+| --------------------------------- | -------------------------------------------------------------- |
+| `s.sql({ type, sqlOnly })`        | Database column type. `sqlOnly` excludes from client layer.    |
+| `.clientInput({ value, schema })` | Client-side input schema and default value for new records.    |
+| `.client(fn)`                     | Client-side validation on the final client union type.         |
+| `.server(fn)`                     | Server-side validation. Stricter rules before database writes. |
+| `.transform({ toClient, toDb })`  | Converts between database and client representations.          |
+
+Note: `.derive()` is a schema-level method, not chainable on individual fields.
 
 ### 1. SQL — Define Your Database Schema
 
@@ -63,34 +63,49 @@ const userSchema = schema({
 
 This generates a Zod schema matching your SQL types exactly.
 
-### 2. Client — Defaults and Client-Side Validation
+### 2. Client Input — Defaults and Client-Side Validation
 
-`.client()` sets the default value and client-side validation type for new records. It combines what was previously done with `.initialState()`.
+`.clientInput()` sets the default value and client-side validation type for new records.
 
 ```typescript
 const userSchema = schema({
   _tableName: "users",
   // DB stores auto-increment integers, but new records need a temp string ID
-  id: s.sql({ type: "int", pk: true }).client({
+  id: s.sql({ type: "int", pk: true }).clientInput({
     value: () => crypto.randomUUID(),
     schema: z.string(),
   }),
-  // Client type becomes: string | number (union of SQL + client)
+  // clientInput type: string (just the user's schema)
   // Default value: a generated UUID string
 
   // Simple default without type override
-  name: s.sql({ type: "varchar" }).client({ value: "Anonymous" }),
-  // Client type: string (inherits from SQL)
+  name: s.sql({ type: "varchar" }).clientInput({ value: "Anonymous" }),
+  // clientInput type: string (inherits from SQL)
   // Default value: "Anonymous"
 
   // Type-only override (no default value change)
-  count: s.sql({ type: "int" }).client(() => z.number().min(0)),
-  // Client type: number (with min validation)
+  count: s.sql({ type: "int" }).clientInput(() => z.number().min(0)),
+  // clientInput type: number (with min validation)
   // Default value: inferred from type (0 for number)
 });
 ```
 
-### 3. Server — Server-Side Validation
+**Note:** The final `client` schema is a union of `sql | clientInput` types, representing the complete app state after transforms.
+
+### 3. Client — Client-Side Validation
+
+`.client()` adds validation rules to the final `client` schema (the union of sql | clientInput). Use it for client-side validation that operates on the complete client type.
+
+```typescript
+name: s.sql({ type: "varchar" })
+  .clientInput({ value: "" })
+  .client((tools) => tools.clientInput.min(3, "Too short"))
+  .server((tools) => tools.clientInput.min(5, "Must be at least 5 chars")),
+```
+
+The `.client()` callback receives `tools` with `sql`, `clientInput`, and `client` schemas.
+
+### 4. Server — Server-Side Validation
 
 `.server()` adds validation rules that run at the server boundary before database writes. It builds on the client schema, adding stricter constraints.
 
@@ -112,18 +127,18 @@ The callback receives the previous schema in the chain so you can refine it:
 ```typescript
 name: s
   .sql({ type: "varchar" })
-  .client(() => z.string().trim())
-  .server(({ client }) => client.min(2, "Too short")),
+  .clientInput(() => z.string().trim())
+  .server(({ clientInput }) => clientInput.min(2, "Too short")),
 ```
 
-### 4. Transform — Convert Between Layers
+### 5. Transform — Convert Between Layers
 
 `.transform()` defines bidirectional conversion functions. These run on the server when reading from or writing to the database.
 
 ```typescript
 status: s
   .sql({ type: "int" })                              // DB: 0 or 1
-  .client(() => z.enum(["active", "inactive"]))       // Client: string enum
+  .clientInput(() => z.enum(["active", "inactive"])) // Client input: string enum
   .transform({
     toClient: (dbValue) => dbValue === 1 ? "active" : "inactive",
     toDb: (clientValue) => clientValue === "active" ? 1 : 0,
@@ -132,37 +147,13 @@ status: s
 
 Transforms are optional — only needed when the client type differs from the SQL type.
 
-### 6. Derive — Computed Fields
+### 6. Layer Separation: DB-Only, Client-Only, and Derived Fields
 
-`.derive()` adds computed fields that are calculated from other values in the row. These are:
-- Available in client schema and defaults
-- NOT stored in the database (computed at runtime)
-- Useful for display-only fields, combinations, or formatted values
+`cogsbox-shape` lets you explicitly define fields that only exist in specific layers, or dynamically compute them.
 
-```typescript
-const userSchema = schema({
-  _tableName: "users",
-  firstName: s.sql({ type: "varchar" }).client({ value: "John" }),
-  lastName: s.sql({ type: "varchar" }).client({ value: "Doe" }),
-  // Define placeholder for derived field
-  fullName: s.client(""),  // Required: tells schema this field exists on client
-}).derive({
-  fullName: (row) => `${row.firstName} ${row.lastName}`,
-});
+#### DB-Only Fields (`sqlOnly: true`)
 
-// Now defaults and toClient include the computed value
-const defaults = box.users.defaults;
-// { firstName: "John", lastName: "Doe", fullName: "John Doe" }
-```
-
-The derived field's default value is computed from other defaults at initialization time.
-
-### 7. sqlOnly — Server-Only Fields
-
-`.sql({ sqlOnly: true })` marks a field as server-only:
-- Included in SQL schema (stored in DB)
-- Excluded from client schema (not sent to client)
-- Useful for internal tokens, computed scores, or sensitive data
+Use `sqlOnly: true` to define fields that belong to the database exclusively (like internal tokens). They are saved in the DB, but dropped before data reaches the client.
 
 ```typescript
 const userSchema = schema({
@@ -170,27 +161,41 @@ const userSchema = schema({
   id: s.sql({ type: "int", pk: true }),
   email: s.sql({ type: "varchar" }),
   internalToken: s.sql({ type: "varchar", sqlOnly: true }),
-  trustScore: s.sql({ type: "int", sqlOnly: true }),
 });
+// DB reads/writes: { id, email, internalToken }
+// Client sees: { id, email }
+```
 
-// Client schema: { id, email } — internalToken and trustScore excluded
-// SQL schema: { id, email, internalToken, trustScore } — all fields
-// Defaults: { id: 0, email: "" } — sqlOnly fields excluded
+#### Client-Only Fields
+
+By skipping `s.sql()` entirely and just using `s.clientInput()`, you can define fields that exist purely on the client (like a temporary UI state or computed field) and will not be sent to the database.
+
+```typescript
+const products = schema({
+  _tableName: "products",
+  price: s.sql({ type: "int" }),
+  formattedPrice: s.clientInput(""), // Client-only field!
+});
 ```
 
-### 8. Client-Only Fields
+#### Derived Fields (`.derive()`)
 
-Use `s.client()` without `s.sql()` to define fields that exist only on the client:
+`.derive()` populates _existing fields_ dynamically on read and default generation. Because you define the fields first, derived fields can be either standard DB fields or Client-only fields.
 
 ```typescript
-const orderSchema = schema({
-  _tableName: "orders",
-  id: s.sql({ type: "int", pk: true }),
-  total: s.sql({ type: "int" }).client({ value: 0 }),
-  // Client-only: computed from other fields, not stored
-  formattedTotal: s.client(""),
+const users = schema({
+  _tableName: "users",
+  firstName: s.sql({ type: "varchar" }).clientInput({ value: "John" }),
+  lastName: s.sql({ type: "varchar" }).clientInput({ value: "Doe" }),
+
+  // 1. Defined purely as a client field
+  fullName: s.clientInput(""),
+  // 2. Defined as a DB field
+  searchIndex: s.sql({ type: "varchar" }),
 }).derive({
-  formattedTotal: (row) => `$${(row.total / 100).toFixed(2)}`,
+  // Computes on toClient() and generateDefaults()
+  fullName: (row) => `${row.firstName} ${row.lastName}`,
+  searchIndex: (row) => `${row.firstName} ${row.lastName}`.toLowerCase(),
 });
 ```
 
@@ -201,13 +206,13 @@ The returned schema object has a clear separation of concerns:
 ```typescript
 const schema = createSchema(mySchema);
 
-schema.schemas;           // { sqlSchema, clientSchema, serverSchema } — Zod schemas
-schema.transforms;        // { toClient, toDb, parseForDb, parseFromDb } — transformations
-schema.defaults;          // Default values for forms
+schema.schemas; // { sql, clientInput, client, server } — Zod schemas
+schema.transforms; // { toClient, toDb, parseForDb, parseFromDb } — transformations
+schema.defaults; // Default values for forms
 schema.generateDefaults; // Function to generate fresh defaults (executes randomizers)
-schema.pk;               // Primary key field names
-schema.clientPk;         // Client-side primary key field names
-schema.isClientRecord;   // Function to check if a record is client-created
+schema.pk; // Primary key field names
+schema.clientPk; // Client-side primary key field names
+schema.isClientRecord; // Function to check if a record is client-created
 ```
 
 ## Using Schemas
@@ -221,17 +226,17 @@ import { s, schema, createSchema } from "cogsbox-shape";
 
 const contactSchema = schema({
   _tableName: "contacts",
-  id: s.sql({ type: "int", pk: true }).client({
+  id: s.sql({ type: "int", pk: true }).clientInput({
     value: () => `new_${crypto.randomUUID().slice(0, 8)}`,
     schema: z.string(),
   }),
   name: s.sql({ type: "varchar" }).server(({ sql }) => sql.min(2)),
   email: s.sql({ type: "varchar" }).server(({ sql }) => sql.email()),
-  isArchived: s
-    .sql({ type: "int" })
-    .client(() => z.boolean())
+  isActive: s
+    .sql({ type: "boolean", default: true })
+    .clientInput(() => z.boolean())
     .transform({
-      toClient: (val) => val === 1,
+      toClient: (val) => Boolean(val),
       toDb: (val) => (val ? 1 : 0),
     }),
 });
@@ -239,22 +244,22 @@ const contactSchema = schema({
 const schema = createSchema(contactSchema);
 
 // Access schemas directly
-const { clientSchema, serverSchema, sqlSchema } = schema;
-const { defaultValues, generateDefaults } = schema;
+const { sql, clientInput, client, server } = schema.schemas;
+const { defaults, generateDefaults } = schema;
 
 // Transforms for converting between layers
 const { toClient, toDb, parseForDb, parseFromDb } = schema.transforms;
 
 // Use in a form
 const [data, setData] = useState(generateDefaults());
-// { id: "new_a1b2c3d4", name: "", email: "", isArchived: false }
+// { id: "new_a1b2c3d4", name: "", email: "", isActive: true }
 
 // Validate explicitly
-const result = serverSchema.safeParse(data);
+const result = server.safeParse(data);
 
 // Or handle validation & transformation in a single step!
 const safeDbRow = parseForDb(data);
-// Validates using serverSchema, outputs { isArchived: 0, ... }
+// Validates using server schema, outputs { isActive: 1, ... }
 ```
 
 ## Relationships and Views
@@ -286,11 +291,14 @@ const posts = schema({
 The `createSchemaBox` function resolves relationships and gives you a type-safe API:
 
 ```typescript
-const box = createSchemaBox({ users, posts }, (s) => ({
-  users: {
-    posts: { fromKey: "id", toKey: s.posts.authorId },
+const box = createSchemaBox(
+  { users, posts },
+  {
+    users: {
+      posts: { fromKey: "id", toKey: posts.authorId },
+    },
   },
-}));
+);
 ```
 
 ### 3. Access Base Schemas
@@ -331,6 +339,27 @@ type UserWithPosts = z.infer<typeof userWithPosts.schemas.client>;
 
 // Views also have transforms for the selected fields
 const { defaults, transforms } = userWithPosts;
-// transforms.apply() handles nested relations automatically
+// transforms.toClient() handles nested relation transforms automatically
 ```
+
+### 5. Nested Defaults and Form Definitions (`defaultsDefinition`)
+
+When working with forms and nested array relations (like `hasMany`), you often need the default state for a _single new item_ to add to a form array.
+
+While `view.defaults` gives you the actual runtime defaults (e.g., an array of 2 default posts if you defined `count: 2`), `view.defaultsDefinition` provides an easy way to grab the structure of a _single element_ using the `__def__relationName` key:
+
+```typescript
+const userView = box.users.createView({
+  posts: { user: true },
+});
+
+// Actual runtime defaults (an array)
+console.log(userView.defaults.posts);
+// => [{ title: "Default Post", user: { ... } }, { title: "Default Post", user: { ... } }]
+
+// Structural definition of a single item for adding to forms
+console.log(userView.defaultsDefinition.__def__posts);
+// => { title: "Default Post", user: { ... } }
 ```
+
+This makes it incredibly simple to implement "Add Item" buttons in complex nested forms without having to manually construct or guess the default object shape.

package/dist/generateSQL.js

@@ -5,7 +5,7 @@ const sqlTypeMap = {
     char: (length = 1) => `CHAR(${length})`,
     text: "TEXT",
     longtext: "LONGTEXT",
-    boolean: "BOOLEAN",
+    boolean: "TINYINT(1)",
     date: "DATE",
     datetime: "DATETIME",
 };

package/dist/schema.d.ts

@@ -35,52 +35,57 @@ type BaseConfig = {
     field?: string;
     sqlOnly?: true;
 };
-type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends true ? TDefault extends true ? z.ZodString : z.ZodNumber : T["nullable"] extends true ? T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodNullable<z.ZodString> : T["type"] extends "int" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodBoolean> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+type SQLToZodType<T extends SQLType, TDefault extends boolean> = T["pk"] extends true ? TDefault extends true ? z.ZodString : z.ZodNumber : T["nullable"] extends true ? T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodNullable<z.ZodString> : T["type"] extends "int" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
     default: "CURRENT_TIMESTAMP";
-} ? TDefault extends true ? never : z.ZodNullable<z.ZodDate> : z.ZodNullable<z.ZodDate> : never : T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodString : T["type"] extends "int" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodBoolean : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+} ? TDefault extends true ? never : z.ZodNullable<z.ZodDate> : z.ZodNullable<z.ZodDate> : never : T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodString : T["type"] extends "int" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodNumber : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
     default: "CURRENT_TIMESTAMP";
 } ? TDefault extends true ? never : z.ZodDate : z.ZodDate : never;
 type ZodTypeFromPrimitive<T> = T extends string ? z.ZodString : T extends number ? z.ZodNumber : T extends boolean ? z.ZodBoolean : T extends Date ? z.ZodDate : z.ZodAny;
 type CollapsedUnion<A extends z.ZodTypeAny, B extends z.ZodTypeAny> = A extends B ? (B extends A ? A : z.ZodUnion<[A, B]>) : z.ZodUnion<[A, B]>;
 export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny, TInitialValue, TClient extends z.ZodTypeAny, TValidation extends z.ZodTypeAny> {
-    client<const TValue>(options: {
+    clientInput<const TValue>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema?: never;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
-    client<const TSchema extends z.ZodTypeAny>(options: {
+    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
+    clientInput<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"client", T, TSql, z.infer<TSchema>, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
-    client<const TSchema extends z.ZodTypeAny>(options: {
+    }): Prettify<Builder<"clientInput", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    clientInput<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema | ((tools: any) => TSchema);
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"client", T, TSql, z.infer<TSchema>, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
-    client<const TValue>(options: {
+    }): Prettify<Builder<"clientInput", T, TSql, z.infer<TSchema>, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    clientInput<const TValue>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema?: never;
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
-    client(options: {
+    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
+    clientInput(options: {
         value?: never;
         schema: (tools: any) => z.ZodTypeAny;
-    }): Prettify<Builder<"client", T, TSql, unknown, z.ZodTypeAny, z.ZodTypeAny>>;
-    client<const TValue, const TSchema extends z.ZodTypeAny>(options: {
+    }): Prettify<Builder<"clientInput", T, TSql, unknown, z.ZodTypeAny, z.ZodTypeAny>>;
+    clientInput<const TValue, const TSchema extends z.ZodTypeAny>(options: {
         value: TValue | ((tools: {
             uuid: () => string;
         }) => TValue);
         schema: TSchema | ((base: ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>) => TSchema);
         clientPk?: boolean | ((val: any) => boolean);
-    }): Prettify<Builder<"client", T, TSql, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
-    client<TClientNext extends z.ZodTypeAny>(schema: ((tools: {
+    }): Prettify<Builder<"clientInput", T, TSql, TValue extends () => infer R ? R : TValue, TSchema, CollapsedUnion<TSql, TSchema>>>;
+    clientInput<TClientNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
-    }) => TClientNext) | TClientNext): Prettify<Builder<"client", T, TSql, TInitialValue, TClientNext, TClientNext>>;
+    }) => TClientNext) | TClientNext): Prettify<Builder<"clientInput", T, TSql, z.infer<TClientNext>, TClientNext, CollapsedUnion<TSql, TClientNext>>>;
+    client: <TClientNext extends z.ZodTypeAny>(schema: ((tools: {
+        sql: TSql;
+        clientInput: TClient;
+        client: z.ZodUnion<[TSql, TClient]>;
+    }) => TClientNext) | TClientNext) => Prettify<Builder<"client", T, TSql, TInitialValue, TClient, z.ZodUnion<[TSql, TClientNext]>>>;
     reference: <TRefSchema extends {
         _tableName: string;
     }>(fieldGetter: () => any) => Builder<"sql", T & {
@@ -88,7 +93,8 @@ export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny,
     }, TSql, TInitialValue, TClient, TValidation>;
     server: <TValidationNext extends z.ZodTypeAny>(schema: ((tools: {
         sql: TSql;
-        client: TClient;
+        clientInput: TClient;
+        client: z.ZodUnion<[TSql, TClient]>;
     }) => TValidationNext) | TValidationNext) => Prettify<Builder<"server", T, TSql, TInitialValue, TClient, TValidationNext>>;
     transform: (transforms: {
         toClient: (dbValue: z.infer<TSql>) => z.infer<TClient>;
@@ -114,10 +120,11 @@ export type RelationConfig<T extends Schema<any>> = (BaseRelationConfig<T> & {
 }) | (BaseRelationConfig<T> & {
     type: "manyToMany";
 });
-type Stage = "sql" | "relation" | "client" | "server" | "done";
+type Stage = "sql" | "relation" | "clientInput" | "client" | "server" | "done";
 type StageMethods = {
-    sql: "client" | "server" | "transform" | "reference";
-    relation: "client" | "server" | "transform";
+    sql: "clientInput" | "client" | "server" | "transform" | "reference";
+    relation: "clientInput" | "client" | "server" | "transform";
+    clientInput: "client" | "server" | "transform";
     client: "server" | "transform";
     server: "transform";
     done: never;
@@ -126,6 +133,7 @@ type BuilderConfig<T extends DbConfig, TSql extends z.ZodTypeAny, TInitialValue,
     sql: T;
     zodSqlSchema: TSql;
     initialValue: TInitialValue;
+    zodClientInputSchema: TClient;
     zodClientSchema: TClient;
     zodValidationSchema: TValidation;
     clientTransform?: (schema: z.ZodTypeAny) => z.ZodTypeAny;
@@ -136,7 +144,8 @@ export type Builder<TStage extends Stage, T extends DbConfig, TSql extends z.Zod
         sql: T;
         zodSqlSchema: TSql;
         initialValue: TInitialValue;
-        zodClientSchema: TClient;
+        zodClientInputSchema: TClient;
+        zodClientSchema: TValidation;
         zodValidationSchema: TValidation;
     };
 } & Pick<IBuilderMethods<T, TSql, TInitialValue, TClient, TValidation>, StageMethods[TStage]>;
@@ -149,10 +158,9 @@ export type Reference<TGetter extends () => any> = {
     getter: TGetter;
 };
 interface ShapeAPI {
-    client: <const TValue>(value: TValue | ((tools: {
+    clientInput: <const TValue>(value: TValue | ((tools: {
         uuid: () => string;
-    }) => TValue)) => Builder<"client", null, z.ZodUndefined, // No SQL schema
-    TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
+    }) => TValue)) => Builder<"clientInput", null, z.ZodUndefined, TValue extends () => infer R ? R : TValue, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>;
     sql: <const T extends SQLType>(sqlConfig: T) => Builder<"sql", T, SQLToZodType<T, false>, z.infer<SQLToZodType<T, false>>, SQLToZodType<T, false>, SQLToZodType<T, false>>;
     reference: <TGetter extends () => any>(getter: TGetter) => Reference<TGetter>;
     hasMany: <T extends HasManyDefault>(config?: T) => PlaceholderRelation<"hasMany">;
@@ -228,6 +236,7 @@ export declare function createSchema<T extends {
     clientPk: string[] | null;
     isClientRecord: (record: any) => boolean;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
+    clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientInputSchema">>>;
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
     serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
     defaultValues: Prettify<DeriveDefaults<TActualSchema>>;
@@ -290,6 +299,7 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
         rawSchema: ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>;
         zodSchemas: {
             sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodSqlSchema">>>;
+            clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientInputSchema">>>;
             clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientSchema">>>;
             serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodValidationSchema">>>;
             defaultValues: Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
@@ -361,6 +371,34 @@ type DeriveViewDefaults<TTableName extends keyof TRegistry, TSelection, TRegistr
         1
     ]> | null : never : never : never;
 } : {})>;
+export type DeriveViewDefaultsDefinition<TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape, Depth extends any[] = []> = Depth["length"] extends 10 ? any : Prettify<TRegistry[TTableName]["zodSchemas"]["defaultValues"] & {
+    [K in keyof TRegistry[TTableName]["rawSchema"] as IsRelationField<TRegistry[TTableName]["rawSchema"][K]> extends true ? K : never]: TRegistry[TTableName]["rawSchema"][K] extends {
+        config: {
+            sql: {
+                type: infer RelType;
+                schema: any;
+            };
+        };
+    } ? GetRelationRegistryKey<TRegistry[TTableName]["rawSchema"][K], TRegistry> extends infer TargetKey ? TargetKey extends keyof TRegistry ? K extends keyof TSelection ? TSelection[K] extends true ? RelType extends "hasMany" | "manyToMany" ? TRegistry[TargetKey]["zodSchemas"]["defaultValues"][] : TRegistry[TargetKey]["zodSchemas"]["defaultValues"] | null : TSelection[K] extends false | undefined ? RelType extends "hasMany" | "manyToMany" ? TRegistry[TargetKey]["zodSchemas"]["defaultValues"][] : TRegistry[TargetKey]["zodSchemas"]["defaultValues"] | null : RelType extends "hasMany" | "manyToMany" ? DeriveViewDefaultsDefinition<TargetKey, TSelection[K], TRegistry, [
+        ...Depth,
+        1
+    ]>[] : DeriveViewDefaultsDefinition<TargetKey, TSelection[K], TRegistry, [
+        ...Depth,
+        1
+    ]> | null : RelType extends "hasMany" | "manyToMany" ? TRegistry[TargetKey]["zodSchemas"]["defaultValues"][] : TRegistry[TargetKey]["zodSchemas"]["defaultValues"] | null : never : never : never;
+} & {
+    [K in keyof TRegistry[TTableName]["rawSchema"] as IsRelationField<TRegistry[TTableName]["rawSchema"][K]> extends true ? `__def__${K & string}` : never]: TRegistry[TTableName]["rawSchema"][K] extends {
+        config: {
+            sql: {
+                type: any;
+                schema: any;
+            };
+        };
+    } ? GetRelationRegistryKey<TRegistry[TTableName]["rawSchema"][K], TRegistry> extends infer TargetKey ? TargetKey extends keyof TRegistry ? K extends keyof TSelection ? TSelection[K] extends true ? TRegistry[TargetKey]["zodSchemas"]["defaultValues"] : TSelection[K] extends false | undefined ? TRegistry[TargetKey]["zodSchemas"]["defaultValues"] : DeriveViewDefaultsDefinition<TargetKey, TSelection[K], TRegistry, [
+        ...Depth,
+        1
+    ]> : TRegistry[TargetKey]["zodSchemas"]["defaultValues"] : never : never : never;
+}>;
 export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRegistry extends RegistryShape> = {
     definition: TRegistry[TTableName]["rawSchema"];
     schemaKey: TTableName;
@@ -376,6 +414,7 @@ export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRe
         parseFromDb: (dbData: Partial<z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>>) => z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>>;
     };
     defaults: DeriveViewDefaults<TTableName, TSelection, TRegistry>;
+    defaultsDefinition: DeriveViewDefaultsDefinition<TTableName, TSelection, TRegistry>;
     pk: string[] | null;
     clientPk: string[] | null;
     supportsReconciliation: boolean;
@@ -410,6 +449,7 @@ type RegistryShape = Record<string, {
     rawSchema: any;
     zodSchemas: {
         sqlSchema: z.ZodObject<any>;
+        clientInputSchema: z.ZodObject<any>;
         clientSchema: z.ZodObject<any>;
         serverSchema: z.ZodObject<any>;
         defaultValues: any;
@@ -432,6 +472,7 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
         schemaKey: K;
         schemas: {
             sql: Resolved[K]["zodSchemas"]["sqlSchema"];
+            clientInput: Resolved[K]["zodSchemas"]["clientInputSchema"];
             client: Resolved[K]["zodSchemas"]["clientSchema"];
             server: Resolved[K]["zodSchemas"]["serverSchema"];
         };
@@ -442,6 +483,7 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
             parseFromDb: (dbData: Partial<z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>>) => z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>;
         };
         defaults: Resolved[K]["zodSchemas"]["defaultValues"];
+        defaultsDefinition: DeriveViewDefaultsDefinition<K & string, {}, Resolved>;
         stateType: Resolved[K]["zodSchemas"]["stateType"];
         generateDefaults: () => Resolved[K]["zodSchemas"]["defaultValues"];
         pk: string[] | null;
@@ -470,7 +512,7 @@ type GetDbKey<K, Field> = Field extends Reference<infer TGetter> ? ReturnType<TG
         };
     };
 } ? string extends F ? K : F : K;
-type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
+type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientInputSchema" | "zodClientSchema" | "zodValidationSchema", Depth extends any[] = []> = Depth["length"] extends 10 ? any : {
     [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" | "derive" | "__derives" ? never : K extends keyof T ? T[K] extends {
         config: {
             sql: {

package/dist/schema.js

@@ -8,7 +8,7 @@ export function currentTimeStamp() {
     };
 }
 export const s = {
-    client: (value) => {
+    clientInput: (value) => {
         const actualValue = isFunction(value) ? value({ uuid }) : value;
         let inferredZodType;
         if (typeof actualValue === "string") {
@@ -30,7 +30,7 @@ export const s = {
             inferredZodType = z.any();
         }
         return createBuilder({
-            stage: "client",
+            stage: "clientInput",
             sqlConfig: null,
             sqlZod: z.undefined(),
             initialValue: actualValue,
@@ -107,6 +107,7 @@ function createBuilder(config) {
             zodSqlSchema: config.sqlZod,
             initialValue: config.initialValue ||
                 inferDefaultFromZod(config.clientZod, config.sqlConfig),
+            zodClientInputSchema: config.clientInputZod || config.clientZod,
             zodClientSchema: config.clientZod,
             zodValidationSchema: config.validationZod,
             clientTransform: config.clientTransform,
@@ -121,15 +122,15 @@ function createBuilder(config) {
                 },
             });
         },
-        client: (...args) => {
-            if (completedStages.has("client")) {
-                throw new Error("client() can only be called once in the chain");
+        clientInput: (...args) => {
+            if (completedStages.has("clientInput")) {
+                throw new Error("clientInput() can only be called once in the chain");
             }
             if (completedStages.has("server")) {
-                throw new Error("client() must be called before server()");
+                throw new Error("clientInput() must be called before server()");
             }
             const newCompletedStages = new Set(completedStages);
-            newCompletedStages.add("client");
+            newCompletedStages.add("clientInput");
             let optionsOrSchema = args[0];
             if (config.stage === "relation") {
                 const assert = typeof optionsOrSchema === "function" ||
@@ -138,8 +139,10 @@ function createBuilder(config) {
                     : optionsOrSchema?.schema;
                 return createBuilder({
                     ...config,
-                    stage: "client",
+                    stage: "clientInput",
                     completedStages: newCompletedStages,
+                    clientZod: assert,
+                    clientInputZod: assert,
                     clientTransform: (baseSchema) => {
                         if (isFunction(assert)) {
                             return assert({ sql: baseSchema });
@@ -254,14 +257,40 @@ function createBuilder(config) {
             }
             return createBuilder({
                 ...config,
-                stage: "client",
+                stage: "clientInput",
                 sqlConfig: newConfig,
                 initialValue: actualValue,
                 clientZod: clientAndServerSchema,
+                clientInputZod: finalSchema,
                 validationZod: clientAndServerSchema,
                 completedStages: newCompletedStages,
             });
         },
+        client: (assert) => {
+            if (completedStages.has("server")) {
+                throw new Error("client() must be called before server()");
+            }
+            const clientSchema = isFunction(assert)
+                ? assert({
+                    sql: config.sqlZod,
+                    clientInput: config.clientInputZod || config.clientZod,
+                    client: config.clientZod,
+                })
+                : assert;
+            const newCompletedStages = new Set(completedStages);
+            newCompletedStages.add("client");
+            const newConfig = {
+                ...config,
+                stage: "client",
+                clientZod: clientSchema,
+                validationZod: clientSchema,
+                completedStages: newCompletedStages,
+            };
+            if (config.clientInputZod !== undefined) {
+                newConfig.clientInputZod = config.clientInputZod;
+            }
+            return createBuilder(newConfig);
+        },
         server: (assert) => {
             if (completedStages.has("server")) {
                 throw new Error("server() can only be called once in the chain");
@@ -269,6 +298,7 @@ function createBuilder(config) {
             const serverSchema = isFunction(assert)
                 ? assert({
                     sql: config.sqlZod,
+                    clientInput: config.clientZod,
                     client: config.clientZod,
                 })
                 : assert;
@@ -282,8 +312,9 @@ function createBuilder(config) {
             });
         },
         transform: (transforms) => {
-            if (!completedStages.has("server") && !completedStages.has("client")) {
-                throw new Error("transform() requires at least client() or server() to be called first");
+            if (!completedStages.has("server") &&
+                !completedStages.has("clientInput")) {
+                throw new Error("transform() requires at least clientInput() or server() to be called first");
             }
             return {
                 config: {
@@ -386,6 +417,7 @@ function isReference(value) {
 }
 export function createSchema(schema, relations) {
     const sqlFields = {};
+    const clientInputFields = {};
     const clientFields = {};
     const serverFields = {};
     const defaultValues = {};
@@ -420,6 +452,7 @@ export function createSchema(schema, relations) {
                 else {
                     clientToDbKeys[key] = dbFieldName;
                     dbToClientKeys[dbFieldName] = key;
+                    clientInputFields[key] = config.zodClientInputSchema;
                     clientFields[key] = config.zodClientSchema;
                     serverFields[key] = config.zodValidationSchema;
                     const initialValueOrFn = config.initialValue;
@@ -461,6 +494,7 @@ export function createSchema(schema, relations) {
                 else {
                     clientToDbKeys[key] = dbFieldName;
                     dbToClientKeys[dbFieldName] = key;
+                    clientInputFields[key] = config.zodClientInputSchema;
                     clientFields[key] = config.zodClientSchema;
                     serverFields[key] = config.zodValidationSchema;
                     if (config.transforms) {
@@ -480,6 +514,7 @@ export function createSchema(schema, relations) {
                 }
             }
             else {
+                clientInputFields[key] = config.zodClientInputSchema;
                 clientFields[key] = config.zodClientSchema;
                 serverFields[key] = config.zodValidationSchema;
                 if (config.transforms) {
@@ -578,19 +613,28 @@ export function createSchema(schema, relations) {
         return clientObject;
     };
     const toDb = (clientObject) => {
+        // 1. Calculate derives FIRST based on the client data
+        const clientWithDerives = { ...clientObject };
+        if (derives) {
+            for (const key in derives) {
+                clientWithDerives[key] = derives[key](clientWithDerives);
+            }
+        }
+        // 2. Map the data (including the newly derived fields) to the DB object
         const dbObject = {};
-        for (const clientKey in clientObject) {
-            if (clientObject[clientKey] === undefined)
+        for (const clientKey in clientWithDerives) {
+            if (clientWithDerives[clientKey] === undefined)
                 continue;
             const dbKey = clientToDbKeys[clientKey] || clientKey;
             const transform = fieldTransforms[clientKey]?.toDb;
             dbObject[dbKey] = transform
-                ? transform(clientObject[clientKey])
-                : clientObject[clientKey];
+                ? transform(clientWithDerives[clientKey])
+                : clientWithDerives[clientKey];
         }
         return dbObject;
     };
     const finalSqlSchema = z.object(sqlFields);
+    const finalClientInputSchema = z.object(clientInputFields);
     const finalClientSchema = z.object(clientFields);
     const finalValidationSchema = z.object(serverFields);
     return {
@@ -598,6 +642,7 @@ export function createSchema(schema, relations) {
         clientPk: clientPkKeys.length ? clientPkKeys : null,
         isClientRecord,
         sqlSchema: finalSqlSchema,
+        clientInputSchema: finalClientInputSchema,
         clientSchema: finalClientSchema,
         serverSchema: finalValidationSchema,
         defaultValues: defaultValues,
@@ -610,8 +655,8 @@ export function createSchema(schema, relations) {
             return toDb(validData);
         },
         parseFromDb: (dbData) => {
-            const mappedData = toClient(dbData);
-            return finalClientSchema.parse(mappedData);
+            finalSqlSchema.parse(dbData);
+            return toClient(dbData);
         },
     };
 }
@@ -639,7 +684,9 @@ function createViewObject(initialRegistryKey, selection, registry, tableNameToRe
         }
         const baseSchema = schemaType === "server"
             ? registryEntry.zodSchemas.serverSchema
-            : registryEntry.zodSchemas.clientSchema;
+            : schemaType === "sql"
+                ? registryEntry.zodSchemas.sqlSchema
+                : registryEntry.zodSchemas.clientSchema;
         const primitiveShape = baseSchema.shape;
         if (subSelection === true) {
             return z.object(primitiveShape);
@@ -670,7 +717,7 @@ function createViewObject(initialRegistryKey, selection, registry, tableNameToRe
         return z.object(finalShape);
     }
     return {
-        sql: registry[initialRegistryKey].zodSchemas.sqlSchema,
+        sql: buildView(initialRegistryKey, selection, "sql"),
         client: buildView(initialRegistryKey, selection, "client"),
         server: buildView(initialRegistryKey, selection, "server"),
         supportsReconciliation: allTablesSupportsReconciliation,
@@ -758,6 +805,44 @@ export function createSchemaBox(schemas, resolutions) {
             generateDefaults: zodSchemas.generateDefaults,
         };
     }
+    const cleanerRegistry = {};
+    const tableNameToRegistryKeyMap = {};
+    for (const key in finalRegistry) {
+        const tableName = finalRegistry[key].rawSchema._tableName;
+        tableNameToRegistryKeyMap[tableName] = key;
+    }
+    for (const tableName in finalRegistry) {
+        const entry = finalRegistry[tableName];
+        const rawSchema = entry.rawSchema;
+        const tableDef = { ...entry.generateDefaults() };
+        for (const key in rawSchema) {
+            if (key === "_tableName" || key.startsWith("__"))
+                continue;
+            const field = rawSchema[key];
+            if (!field?.config?.sql)
+                continue;
+            const sqlConfig = field.config.sql;
+            if (sqlConfig.schema) {
+                const targetTableName = sqlConfig.schema()._tableName;
+                const targetRegKey = tableNameToRegistryKeyMap[targetTableName];
+                if (targetRegKey && finalRegistry[targetRegKey]) {
+                    const targetEntry = finalRegistry[targetRegKey];
+                    const targetDefaults = targetEntry.generateDefaults();
+                    if (sqlConfig.type === "hasMany" || sqlConfig.type === "manyToMany") {
+                        const count = sqlConfig?.defaultCount || 1;
+                        tableDef[key] = Array.from({ length: count }, () => targetDefaults);
+                        tableDef[`__def__${key}`] = targetDefaults;
+                    }
+                    else {
+                        tableDef[key] =
+                            sqlConfig.defaultConfig === null ? null : targetDefaults;
+                        tableDef[`__def__${key}`] = targetDefaults;
+                    }
+                }
+            }
+        }
+        entry.zodSchemas.defaultsDefinition = tableDef;
+    }
     const createNavProxy = (currentTable, registry) => {
         return new Proxy({}, {
             get(target, relationName) {
@@ -776,12 +861,6 @@ export function createSchemaBox(schemas, resolutions) {
             },
         });
     };
-    const cleanerRegistry = {};
-    const tableNameToRegistryKeyMap = {};
-    for (const key in finalRegistry) {
-        const tableName = finalRegistry[key].rawSchema._tableName;
-        tableNameToRegistryKeyMap[tableName] = key;
-    }
     for (const tableName in finalRegistry) {
         const entry = finalRegistry[tableName];
         cleanerRegistry[tableName] = {
@@ -789,6 +868,7 @@ export function createSchemaBox(schemas, resolutions) {
             schemaKey: tableName,
             schemas: {
                 sql: entry.zodSchemas.sqlSchema,
+                clientInput: entry.zodSchemas.clientInputSchema,
                 client: entry.zodSchemas.clientSchema,
                 server: entry.zodSchemas.serverSchema,
             },
@@ -799,6 +879,7 @@ export function createSchemaBox(schemas, resolutions) {
                 parseFromDb: entry.transforms.parseFromDb,
             },
             defaults: entry.generateDefaults(),
+            defaultsDefinition: entry.zodSchemas.defaultsDefinition,
             stateType: entry.zodSchemas.stateType,
             generateDefaults: entry.generateDefaults,
             pk: entry.pk,
@@ -808,6 +889,7 @@ export function createSchemaBox(schemas, resolutions) {
             createView: (selection) => {
                 const view = createViewObject(tableName, selection, finalRegistry, tableNameToRegistryKeyMap);
                 const defaults = computeViewDefaults(tableName, selection, finalRegistry, tableNameToRegistryKeyMap);
+                const defaultsDefinition = computeViewDefaultsDefinition(tableName, selection, finalRegistry, tableNameToRegistryKeyMap);
                 const deepToClient = (dbData, currentSelection, currentKey) => {
                     if (!dbData)
                         return dbData;
@@ -877,13 +959,18 @@ export function createSchemaBox(schemas, resolutions) {
                         toClient: viewToClient,
                         toDb: viewToDb,
                         parseForDb: (appData) => {
-                            return viewToDb(appData);
+                            // FIX: Now correctly validates against the view's server schema first
+                            const validData = view.server.parse(appData);
+                            return viewToDb(validData);
                         },
                         parseFromDb: (dbData) => {
-                            return viewToClient(dbData);
+                            // FIX: Now correctly validates against the view's client schema after mapping
+                            const mappedData = view.sql.parse(dbData);
+                            return viewToClient(mappedData);
                         },
                     },
                     defaults: defaults,
+                    defaultsDefinition: defaultsDefinition,
                     pk: entry.zodSchemas.pk,
                     clientPk: entry.zodSchemas.clientPk,
                     supportsReconciliation: view.supportsReconciliation,
@@ -946,3 +1033,68 @@ function computeViewDefaults(currentRegistryKey, selection, registry, tableNameT
     }
     return baseDefaults;
 }
+function computeViewDefaultsDefinition(currentRegistryKey, selection, registry, tableNameToRegistryKeyMap, visited = new Set()) {
+    if (visited.has(currentRegistryKey)) {
+        return undefined;
+    }
+    visited.add(currentRegistryKey);
+    const entry = registry[currentRegistryKey];
+    if (!entry) {
+        return {};
+    }
+    const baseDef = { ...entry.generateDefaults() };
+    for (const key in entry.rawSchema) {
+        if (key === "_tableName" || key.startsWith("__"))
+            continue;
+        const field = entry.rawSchema[key];
+        if (!field?.config?.sql)
+            continue;
+        const sqlConfig = field.config.sql;
+        if (sqlConfig.schema) {
+            const targetTableName = sqlConfig.schema()._tableName;
+            const nextRegKey = tableNameToRegistryKeyMap[targetTableName];
+            if (!nextRegKey)
+                continue;
+            const targetEntry = registry[nextRegKey];
+            const targetDefaults = targetEntry.generateDefaults();
+            if (sqlConfig.type === "hasMany" || sqlConfig.type === "manyToMany") {
+                const count = sqlConfig?.defaultCount || 1;
+                baseDef[key] = Array.from({ length: count }, () => targetDefaults);
+                baseDef[`__def__${key}`] = targetDefaults;
+            }
+            else {
+                baseDef[key] = sqlConfig.defaultConfig === null ? null : targetDefaults;
+                baseDef[`__def__${key}`] = targetDefaults;
+            }
+        }
+    }
+    if (selection === true || typeof selection !== "object") {
+        return baseDef;
+    }
+    const result = { ...baseDef };
+    for (const key in selection) {
+        if (!selection[key])
+            continue;
+        const field = entry.rawSchema[key];
+        if (!field?.config?.sql?.schema)
+            continue;
+        const relationConfig = field.config.sql;
+        const targetTableName = relationConfig.schema()._tableName;
+        const nextRegistryKey = tableNameToRegistryKeyMap[targetTableName];
+        if (!nextRegistryKey)
+            continue;
+        const nestedDef = computeViewDefaultsDefinition(nextRegistryKey, selection[key], registry, tableNameToRegistryKeyMap, new Set(visited));
+        if (nestedDef) {
+            result[`__def__${key}`] = nestedDef;
+            if (relationConfig.type === "hasMany" ||
+                relationConfig.type === "manyToMany") {
+                const count = relationConfig?.defaultCount || 1;
+                result[key] = Array.from({ length: count }, () => nestedDef);
+            }
+            else {
+                result[key] = relationConfig.defaultConfig === null ? null : nestedDef;
+            }
+        }
+    }
+    return result;
+}

package/package.json

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