cogsbox-shape 0.5.186 → 0.5.188

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

@@ -0,0 +1,307 @@
+import { Kysely, sql } from "kysely";
+import { buildWhereConditions, buildPkConditions } from "./where-builder.js";
+import { RecordNotFoundError } from "./errors.js";
+export class TableDB {
+    db;
+    meta;
+    transforms;
+    reconcile;
+    constructor(db, meta, transforms, reconcile) {
+        this.db = db;
+        this.meta = meta;
+        this.transforms = transforms;
+        this.reconcile = reconcile;
+    }
+    async findMany(opts) {
+        const qb = this.db;
+        let query = qb.selectFrom(this.meta.tableName).selectAll();
+        if (opts?.where) {
+            const conditions = buildWhereConditions(opts.where, this.meta);
+            if (conditions.length > 0) {
+                query = query.where(sql.join(conditions, sql ` AND `));
+            }
+        }
+        if (opts?.orderBy) {
+            for (const [col, dir] of Object.entries(opts.orderBy)) {
+                if (dir) {
+                    const field = this.meta.dbFields.get(col);
+                    const dbCol = field?.dbName ?? col;
+                    query = query.orderBy(dbCol, dir);
+                }
+            }
+        }
+        const limit = opts?.limit ?? 100;
+        query = query.limit(limit);
+        if (opts?.offset !== undefined) {
+            query = query.offset(opts.offset);
+        }
+        const rows = (await query.execute());
+        return rows.map((r) => this.transforms.parseFromDb(r));
+    }
+    async findById(id) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const rows = await qb
+            .selectFrom(this.meta.tableName)
+            .selectAll()
+            .where(sql.join(conditions, sql ` AND `))
+            .limit(1)
+            .execute();
+        const row = rows[0] ?? null;
+        if (!row)
+            return null;
+        return this.transforms.parseFromDb(row);
+    }
+    insert(data, ...args) {
+        const dbOnlyData = args[0];
+        return {
+            ids: () => this.insertIds(data, dbOnlyData),
+            full: async () => {
+                const ids = await this.insertIds(data, dbOnlyData);
+                return this.reconcileIds(data, ids);
+            },
+        };
+    }
+    async create(data, ...args) {
+        const dbOnlyData = args[0];
+        return this.insertIds(data, dbOnlyData);
+    }
+    async insertIds(data, dbOnlyData) {
+        const dbData = this.transforms.parseForDb(data);
+        const parsedDbOnlyData = this.parseDbOnlyData(dbOnlyData, {
+            requireRequired: true,
+        });
+        const clientPkClientKeys = this.meta.clientPkFields;
+        const pkDbNames = new Set(clientPkClientKeys.map((k) => {
+            const field = this.meta.dbFields.get(k);
+            return field?.dbName ?? k;
+        }));
+        const insertData = {};
+        for (const key of Object.keys(dbData)) {
+            if (!pkDbNames.has(key)) {
+                insertData[key] = dbData[key];
+            }
+        }
+        Object.assign(insertData, parsedDbOnlyData);
+        const qb = this.db;
+        const result = await qb
+            .insertInto(this.meta.tableName)
+            .values(insertData)
+            .execute();
+        const insertId = result[0]?.insertId;
+        if (insertId !== undefined && this.meta.pkFields.length > 0) {
+            const dbPkField = this.meta.pkFields[0];
+            return { [dbPkField]: Number(insertId) };
+        }
+        return {};
+    }
+    update(id, data, dbOnlyData) {
+        return {
+            ids: () => this.updateIds(id, data, dbOnlyData),
+            full: async () => {
+                const ids = await this.updateIds(id, data, dbOnlyData);
+                const idValue = this.firstPkValue(ids);
+                const row = await this.findById(idValue);
+                if (!row) {
+                    throw new RecordNotFoundError(this.meta.tableName, idValue);
+                }
+                return row;
+            },
+        };
+    }
+    async updateIds(id, data, dbOnlyData) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const patchData = data;
+        const deriveKeys = this.affectedDbBackedDerives(patchData);
+        const missingDeps = this.missingDeriveDependencies(patchData, deriveKeys);
+        const fetchedDeps = missingDeps.length > 0
+            ? await this.fetchClientFieldsById(pkValues, pkFields, missingDeps)
+            : {};
+        const parseInput = { ...fetchedDeps, ...patchData };
+        const parsedDbData = this.transforms.parsePatchForDb(parseInput);
+        const dbData = this.pickDbPatchFields(parsedDbData, [
+            ...Object.keys(patchData),
+            ...deriveKeys,
+        ]);
+        Object.assign(dbData, this.parseDbOnlyData(dbOnlyData, { requireRequired: false }));
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const result = await qb
+            .updateTable(this.meta.tableName)
+            .set(dbData)
+            .where(sql.join(conditions, sql ` AND `))
+            .execute();
+        const numUpdated = result[0]?.numUpdatedRows ?? 0n;
+        if (Number(numUpdated) === 0) {
+            throw new RecordNotFoundError(this.meta.tableName, id);
+        }
+        const pkResult = {};
+        for (let i = 0; i < pkFields.length; i++) {
+            pkResult[pkFields[i]] = pkValues[i];
+        }
+        return pkResult;
+    }
+    affectedDbBackedDerives(patchData) {
+        const patchKeys = new Set(Object.keys(patchData));
+        const affected = [];
+        for (const [deriveKey, deps] of this.meta.deriveDependencies.entries()) {
+            if (!this.meta.dbFields.has(deriveKey))
+                continue;
+            if (deps.some((dep) => patchKeys.has(dep))) {
+                affected.push(deriveKey);
+            }
+        }
+        return affected;
+    }
+    missingDeriveDependencies(patchData, deriveKeys) {
+        const patchKeys = new Set(Object.keys(patchData));
+        const missing = new Set();
+        for (const deriveKey of deriveKeys) {
+            const deps = this.meta.deriveDependencies.get(deriveKey) ?? [];
+            for (const dep of deps) {
+                if (!patchKeys.has(dep))
+                    missing.add(dep);
+            }
+        }
+        return Array.from(missing).filter((dep) => this.meta.dbFields.has(dep));
+    }
+    async fetchClientFieldsById(pkValues, pkFields, clientFields) {
+        const dbColumns = clientFields.map((clientKey) => {
+            const field = this.meta.dbFields.get(clientKey);
+            return field?.dbName ?? clientKey;
+        });
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const row = (await qb
+            .selectFrom(this.meta.tableName)
+            .select(dbColumns)
+            .where(sql.join(conditions, sql ` AND `))
+            .limit(1)
+            .executeTakeFirst());
+        if (!row) {
+            throw new RecordNotFoundError(this.meta.tableName, pkValues);
+        }
+        const result = {};
+        for (const clientKey of clientFields) {
+            const field = this.meta.dbFields.get(clientKey);
+            const dbName = field?.dbName ?? clientKey;
+            const value = row[dbName];
+            result[clientKey] = field?.toClient ? field.toClient(value) : value;
+        }
+        return result;
+    }
+    pickDbPatchFields(dbData, clientKeys) {
+        const picked = {};
+        for (const clientKey of clientKeys) {
+            const dbName = this.meta.clientToDbName.get(clientKey) ?? clientKey;
+            if (dbData[dbName] !== undefined) {
+                picked[dbName] = dbData[dbName];
+            }
+        }
+        return picked;
+    }
+    parseDbOnlyData(dbOnlyData, opts = { requireRequired: false }) {
+        if (opts.requireRequired) {
+            for (const requiredKey of this.meta.sqlOnlyRequiredClientFields) {
+                if (!dbOnlyData || dbOnlyData[requiredKey] === undefined) {
+                    throw new Error(`Missing required sqlOnly field "${requiredKey}" for "${this.meta.tableName}".`);
+                }
+            }
+        }
+        if (!dbOnlyData)
+            return {};
+        const parsed = {};
+        for (const [clientKey, value] of Object.entries(dbOnlyData)) {
+            if (!this.meta.sqlOnlyClientFields.has(clientKey)) {
+                throw new Error(`Field "${clientKey}" is not a sqlOnly field on "${this.meta.tableName}".`);
+            }
+            const validator = this.meta.sqlOnlyValidators.get(clientKey);
+            const validValue = validator ? validator(value) : value;
+            const field = this.meta.dbFields.get(clientKey);
+            const dbName = field?.dbName ?? clientKey;
+            parsed[dbName] = field?.toDb ? field.toDb(validValue) : validValue;
+        }
+        return parsed;
+    }
+    reconcileIds(clientData, ids) {
+        if (this.reconcile) {
+            return this.reconcile(clientData).withServer(ids);
+        }
+        return this.reconcileFlatIds(clientData, ids);
+    }
+    reconcileFlatIds(clientData, ids) {
+        if (Array.isArray(clientData)) {
+            if (!Array.isArray(ids))
+                return clientData;
+            return clientData.map((item, index) => this.reconcileFlatIds(item, ids[index]));
+        }
+        if (typeof clientData !== "object" ||
+            clientData === null ||
+            typeof ids !== "object" ||
+            ids === null) {
+            return clientData;
+        }
+        return {
+            ...clientData,
+            ...this.mapIdsToClientFields(ids),
+        };
+    }
+    mapIdsToClientFields(ids) {
+        const mapped = {};
+        for (const [idKey, value] of Object.entries(ids)) {
+            const clientKey = this.clientKeyForDbField(idKey);
+            const field = this.meta.dbFields.get(clientKey);
+            mapped[clientKey] = field?.toClient ? field.toClient(value) : value;
+        }
+        return mapped;
+    }
+    clientKeyForDbField(dbField) {
+        for (const [clientKey, field] of this.meta.dbFields.entries()) {
+            if (field.dbName === dbField)
+                return clientKey;
+        }
+        return dbField;
+    }
+    firstPkValue(ids) {
+        const pkField = this.meta.pkFields[0];
+        if (pkField && ids[pkField] !== undefined) {
+            return ids[pkField];
+        }
+        return Object.values(ids)[0];
+    }
+    async delete(id) {
+        const pkValues = Array.isArray(id) ? id : [id];
+        const pkFields = this.meta.pkFields.length > 0
+            ? this.meta.pkFields
+            : Array.from(this.meta.dbFields.values()).map((f) => f.dbName);
+        const conditions = buildPkConditions(pkValues, pkFields);
+        const qb = this.db;
+        const result = await qb
+            .deleteFrom(this.meta.tableName)
+            .where(sql.join(conditions, sql ` AND `))
+            .execute();
+        const numDeleted = result[0]?.numDeletedRows ?? 0n;
+        return { deleted: Number(numDeleted) > 0 };
+    }
+    async count(where) {
+        const qb = this.db;
+        let query = qb
+            .selectFrom(this.meta.tableName)
+            .select(sql `count(*)`.as("count"));
+        if (where) {
+            const conditions = buildWhereConditions(where, this.meta);
+            if (conditions.length > 0) {
+                query = query.where(sql.join(conditions, sql ` AND `));
+            }
+        }
+        const row = (await query.execute());
+        return Number(row[0]?.count ?? 0);
+    }
+}

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

