cogsbox-shape 0.5.173 → 0.5.175

package/README.md

@@ -36,13 +36,13 @@ Define a field by chaining methods. Each step is optional — use only what you
 s.sql()  →  .initialState()  →  .client()  →  .server()  →  .transform()
 ```
 
-| Method                             | Purpose                                                        |
-| ---------------------------------- | -------------------------------------------------------------- |
-| `s.sql({ type })`                  | Database column type. The starting point for every field.      |
-| `.initialState({ value, schema })` | Default value and type for new records created on the client.  |
-| `.client(fn)`                      | Client-side validation. Overrides the client type if needed.   |
-| `.server(fn)`                      | Server-side validation. Stricter rules before database writes. |
-| `.transform({ toClient, toDb })`   | Converts between database and client representations.          |
+| Method                                       | Purpose                                                        |
+| -------------------------------------------- | -------------------------------------------------------------- |
+| `s.sql({ type })`                            | Database column type. The starting point for every field.      |
+| `.initialState({ value, schema, clientPk })` | Default value and type for new records created on the client.  |
+| `.client(fn)`                                | Client-side validation. Overrides the client type if needed.   |
+| `.server(fn)`                                | Server-side validation. Stricter rules before database writes. |
+| `.transform({ toClient, toDb })`             | Converts between database and client representations.          |
 
 ### 1. SQL — Define Your Database Schema
 
@@ -72,6 +72,7 @@ const userSchema = schema({
   id: s.sql({ type: "int", pk: true }).initialState({
     value: () => crypto.randomUUID(),
     schema: z.string(),
+    clientPk: true, // Explicitly marks this as a client PK, auto-creating a union type
   }),
   // Client type becomes: string | number (union of SQL + initialState)
   // Default value: a generated UUID string
@@ -175,6 +176,7 @@ const contactSchema = schema({
   id: s.sql({ type: "int", pk: true }).initialState({
     value: () => `new_${crypto.randomUUID().slice(0, 8)}`,
     schema: z.string(),
+    clientPk: true,
   }),
   name: s.sql({ type: "varchar" }).server(({ sql }) => sql.min(2)),
   email: s.sql({ type: "varchar" }).server(({ sql }) => sql.email()),
@@ -189,23 +191,24 @@ const contactSchema = schema({
 
 const {
   clientSchema, // Zod schema for client-side validation
-  validationSchema, // Zod schema with .server() rules
+  serverSchema, // Zod schema with .server() rules
   sqlSchema, // Zod schema matching DB column types
   defaultValues, // Typed defaults matching clientSchema
-  toClient, // DB row → client object
-  toDb, // Client object → DB row
+  generateDefaults, // Generates fresh defaults (executes randomizers/dates)
+  parseForDb, // Validates client app data & transforms to DB format
+  parseFromDb, // Transforms DB data & validates to Client format
 } = createSchema(contactSchema);
 
 // Use in a form
-const [data, setData] = useState(defaultValues);
+const [data, setData] = useState(generateDefaults());
 // { id: "new_a1b2c3d4", name: "", email: "", isArchived: false }
 
-// Validate
-const result = validationSchema.safeParse(data);
+// Validate explicitly
+const result = serverSchema.safeParse(data);
 
-// Transform (on the server)
-const dbRow = toDb(data); // { isArchived: 0, ... }
-const clientObj = toClient(row); // { isArchived: true, ... }
+// Or handle validation & transformation in a single step!
+const safeDbRow = parseForDb(data);
+// Validates using serverSchema, outputs { isArchived: 0, ... }
 ```
 
 ## Relationships and Views
@@ -258,7 +261,7 @@ type UserClient = z.infer<typeof schemas.client>;
 
 ### 4. Create Views to Include Relations
 
-Explicitly select which relations to include:
+Explicitly select which relations to include. The resulting views automatically apply nested transforms and deep schema validations.
 
 ```typescript
 const userWithPosts = box.users.createView({
@@ -273,92 +276,5 @@ type UserWithPosts = z.infer<typeof userWithPosts.schemas.client>;
 // }
 
 const defaults = userWithPosts.defaults;
-// { id: 0, name: '', posts: [] }
+// { id: 0, name: '', posts:
 ```
