@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/{drizzle/drizzle-adapter-pglite.test.ts → generic-sql/sql-adapter-pglite-queries.test.ts}

@@ -1,18 +1,18 @@
 import { PGlite } from "@electric-sql/pglite";
 import { KyselyPGlite } from "kysely-pglite";
-import { DrizzleAdapter } from "./drizzle-adapter";
+import { SqlAdapter } from "./generic-sql-adapter";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { Cursor } from "../../query/cursor";
-import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+import { PGLiteDriverConfig } from "./driver-config";
 import type { CompiledQuery } from "../../sql-driver/sql-driver";
 import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("DrizzleAdapter PGLite", () => {
+describe("SqlAdapter PGLite", () => {
   let pgliteDatabase: PGlite;
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -73,7 +73,7 @@ describe("DrizzleAdapter PGLite", () => {
       });
   });
 
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -98,7 +98,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const { dialect } = new KyselyPGlite(pgliteDatabase);
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
     });
@@ -321,7 +321,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "emails_namespace"."id" as "id", "emails_namespace"."user_id" as "user_id", "emails_namespace"."email" as "email", "emails_namespace"."is_primary" as "is_primary", "emails_namespace"."_internalId" as "_internalId", "emails_namespace"."_version" as "_version" from "emails_namespace" left join "users_namespace" as "user" on "emails_namespace"."user_id" = "user"."_internalId""`,
+      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "namespace"."emails"."id" as "id", "namespace"."emails"."user_id" as "user_id", "namespace"."emails"."email" as "email", "namespace"."emails"."is_primary" as "is_primary", "namespace"."emails"."_internalId" as "_internalId", "namespace"."emails"."_version" as "_version" from "namespace"."emails" left join "namespace"."users" as "user" on "namespace"."emails"."user_id" = "user"."_internalId""`,
     );
 
     expect(email).toMatchObject({
@@ -502,7 +502,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "comments_namespace"."id" as "id", "comments_namespace"."post_id" as "post_id", "comments_namespace"."user_id" as "user_id", "comments_namespace"."text" as "text", "comments_namespace"."_internalId" as "_internalId", "comments_namespace"."_version" as "_version" from "comments_namespace" left join "posts_namespace" as "post" on "comments_namespace"."post_id" = "post"."_internalId" left join "users_namespace" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "users_namespace" as "commenter" on "comments_namespace"."user_id" = "commenter"."_internalId""`,
+      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "namespace"."comments"."id" as "id", "namespace"."comments"."post_id" as "post_id", "namespace"."comments"."user_id" as "user_id", "namespace"."comments"."text" as "text", "namespace"."comments"."_internalId" as "_internalId", "namespace"."comments"."_version" as "_version" from "namespace"."comments" left join "namespace"."posts" as "post" on "namespace"."comments"."post_id" = "post"."_internalId" left join "namespace"."users" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "namespace"."users" as "commenter" on "namespace"."comments"."user_id" = "commenter"."_internalId""`,
     );
   });
 
