cogsbox-shape 0.5.189 → 0.5.191

package/cogsbox-shape-db/dist/connect.js

@@ -50,8 +50,9 @@ function extractTableMeta(entry) {
         clientToDbName.set(key, dbName);
         if (sqlConfig.pk)
             pkFields.push(dbName);
-        if (sqlConfig.isClientPk)
+        if (sqlConfig.isClientPk && !sqlConfig.isForeignKey) {
             clientPkFields.push(key);
+        }
         if (sqlConfig.sqlOnly) {
             sqlOnlyFields.add(dbName);
             sqlOnlyClientFields.add(key);
@@ -96,6 +97,84 @@ function enhanceTable(entry, meta, db) {
         },
     });
 }
+function registryKeyForTableName(registry, tableName) {
+    return Object.keys(registry).find((key) => registry[key]?.rawSchema?._tableName === tableName);
+}
+function dbNameForClientKey(meta, clientKey) {
+    return meta.clientToDbName.get(clientKey) ?? clientKey;
+}
+function clientKeyForRelationTarget(targetField, targetDefinition) {
+    const metaKey = targetField?.__meta?._key;
+    if (typeof metaKey === "string")
+        return metaKey;
+    for (const [key, field] of Object.entries(targetDefinition)) {
+        if (field === targetField)
+            return key;
+    }
+    return undefined;
+}
+function createViewHydrator(db, registry, baseRegistryKey, selection) {
+    const metas = new Map();
+    const getMeta = (registryKey) => {
+        let meta = metas.get(registryKey);
+        if (!meta) {
+            const entry = registry[registryKey];
+            meta = extractTableMeta({
+                definition: entry?.rawSchema,
+                deriveDependencies: entry?.deriveDependencies,
+            });
+            metas.set(registryKey, meta);
+        }
+        return meta;
+    };
+    const hydrate = async (row, currentRegistryKey, currentSelection) => {
+        if (!row || typeof currentSelection !== "object")
+            return row;
+        const currentEntry = registry[currentRegistryKey];
+        if (!currentEntry)
+            return row;
+        const currentMeta = getMeta(currentRegistryKey);
+        const hydrated = { ...row };
+        for (const [relationKey, relationSelection] of Object.entries(currentSelection)) {
+            if (!relationSelection)
+                continue;
+            const relationField = currentEntry.rawSchema?.[relationKey];
+            const relationConfig = relationField?.config?.sql;
+            if (!relationConfig?.schema)
+                continue;
+            const targetTableName = relationConfig.schema()._tableName;
+            const targetRegistryKey = registryKeyForTableName(registry, targetTableName);
+            if (!targetRegistryKey)
+                continue;
+            const targetEntry = registry[targetRegistryKey];
+            const targetMeta = getMeta(targetRegistryKey);
+            const fromDbName = dbNameForClientKey(currentMeta, relationConfig.fromKey);
+            const targetClientKey = clientKeyForRelationTarget(relationConfig.toKey?.(), targetEntry.rawSchema);
+            if (!targetClientKey)
+                continue;
+            const targetDbName = dbNameForClientKey(targetMeta, targetClientKey);
+            const fromValue = row[fromDbName];
+            if (fromValue === undefined || fromValue === null) {
+                hydrated[relationKey] = ["hasMany", "manyToMany"].includes(relationConfig.type)
+                    ? []
+                    : null;
+                continue;
+            }
+            const qb = db;
+            const relatedRows = (await qb
+                .selectFrom(targetMeta.tableName)
+                .selectAll()
+                .where(targetDbName, "=", fromValue)
+                .execute());
+            const hydratedRelated = await Promise.all(relatedRows.map((relatedRow) => hydrate(relatedRow, targetRegistryKey, relationSelection)));
+            hydrated[relationKey] = ["hasMany", "manyToMany"].includes(relationConfig.type)
+                ? hydratedRelated
+                : hydratedRelated[0] ?? null;
+        }
+        return hydrated;
+    };
+    return (row) => hydrate(row, baseRegistryKey, selection);
+}
 export function connect(box, db) {
     const result = {};
     for (const key of Object.keys(box)) {
@@ -114,13 +193,19 @@ export function connect(box, db) {
                     const viewMeta = { ...meta };
                     const viewTransforms = view.transforms ?? {};
                     const reconcile = view.reconcile;
+                    const registry = view.__registry;
+                    const baseTable = view.baseTable;
+                    const viewSelection = view.viewSelection;
+                    const hydrateRow = registry && baseTable && viewSelection
+                        ? createViewHydrator(db, registry, baseTable, viewSelection)
+                        : undefined;
                     const viewDb = new TableDB(db, viewMeta, {
                         toClient: viewTransforms.toClient ?? ((r) => r),
                         toDb: viewTransforms.toDb ?? ((r) => r),
                         parseForDb: viewTransforms.parseForDb ?? ((r) => r),
                         parsePatchForDb: viewTransforms.parsePatchForDb ?? viewTransforms.toDb ?? ((r) => r),
                         parseFromDb: viewTransforms.parseFromDb ?? ((r) => r),
-                    }, reconcile);
+                    }, reconcile, hydrateRow);
                     return new Proxy(view, {
                         get(target, prop, receiver) {
                             if (prop === "db")

package/cogsbox-shape-db/dist/table-db.d.ts

@@ -10,6 +10,7 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     private meta;
     private transforms;
     private reconcile?;
+    private hydrateRow?;
     constructor(db: Kysely<unknown>, meta: TableMeta, transforms: {
         toClient: (row: Record<string, unknown>) => TClient;
         toDb: (row: Record<string, unknown>) => Record<string, unknown>;
@@ -18,7 +19,7 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
         parseFromDb: (data: Record<string, unknown>) => TClient;
     }, reconcile?: ((clientData: unknown) => {
         withServer: (serverData: unknown) => unknown;
-    }) | undefined);
+    }) | undefined, hydrateRow?: ((row: Record<string, unknown>) => Promise<Record<string, unknown>>) | undefined);
     findMany(opts?: FindManyOpts<TClient>): Promise<TClient[]>;
     findById(id: unknown): Promise<TClient | null>;
     insert(data: TCreate, ...args: InsertDbOnlyArgs<TDbOnly>): {

package/cogsbox-shape-db/dist/table-db.js

@@ -6,11 +6,13 @@ export class TableDB {
     meta;
     transforms;
     reconcile;
-    constructor(db, meta, transforms, reconcile) {
+    hydrateRow;
+    constructor(db, meta, transforms, reconcile, hydrateRow) {
         this.db = db;
         this.meta = meta;
         this.transforms = transforms;
         this.reconcile = reconcile;
+        this.hydrateRow = hydrateRow;
     }
     async findMany(opts) {
         const qb = this.db;
@@ -36,7 +38,10 @@ export class TableDB {
             query = query.offset(opts.offset);
         }
         const rows = (await query.execute());
-        return rows.map((r) => this.transforms.parseFromDb(r));
+        const hydratedRows = this.hydrateRow
+            ? await Promise.all(rows.map((row) => this.hydrateRow(row)))
+            : rows;
+        return hydratedRows.map((r) => this.transforms.parseFromDb(r));
     }
     async findById(id) {
         const pkValues = Array.isArray(id) ? id : [id];
@@ -54,7 +59,8 @@ export class TableDB {
         const row = rows[0] ?? null;
         if (!row)
             return null;
-        return this.transforms.parseFromDb(row);
+        const hydratedRow = this.hydrateRow ? await this.hydrateRow(row) : row;
+        return this.transforms.parseFromDb(hydratedRow);
     }
     insert(data, ...args) {
         const dbOnlyData = args[0];

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);
@@ -760,7 +765,11 @@ export function createSchemaBox(schemas, resolutions) {
                 if (targetField && targetField.config) {
                     const newConfig = {
                         ...targetField.config,
-                        sql: { ...targetField.config.sql, isForeignKey: true },
+                        sql: {
+                            ...targetField.config.sql,
+                            field: fieldName,
+                            isForeignKey: true,
+                        },
                     };
                     resolvedSchemas[tableName][fieldName] = {
                         ...targetField,
@@ -941,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.189",
+  "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",