@@ -0,0 +1,39 @@
+export type WhereValue<T> = T | {
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    in?: T[];
+    not?: T | Exclude<WhereValue<T>, T>;
+};
+export type WhereInput<T> = {
+    [K in keyof T]?: WhereValue<T[K]>;
+};
+export interface FindManyOpts<T> {
+    where?: WhereInput<Partial<T>>;
+    orderBy?: {
+        [K in keyof T]?: "asc" | "desc";
+    };
+    limit?: number;
+    offset?: number;
+}
+export interface ClientToDbField {
+    dbName: string;
+    toDb?: (val: any) => any;
+    toClient?: (val: any) => any;
+}
+export interface TableMeta {
+    tableName: string;
+    dbFields: Map<string, ClientToDbField>;
+    clientToDbName: Map<string, string>;
+    pkFields: string[];
+    clientPkFields: string[];
+    sqlOnlyFields: Set<string>;
+    sqlOnlyClientFields: Set<string>;
+    sqlOnlyRequiredClientFields: Set<string>;
+    sqlOnlyValidators: Map<string, (val: unknown) => unknown>;
+    deriveDependencies: Map<string, string[]>;
+}

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

@@ -0,0 +1 @@
+export {};

package/cogsbox-shape-db/dist/where-builder.d.ts

