@fragno-dev/db 0.1.13 → 0.1.15

package/src/migration-engine/generation-engine.test.ts

@@ -18,6 +18,21 @@ describe("generateMigrationsOrSchema - kysely", () => {
   beforeAll(() => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     db = new Kysely({ dialect: new PostgresDialect({} as any) });
+
+    // Mock Kysely transaction to prevent actual database connections
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.spyOn(db, "transaction").mockReturnValue({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      execute: async (callback: any) => {
+        // Return a mock transaction executor that returns empty results
+        const mockTx = {
+          executeQuery: async () => ({ rows: [] }),
+        };
+        return callback(mockTx);
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
     adapter = new KyselyAdapter({ db, provider: "postgresql" });
 
     // Mock the adapter methods
@@ -50,8 +65,8 @@ describe("generateMigrationsOrSchema - kysely", () => {
     const results = await generateMigrationsOrSchema([fragnoDb]);
 
     expect(results).toHaveLength(2); // Settings + test-db
-    expect(results[0].namespace).toBe("fragno-db-settings");
-    expect(results[0].path).toBe("20251024_001_f000_t001_fragno-db-settings.sql");
+    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(results[0].path).toBe("20251024_001_f000_t001_fragno_db_settings.sql");
     expect(results[0].schema).toContain("create table");
     expect(results[0].schema).toContain("fragno_db_settings");
 
@@ -101,8 +116,8 @@ describe("generateMigrationsOrSchema - kysely", () => {
     const results = await generateMigrationsOrSchema([fragnoDb1, fragnoDb2, fragnoDb3]);
 
     expect(results).toHaveLength(4); // Settings + 3 databases
-    expect(results[0].namespace).toBe("fragno-db-settings");
-    expect(results[0].path).toBe("20251024_001_f000_t001_fragno-db-settings.sql");
+    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(results[0].path).toBe("20251024_001_f000_t001_fragno_db_settings.sql");
 
     expect(results[1].namespace).toBe("apple-db");
     expect(results[1].path).toBe("20251024_002_f000_t001_apple-db.sql");
@@ -142,7 +157,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
     // Settings table already at version 1, so no settings migration needed
     // But fragment migration is still generated
     expect(results).toHaveLength(2);
-    expect(results[0].namespace).toBe("fragno-db-settings");
+    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
     expect(results[1].namespace).toBe("test-db");
     expect(results[1].path).toBe("20251024_002_f000_t002_test-db.sql");
     expect(results[1].schema).toContain("create table");
@@ -170,7 +185,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
 
     // Settings migration is generated, but no fragment migration (since toVersion=0)
     expect(results).toHaveLength(1);
-    expect(results[0].namespace).toBe("fragno-db-settings");
+    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
   });
 
   it("should throw error when no databases provided", async () => {
@@ -283,6 +298,20 @@ describe("generateMigrationsOrSchema - kysely", () => {
   it("should include MySQL-specific foreign key checks in generated SQL", async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const mysqlDb = new Kysely({ dialect: new PostgresDialect({} as any) });
+
+    // Mock Kysely transaction to prevent actual database connections
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.spyOn(mysqlDb, "transaction").mockReturnValue({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      execute: async (callback: any) => {
+        const mockTx = {
+          executeQuery: async () => ({ rows: [] }),
+        };
+        return callback(mockTx);
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
     const mysqlAdapter = new KyselyAdapter({ db: mysqlDb, provider: "mysql" });
 
     vi.spyOn(mysqlAdapter, "isConnectionHealthy").mockResolvedValue(true);
@@ -318,6 +347,20 @@ describe("generateMigrationsOrSchema - kysely", () => {
   it("should include SQLite-specific pragma in generated SQL", async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const sqliteDb = new Kysely({ dialect: new PostgresDialect({} as any) });
+
+    // Mock Kysely transaction to prevent actual database connections
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.spyOn(sqliteDb, "transaction").mockReturnValue({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      execute: async (callback: any) => {
+        const mockTx = {
+          executeQuery: async () => ({ rows: [] }),
+        };
+        return callback(mockTx);
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
     const sqliteAdapter = new KyselyAdapter({ db: sqliteDb, provider: "sqlite" });
 
     vi.spyOn(sqliteAdapter, "isConnectionHealthy").mockResolvedValue(true);
@@ -377,7 +420,7 @@ describe("postProcessMigrationFilenames", () => {
       {
         schema: "schema2",
         path: "placeholder.sql",
-        namespace: "fragno-db-settings",
+        namespace: "", // Empty namespace for settings table
         fromVersion: 0,
         toVersion: 1,
       },
@@ -393,8 +436,8 @@ describe("postProcessMigrationFilenames", () => {
     const result = postProcessMigrationFilenames(files);
 
     expect(result).toHaveLength(3);
-    expect(result[0].namespace).toBe("fragno-db-settings");
-    expect(result[0].path).toBe("20251024_001_f000_t001_fragno-db-settings.sql");
+    expect(result[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(result[0].path).toBe("20251024_001_f000_t001_fragno_db_settings.sql");
   });
 
   it("should sort non-settings namespaces alphabetically", () => {
@@ -435,9 +478,9 @@ describe("postProcessMigrationFilenames", () => {
       {
         schema: "CREATE TABLE users;",
         path: "placeholder.sql",
-        namespace: "fragno-db-settings",
+        namespace: "", // Empty namespace for settings table
         fromVersion: 0,
-        toVersion: 1,
+        toVersion: 5,
       },
       {
         schema: "CREATE TABLE comments;",
@@ -450,7 +493,7 @@ describe("postProcessMigrationFilenames", () => {
 
     const result = postProcessMigrationFilenames(files);
 
-    expect(result[0].path).toBe("20251024_001_f000_t001_fragno-db-settings.sql");
+    expect(result[0].path).toBe("20251024_001_f000_t005_fragno_db_settings.sql");
     expect(result[1].path).toBe("20251024_002_f005_t010_comment-db.sql");
   });
 
@@ -514,7 +557,7 @@ describe("postProcessMigrationFilenames", () => {
       {
         schema: "schema2",
         path: "placeholder.sql",
-        namespace: "fragno-db-settings",
+        namespace: "", // Empty namespace for settings table
         fromVersion: 0,
         toVersion: 5,
       },
@@ -537,8 +580,8 @@ describe("postProcessMigrationFilenames", () => {
     const result = postProcessMigrationFilenames(files);
 
     expect(result).toHaveLength(4);
-    expect(result[0].namespace).toBe("fragno-db-settings");
-    expect(result[0].path).toBe("20251024_001_f000_t005_fragno-db-settings.sql");
+    expect(result[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(result[0].path).toBe("20251024_001_f000_t005_fragno_db_settings.sql");
     expect(result[1].namespace).toBe("apple-db");
     expect(result[1].path).toBe("20251024_002_f003_t004_apple-db.sql");
     expect(result[2].namespace).toBe("mango-db");

package/src/migration-engine/generation-engine.ts

@@ -1,15 +1,17 @@
 import type { FragnoDatabase } from "../mod";
 import type { AnySchema } from "../schema/create";
 import type { PreparedMigration } from "./create";
-import {
-  settingsSchema,
-  SETTINGS_NAMESPACE,
-  createSettingsManager,
-} from "../shared/settings-schema";
 import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
 } from "../adapters/adapters";
+import {
+  internalFragmentDef,
+  settingsSchema,
+  SETTINGS_TABLE_NAME,
+  SETTINGS_NAMESPACE,
+} from "../fragments/internal-fragment";
+import { instantiate } from "@fragno-dev/core";
 
 export interface GenerationEngineResult {
   schema: string;
@@ -59,12 +61,30 @@ export async function generateMigrationsOrSchema<
       );
     }
 
-    const fragments = databases.map((db) => ({
-      schema: db.schema,
-      namespace: db.namespace,
-    }));
+    // Collect all schemas, de-duplicating by namespace.
+    // The internal fragment (settings schema) is always included first since all database
+    // fragments automatically link to it via withDatabase().
+    const fragmentsMap = new Map<string, { schema: AnySchema; namespace: string }>();
+
+    // Include internal fragment first with empty namespace (settings table has no prefix)
+    fragmentsMap.set("", {
+      schema: settingsSchema,
+      namespace: "",
+    });
+
+    // Add user fragments, de-duplicating by namespace
+    // Each FragnoDatabase has a unique namespace, so this prevents duplicate schema generation
+    for (const db of databases) {
+      if (!fragmentsMap.has(db.namespace)) {
+        fragmentsMap.set(db.namespace, {
+          schema: db.schema,
+          namespace: db.namespace,
+        });
+      }
+    }
 
-    const generator = adapter.createSchemaGenerator(fragments, {
+    const allFragments = Array.from(fragmentsMap.values());
+    const generator = adapter.createSchemaGenerator(allFragments, {
       path: options?.path,
     });
 
@@ -89,12 +109,22 @@ export async function generateMigrationsOrSchema<
     );
   }
 
-  const settingsQueryEngine = adapter.createQueryEngine(settingsSchema, "");
-  const settingsManager = createSettingsManager(settingsQueryEngine, SETTINGS_NAMESPACE);
+  // Use the internal fragment for settings management
+  const internalFragment = instantiate(internalFragmentDef)
+    .withConfig({})
+    .withOptions({ databaseAdapter: adapter })
+    .build();
 
   let settingsSourceVersion: number;
   try {
-    const result = await settingsManager.get("version");
+    const result = await internalFragment.inContext(async function () {
+      return await this.uow(async ({ executeRetrieve }) => {
+        const v = internalFragment.services.settingsService.get("version");
+        await executeRetrieve();
+
+        return v;
+      });
+    });
 
     if (!result) {
       settingsSourceVersion = 0;
@@ -102,13 +132,14 @@ export async function generateMigrationsOrSchema<
       settingsSourceVersion = parseInt(result.value);
     }
   } catch {
-    // We don't really have a way to verify this error happens because the key doesn't exist in the database
+    // Settings table doesn't exist yet (first migration)
     settingsSourceVersion = 0;
   }
 
   const generatedFiles: GenerationInternalResult[] = [];
 
-  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, SETTINGS_NAMESPACE);
+  // Use empty namespace for settings (SETTINGS_NAMESPACE is for prefixing keys, not the database namespace)
+  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, "");
   const settingsTargetVersion = settingsSchema.version;
 
   // Generate settings table migration
@@ -128,7 +159,7 @@ export async function generateMigrationsOrSchema<
     generatedFiles.push({
       schema: settingsSql,
       path: "settings-migration.sql", // Placeholder, will be renamed in post-processing
-      namespace: SETTINGS_NAMESPACE,
+      namespace: "", // Empty namespace for settings table
       fromVersion: settingsSourceVersion,
       toVersion: settingsTargetVersion,
       preparedMigration: settingsMigration,
@@ -237,18 +268,35 @@ export async function executeMigrations<const TDatabases extends FragnoDatabase<
   }> = [];
 
   // 1. Prepare settings table migration
-  const settingsQueryEngine = adapter.createQueryEngine(settingsSchema, "");
-  const settingsManager = createSettingsManager(settingsQueryEngine, SETTINGS_NAMESPACE);
+  // Use the internal fragment for settings management
+  const internalFragment = instantiate(internalFragmentDef)
+    .withConfig({})
+    .withOptions({ databaseAdapter: adapter })
+    .build();
 
   let settingsSourceVersion: number;
   try {
-    const result = await settingsManager.get("version");
+    const result = await internalFragment.inContext(async function () {
+      return this.uow(async ({ forSchema, executeRetrieve }) => {
+        const uow = forSchema(settingsSchema);
+        const findOp = uow.find(SETTINGS_TABLE_NAME, (b) =>
+          b.whereIndex("unique_key", (eb) => eb("key", "=", `${SETTINGS_NAMESPACE}.version`)),
+        );
+
+        await executeRetrieve();
+
+        const [results] = await findOp.retrievalPhase;
+        return results?.[0];
+      });
+    });
     settingsSourceVersion = result ? parseInt(result.value) : 0;
   } catch {
+    // Settings table doesn't exist yet (first migration)
     settingsSourceVersion = 0;
   }
 
-  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, SETTINGS_NAMESPACE);
+  // Use empty namespace for settings (SETTINGS_NAMESPACE is for prefixing keys, not the database namespace)
+  const settingsMigrator = adapter.createMigrationEngine(settingsSchema, "");
   const settingsTargetVersion = settingsSchema.version;
 
   if (settingsSourceVersion < settingsTargetVersion) {
@@ -259,7 +307,7 @@ export async function executeMigrations<const TDatabases extends FragnoDatabase<
 
     if (settingsMigration.operations.length > 0) {
       migrationsToExecute.push({
-        namespace: SETTINGS_NAMESPACE,
+        namespace: "", // Empty namespace for settings table
         fromVersion: settingsSourceVersion,
         toVersion: settingsTargetVersion,
         preparedMigration: settingsMigration,
@@ -334,12 +382,13 @@ export function postProcessMigrationFilenames(
     return [];
   }
 
-  // Sort files: settings namespace first, then alphabetically by namespace
+  // Sort files: settings namespace first (empty string), then alphabetically by namespace
   const sortedFiles = [...files].sort((a, b) => {
-    if (a.namespace === SETTINGS_NAMESPACE) {
+    // Settings table has empty namespace - sort it first
+    if (a.namespace === "") {
       return -1;
     }
-    if (b.namespace === SETTINGS_NAMESPACE) {
+    if (b.namespace === "") {
       return 1;
     }
     return a.namespace.localeCompare(b.namespace);
@@ -357,7 +406,11 @@ export function postProcessMigrationFilenames(
     const orderNum = (index + 1).toString().padStart(3, "0");
     const fromPadded = fromVersion.toString().padStart(3, "0");
     const toPadded = toVersion.toString().padStart(3, "0");
-    const safeName = file.namespace.replace(/[^a-z0-9-]/gi, "_");
+
+    // For settings table (empty namespace), use "fragno_db_settings" in the filename
+    // For other tables, use their namespace
+    const safeName =
+      file.namespace === "" ? "fragno_db_settings" : file.namespace.replace(/[^a-z0-9-]/gi, "_");
     const newPath = `${date}_${orderNum}_f${fromPadded}_t${toPadded}_${safeName}.sql`;
 
     return {

package/src/mod.ts

@@ -30,40 +30,6 @@ export function isFragnoDatabase(value: unknown): value is FragnoDatabase<AnySch
   );
 }
 
-/**
- * Definition of a Fragno database schema and namespace.
- * Created by library authors using defineFragnoDatabase().
- * Apps instantiate it by calling .create(adapter).
- */
-export class FragnoDatabaseDefinition<const T extends AnySchema> {
-  #namespace: string;
-  #schema: T;
-
-  constructor(options: CreateFragnoDatabaseDefinitionOptions<T>) {
-    this.#namespace = options.namespace;
-    this.#schema = options.schema;
-  }
-
-  get namespace() {
-    return this.#namespace;
-  }
-
-  get schema() {
-    return this.#schema;
-  }
-
-  /**
-   * Creates a FragnoDatabase instance by binding an adapter to this definition.
-   */
-  create<TUOWConfig = void>(adapter: DatabaseAdapter<TUOWConfig>): FragnoDatabase<T, TUOWConfig> {
-    return new FragnoDatabase({
-      namespace: this.#namespace,
-      schema: this.#schema,
-      adapter,
-    });
-  }
-}
-
 /**
  * A Fragno database instance with a bound adapter.
  * Created from a FragnoDatabaseDefinition by calling .create(adapter).
@@ -120,17 +86,43 @@ export class FragnoDatabase<const T extends AnySchema, TUOWConfig = void> {
   }
 }
 
-export function defineFragnoDatabase<const TSchema extends AnySchema>(
-  options: CreateFragnoDatabaseDefinitionOptions<TSchema>,
-): FragnoDatabaseDefinition<TSchema> {
-  return new FragnoDatabaseDefinition(options);
-}
-
 export {
-  defineFragmentWithDatabase,
-  DatabaseFragmentBuilder,
+  DatabaseFragmentDefinitionBuilder,
   type FragnoPublicConfigWithDatabase,
   type DatabaseFragmentContext,
-} from "./fragment";
+  type DatabaseHandlerContext as DatabaseRequestContext,
+  type ImplicitDatabaseDependencies,
+} from "./db-fragment-definition-builder";
+
+export { withDatabase } from "./with-database";
 
 export { decodeCursor, type CursorData } from "./query/cursor";
+
+export {
+  createUnitOfWork,
+  UnitOfWork,
+  TypedUnitOfWork,
+  type IUnitOfWork,
+  type IUnitOfWorkRestricted,
+  type UOWCompiler,
+  type UOWExecutor,
+  type UOWDecoder,
+} from "./query/unit-of-work";
+
+export {
+  type RetryPolicy,
+  NoRetryPolicy,
+  ExponentialBackoffRetryPolicy,
+  LinearBackoffRetryPolicy,
+} from "./query/retry-policy";
+
+export {
+  executeUnitOfWork,
+  type ExecuteUnitOfWorkResult,
+  type ExecuteUnitOfWorkCallbacks,
+  type ExecuteUnitOfWorkOptions,
+} from "./query/execute-unit-of-work";
+
+export { type BoundServices } from "@fragno-dev/core";
+
+export { internalFragmentDef } from "./fragments/internal-fragment";

package/src/query/cursor.test.ts

@@ -314,6 +314,125 @@ describe("Cursor utilities", () => {
       expect(serialized["createdAt"]).toBe(1234567890);
     });
 
+    it("should handle Date objects in cursors for PostgreSQL", () => {
+      const testSchema = schema((s) =>
+        s.addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("createdAt", column("timestamp"))
+            .createIndex("created", ["createdAt"]),
+        ),
+      );
+
+      const table = testSchema.tables.posts;
+      const createdAtDate = new Date("2025-11-07T09:36:57.959Z");
+      const record = {
+        id: "post123",
+        createdAt: createdAtDate,
+      };
+
+      const index = table.indexes.created;
+      const indexColumns = index.columns;
+
+      // Create cursor from record (has Date object)
+      const cursor = createCursorFromRecord(record, indexColumns, {
+        indexName: "created",
+        orderDirection: "asc",
+        pageSize: 10,
+      });
+
+      // Encode and decode (Date becomes string in JSON)
+      const encoded = cursor.encode();
+      const decoded = decodeCursor(encoded);
+
+      // After decode, the value is a string (from JSON.parse)
+      expect(typeof decoded.indexValues["createdAt"]).toBe("string");
+      expect(decoded.indexValues["createdAt"]).toBe("2025-11-07T09:36:57.959Z");
+
+      // Serialize should convert it back to Date for the database
+      const serialized = serializeCursorValues(decoded, indexColumns, "postgresql");
+
+      // For PostgreSQL, Date objects should be passed through as-is
+      expect(serialized["createdAt"]).toBeInstanceOf(Date);
+      expect((serialized["createdAt"] as Date).toISOString()).toBe("2025-11-07T09:36:57.959Z");
+    });
+
+    it("should handle Date objects in cursors for SQLite", () => {
+      const testSchema = schema((s) =>
+        s.addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("createdAt", column("timestamp"))
+            .createIndex("created", ["createdAt"]),
+        ),
+      );
+
+      const table = testSchema.tables.posts;
+      const createdAtDate = new Date("2025-11-07T09:36:57.959Z");
+      const record = {
+        id: "post123",
+        createdAt: createdAtDate,
+      };
+
+      const index = table.indexes.created;
+      const indexColumns = index.columns;
+
+      // Create cursor from record
+      const cursor = createCursorFromRecord(record, indexColumns, {
+        indexName: "created",
+        orderDirection: "asc",
+        pageSize: 10,
+      });
+
+      // Encode and decode
+      const decoded = decodeCursor(cursor.encode());
+
+      // Serialize should convert string back to Date, then to timestamp number for SQLite
+      const serialized = serializeCursorValues(decoded, indexColumns, "sqlite");
+
+      // For SQLite, Date should be converted to timestamp number
+      expect(typeof serialized["createdAt"]).toBe("number");
+      expect(serialized["createdAt"]).toBe(createdAtDate.getTime());
+    });
+
+    it("should handle Date objects in cursors for MySQL", () => {
+      const testSchema = schema((s) =>
+        s.addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("createdAt", column("timestamp"))
+            .createIndex("created", ["createdAt"]),
+        ),
+      );
+
+      const table = testSchema.tables.posts;
+      const createdAtDate = new Date("2025-11-07T09:36:57.959Z");
+      const record = {
+        id: "post123",
+        createdAt: createdAtDate,
+      };
+
+      const index = table.indexes.created;
+      const indexColumns = index.columns;
+
+      // Create cursor from record
+      const cursor = createCursorFromRecord(record, indexColumns, {
+        indexName: "created",
+        orderDirection: "asc",
+        pageSize: 10,
+      });
+
+      // Encode and decode
+      const decoded = decodeCursor(cursor.encode());
+
+      // Serialize for MySQL
+      const serialized = serializeCursorValues(decoded, indexColumns, "mysql");
+
+      // For MySQL, Date objects should be passed through as-is
+      expect(serialized["createdAt"]).toBeInstanceOf(Date);
+      expect((serialized["createdAt"] as Date).toISOString()).toBe("2025-11-07T09:36:57.959Z");
+    });
+
     it("should handle different order directions correctly", () => {
       const cursorAsc = new Cursor({
         indexName: "_primary",

package/src/query/cursor.ts

@@ -1,5 +1,5 @@
 import type { AnyColumn } from "../schema/create";
-import { serialize } from "../schema/serialize";
+import { deserialize, serialize } from "../schema/serialize";
 import type { SQLProvider } from "../shared/providers";
 
 /**
@@ -78,6 +78,10 @@ export interface CursorResult<T> {
    * Cursor to fetch the next page (undefined if no more results)
    */
   cursor?: Cursor;
+  /**
+   * Whether there are more results available after this page
+   */
+  hasNextPage: boolean;
 }
 
 /**
@@ -203,8 +207,12 @@ export function createCursorFromRecord(
 /**
  * Serialize cursor values for database queries
  *
- * Converts cursor values (which are in application format) to database format
- * using the column serialization rules.
+ * Converts cursor values (which are in JSON-compatible format after decode)
+ * to database format using the column serialization rules.
+ *
+ * This function performs a two-step process:
+ * 1. Deserialize from JSON format to application format (e.g., ISO string → Date)
+ * 2. Serialize from application format to database format (e.g., Date → driver format)
  *
  * @param cursor - The cursor object
  * @param indexColumns - The columns that make up the index
@@ -230,7 +238,12 @@ export function serializeCursorValues(
   for (const col of indexColumns) {
     const value = cursor.indexValues[col.ormName];
     if (value !== undefined) {
-      serialized[col.ormName] = serialize(value, col, provider);
+      // First deserialize from JSON format to application format
+      // (e.g., "2025-11-07T09:36:57.959Z" string → Date object)
+      const deserialized = deserialize(value, col, provider);
+      // Then serialize to database format
+      // (e.g., Date → database driver format)
+      serialized[col.ormName] = serialize(deserialized, col, provider);
     }
   }