cogsbox-shape 0.5.190 → 0.5.191

package/dist/schema.d.ts

@@ -194,11 +194,38 @@ type PickPrimaryKeys<T extends ShapeSchema> = {
         };
     } ? K : never]: T[K];
 };
+type PickClientOnlyKeys<T extends ShapeSchema> = {
+    [K in keyof T]: T[K] extends {
+        config: {
+            sql: null;
+        };
+    } ? K : never;
+}[keyof T];
+type PickSqlOnlyKeys<T extends ShapeSchema> = {
+    [K in keyof T]: T[K] extends {
+        config: {
+            sql: {
+                sqlOnly: true;
+            };
+        };
+    } ? K : never;
+}[keyof T];
+type InferClientRow<T extends ShapeSchema> = Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientSchema">>>>>;
 type SchemaBuilder<T extends ShapeSchema> = Prettify<EnrichFields<T>> & {
     __primaryKeySQL?: string;
-    __derives?: Record<string, (row: any) => any>;
+    __derives?: {
+        forClient?: Record<string, (row: any) => any>;
+        forDb?: Record<string, (row: any) => any>;
+    };
     primaryKeySQL: (definer: (pkFields: PickPrimaryKeys<T>) => string) => SchemaBuilder<T>;
-    derive: <D extends Partial<Record<keyof T, (row: Prettify<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<T, "zodClientSchema">>>>>) => any>>>(derivers: D) => SchemaBuilder<T>;
+    derive: (derivers: {
+        forClient?: {
+            [K in PickClientOnlyKeys<T>]?: (row: InferClientRow<T>) => any;
+        };
+        forDb?: {
+            [K in PickSqlOnlyKeys<T>]?: (row: InferClientRow<T>) => any;
+        };
+    }) => SchemaBuilder<T>;
 };
 export declare function schema<T extends string, U extends ShapeSchema<T>>(schema: U): SchemaBuilder<U>;
 export type RelationType = "hasMany" | "hasOne" | "manyToMany";

package/dist/schema.js

@@ -578,6 +578,7 @@ export function createSchema(schema, relations) {
     const generateDefaults = () => {
         const freshDefaults = {};
         for (const key in defaultGenerators) {
+            // ... same logic for mapping standard defaults ...
             const generatorOrValue = defaultGenerators[key];
             let rawValue = isFunction(generatorOrValue)
                 ? generatorOrValue({ uuid })
@@ -586,9 +587,10 @@ export function createSchema(schema, relations) {
                 ? fieldTransforms[key].toClient(rawValue)
                 : rawValue;
         }
-        if (derives) {
-            for (const key in derives) {
-                freshDefaults[key] = derives[key](freshDefaults);
+        // Only apply client derivations
+        if (derives?.forClient) {
+            for (const key in derives.forClient) {
+                freshDefaults[key] = derives.forClient[key]?.(freshDefaults);
             }
         }
         return freshDefaults;
@@ -606,31 +608,34 @@ export function createSchema(schema, relations) {
                 ? transform(dbObject[dbKey])
                 : dbObject[dbKey];
         }
-        if (derives) {
-            for (const key in derives) {
-                clientObject[key] = derives[key](clientObject);
+        // Only apply Client derives AFTER mapping standard fields
+        if (derives?.forClient) {
+            for (const key in derives.forClient) {
+                clientObject[key] = derives.forClient[key]?.(clientObject);
             }
         }
         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 clientWithDerives) {
-            if (clientWithDerives[clientKey] === undefined)
+        // 1. Map standard client fields to DB fields
+        for (const clientKey in clientObject) {
+            if (clientObject[clientKey] === undefined)
                 continue;
             const dbKey = clientToDbKeys[clientKey] || clientKey;
             const transform = fieldTransforms[clientKey]?.toDb;
             dbObject[dbKey] = transform
-                ? transform(clientWithDerives[clientKey])
-                : clientWithDerives[clientKey];
+                ? transform(clientObject[clientKey])
+                : clientObject[clientKey];
+        }
+        // 2. Map Database ONLY derives directly to the dbObject
+        if (derives?.forDb) {
+            for (const schemaKey in derives.forDb) {
+                // Resolve custom DB column name if they used s.sql({ field: "custom_name" })
+                const sqlConfig = fullSchema[schemaKey]?.config?.sql;
+                const dbKey = sqlConfig?.field || schemaKey;
+                dbObject[dbKey] = derives.forDb[schemaKey]?.(clientObject);
+            }
         }
         return dbObject;
     };
@@ -639,9 +644,9 @@ export function createSchema(schema, relations) {
     const finalClientSchema = z.object(clientFields);
     const finalValidationSchema = z.object(serverFields);
     const deriveDependencies = {};
-    if (derives) {
+    if (derives?.forClient) {
         const trackingSeed = { ...defaultValues };
-        for (const key in derives) {
+        for (const key in derives.forClient) {
             const accessed = new Set();
             const trackingRow = new Proxy(trackingSeed, {
                 get(target, prop, receiver) {
@@ -652,7 +657,7 @@ export function createSchema(schema, relations) {
                 },
             });
             try {
-                derives[key](trackingRow);
+                derives.forClient[key]?.(trackingRow);
             }
             catch (e) { }
             deriveDependencies[key] = Array.from(accessed);
@@ -945,9 +950,10 @@ export function createSchemaBox(schemas, resolutions) {
                             }
                         }
                     }
-                    if (regEntry.rawSchema.__derives) {
-                        for (const key in regEntry.rawSchema.__derives) {
-                            baseMapped[key] = regEntry.rawSchema.__derives[key](baseMapped);
+                    if (regEntry.rawSchema.__derives?.forClient) {
+                        for (const key in regEntry.rawSchema.__derives.forClient) {
+                            baseMapped[key] =
+                                regEntry.rawSchema.__derives.forClient[key](baseMapped);
                         }
                     }
                     return baseMapped;

package/package.json

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