@@ -614,11 +614,11 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [insertUserQuery, insertPostQuery] = queries;
     expect(insertUserQuery.sql).toMatchInlineSnapshot(
-      `"insert into "users_namespace" ("id", "name", "age") values ($1, $2, $3) returning "users_namespace"."id" as "id", "users_namespace"."name" as "name", "users_namespace"."age" as "age", "users_namespace"."_internalId" as "_internalId", "users_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."users" ("id", "name", "age") values ($1, $2, $3) returning "namespace"."users"."id" as "id", "namespace"."users"."name" as "name", "namespace"."users"."age" as "age", "namespace"."users"."_internalId" as "_internalId", "namespace"."users"."_version" as "_version""`,
     );
     expect(insertUserQuery.parameters).toEqual([userId.externalId, "UOW Test User", 35]);
     expect(insertPostQuery.sql).toMatchInlineSnapshot(
-      `"insert into "posts_namespace" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit $3), $4, $5) returning "posts_namespace"."id" as "id", "posts_namespace"."user_id" as "user_id", "posts_namespace"."title" as "title", "posts_namespace"."content" as "content", "posts_namespace"."created_at" as "created_at", "posts_namespace"."_internalId" as "_internalId", "posts_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."posts" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "namespace"."users" where "id" = $2 limit $3), $4, $5) returning "namespace"."posts"."id" as "id", "namespace"."posts"."user_id" as "user_id", "namespace"."posts"."title" as "title", "namespace"."posts"."content" as "content", "namespace"."posts"."created_at" as "created_at", "namespace"."posts"."_internalId" as "_internalId", "namespace"."posts"."_version" as "_version""`,
     );
     expect(insertPostQuery.parameters).toEqual([
       postId.externalId,

package/src/adapters/generic-sql/{test/generic-drizzle-adapter-sqlite3.test.ts → sql-adapter-sqlite3-driver.test.ts}

@@ -1,20 +1,21 @@
 import SQLite from "better-sqlite3";
-import { beforeAll, describe, expect, expectTypeOf, it, assert } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../../schema/create";
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import {
   Cursor,
-  executeUnitOfWork,
+  createServiceTxBuilder,
+  createHandlerTxBuilder,
   ExponentialBackoffRetryPolicy,
   type DatabaseAdapter,
-} from "../../../mod";
+} from "../../mod";
 import { SqliteDialect } from "kysely";
-import { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
-import { BetterSQLite3DriverConfig } from "../driver-config";
-import { GenericSQLAdapter } from "../generic-sql-adapter";
-import { internalSchema } from "../../../fragments/internal-fragment";
+import { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
+import { BetterSQLite3DriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
+import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter with better-sqlite3", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -72,7 +73,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -104,7 +105,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     });
     const sqlAdapter = new SqlDriverAdapter(dialect);
     const driverConfig = new BetterSQLite3DriverConfig();
-    const genericAdapter = new GenericSQLAdapter({ dialect, driverConfig });
+    const genericAdapter = new SqlAdapter({ dialect, driverConfig });
 
     {
       const migrations = genericAdapter.prepareMigrations(internalSchema, "");
@@ -793,7 +794,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     expect(emptyPage.cursor).toBeUndefined();
   });
 
-  it("should support executeUnitOfWork with retry logic", async () => {
+  it("should support handlerTx with retry logic", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create a test user
@@ -807,31 +808,44 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
       .find("users", (b) => b.whereIndex("name_idx", (eb) => eb("name", "=", "Execute UOW User")))
       .executeRetrieve();
 
-    // Use executeUnitOfWork to increment age with optimistic locking
-    const result = await executeUnitOfWork(
-      {
-        retrieve: (uow) =>
-          uow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", user.id))),
-        mutate: (uow, [users]) => {
-          const foundUser = users[0];
-          const newAge = foundUser.age! + 1;
-          uow.update("users", foundUser.id, (b) => b.set({ age: newAge }).check());
-          return { previousAge: foundUser.age, newAge };
-        },
-        onSuccess: ({ mutationResult }) => {
-          // Verify the age was incremented correctly
-          expect(mutationResult.newAge).toBe(mutationResult.previousAge! + 1);
-        },
-      },
-      {
-        createUnitOfWork: () => queryEngine.createUnitOfWork("execute-uow-update"),
-        retryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3, initialDelayMs: 1 }),
+    // Use handlerTx to increment age with optimistic locking
+    let currentUow: ReturnType<typeof queryEngine.createUnitOfWork> | null = null;
+
+    // Service that retrieves user by ID
+    const getUserById = (userId: typeof user.id) => {
+      return createServiceTxBuilder(testSchema, currentUow!)
+        .retrieve((uow) =>
+          uow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userId))),
+        )
+        .transformRetrieve(([users]) => users[0] ?? null)
+        .build();
+    };
+
+    const result = await createHandlerTxBuilder({
+      createUnitOfWork: () => {
+        currentUow = queryEngine.createUnitOfWork("execute-uow-update");
+        return currentUow;
       },
-    );
+      retryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3, initialDelayMs: 1 }),
+    })
+      .withServiceCalls(() => [getUserById(user.id)])
+      .mutate(({ forSchema, serviceIntermediateResult: [foundUser] }) => {
+        if (!foundUser) {
+          throw new Error("User not found");
+        }
+        const newAge = foundUser.age! + 1;
+        forSchema(testSchema).update("users", foundUser.id, (b) => b.set({ age: newAge }).check());
+        return { previousAge: foundUser.age, newAge };
+      })
+      .transform(({ mutateResult }) => {
+        // Verify the age was incremented correctly
+        expect(mutateResult.newAge).toBe(mutateResult.previousAge! + 1);
+        return mutateResult;
+      })
+      .execute();
 
     // Verify the operation succeeded
