cogsbox-shape 0.5.186 → 0.5.187

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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.186",
+  "version": "0.5.187",
   "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",
@@ -12,7 +12,8 @@
     "build": " tsc",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
-    "test": "vitest  "
+    "test": "vitest  ",
+    "playground": "pnpm --filter cogsbox-shape-playground dev"
   },
   "bin": {
     "cogsbox-shape": "./dist/cli.js"
@@ -55,5 +56,10 @@
   "peerDependencies": {
     "zod": "^3.22.4 || ^4.0.0"
   },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3"
+    ]
+  },
   "type": "module"
 }