@@ -0,0 +1,4 @@
+import type { TableMeta } from "./types.js";
+import { sql } from "kysely";
+export declare function buildWhereConditions(filter: Record<string, unknown>, meta: TableMeta): ReturnType<typeof sql>[];
+export declare function buildPkConditions(pkValues: unknown[], pkFields: string[]): ReturnType<typeof sql>[];

package/cogsbox-shape-db/dist/where-builder.js

@@ -0,0 +1,71 @@
+import { sql } from "kysely";
+export function buildWhereConditions(filter, meta) {
+    const conditions = [];
+    for (const [clientKey, value] of Object.entries(filter)) {
+        if (value === undefined)
+            continue;
+        const field = meta.dbFields.get(clientKey);
+        const dbName = field?.dbName ?? clientKey;
+        const dbRef = sql.ref(dbName);
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            const op = value;
+            if ("contains" in op) {
+                const tv = field?.toDb ? field.toDb(op.contains) : op.contains;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`%${String(tv ?? "")}%`)}`);
+            }
+            else if ("startsWith" in op) {
+                const tv = field?.toDb ? field.toDb(op.startsWith) : op.startsWith;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`${String(tv ?? "")}%`)}`);
+            }
+            else if ("endsWith" in op) {
+                const tv = field?.toDb ? field.toDb(op.endsWith) : op.endsWith;
+                conditions.push(sql `${dbRef} LIKE ${sql.val(`%${String(tv ?? "")}`)}`);
+            }
+            else if ("gt" in op) {
+                const tv = field?.toDb ? field.toDb(op.gt) : op.gt;
+                conditions.push(sql `${dbRef} > ${sql.val(tv)}`);
+            }
+            else if ("gte" in op) {
+                const tv = field?.toDb ? field.toDb(op.gte) : op.gte;
+                conditions.push(sql `${dbRef} >= ${sql.val(tv)}`);
+            }
+            else if ("lt" in op) {
+                const tv = field?.toDb ? field.toDb(op.lt) : op.lt;
+                conditions.push(sql `${dbRef} < ${sql.val(tv)}`);
+            }
+            else if ("lte" in op) {
+                const tv = field?.toDb ? field.toDb(op.lte) : op.lte;
+                conditions.push(sql `${dbRef} <= ${sql.val(tv)}`);
+            }
+            else if ("in" in op && Array.isArray(op.in)) {
+                const items = op.in.map((v) => {
+                    const tv = field?.toDb ? field.toDb(v) : v;
+                    return sql.val(tv);
+                });
+                conditions.push(sql `${dbRef} IN (${sql.join(items, sql `, `)})`);
+            }
+            else if ("not" in op) {
+                const nv = op.not;
+                if (nv !== null && typeof nv === "object" && !Array.isArray(nv)) {
+                    const no = nv;
+                    if ("contains" in no) {
+                        const tv = field?.toDb ? field.toDb(no.contains) : no.contains;
+                        conditions.push(sql `${dbRef} NOT LIKE ${sql.val(`%${String(tv ?? "")}%`)}`);
+                    }
+                }
+                else {
+                    const tv = field?.toDb ? field.toDb(nv) : nv;
+                    conditions.push(sql `${dbRef} != ${sql.val(tv)}`);
+                }
+            }
+        }
+        else {
+            const transformed = field?.toDb ? field.toDb(value) : value;
+            conditions.push(sql `${dbRef} = ${sql.val(transformed)}`);
+        }
+    }
+    return conditions;
+}
+export function buildPkConditions(pkValues, pkFields) {
+    return pkFields.map((f, i) => sql `${sql.ref(f)} = ${sql.val(pkValues[i])}`);
+}