-    assert(result.success);
-    expect(result.mutationResult).toEqual({
+    expect(result).toEqual({
       previousAge: 42,
       newAge: 43,
     });

package/src/adapters/{drizzle/drizzle-adapter-sqlite3.test.ts → generic-sql/sql-adapter-sqlite3-uow.test.ts}

@@ -1,16 +1,19 @@
 import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
-import { DrizzleAdapter } from "./drizzle-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it, assert } from "vitest";
+import { SqlAdapter } from "./generic-sql-adapter";
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import { Cursor } from "../../query/cursor";
-import { executeUnitOfWork } from "../../query/unit-of-work/execute-unit-of-work";
+import {
+  createServiceTxBuilder,
+  createHandlerTxBuilder,
+} from "../../query/unit-of-work/execute-unit-of-work";
 import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
-import { BetterSQLite3DriverConfig } from "../generic-sql/driver-config";
+import { BetterSQLite3DriverConfig } from "./driver-config";
 import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("DrizzleAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -68,7 +71,7 @@ describe("DrizzleAdapter SQLite", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -91,7 +94,7 @@ describe("DrizzleAdapter SQLite", () => {
       });
   });
 
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
   let sqliteDatabase: InstanceType<typeof SQLite>;
 
   beforeAll(async () => {
@@ -101,7 +104,7 @@ describe("DrizzleAdapter SQLite", () => {
       database: sqliteDatabase,
     });
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new BetterSQLite3DriverConfig(),
     });
@@ -793,7 +796,7 @@ describe("DrizzleAdapter SQLite", () => {
     expect(emptyPage.cursor).toBeUndefined();
   });
 