-
-## Complete Example
-
-```typescript
-import { s, schema, createSchemaBox } from "cogsbox-shape";
-import { z } from "zod";
-
-const users = schema({
-  _tableName: "users",
-  id: s.sql({ type: "int", pk: true }).initialState({
-    value: () => `user_${crypto.randomUUID()}`,
-    schema: z.string(),
-  }),
-  email: s
-    .sql({ type: "varchar", length: 255 })
-    .server(({ sql }) => sql.email()),
-  isActive: s
-    .sql({ type: "int" })
-    .client(() => z.boolean())
-    .transform({
-      toClient: (val) => val === 1,
-      toDb: (val) => (val ? 1 : 0),
-    }),
-  posts: s.hasMany({ count: 0 }),
-});
-
-const posts = schema({
-  _tableName: "posts",
-  id: s.sql({ type: "int", pk: true }),
-  title: s.sql({ type: "varchar" }),
-  authorId: s.reference(() => users.id),
-});
-
-const box = createSchemaBox({ users, posts }, (s) => ({
-  users: {
-    posts: { fromKey: "id", toKey: s.posts.authorId },
-  },
-}));
-
-// Base schema (no relations)
-const { schemas, defaults, transforms } = box.users;
-
-// View with relations
-const userView = box.users.createView({ posts: true });
-const { client, server } = userView.schemas;
-
-// Type inference
-type User = z.infer<typeof client>;
-
-// Validation
-const result = server.safeParse(formData);
-
-// Transformation (server-side)
-const dbRow = transforms.toDb(validated);
-const apiResponse = transforms.toClient(dbRow);
-```
-
-## API Reference
-
-### Schema Definition
-
-- `s.sql(config)` — Define SQL column type. The starting point for every field.
-- `.initialState({ value, schema })` — Set default value for new records. Optionally provide a Zod schema to widen or narrow the client type.
-- `.client(schema | fn)` — Define the client-side Zod schema for validation. Use when the client type differs from SQL.
-- `.server(schema | fn)` — Add server-side validation rules. Receives the previous schema in the chain for refinement.
-- `.transform({ toClient, toDb })` — Define bidirectional conversion between SQL and client types. Runs on the server.
-
-### Relationships
-
-- `s.reference(getter)` — Create a foreign key reference to another schema's field.
-- `s.hasMany(config)` — Declare a one-to-many relationship placeholder.
-- `s.hasOne(config)` — Declare a one-to-one relationship placeholder.
-- `s.manyToMany(config)` — Declare a many-to-many relationship placeholder.
-
-### Schema Processing
-
-- `schema(definition)` — Create a schema definition from field declarations.
-- `createSchema(schema)` — Process a single schema. Returns `clientSchema`, `validationSchema`, `sqlSchema`, `defaultValues`, `toClient`, `toDb`.
-- `createSchemaBox(schemas, resolver)` — Process multiple schemas with relationships. Returns a registry with:
-  - `.schemas` — Base Zod schemas (excludes relations).
-  - `.defaults` — Typed default values.
-  - `.transforms` — `toClient` and `toDb` functions.
-  - `.createView(selection)` — Create a view including selected relations.
-
-## License
-
-MIT

package/dist/schema.d.ts

@@ -47,21 +47,20 @@ export interface IBuilderMethods<T extends DbConfig, TSql extends z.ZodTypeAny,
             uuid: () => string;
         }) => TValue);
         schema?: never;