package/dist/schema.d.ts

@@ -1,4 +1,7 @@
 import { z } from "zod";
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
 type CurrentTimestampConfig = {
     default: "CURRENT_TIMESTAMP";
     defaultValue: Date;
@@ -234,6 +237,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;
+    deriveDependencies: Record<string, string[]>;
     isClientRecord: (record: any) => boolean;
     sqlSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>;
     clientInputSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientInputSchema">>>;
@@ -245,6 +249,7 @@ export declare function createSchema<T extends {
     toClient: (dbObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>;
     toDb: (clientObject: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>;
     parseForDb: (appData: z.input<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>;
+    parsePatchForDb: (patchData: Partial<z.input<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>>>) => Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>;
     parseFromDb: (dbData: Partial<z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodSqlSchema">>>>>) => z.infer<z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>>;
 };
 export type PlaceholderReference = {
@@ -309,6 +314,7 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
             toClient: (dbObject: any) => any;
             toDb: (clientObject: any) => any;
             parseForDb: (appData: any) => any;
+            parsePatchForDb: (patchData: any) => any;
             parseFromDb: (dbData: any) => any;
         };
         pk: string[] | null;
@@ -411,8 +417,12 @@ export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRe
         toClient: TRegistry[TTableName]["transforms"]["toClient"];
         toDb: TRegistry[TTableName]["transforms"]["toDb"];
         parseForDb: (appData: z.input<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "serverSchema">>>) => z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>;
+        parsePatchForDb: (patchData: Partial<z.input<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "serverSchema">>>>) => Partial<z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>>;
         parseFromDb: (dbData: Partial<z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>>) => z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>>;
     };
+    reconcile: (clientData: z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>> | z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>>[]) => {
+        withServer: (serverData: DeepPartial<z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>> | DeepPartial<z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "sqlSchema">>>>[]) => z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>> | z.infer<z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientSchema">>>[];
+    };
     defaults: () => DeriveViewDefaults<TTableName, TSelection, TRegistry>;
     defaultsDefinition: () => DeriveViewDefaultsDefinition<TTableName, TSelection, TRegistry>;
     pk: string[] | null;
@@ -454,19 +464,22 @@ type RegistryShape = Record<string, {
         serverSchema: z.ZodObject<any>;
         defaultValues: any;
         stateType: any;
+        deriveDependencies: Record<string, string[]>;
     };
     transforms: {
         toClient: (dbObject: any) => any;
         toDb: (clientObject: any) => any;
         parseForDb: (appData: any) => any;
+        parsePatchForDb: (patchData: any) => any;
         parseFromDb: (dbData: any) => any;
     };
     pk: string[] | null;
     clientPk: string[] | null;
+    deriveDependencies: Record<string, string[]>;
     isClientRecord: (record: any) => boolean;
     generateDefaults: () => any;
 }>;
-type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R extends ResolutionMap<S>, Resolved extends RegistryShape = ResolvedRegistryWithSchemas<S, R> extends RegistryShape ? ResolvedRegistryWithSchemas<S, R> : RegistryShape> = {
+type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R extends ResolutionMap<S>, Resolved extends Record<string, any> = ResolvedRegistryWithSchemas<S, R>> = {
     [K in keyof Resolved]: {
         definition: Resolved[K]["rawSchema"];
         schemaKey: K;
@@ -480,6 +493,7 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
             toClient: (dbData: z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>) => z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>;
             toDb: (clientData: z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>) => z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>;
             parseForDb: (appData: z.input<Resolved[K]["zodSchemas"]["serverSchema"]>) => z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>;
+            parsePatchForDb: (patchData: Partial<z.input<Resolved[K]["zodSchemas"]["serverSchema"]>>) => Partial<z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>>;
             parseFromDb: (dbData: Partial<z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>>) => z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>;
         };
         defaults: Resolved[K]["zodSchemas"]["defaultValues"];

package/dist/schema.js

@@ -638,9 +638,30 @@ export function createSchema(schema, relations) {
     const finalClientInputSchema = z.object(clientInputFields);
     const finalClientSchema = z.object(clientFields);
     const finalValidationSchema = z.object(serverFields);
+    const deriveDependencies = {};
+    if (derives) {
+        const trackingSeed = { ...defaultValues };
+        for (const key in derives) {
+            const accessed = new Set();
+            const trackingRow = new Proxy(trackingSeed, {
+                get(target, prop, receiver) {
+                    if (typeof prop === "string" && prop !== key) {
+                        accessed.add(prop);
+                    }
+                    return Reflect.get(target, prop, receiver);
+                },
+            });
+            try {
+                derives[key](trackingRow);
+            }
+            catch (e) { }
+            deriveDependencies[key] = Array.from(accessed);
+        }
+    }
     return {
         pk: pkKeys.length ? pkKeys : null,
         clientPk: clientPkKeys.length ? clientPkKeys : null,
+        deriveDependencies,
         isClientRecord,
         sqlSchema: finalSqlSchema,
         clientInputSchema: finalClientInputSchema,
@@ -655,6 +676,10 @@ export function createSchema(schema, relations) {
             const validData = finalValidationSchema.parse(appData);
             return toDb(validData);
         },
+        parsePatchForDb: (patchData) => {
+            const validPatch = finalValidationSchema.partial().parse(patchData);
+            return toDb(validPatch);
+        },
         parseFromDb: (dbData) => {
             const parsed = finalSqlSchema.parse(dbData);
             return toClient(parsed);
@@ -798,10 +823,12 @@ export function createSchemaBox(schemas, resolutions) {
                 toClient: zodSchemas.toClient,
                 toDb: zodSchemas.toDb,
                 parseForDb: zodSchemas.parseForDb,
+                parsePatchForDb: zodSchemas.parsePatchForDb,
                 parseFromDb: zodSchemas.parseFromDb,
             },
             pk: zodSchemas.pk,
             clientPk: zodSchemas.clientPk,
+            deriveDependencies: zodSchemas.deriveDependencies,
             isClientRecord: zodSchemas.isClientRecord,
             generateDefaults: zodSchemas.generateDefaults,
         };
@@ -877,6 +904,7 @@ export function createSchemaBox(schemas, resolutions) {
                 toClient: entry.transforms.toClient,
                 toDb: entry.transforms.toDb,
                 parseForDb: entry.transforms.parseForDb,
+                parsePatchForDb: entry.transforms.parsePatchForDb,
                 parseFromDb: entry.transforms.parseFromDb,
             },
             defaults: entry.generateDefaults(),
@@ -885,6 +913,7 @@ export function createSchemaBox(schemas, resolutions) {
             generateDefaults: entry.generateDefaults,
             pk: entry.pk,
             clientPk: entry.clientPk,
+            deriveDependencies: entry.deriveDependencies,
             isClientRecord: entry.isClientRecord,
             nav: createNavProxy(tableName, finalRegistry),
             createView: (selection) => {
@@ -946,6 +975,64 @@ export function createSchemaBox(schemas, resolutions) {
                 };
                 const viewToClient = (dbData) => deepToClient(dbData, selection, tableName);
                 const viewToDb = (clientData) => deepToDb(clientData, selection, tableName);
+                const reconcile = (clientData) => {
+                    return {
+                        withServer: (serverData) => {
+                            const parsedServerData = viewToClient(serverData);
+                            const mergeTrees = (cNode, sNode, tableKey, sel) => {
+                                if (sNode === undefined || sNode === null)
+                                    return cNode;
+                                if (cNode === undefined || cNode === null)
+                                    return sNode;
+                                const regEntry = finalRegistry[tableKey];
+                                const clientPkField = regEntry.clientPk?.[0] || regEntry.pk?.[0];
+                                const dbPkField = regEntry.pk?.[0] || clientPkField;
+                                if (Array.isArray(cNode)) {
+                                    if (!Array.isArray(sNode))
+                                        return cNode;
+                                    return cNode.map((cItem, index) => {
+                                        let sItem = undefined;
+                                        if (clientPkField && cItem[clientPkField] !== undefined) {
+                                            sItem = sNode.find((s) => s[clientPkField] === cItem[clientPkField]);
+                                        }
+                                        if (!sItem && dbPkField && cItem[dbPkField] !== undefined) {
+                                            sItem = sNode.find((s) => s[dbPkField] === cItem[dbPkField]);
+                                        }
+                                        if (!sItem && sNode[index]) {
+                                            sItem = sNode[index];
+                                        }
+                                        return mergeTrees(cItem, sItem, tableKey, sel);
+                                    });
+                                }
+                                if (typeof cNode === "object" && typeof sNode === "object") {
+                                    const merged = { ...cNode };
+                                    for (const key in sNode) {
+                                        const selValue = typeof sel === "object" ? sel[key] : undefined;
+                                        const relField = regEntry.rawSchema[key];
+                                        const isRelation = !!(selValue && relField?.config?.sql?.schema);
+                                        if (isRelation) {
+                                            const nextTableKey = tableNameToRegistryKeyMap[relField.config.sql.schema()._tableName];
+                                            merged[key] = mergeTrees(cNode[key], sNode[key], nextTableKey, selValue);
+                                        }
+                                        else {
+                                            merged[key] = sNode[key];
+                                        }
+                                    }
+                                    if (clientPkField &&
+                                        dbPkField &&
+                                        clientPkField !== dbPkField &&
+                                        merged[dbPkField] !== undefined &&
+                                        merged[dbPkField] !== null) {
+                                        delete merged[clientPkField];
+                                    }
+                                    return merged;
+                                }
+                                return sNode !== undefined ? sNode : cNode;
+                            };
+                            return mergeTrees(clientData, parsedServerData, tableName, selection);
+                        },
+                    };
+                };
                 return {
                     definition: entry.rawSchema,
                     schemaKey: tableName,
@@ -958,16 +1045,19 @@ export function createSchemaBox(schemas, resolutions) {
                         toClient: viewToClient,
                         toDb: viewToDb,
                         parseForDb: (appData) => {
-                            // FIX: Now correctly validates against the view's server schema first
                             const validData = view.server.parse(appData);
                             return viewToDb(validData);
                         },
+                        parsePatchForDb: (patchData) => {
+                            const validPatch = view.server.partial().parse(patchData);
+                            return viewToDb(validPatch);
+                        },
                         parseFromDb: (dbData) => {
-                            // FIX: Now correctly validates against the view's client schema after mapping
                             const mappedData = view.sql.parse(dbData);
                             return viewToClient(mappedData);
                         },
                     },
+                    reconcile,
                     defaults: () => computeViewDefaults(tableName, selection, finalRegistry, tableNameToRegistryKeyMap),
                     defaultsDefinition: () => computeViewDefaultsDefinition(tableName, selection, finalRegistry, tableNameToRegistryKeyMap),
                     pk: entry.zodSchemas.pk,