-  it("should support executeUnitOfWork with retry logic", async () => {
+  it("should support handlerTx with retry logic", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create a test user
@@ -807,31 +810,44 @@ describe("DrizzleAdapter SQLite", () => {
       .find("users", (b) => b.whereIndex("name_idx", (eb) => eb("name", "=", "Execute UOW User")))
       .executeRetrieve();
 
-    // Use executeUnitOfWork to increment age with optimistic locking
-    const result = await executeUnitOfWork(
-      {
-        retrieve: (uow) =>
-          uow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", user.id))),
-        mutate: (uow, [users]) => {
-          const foundUser = users[0];
-          const newAge = foundUser.age! + 1;
-          uow.update("users", foundUser.id, (b) => b.set({ age: newAge }).check());
-          return { previousAge: foundUser.age, newAge };
-        },
-        onSuccess: ({ mutationResult }) => {
-          // Verify the age was incremented correctly
-          expect(mutationResult.newAge).toBe(mutationResult.previousAge! + 1);
-        },
-      },
-      {
-        createUnitOfWork: () => queryEngine.createUnitOfWork("execute-uow-update"),
-        retryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3, initialDelayMs: 1 }),
+    // Use handlerTx to increment age with optimistic locking
+    let currentUow: ReturnType<typeof queryEngine.createUnitOfWork> | null = null;
+
+    // Service that retrieves user by ID
+    const getUserById = (userId: typeof user.id) => {
+      return createServiceTxBuilder(testSchema, currentUow!)
+        .retrieve((uow) =>
+          uow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userId))),
+        )
+        .transformRetrieve(([users]) => users[0] ?? null)
+        .build();
+    };
+
+    const result = await createHandlerTxBuilder({
+      createUnitOfWork: () => {
+        currentUow = queryEngine.createUnitOfWork("execute-uow-update");
+        return currentUow;
       },
-    );
+      retryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3, initialDelayMs: 1 }),
+    })
+      .withServiceCalls(() => [getUserById(user.id)])
+      .mutate(({ forSchema, serviceIntermediateResult: [foundUser] }) => {
+        if (!foundUser) {
+          throw new Error("User not found");
+        }
+        const newAge = foundUser.age! + 1;
+        forSchema(testSchema).update("users", foundUser.id, (b) => b.set({ age: newAge }).check());
+        return { previousAge: foundUser.age, newAge };
+      })
+      .transform(({ mutateResult }) => {
+        // Verify the age was incremented correctly
+        expect(mutateResult.newAge).toBe(mutateResult.previousAge! + 1);
+        return mutateResult;
+      })
+      .execute();
 
     // Verify the operation succeeded
