cogsbox-shape 0.5.188 → 0.5.190

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>): {
@@ -36,6 +37,7 @@ export declare class TableDB<TClient extends Record<string, unknown>, TCreate, T
     private missingDeriveDependencies;
     private fetchClientFieldsById;
     private pickDbPatchFields;
+    private isWritableDbColumn;
     private parseDbOnlyData;
     reconcileIds(clientData: unknown, ids: unknown): unknown;
     private reconcileFlatIds;

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];
@@ -82,7 +88,7 @@ export class TableDB {
         }));
         const insertData = {};
         for (const key of Object.keys(dbData)) {
-            if (!pkDbNames.has(key)) {
+            if (!pkDbNames.has(key) && this.isWritableDbColumn(key)) {
                 insertData[key] = dbData[key];
             }
         }
@@ -200,13 +206,22 @@ export class TableDB {
     pickDbPatchFields(dbData, clientKeys) {
         const picked = {};
         for (const clientKey of clientKeys) {
-            const dbName = this.meta.clientToDbName.get(clientKey) ?? clientKey;
+            const dbName = this.meta.clientToDbName.get(clientKey);
+            if (!dbName)
+                continue;
             if (dbData[dbName] !== undefined) {
                 picked[dbName] = dbData[dbName];
             }
         }
         return picked;
     }
+    isWritableDbColumn(dbName) {
+        for (const field of this.meta.dbFields.values()) {
+            if (field.dbName === dbName)
+                return true;
+        }
+        return false;
+    }
     parseDbOnlyData(dbOnlyData, opts = { requireRequired: false }) {
         if (opts.requireRequired) {
             for (const requiredKey of this.meta.sqlOnlyRequiredClientFields) {

package/dist/schema.js

@@ -760,7 +760,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,

package/package.json

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