-        clientPk?: boolean;
+        clientPk?: boolean | ((val: any) => boolean);
     }): Prettify<Builder<"new", T, TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>, TValue extends () => infer R ? R : TValue, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>, CollapsedUnion<TSql, ZodTypeFromPrimitive<TValue extends () => infer R ? R : TValue>>>>;
     initialState<const TSchema extends z.ZodTypeAny>(options: {
         value?: never;
         schema: TSchema;
-        clientPk?: boolean;
+        clientPk?: boolean | ((val: any) => boolean);
     }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
     initialState<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;
-    }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, // <-- THIS IS THE FIX: Use schema's type, not literal value
-    CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
+        clientPk?: boolean | ((val: any) => boolean);
+    }): Prettify<Builder<"new", T, TSql, TSchema, z.infer<TSchema>, CollapsedUnion<TSql, TSchema>, CollapsedUnion<TSql, TSchema>>>;
     reference: <TRefSchema extends {
         _tableName: string;
     }>(fieldGetter: () => any) => Builder<"sql", T & {
@@ -174,9 +173,7 @@ type PickPrimaryKeys<T extends ShapeSchema> = {
 };
 type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
     __primaryKeySQL?: string;
-    __isClientChecker?: (record: any) => boolean;
     primaryKeySQL: (definer: (pkFields: PickPrimaryKeys<T>) => string) => SchemaBuilder<T>;
-    isClient: (checker: (record: Prettify<z.infer<z.ZodObject<DeriveSchemaByKey<T, "zodSqlSchema">>> | z.infer<z.ZodObject<DeriveSchemaByKey<T, "zodClientSchema">>>>) => boolean) => SchemaBuilder<T>;
 };
 export declare function schema<T extends string, U extends ShapeSchema<T>>(schema: U): SchemaBuilder<U>;
 export type RelationType = "hasMany" | "hasOne" | "manyToMany";