-    assert(result.success);
-    expect(result.mutationResult).toEqual({
+    expect(result).toEqual({
       previousAge: 42,
       newAge: 43,
     });

package/src/adapters/{kysely/kysely-adapter-sqlocal.test.ts → generic-sql/sql-adapter-sqlocal.test.ts}

@@ -1,11 +1,11 @@
 import { SQLocalKysely } from "sqlocal/kysely";
 import { beforeAll, describe, expect, it } from "vitest";
-import { KyselyAdapter } from "./kysely-adapter";
+import { SqlAdapter } from "./generic-sql-adapter";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { SQLocalDriverConfig } from "../generic-sql/driver-config";
+import { SQLocalDriverConfig } from "./driver-config";
 
-describe("KyselyAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("accounts", (t) => {
         return t
@@ -33,11 +33,11 @@ describe("KyselyAdapter SQLite", () => {
       });
   });
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(async () => {
     const { dialect } = new SQLocalKysely(":memory:");
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
     });

package/src/adapters/generic-sql/sqlite-storage.ts

@@ -0,0 +1,20 @@
+export type SQLiteDateStorage = "epoch-ms" | "iso-text";
+export type SQLiteBigintStorage = "blob" | "integer";
+
+export interface SQLiteStorageMode {
+  timestampStorage: SQLiteDateStorage;
+  dateStorage: SQLiteDateStorage;
+  bigintStorage: SQLiteBigintStorage;
+}
+
+export const sqliteStorageDefault: SQLiteStorageMode = {
+  timestampStorage: "epoch-ms",
+  dateStorage: "epoch-ms",
+  bigintStorage: "blob",
+};
+
+export const sqliteStoragePrisma: SQLiteStorageMode = {
+  timestampStorage: "iso-text",
+  dateStorage: "iso-text",
+  bigintStorage: "integer",
+};

package/src/adapters/generic-sql/uow-decoder.test.ts

@@ -8,7 +8,7 @@ import type { AnySchema } from "../../schema/create";
 describe("UnitOfWorkDecoder", () => {
   const driverConfig = new SQLocalDriverConfig();
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t

package/src/adapters/generic-sql/uow-decoder.ts

@@ -4,6 +4,8 @@ import type { AnySchema, AnyTable } from "../../schema/create";
 import { decodeResult } from "../../query/value-decoding";
 import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
 import type { DriverConfig } from "./driver-config";
+import type { SQLiteStorageMode } from "./sqlite-storage";
+import type { NamingResolver } from "../../naming/sql-naming";
 
 /**
  * Decoder class for Unit of Work retrieval results.
@@ -13,9 +15,17 @@ import type { DriverConfig } from "./driver-config";
  */
 export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
   readonly #driverConfig: DriverConfig;
-
-  constructor(driverConfig: DriverConfig) {
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
+
+  constructor(
+    driverConfig: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
+  ) {
     this.#driverConfig = driverConfig;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -60,7 +70,15 @@ export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
       return this.decodeCountResult(rows);
     }
 
-    const decodedRows = rows.map((row) => decodeResult(row, operation.table, this.#driverConfig));
+    const decodedRows = rows.map((row) =>
+      decodeResult(
+        row,
+        operation.table,
+        this.#driverConfig,
+        this.#sqliteStorageMode,
+        this.#resolver,
+      ),
+    );
 
     if (operation.withCursor) {
       return this.decodeCursorResult(decodedRows, operation.table, operation);

package/src/adapters/generic-sql/uow-encoder.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from "vitest";
+import { Kysely, PostgresDialect } from "kysely";
 import { UnitOfWorkEncoder } from "./uow-encoder";
 import { schema, column, idColumn, referenceColumn } from "../../schema/create";
+import { dbNow } from "../../query/db-now";
 import {
   BetterSQLite3DriverConfig,
   MySQL2DriverConfig,
@@ -8,7 +10,7 @@ import {
 } from "./driver-config";
 
 describe("UnitOfWorkEncoder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -16,7 +18,8 @@ describe("UnitOfWorkEncoder", () => {
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
           .addColumn("isActive", column("bool"))
-          .addColumn("createdAt", column("timestamp"));
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("birthDate", column("date").nullable());
       })
       .addTable("posts", (t) => {
         return t
@@ -111,6 +114,34 @@ describe("UnitOfWorkEncoder", () => {
       expect(typeof result["id"]).toBe("string");
       expect(result["title"]).toBe("Test");
     });
+
+    it("should use sqlite dateStorage for dbNow date columns", () => {
+      type TestDB = { users: { id: string; birthDate: unknown } };
+      const dialectConfig = {} as unknown as ConstructorParameters<typeof PostgresDialect>[0];
+      const sqliteDb = new Kysely<TestDB>({
+        dialect: new PostgresDialect(dialectConfig),
+      });
+      const encoderWithStorage = new UnitOfWorkEncoder(sqliteConfig, sqliteDb, {
+        timestampStorage: "epoch-ms",
+        dateStorage: "iso-text",
+        bigintStorage: "blob",
+      });
+
+      const result = encoderWithStorage.encodeForDatabase({
+        values: { birthDate: dbNow() },
+        table: usersTable,
+        generateDefaults: false,
+      });
+
+      const query = sqliteDb
+        .updateTable("users")
+        .set({ birthDate: result["birthDate"] as unknown })
+        .where("id", "=", "test");
+
+      const sqlText = query.compile().sql;
+      expect(sqlText).toContain("CURRENT_TIMESTAMP");
+      expect(sqlText).not.toContain("julianday");
+    });
   });
 
   describe("PostgreSQL encoding", () => {

package/src/adapters/generic-sql/uow-encoder.ts

@@ -6,8 +6,10 @@ import {
 } from "../../query/serialize/create-sql-serializer";
 import { encodeValues } from "../../query/value-encoding";
 import { processReferenceSubqueries } from "./query/where-builder";
-import type { TableNameMapper } from "../shared/table-name-mapper";
-import type { Kysely } from "kysely";
+import type { NamingResolver } from "../../naming/sql-naming";
+import { sql, type Kysely } from "kysely";
+import { isDbNow } from "../../query/db-now";
+import { sqliteStorageDefault, type SQLiteStorageMode } from "./sqlite-storage";
 
 /**
  * Encoder class for Unit of Work mutation operations.
@@ -21,18 +23,23 @@ import type { Kysely } from "kysely";
  * This class mirrors the UnitOfWorkDecoder pattern for symmetry.
  */
 export class UnitOfWorkEncoder {
+  readonly #driverConfig: DriverConfig;
   readonly #serializer: SQLSerializer;
   readonly #db: Kysely<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-  readonly #mapper?: TableNameMapper;
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
 
   constructor(
     driverConfig: DriverConfig,
     db: Kysely<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
-    mapper?: TableNameMapper,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
   ) {
-    this.#serializer = createSQLSerializer(driverConfig);
+    this.#driverConfig = driverConfig;
+    this.#serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
     this.#db = db;
-    this.#mapper = mapper;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -66,10 +73,16 @@ export class UnitOfWorkEncoder {
     generateDefaults: boolean;
   }): Record<string, unknown> {
     // Step 1: Resolution - Resolve FragnoId/FragnoReference and generate defaults
-    const resolved = encodeValues(options.values, options.table, options.generateDefaults);
+    const resolved = encodeValues(
+      options.values,
+      options.table,
+      options.generateDefaults,
+      {},
+      this.#resolver,
+    );
 
     // Step 2: Reference Processing - Convert external IDs to subqueries
-    const processed = processReferenceSubqueries(resolved, this.#db, this.#mapper);
+    const processed = processReferenceSubqueries(resolved, this.#db, this.#resolver);
 
     // Step 3: Serialization - Apply database-specific type conversions
     const serialized = this.serializeValues(processed, options.table);
@@ -94,10 +107,11 @@ export class UnitOfWorkEncoder {
     table: AnyTable,
   ): Record<string, unknown> {
     const result: Record<string, unknown> = {};
+    const columnMap = this.#resolver ? this.#resolver.getColumnNameMap(table) : undefined;
 
     for (const [dbColumnName, value] of Object.entries(values)) {
       // Find the column definition by database column name
-      const col = this.findColumnByDbName(table, dbColumnName);
+      const col = this.findColumnByDbName(table, dbColumnName, columnMap);
 
       if (!col) {
         // Not a regular column (might be a special value like sql.raw())
@@ -106,6 +120,22 @@ export class UnitOfWorkEncoder {
         continue;
       }
 
+      if (isDbNow(value)) {
+        if (this.#driverConfig.databaseType === "sqlite") {
+          const storageMode = this.#sqliteStorageMode ?? sqliteStorageDefault;
+          const storage =
+            col.type === "date" ? storageMode.dateStorage : storageMode.timestampStorage;
+          if ((col.type === "timestamp" || col.type === "date") && storage === "epoch-ms") {
+            result[dbColumnName] = sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
+          } else {
+            result[dbColumnName] = sql`CURRENT_TIMESTAMP`;
+          }
+        } else {
+          result[dbColumnName] = sql`CURRENT_TIMESTAMP`;
+        }
+        continue;
+      }
+
       // Serialize the value using the column definition and database type
       result[dbColumnName] = this.#serializer.serialize(value, col);
     }
@@ -120,9 +150,18 @@ export class UnitOfWorkEncoder {
    * @param dbColumnName - The database column name (e.g., "user_id")
    * @returns The column definition or undefined if not found
    */
-  private findColumnByDbName(table: AnyTable, dbColumnName: string): AnyColumn | undefined {
+  private findColumnByDbName(
+    table: AnyTable,
+    dbColumnName: string,
+    columnMap?: Record<string, string>,
+  ): AnyColumn | undefined {
+    const logicalName = columnMap?.[dbColumnName] ?? dbColumnName;
+    const direct = table.columns[logicalName];
+    if (direct) {
+      return direct;
+    }
     for (const col of Object.values(table.columns)) {
-      if (col.name === dbColumnName) {
+      if (col.name === logicalName) {
         return col;
       }
     }