@fragno-dev/db 0.2.2 → 0.3.0

package/src/adapters/generic-sql/query/cursor-utils.ts

@@ -2,6 +2,7 @@ import type { AnyColumn } from "../../../schema/create";
 import type { Condition } from "../../../query/condition-builder";
 import { decodeCursor, serializeCursorValues, type Cursor } from "../../../query/cursor";
 import type { DriverConfig } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 
 /**
  * Build a cursor condition for pagination.
@@ -15,6 +16,7 @@ import type { DriverConfig } from "../driver-config";
  * @param orderDirection - Direction of ordering (asc/desc)
  * @param isAfter - True for "after" cursor (forward pagination), false for "before" (backward)
  * @param driverConfig - The driver configuration for value serialization
+ * @param sqliteStorageMode - Optional SQLite storage mode for date/bigint serialization
  * @returns A Condition object for the cursor, or undefined if no cursor
  * @throws Error if multi-column cursors are not supported by the implementation
  */
@@ -24,6 +26,7 @@ export function buildCursorCondition(
   orderDirection: "asc" | "desc",
   isAfter: boolean,
   driverConfig: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
 ): Condition | undefined {
   if (!cursor || indexColumns.length === 0) {
     return undefined;
@@ -31,7 +34,12 @@ export function buildCursorCondition(
 
   // Decode cursor if it's a string, otherwise use it as-is
   const cursorObj = typeof cursor === "string" ? decodeCursor(cursor) : cursor;
-  const serializedValues = serializeCursorValues(cursorObj, indexColumns, driverConfig);
+  const serializedValues = serializeCursorValues(
+    cursorObj,
+    indexColumns,
+    driverConfig,
+    sqliteStorageMode,
+  );
 
   // Determine comparison operator based on direction and after/before
   const useGreaterThan =
@@ -40,7 +48,7 @@ export function buildCursorCondition(
   if (indexColumns.length === 1) {
     // Simple single-column case
     const col = indexColumns[0]!;
-    const val = serializedValues[col.ormName];
+    const val = serializedValues[col.name];
     const operator = useGreaterThan ? ">" : "<";
     return {
       type: "compare",
@@ -48,9 +56,36 @@ export function buildCursorCondition(
       operator,
       b: val,
     };
-  } else {
-    throw new Error(
-      "Multi-column cursor pagination is not yet supported in Generic SQL implementation",
-    );
   }
+
+  const operator = useGreaterThan ? ">" : "<";
+  const orConditions: Condition[] = [];
+  const isNullish = (value: unknown): value is null | undefined =>
+    value === null || value === undefined;
+  const buildEqualityCondition = (column: AnyColumn, value: unknown): Condition =>
+    isNullish(value)
+      ? { type: "compare", a: column, operator: "is", b: null }
+      : { type: "compare", a: column, operator: "=", b: value };
+
+  for (let i = 0; i < indexColumns.length; i += 1) {
+    const col = indexColumns[i]!;
+    const val = serializedValues[col.name];
+    const andItems: Condition[] = [];
+
+    for (let j = 0; j < i; j += 1) {
+      const prevCol = indexColumns[j]!;
+      andItems.push(buildEqualityCondition(prevCol, serializedValues[prevCol.name]));
+    }
+
+    andItems.push({
+      type: "compare",
+      a: col,
+      operator,
+      b: val,
+    });
+
+    orConditions.push(andItems.length === 1 ? andItems[0]! : { type: "and", items: andItems });
+  }
+
+  return { type: "or", items: orConditions };
 }

package/src/adapters/generic-sql/query/generic-sql-uow-operation-compiler.test.ts

@@ -5,7 +5,7 @@ import { schema, column, idColumn, referenceColumn, FragnoId } from "../../../sc
 import { Cursor } from "../../../query/cursor";
 
 // Test schema with indexes
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s
     .addTable("users", (t) => {
       return t
@@ -17,7 +17,7 @@ const testSchema = schema((s) => {
         .addColumn("createdAt", column("timestamp"))
         .addColumn("invitedBy", referenceColumn().nullable())
         .createIndex("idx_email", ["email"], { unique: true })
-        .createIndex("idx_name", ["name"])
+        .createIndex("idx_users_name", ["name"])
         .createIndex("idx_age", ["age"]);
     })
     .addTable("posts", (t) => {
@@ -37,21 +37,21 @@ const testSchema = schema((s) => {
         .addColumn("content", column("string"))
         .addColumn("postId", referenceColumn())
         .addColumn("authorId", referenceColumn())
-        .createIndex("idx_post", ["postId"])
+        .createIndex("idx_comments_post", ["postId"])
         .createIndex("idx_author", ["authorId"]);
     })
     .addTable("tags", (t) => {
       return t
         .addColumn("id", idColumn())
         .addColumn("name", column("string"))
-        .createIndex("idx_name", ["name"]);
+        .createIndex("idx_tags_name", ["name"]);
     })
     .addTable("post_tags", (t) => {
       return t
         .addColumn("id", idColumn())
         .addColumn("postId", referenceColumn())
         .addColumn("tagId", referenceColumn())
-        .createIndex("idx_post", ["postId"])
+        .createIndex("idx_post_tags_post", ["postId"])
         .createIndex("idx_tag", ["tagId"]);
     })
     .addReference("author", {
@@ -87,7 +87,7 @@ const testSchema = schema((s) => {
 });
 
 // Schema with custom-named id columns
-const customIdSchema = schema((s) => {
+const customIdSchema = schema("customid", (s) => {
   return s
     .addTable("products", (t) => {
       return t
@@ -232,7 +232,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
 
     expect(result).not.toBeNull();
     expect(result!.query.sql).toMatchInlineSnapshot(
-      `"update "users" set "name" = ?, "_version" = COALESCE(_version, 0) + 1 where "users"."id" = ?"`,
+      `"update "users" set "name" = ?, "_version" = coalesce("_version", 0) + 1 where "users"."id" = ?"`,
     );
     expect(result!.expectedAffectedRows).toBeNull();
   });
@@ -253,7 +253,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
 
     expect(result).not.toBeNull();
     expect(result!.query.sql).toMatchInlineSnapshot(
-      `"update "users" set "name" = ?, "_version" = COALESCE(_version, 0) + 1 where ("users"."id" = ? and "users"."_version" = ?)"`,
+      `"update "users" set "name" = ?, "_version" = coalesce("_version", 0) + 1 where ("users"."id" = ? and "users"."_version" = ?)"`,
     );
     expect(result!.expectedAffectedRows).toBe(1n);
   });
@@ -396,7 +396,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
 
       expect(result).not.toBeNull();
       expect(result!.query.sql).toMatchInlineSnapshot(
-        `"update "posts" set "userId" = (select "_internalId" from "users" where "id" = ? limit ?), "_version" = COALESCE(_version, 0) + 1 where "posts"."id" = ?"`,
+        `"update "posts" set "userId" = (select "_internalId" from "users" where "id" = ? limit ?), "_version" = coalesce("_version", 0) + 1 where "posts"."id" = ?"`,
       );
     });
 
@@ -418,7 +418,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
       // Should not have nested SELECT for the userId value
       expect(result!.query.sql).not.toMatch(/\(select.*from.*users/i);
       expect(result!.query.sql).toMatchInlineSnapshot(
-        `"update "posts" set "userId" = ?, "_version" = COALESCE(_version, 0) + 1 where "posts"."id" = ?"`,
+        `"update "posts" set "userId" = ?, "_version" = coalesce("_version", 0) + 1 where "posts"."id" = ?"`,
       );
     });
 
@@ -440,7 +440,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
 
       expect(result).not.toBeNull();
       expect(result!.query.sql).toMatchInlineSnapshot(
-        `"update "users" set "name" = ?, "email" = ?, "isActive" = ?, "_version" = COALESCE(_version, 0) + 1 where "users"."id" = ?"`,
+        `"update "users" set "name" = ?, "email" = ?, "isActive" = ?, "_version" = coalesce("_version", 0) + 1 where "users"."id" = ?"`,
       );
     });
   });
@@ -612,7 +612,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
 
       expect(result).not.toBeNull();
       expect(result!.query.sql).toMatchInlineSnapshot(
-        `"update "products" set "price" = ?, "_version" = COALESCE(_version, 0) + 1 where "products"."productId" = ?"`,
+        `"update "products" set "price" = ?, "_version" = coalesce("_version", 0) + 1 where "products"."productId" = ?"`,
       );
     });
 
@@ -757,11 +757,11 @@ describe("GenericSQLUOWOperationCompiler", () => {
         type: "find",
         schema: testSchema,
         table: testSchema.tables.users,
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         options: {
-          useIndex: "idx_name",
+          useIndex: "idx_users_name",
           select: true,
-          orderByIndex: { indexName: "idx_name", direction: "asc" },
+          orderByIndex: { indexName: "idx_users_name", direction: "asc" },
         },
       });
 
@@ -799,7 +799,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
     test("should compile find with cursor pagination using after", () => {
       const compiler = new GenericSQLUOWOperationCompiler(driverConfig);
       const cursor = new Cursor({
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         orderDirection: "asc",
         pageSize: 10,
         indexValues: { name: "Alice" },
@@ -809,11 +809,11 @@ describe("GenericSQLUOWOperationCompiler", () => {
         type: "find",
         schema: testSchema,
         table: testSchema.tables.users,
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         options: {
-          useIndex: "idx_name",
+          useIndex: "idx_users_name",
           select: true,
-          orderByIndex: { indexName: "idx_name", direction: "asc" },
+          orderByIndex: { indexName: "idx_users_name", direction: "asc" },
           after: cursor,
           pageSize: 10,
         },
@@ -829,7 +829,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
     test("should compile find with cursor pagination using before", () => {
       const compiler = new GenericSQLUOWOperationCompiler(driverConfig);
       const cursor = new Cursor({
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         orderDirection: "desc",
         pageSize: 10,
         indexValues: { name: "Bob" },
@@ -839,11 +839,11 @@ describe("GenericSQLUOWOperationCompiler", () => {
         type: "find",
         schema: testSchema,
         table: testSchema.tables.users,
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         options: {
-          useIndex: "idx_name",
+          useIndex: "idx_users_name",
           select: true,
-          orderByIndex: { indexName: "idx_name", direction: "desc" },
+          orderByIndex: { indexName: "idx_users_name", direction: "desc" },
           before: cursor,
           pageSize: 10,
         },
@@ -859,7 +859,7 @@ describe("GenericSQLUOWOperationCompiler", () => {
     test("should compile find with cursor pagination and additional where conditions", () => {
       const compiler = new GenericSQLUOWOperationCompiler(driverConfig);
       const cursor = new Cursor({
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         orderDirection: "asc",
         pageSize: 5,
         indexValues: { name: "Alice" },
@@ -869,12 +869,12 @@ describe("GenericSQLUOWOperationCompiler", () => {
         type: "find",
         schema: testSchema,
         table: testSchema.tables.users,
-        indexName: "idx_name",
+        indexName: "idx_users_name",
         options: {
-          useIndex: "idx_name",
+          useIndex: "idx_users_name",
           select: true,
           where: (eb) => eb("isActive", "=", true),
-          orderByIndex: { indexName: "idx_name", direction: "asc" },
+          orderByIndex: { indexName: "idx_users_name", direction: "asc" },
           after: cursor,
           pageSize: 5,
         },

package/src/adapters/generic-sql/query/generic-sql-uow-operation-compiler.ts

@@ -1,7 +1,8 @@
 import { UOWOperationCompiler } from "../../shared/uow-operation-compiler";
 import type { CompiledQuery } from "kysely";
 import type { DriverConfig } from "../driver-config";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
+import type { NamingResolver } from "../../../naming/sql-naming";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 import type {
   RetrievalOperation,
   MutationOperation,
@@ -24,26 +25,40 @@ import { createColdKysely } from "../migration/cold-kysely";
  * high-level business logic like cursor pagination, version checking, and index resolution.
  */
 export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<CompiledQuery> {
+  private readonly sqliteStorageMode?: SQLiteStorageMode;
+
   constructor(
     driverConfig: DriverConfig,
-    mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolverFactory?: (schema: AnySchema, namespace: string | null) => NamingResolver,
   ) {
-    super(driverConfig, mapperFactory);
+    super(driverConfig, resolverFactory);
+    this.sqliteStorageMode = sqliteStorageMode;
   }
 
   /**
    * Get SQL compiler for a specific namespace
    */
-  private getSQLCompiler(namespace: string | undefined): SQLQueryCompiler {
-    const mapper = this.getMapperForOperation(namespace);
+  private getSQLCompiler(
+    schema: AnySchema,
+    namespace: string | null | undefined,
+  ): SQLQueryCompiler {
+    const resolver = this.getNamingResolver(schema, namespace ?? null);
     const kysely = createColdKysely(this.driverConfig.databaseType);
-    return createSQLQueryCompiler(kysely, this.driverConfig, mapper);
+    const schemaName = resolver.getSchemaName();
+    const scopedKysely = schemaName ? kysely.withSchema(schemaName) : kysely;
+    return createSQLQueryCompiler(
+      scopedKysely,
+      this.driverConfig,
+      this.sqliteStorageMode,
+      resolver,
+    );
   }
 
   override compileCount(
     op: RetrievalOperation<AnySchema> & { type: "count" },
   ): CompiledQuery | null {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
 
     // Build where condition
     let conditions = op.options.where
@@ -61,7 +76,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
   }
 
   override compileFind(op: RetrievalOperation<AnySchema> & { type: "find" }): CompiledQuery | null {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
 
     // Extract options
     const {
@@ -116,6 +131,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
       orderDirection,
       !!after,
       this.driverConfig,
+      this.sqliteStorageMode,
     );
 
     // Combine user where clause with cursor condition
@@ -160,7 +176,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
     const compiledOptions = buildFindOptions(op.table, {
       ...findManyOptions,
       where: combinedWhere ? () => combinedWhere! : undefined,
-      orderBy: orderBy?.map(([col, dir]) => [col.ormName, dir]),
+      orderBy: orderBy?.map(([col, dir]) => [col.name, dir]),
       limit: effectiveLimit,
     });
 
@@ -174,11 +190,12 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
   override compileCreate(
     op: MutationOperation<AnySchema> & { type: "create" },
   ): CompiledMutation<CompiledQuery> | null {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
     const table = this.getTable(op.schema, op.table);
 
     return {
       query: sqlCompiler.compileCreate(table, op.values),
+      operation: op,
       op: "create",
       expectedAffectedRows: null, // creates don't need affected row checks
       expectedReturnedRows: null,
@@ -188,7 +205,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
   override compileUpdate(
     op: MutationOperation<AnySchema> & { type: "update" },
   ): CompiledMutation<CompiledQuery> | null {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
     const table = this.getTable(op.schema, op.table);
     const idColumn = table.getIdColumn();
     const versionColumn = table.getVersionColumn();
@@ -200,12 +217,9 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
     const conditionsResult =
       versionToCheck !== undefined
         ? buildCondition(table.columns, (eb) =>
-            eb.and(
-              eb(idColumn.ormName, "=", externalId),
-              eb(versionColumn.ormName, "=", versionToCheck),
-            ),
+            eb.and(eb(idColumn.name, "=", externalId), eb(versionColumn.name, "=", versionToCheck)),
           )
-        : buildCondition(table.columns, (eb) => eb(idColumn.ormName, "=", externalId));
+        : buildCondition(table.columns, (eb) => eb(idColumn.name, "=", externalId));
 
     if (conditionsResult === false) {
       return null;
@@ -229,6 +243,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
 
     return {
       query,
+      operation: op,
       op: "update",
       expectedAffectedRows: useReturningForCheck ? null : op.checkVersion ? 1n : null,
       expectedReturnedRows: useReturningForCheck ? 1 : null,
@@ -238,7 +253,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
   override compileDelete(
     op: MutationOperation<AnySchema> & { type: "delete" },
   ): CompiledMutation<CompiledQuery> | null {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
     const table = this.getTable(op.schema, op.table);
     const idColumn = table.getIdColumn();
     const versionColumn = table.getVersionColumn();
@@ -250,12 +265,9 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
     const conditionsResult =
       versionToCheck !== undefined
         ? buildCondition(table.columns, (eb) =>
-            eb.and(
-              eb(idColumn.ormName, "=", externalId),
-              eb(versionColumn.ormName, "=", versionToCheck),
-            ),
+            eb.and(eb(idColumn.name, "=", externalId), eb(versionColumn.name, "=", versionToCheck)),
           )
-        : buildCondition(table.columns, (eb) => eb(idColumn.ormName, "=", externalId));
+        : buildCondition(table.columns, (eb) => eb(idColumn.name, "=", externalId));
 
     if (conditionsResult === false) {
       return null;
@@ -278,6 +290,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
 
     return {
       query,
+      operation: op,
       op: "delete",
       expectedAffectedRows: useReturningForCheck ? null : op.checkVersion ? 1n : null,
       expectedReturnedRows: useReturningForCheck ? 1 : null,
@@ -287,7 +300,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
   override compileCheck(
     op: MutationOperation<AnySchema> & { type: "check" },
   ): CompiledMutation<CompiledQuery> {
-    const sqlCompiler = this.getSQLCompiler(op.namespace);
+    const sqlCompiler = this.getSQLCompiler(op.schema, op.namespace);
     const table = this.getTable(op.schema, op.table);
     const idColumn = table.getIdColumn();
     const versionColumn = table.getVersionColumn();
@@ -297,7 +310,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
 
     // Build a SELECT 1 query to check if the row exists with the correct version
     const condition = buildCondition(table.columns, (eb) =>
-      eb.and(eb(idColumn.ormName, "=", externalId), eb(versionColumn.ormName, "=", version)),
+      eb.and(eb(idColumn.name, "=", externalId), eb(versionColumn.name, "=", version)),
     );
 
     if (typeof condition === "boolean") {
@@ -306,6 +319,7 @@ export class GenericSQLUOWOperationCompiler extends UOWOperationCompiler<Compile
 
     return {
       query: sqlCompiler.compileCheck(table, condition),
+      operation: op,
       op: "check",
       expectedAffectedRows: null,
       expectedReturnedRows: 1, // Check that exactly 1 row was returned

package/src/adapters/generic-sql/query/select-builder.test.ts

@@ -3,7 +3,7 @@ import { column, idColumn, referenceColumn, schema } from "../../../schema/creat
 import { mapSelect, extendSelect } from "./select-builder";
 
 describe("select-builder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -35,7 +35,7 @@ describe("select-builder", () => {
 
   describe("mapSelect", () => {
     it("should map select clause with array of keys", () => {
-      const result = mapSelect(["id", "name", "email"], usersTable);
+      const result = mapSelect(["id", "name", "email"], usersTable, undefined);
       expect(result).toEqual([
         "users.id as id",
         "users.name as name",
@@ -46,7 +46,7 @@ describe("select-builder", () => {
     });
 
     it("should map select all columns when true", () => {
-      const result = mapSelect(true, usersTable);
+      const result = mapSelect(true, usersTable, undefined);
       expect(result).toEqual([
         "users.id as id",
         "users.name as name",
@@ -60,7 +60,9 @@ describe("select-builder", () => {
     });
 
     it("should map select with relation prefix", () => {
-      const result = mapSelect(["id", "name"], usersTable, { relation: "author" });
+      const result = mapSelect(["id", "name"], usersTable, undefined, {
+        relation: "author",
+      });
       expect(result).toEqual([
         "users.id as author:id",
         "users.name as author:name",
@@ -70,7 +72,9 @@ describe("select-builder", () => {
     });
 
     it("should map select with custom table name", () => {
-      const result = mapSelect(["id", "title"], postsTable, { tableName: "p" });
+      const result = mapSelect(["id", "title"], postsTable, undefined, {
+        tableName: "p",
+      });
       expect(result).toEqual([
         "p.id as id",
         "p.title as title",
@@ -80,7 +84,7 @@ describe("select-builder", () => {
     });
 
     it("should map select with both relation and custom table name", () => {
-      const result = mapSelect(["id", "title"], postsTable, {
+      const result = mapSelect(["id", "title"], postsTable, undefined, {
         relation: "posts",
         tableName: "p",
       });
@@ -93,7 +97,7 @@ describe("select-builder", () => {
     });
 
     it("should handle single column select", () => {
-      const result = mapSelect(["name"], usersTable);
+      const result = mapSelect(["name"], usersTable, undefined);
       expect(result).toEqual([
         "users.name as name",
         "users._internalId as _internalId",
@@ -104,7 +108,7 @@ describe("select-builder", () => {
     it("should skip hidden columns when explicitly selecting", () => {
       // When an array is passed, hidden columns should not be included in the select
       // (unless they are in the array), but they should always be added at the end
-      const result = mapSelect(["name", "email"], usersTable);
+      const result = mapSelect(["name", "email"], usersTable, undefined);
       // Should not duplicate _internalId or _version in the main select
       expect(result).toEqual([
         "users.name as name",
@@ -116,19 +120,19 @@ describe("select-builder", () => {
 
     it("should always include hidden columns", () => {
       // Hidden columns (_internalId, _version) should always be included
-      const result = mapSelect(["name"], usersTable);
+      const result = mapSelect(["name"], usersTable, undefined);
       expect(result.some((col) => col.includes("_internalId"))).toBe(true);
       expect(result.some((col) => col.includes("_version"))).toBe(true);
     });
 
     it("should handle empty select array", () => {
-      const result = mapSelect([], usersTable);
+      const result = mapSelect([], usersTable, undefined);
       // Should still include hidden columns
       expect(result).toEqual(["users._internalId as _internalId", "users._version as _version"]);
     });
 
     it("should work with different table schemas", () => {
-      const result = mapSelect(["id", "title", "content"], postsTable);
+      const result = mapSelect(["id", "title", "content"], postsTable, undefined);
       expect(result).toEqual([
         "posts.id as id",
         "posts.title as title",

package/src/adapters/generic-sql/query/select-builder.ts

@@ -1,5 +1,6 @@
 import type { AnyTable } from "../../../schema/create";
 import type { AnySelectClause } from "../../../query/simple-query-interface";
+import type { NamingResolver } from "../../../naming/sql-naming";
 
 /**
  * Maps a select clause to SQL column names with optional aliases.
@@ -18,6 +19,7 @@ import type { AnySelectClause } from "../../../query/simple-query-interface";
 export function mapSelect(
   select: AnySelectClause,
   table: AnyTable,
+  resolver: NamingResolver | undefined,
   options: {
     relation?: string;
     tableName?: string;
@@ -37,7 +39,8 @@ export function mapSelect(
 
     // Add the column to the select list
     const name = relation ? `${relation}:${key}` : key;
-    out.push(`${tableName}.${col.name} as ${name}`);
+    const columnName = resolver ? resolver.getColumnName(table.name, col.name) : col.name;
+    out.push(`${tableName}.${columnName} as ${name}`);
   }
 
   // Always include hidden columns (for FragnoId construction with internal ID and version)
@@ -45,7 +48,8 @@ export function mapSelect(
     const col = table.columns[key];
     if (col.isHidden && !keys.includes(key)) {
       const name = relation ? `${relation}:${key}` : key;
-      out.push(`${tableName}.${col.name} as ${name}`);
+      const columnName = resolver ? resolver.getColumnName(table.name, col.name) : col.name;
+      out.push(`${tableName}.${columnName} as ${name}`);
     }
   }
 

package/src/adapters/generic-sql/query/sql-query-compiler.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from "vitest";
 import { Kysely, SqliteDialect } from "kysely";
 import Database from "better-sqlite3";
 import { schema, column, idColumn, referenceColumn } from "../../../schema/create";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../naming/sql-naming";
 import { PostgreSQLQueryCompiler } from "./dialect/postgres";
 import { MySQLQueryCompiler } from "./dialect/mysql";
 import { SQLiteQueryCompiler } from "./dialect/sqlite";
@@ -12,7 +13,7 @@ import {
 } from "../driver-config";
 
 // Test schema
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s
     .addTable("users", (t) => {
       return t
@@ -130,7 +131,7 @@ describe("SQLQueryCompiler", () => {
       });
 
       expect(query.sql).toMatchInlineSnapshot(
-        `"update "users" set "name" = ?, "_version" = COALESCE(_version, 0) + 1 where "users"."id" = ?"`,
+        `"update "users" set "name" = ?, "_version" = coalesce("_version", 0) + 1 where "users"."id" = ?"`,
       );
     });
 
@@ -191,5 +192,54 @@ describe("SQLQueryCompiler", () => {
       );
       expect(query.sql).toContain("returning");
     });
+
+    test("compileUpdate succeeds when version column needs quoting", async () => {
+      const db = new Kysely({
+        dialect: new SqliteDialect({ database: new Database(":memory:") }),
+      });
+
+      await db.schema
+        .createTable("users")
+        .addColumn("id", "text")
+        .addColumn("name", "text")
+        .addColumn("users-version", "integer")
+        .execute();
+
+      const namingStrategy: SqlNamingStrategy = {
+        namespaceScope: "suffix",
+        namespaceToSchema: (namespace) => namespace,
+        tableName: (logicalTable) => logicalTable,
+        columnName: (logicalColumn, logicalTable) =>
+          logicalColumn === "_version" ? `${logicalTable}-version` : logicalColumn,
+        indexName: (logicalIndex) => logicalIndex,
+        uniqueIndexName: (logicalIndex) => logicalIndex,
+        foreignKeyName: ({ referenceName }) => referenceName,
+      };
+
+      const resolver = createNamingResolver(testSchema, null, namingStrategy);
+      const compiler = new SQLiteQueryCompiler(
+        db,
+        new BetterSQLite3DriverConfig(),
+        undefined,
+        resolver,
+      );
+
+      const query = compiler.compileUpdate(testSchema.tables.users, {
+        set: { name: "Jane" },
+        where: {
+          type: "compare",
+          a: testSchema.tables.users.columns.id,
+          operator: "=",
+          b: "user123",
+        },
+      });
+
+      expect(query.sql).toContain('coalesce("users-version", 0) + 1');
+      try {
+        await expect(db.executeQuery(query)).resolves.toBeDefined();
+      } finally {
+        await db.destroy();
+      }
+    });
   });
 });