@@ -215,7 +212,7 @@ export declare function createSchema<T extends {
 }, R extends Record<string, any> = {}, TActualSchema extends Omit<T & R, typeof SchemaWrapperBrand> = Omit<T & R, typeof SchemaWrapperBrand>>(schema: T, relations?: R): {
     pk: string[] | null;
     clientPk: string[] | null;
-    isClientRecord: ((record: any) => boolean) | undefined;
+    isClientRecord: (record: any) => boolean;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
     serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
@@ -246,15 +243,7 @@ type KnownKeys<T> = keyof {
 type ResolutionMap<S extends Record<string, SchemaWithPlaceholders>> = {
     [TableName in keyof S]?: {
         [FieldName in keyof S[TableName] as S[TableName][FieldName] extends PlaceholderReference | PlaceholderRelation<any> ? FieldName : never]?: S[TableName][FieldName] extends PlaceholderRelation<any> ? {
-            /**
-             * The key on the current table (`users`) to join from.
-             * Autocompletes with: 'id', 'name', etc.
-             */
             fromKey: KnownKeys<S[TableName]>;
-            /**
-             * The target key on the related table.
-             * Must be a field reference from the proxy, e.g., `s.pets.userId`
-             */
             toKey: {
                 __meta: any;
                 __parentTableType: any;
@@ -297,7 +286,7 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
             parseFromDb: (dbData: any) => any;
             pk: string[] | null;
             clientPk: string[] | null;
-            isClientRecord: ((record: any) => boolean) | undefined;
+            isClientRecord: (record: any) => boolean;
             generateDefaults: () => Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
         };
     };
@@ -414,7 +403,7 @@ type RegistryShape = Record<string, {
         parseFromDb: (dbData: any) => any;
         pk: string[] | null;
         clientPk: string[] | null;
-        isClientRecord: ((record: any) => boolean) | undefined;
+        isClientRecord: (record: any) => boolean;
         generateDefaults: () => any;
     };
 }>;
@@ -438,7 +427,7 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
         generateDefaults: () => Resolved[K]["zodSchemas"]["defaultValues"];
         pk: string[] | null;
         clientPk: string[] | null;
-        isClientRecord: ((record: any) => boolean) | undefined;
+        isClientRecord: (record: any) => boolean;
         nav: NavigationProxy<K & string, Resolved>;
         RelationSelection: NavigationToSelection<NavigationProxy<K & string, Resolved>>;
         createView: <const TSelection extends NavigationToSelection<NavigationProxy<K & string, Resolved>>>(selection: TSelection) => DeriveViewResult<K & string, TSelection, Resolved>;
@@ -476,7 +465,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 : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "__isClientChecker" | "primaryKeySQL" | "isClient" ? never : K extends keyof T ? T[K] extends Reference<any> ? Key extends "zodSqlSchema" ? GetDbKey<K, T[K]> : K : T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" ? never : K extends keyof T ? T[K] extends Reference<any> ? Key extends "zodSqlSchema" ? GetDbKey<K, T[K]> : K : T[K] extends {
         config: {
             sql: {
                 type: "hasMany" | "manyToMany" | "hasOne" | "belongsTo";
@@ -493,7 +482,7 @@ type DeriveSchemaByKey<T, Key extends "zodSqlSchema" | "zodClientSchema" | "zodV
     } ? ZodSchema : never;
 };
 type DeriveDefaults<T, Depth extends any[] = []> = Prettify<Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "__isClientChecker" | "primaryKeySQL" | "isClient" ? never : K extends keyof T ? T[K] extends Reference<any> ? K : T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" ? never : K extends keyof T ? T[K] extends Reference<any> ? K : T[K] extends {
         config: {
             sql: {
                 type: "hasMany" | "manyToMany" | "hasOne" | "belongsTo";
@@ -513,7 +502,7 @@ type DeriveDefaults<T, Depth extends any[] = []> = Prettify<Depth["length"] exte
     } ? TNew extends TSql ? z.infer<TClient> : D extends () => infer R ? R : D : never;
 }>;
 type DeriveStateType<T, Depth extends any[] = []> = Prettify<Depth["length"] extends 10 ? any : {
-    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "__isClientChecker" | "primaryKeySQL" | "isClient" ? never : K extends keyof T ? T[K] extends Reference<any> ? K : T[K] extends {
+    [K in keyof T as K extends "_tableName" | typeof SchemaWrapperBrand | "__primaryKeySQL" | "primaryKeySQL" ? never : K extends keyof T ? T[K] extends Reference<any> ? K : T[K] extends {
         config: {
             sql: {
                 type: "hasMany" | "manyToMany" | "hasOne" | "belongsTo";

package/dist/schema.js

@@ -103,7 +103,6 @@ export const s = {
         });
     },
 };
-// PASTE THIS ENTIRE FUNCTION OVER YOUR EXISTING createBuilder
 function createBuilder(config) {
     const completedStages = config.completedStages || new Set([config.stage]);
     const builderObject = {
@@ -115,8 +114,8 @@ function createBuilder(config) {
                 inferDefaultFromZod(config.clientZod, config.sqlConfig),
             zodClientSchema: config.clientZod,
             zodValidationSchema: config.validationZod,
-            clientTransform: config.clientTransform, // <-- FIX: Make sure transform is passed through
-            validationTransform: config.validationTransform, // <-- FIX: Make sure transform is passed through
+            clientTransform: config.clientTransform,
+            validationTransform: config.validationTransform,
         },
         initialState: (options) => {
             if (completedStages.has("new")) {
@@ -169,11 +168,10 @@ function createBuilder(config) {
             const newCompletedStages = new Set(completedStages);
             newCompletedStages.add("new");
             const newConfig = { ...config.sqlConfig };
-            if (clientPk) {
-                newConfig.isClientPk = true;
+            if (clientPk !== undefined) {
+                // Store the boolean OR the function directly into the config
+                newConfig.isClientPk = clientPk;
             }
-            // When clientPk is true, ALWAYS union the SQL type with the client type
-            // because records can be either DB-sourced (number) or client-created (string)
             let clientAndServerSchema;
             if (clientPk) {
                 // Always union for clientPk fields
@@ -221,11 +219,8 @@ function createBuilder(config) {
                     ...config,
                     stage: "client",
                     completedStages: newCompletedStages,
-                    // Store the transform function to be used later
                     clientTransform: (baseSchema) => {
                         if (isFunction(assert)) {
-                            // We use `as any` here to resolve the complex generic type error.
-                            // It's safe because we know the baseSchema will have the necessary Zod methods.
                             return assert({
                                 sql: baseSchema,
                                 initialState: config.newZod,
@@ -235,7 +230,6 @@ function createBuilder(config) {
                     },
                 });
             }
-            // This is the original logic for non-relation fields
             const clientSchema = isFunction(assert)
                 ? assert({ sql: config.sqlZod, initialState: config.newZod })
                 : assert;
@@ -247,9 +241,7 @@ function createBuilder(config) {
                 completedStages: newCompletedStages,
             });
         },
-        server: (
-        // ... this validation function remains unchanged ...
-        assert) => {
+        server: (assert) => {
             if (completedStages.has("server")) {
                 throw new Error("validation() can only be called once in the chain");
             }
@@ -305,13 +297,9 @@ export function schema(schema) {
         }
     }
     enrichedSchema[SchemaWrapperBrand] = true;
-    // Add private properties
     enrichedSchema.__primaryKeySQL = undefined;
-    enrichedSchema.__isClientChecker = undefined;
-    // Add methods directly
     enrichedSchema.primaryKeySQL = function (definer) {
         const pkFieldsOnly = {};
-        // Find all PK fields
         for (const key in schema) {
             const field = schema[key];
             if (field &&
@@ -323,29 +311,21 @@ export function schema(schema) {
         enrichedSchema.__primaryKeySQL = definer(pkFieldsOnly);
         return enrichedSchema;
     };
-    enrichedSchema.isClient = function (checker) {
-        enrichedSchema.__isClientChecker = checker;
-        return enrichedSchema;
-    };
     return enrichedSchema;
 }
 function inferDefaultFromZod(zodType, sqlConfig) {
-    // --- START OF FIX ---
-    // If the database is responsible for the default, the client shouldn't generate a value.
     if (sqlConfig &&
         "default" in sqlConfig &&
         sqlConfig.default === "CURRENT_TIMESTAMP") {
         return undefined;
     }
-    // --- END OF FIX ---
     if (sqlConfig && typeof sqlConfig === "object" && "type" in sqlConfig) {
         if ("default" in sqlConfig && sqlConfig.default !== undefined) {
-            // This part now runs only if default is not CURRENT_TIMESTAMP
             return sqlConfig.default;
         }
         if (typeof sqlConfig.type === "string" &&
             ["hasMany", "hasOne", "belongsTo", "manyToMany"].includes(sqlConfig.type)) {
-            // ... (rest of the function is unchanged)
+            // ...
         }
         const sqlTypeConfig = sqlConfig;
         if (sqlTypeConfig.type && !sqlTypeConfig.nullable) {
@@ -361,7 +341,7 @@ function inferDefaultFromZod(zodType, sqlConfig) {
                     return false;
                 case "date":
                 case "datetime":
-                case "timestamp": // Added timestamp here for completeness
+                case "timestamp":
                     return new Date();
             }
         }
@@ -381,7 +361,6 @@ function inferDefaultFromZod(zodType, sqlConfig) {
     }
     return undefined;
 }
-// Helper to check if something is a reference
 function isReference(value) {
     return value && typeof value === "object" && value.__type === "reference";
 }
@@ -392,7 +371,6 @@ export function createSchema(schema, relations) {
     const defaultValues = {};
     const defaultGenerators = {};
     const fieldTransforms = {};
-    // NEW: Track the runtime mappings
     const clientToDbKeys = {};
     const dbToClientKeys = {};
     const fullSchema = { ...schema, ...(relations || {}) };
@@ -403,7 +381,6 @@ export function createSchema(schema, relations) {
         if (key === "_tableName" ||
             key.startsWith("__") ||
             key === String(SchemaWrapperBrand) ||
-            key === "isClient" ||
             key === "primaryKeySQL" ||
             typeof value === "function")
             continue;
@@ -412,11 +389,9 @@ export function createSchema(schema, relations) {
             const targetField = definition.getter();
             if (targetField && targetField.config) {
                 const config = targetField.config;
-                // Track mapping
                 const dbFieldName = config.sql?.field || key;
                 clientToDbKeys[key] = dbFieldName;
                 dbToClientKeys[dbFieldName] = key;
-                // ALL SCHEMAS STRICTLY USE THE JS KEY
                 sqlFields[dbFieldName] = config.zodSqlSchema;
                 clientFields[key] = config.zodClientSchema;
                 serverFields[key] = config.zodValidationSchema;
@@ -445,11 +420,9 @@ export function createSchema(schema, relations) {
                 continue;
             }
             else {
-                // Track mapping
                 const dbFieldName = sqlConfig?.field || key;
                 clientToDbKeys[key] = dbFieldName;
                 dbToClientKeys[dbFieldName] = key;
-                // ALL SCHEMAS STRICTLY USE THE JS KEY
                 sqlFields[dbFieldName] = config.zodSqlSchema;
                 clientFields[key] = config.zodClientSchema;
                 serverFields[key] = config.zodValidationSchema;
@@ -470,23 +443,51 @@ export function createSchema(schema, relations) {
             }
         }
     }
-    let isClientRecord;
-    const explicitChecker = fullSchema.__isClientChecker;
-    if (explicitChecker) {
-        isClientRecord = explicitChecker;
-    }
-    else if (clientPkKeys.length > 0) {
-        const autoChecks = [];
+    // --- NEW: SMART CHECKER BUILDER ---
+    let isClientRecord = () => false;
+    if (clientPkKeys.length > 0) {
+        const checkers = [];
         for (const key of clientPkKeys) {
             const field = fullSchema[key];
-            const sqlType = field?.config?.sql?.type;
-            const initialValue = field?.config?.initialValue;
-            if (sqlType === "int" && typeof initialValue === "string") {
-                autoChecks.push({ key, check: (val) => typeof val === "string" });
+            const sqlConfig = field?.config?.sql;
+            const dbKey = sqlConfig?.field || key;
+            const isClientPkVal = sqlConfig?.isClientPk;
+            if (typeof isClientPkVal === "function") {
+                // Explicit checker provided directly in the field!
+                checkers.push({ clientKey: key, dbKey, check: isClientPkVal });
+            }
+            else {
+                // Fallback auto-detection: If they just passed `true`
+                const initialValueOrFn = field?.config?.initialValue;
+                let sampleValue = initialValueOrFn;
+                // Safely execute the function once to figure out its return type!
+                if (isFunction(initialValueOrFn)) {
+                    try {
+                        sampleValue = initialValueOrFn({ uuid });
+                    }
+                    catch (e) {
+                        // Ignore if the factory fails with a dummy payload
+                    }
+                }
+                if (sqlConfig?.type === "int" && typeof sampleValue === "string") {
+                    checkers.push({
+                        clientKey: key,
+                        dbKey,
+                        check: (val) => typeof val === "string",
+                    });
+                }
             }
         }
-        if (autoChecks.length > 0) {
-            isClientRecord = (record) => autoChecks.some(({ key, check }) => check(record[key]));
+        if (checkers.length > 0) {
+            isClientRecord = (record) => {
+                if (!record || typeof record !== "object")
+                    return false;
+                return checkers.some(({ clientKey, dbKey, check }) => {
+                    // Look at both the client shape key AND the db shape key safely
+                    const val = record[clientKey] !== undefined ? record[clientKey] : record[dbKey];
+                    return check(val);
+                });
+            };
         }
     }
     const generateDefaults = () => {
@@ -502,7 +503,6 @@ export function createSchema(schema, relations) {
         }
         return freshDefaults;
     };
-    // --- RUNTIME TRANSFORMERS: Map keys and apply value transforms ---
     const toClient = (dbObject) => {
         const clientObject = {};
         for (const dbKey in dbObject) {
@@ -529,7 +529,6 @@ export function createSchema(schema, relations) {
         }
         return dbObject;
     };
-    // Create the final Zod objects once
     const finalSqlSchema = z.object(sqlFields);
     const finalClientSchema = z.object(clientFields);
     const finalValidationSchema = z.object(serverFields);
@@ -556,16 +555,13 @@ export function createSchema(schema, relations) {
     };
 }
 function createViewObject(initialRegistryKey, selection, registry, tableNameToRegistryKeyMap) {
-    // Add a flag to track if all tables support reconciliation
     let allTablesSupportsReconciliation = true;
-    // Debug: track which tables are checked
     const checkedTables = {};
     function buildView(currentRegistryKey, subSelection, schemaType) {
         const registryEntry = registry[currentRegistryKey];
         if (!registryEntry) {
             throw new Error(`Schema with key "${currentRegistryKey}" not found in the registry.`);
         }
-        // FIX: Check at the correct path - registryEntry.zodSchemas
         if (!(currentRegistryKey in checkedTables)) {
             const hasPks = !!(registryEntry.zodSchemas?.pk &&
                 registryEntry.zodSchemas.pk.length > 0 &&
@@ -599,7 +595,6 @@ function createViewObject(initialRegistryKey, selection, registry, tableNameToRe
                     if (!nextRegistryKey) {
                         throw new Error(`Could not resolve registry key for table "${targetTableName}"`);
                     }
-                    // Recursive call will also check that table's pk/clientPk
                     const relationSchema = buildView(nextRegistryKey, subSelection[relationKey], schemaType);
                     if (["hasMany", "manyToMany"].includes(relationConfig.type)) {
                         selectedRelationShapes[relationKey] = z.array(relationSchema);
@@ -621,7 +616,6 @@ function createViewObject(initialRegistryKey, selection, registry, tableNameToRe
     };
 }
 export function createSchemaBox(schemas, resolver) {
-    // Your existing implementation stays exactly the same
     const schemaProxy = new Proxy({}, {
         get(target, tableName) {
             const schema = schemas[tableName];
@@ -647,14 +641,12 @@ export function createSchemaBox(schemas, resolver) {
     });
     const resolutionConfig = resolver(schemaProxy);
     const resolvedSchemas = schemas;
-    // STAGE 1: Resolve references
     for (const tableName in schemas) {
         for (const fieldName in schemas[tableName]) {
             const field = schemas[tableName][fieldName];
             if (isReference(field)) {
                 const targetField = field.getter();
                 if (targetField && targetField.config) {
-                    // FIX: Shallow copy preserving Zod instances
                     const newConfig = {
                         ...targetField.config,
                         sql: { ...targetField.config.sql, isForeignKey: true },
@@ -670,7 +662,6 @@ export function createSchemaBox(schemas, resolver) {
             }
         }
     }
-    // STAGE 2: Resolve relations
     for (const tableName in schemas) {
         const tableConfig = resolutionConfig[tableName];
         if (!tableConfig)
@@ -744,7 +735,6 @@ export function createSchemaBox(schemas, resolver) {
         const tableName = finalRegistry[key].rawSchema._tableName;
         tableNameToRegistryKeyMap[tableName] = key;
     }
-    // Inside createSchemaBox, in the cleanerRegistry loop:
     for (const tableName in finalRegistry) {
         const entry = finalRegistry[tableName];
         cleanerRegistry[tableName] = {
@@ -759,13 +749,11 @@ export function createSchemaBox(schemas, resolver) {
                 toClient: entry.zodSchemas.toClient,
                 toDb: entry.zodSchemas.toDb,
             },
-            // ADD: parse functions
             parseForDb: entry.zodSchemas.parseForDb,
             parseFromDb: entry.zodSchemas.parseFromDb,
             defaults: entry.zodSchemas.defaultValues,
             stateType: entry.zodSchemas.stateType,
             generateDefaults: entry.zodSchemas.generateDefaults,
-            // ADD: PK info
             pk: entry.zodSchemas.pk,
             clientPk: entry.zodSchemas.clientPk,
             isClientRecord: entry.zodSchemas.isClientRecord,
@@ -773,6 +761,32 @@ export function createSchemaBox(schemas, resolver) {
             createView: (selection) => {
                 const view = createViewObject(tableName, selection, finalRegistry, tableNameToRegistryKeyMap);
                 const defaults = computeViewDefaults(tableName, selection, finalRegistry, tableNameToRegistryKeyMap);
+                const deepToClient = (dbData, currentSelection, currentKey) => {
+                    if (!dbData)
+                        return dbData;
+                    if (Array.isArray(dbData))
+                        return dbData.map((item) => deepToClient(item, currentSelection, currentKey));
+                    const regEntry = finalRegistry[currentKey];
+                    const baseMapped = regEntry.zodSchemas.toClient(dbData);
+                    if (typeof currentSelection === "object") {
+                        for (const relKey in currentSelection) {
+                            if (currentSelection[relKey] &&
+                                dbData[relKey] !== undefined &&
+                                dbData[relKey] !== null) {
+                                const relField = regEntry.rawSchema[relKey];
+                                if (relField?.config?.sql?.schema) {
+                                    const targetTableName = relField.config.sql.schema()._tableName;
+                                    const nextRegKey = tableNameToRegistryKeyMap[targetTableName];
+                                    if (nextRegKey) {
+                                        baseMapped[relKey] = deepToClient(dbData[relKey], currentSelection[relKey], nextRegKey);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return baseMapped;
+                };
+                const viewToClient = (dbData) => deepToClient(dbData, selection, tableName);
                 return {
                     definition: entry.rawSchema,
                     schemaKey: tableName,
@@ -782,10 +796,13 @@ export function createSchemaBox(schemas, resolver) {
                         server: view.server,
                     },
                     transforms: {
-                        toClient: entry.zodSchemas.toClient,
+                        toClient: viewToClient,
                         toDb: entry.zodSchemas.toDb,
-                        parseForDb: entry.zodSchemas.parseForDb,
-                        parseFromDb: entry.zodSchemas.parseFromDb,
+                    },
+                    parseForDb: entry.zodSchemas.parseForDb,
+                    parseFromDb: (dbData) => {
+                        const mapped = viewToClient(dbData);
+                        return view.client.parse(mapped);
                     },
                     defaults: defaults,
                     pk: entry.zodSchemas.pk,
@@ -798,23 +815,18 @@ export function createSchemaBox(schemas, resolver) {
                 };
             },
             RelationSelection: {},
-            __registry: finalRegistry, // ADD THIS - was in type but not runtime
+            __registry: finalRegistry,
         };
     }
     return cleanerRegistry;
 }
-function computeViewDefaults(currentRegistryKey, // Renamed for clarity, e.g., "users"
-selection, registry, tableNameToRegistryKeyMap, // Accept the map
-visited = new Set()) {
+function computeViewDefaults(currentRegistryKey, selection, registry, tableNameToRegistryKeyMap, visited = new Set()) {
     if (visited.has(currentRegistryKey)) {
-        return undefined; // Prevent circular references
+        return undefined;
     }
     visited.add(currentRegistryKey);
-    // This lookup now uses the correct key every time.
     const entry = registry[currentRegistryKey];
-    // This check prevents the crash.
     if (!entry) {
-        // This case should ideally not be hit if the map is correct, but it's safe to have.
         console.warn(`Could not find entry for key "${currentRegistryKey}" in registry while computing defaults.`);
         return {};
     }
@@ -823,7 +835,6 @@ visited = new Set()) {
     if (selection === true || typeof selection !== "object") {
         return baseDefaults;
     }
-    // Add relation defaults based on selection
     for (const key in selection) {
         if (!selection[key])
             continue;
@@ -831,14 +842,10 @@ visited = new Set()) {
         if (!field?.config?.sql?.schema)
             continue;
         const relationConfig = field.config.sql;
-        // --- THE CORE FIX ---
-        // 1. Get the internal _tableName of the related schema (e.g., "post_table")
         const targetTableName = relationConfig.schema()._tableName;
-        // 2. Use the map to find the correct registry key for it (e.g., "posts")
         const nextRegistryKey = tableNameToRegistryKeyMap[targetTableName];
         if (!nextRegistryKey)
-            continue; // Could not resolve, skip this relation
-        // Handle different default configurations
+            continue;
         const defaultConfig = relationConfig.defaultConfig;
         if (defaultConfig === undefined) {
             delete baseDefaults[key];
@@ -852,17 +859,10 @@ visited = new Set()) {
         else if (relationConfig.type === "hasMany" ||
             relationConfig.type === "manyToMany") {
             const count = defaultConfig?.count || relationConfig.defaultCount || 1;
-            baseDefaults[key] = Array.from({ length: count }, () => 
-            // 3. Make the recursive call with the CORRECT key
-            computeViewDefaults(nextRegistryKey, selection[key], registry, tableNameToRegistryKeyMap, // Pass the map along
-            new Set(visited)));
+            baseDefaults[key] = Array.from({ length: count }, () => computeViewDefaults(nextRegistryKey, selection[key], registry, tableNameToRegistryKeyMap, new Set(visited)));
         }
         else {
-            // hasOne or belongsTo
-            baseDefaults[key] =
-                // 3. Make the recursive call with the CORRECT key
-                computeViewDefaults(nextRegistryKey, selection[key], registry, tableNameToRegistryKeyMap, // Pass the map along
-                new Set(visited));
+            baseDefaults[key] = computeViewDefaults(nextRegistryKey, selection[key], registry, tableNameToRegistryKeyMap, new Set(visited));
         }
     }
     return baseDefaults;

package/package.json

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