@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,9 +1,10 @@
 import { describe, expect, it } from "vitest";
+
 import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
 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 +36,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 +47,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 +61,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 +73,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 +85,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 +98,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 +109,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 +121,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 { NamingResolver } from "../../../naming/sql-naming";
 import type { AnySelectClause } from "../../../query/simple-query-interface";
+import type { AnyTable } from "../../../schema/create";
 
 /**
  * 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

@@ -1,18 +1,21 @@
 import { describe, test, expect } from "vitest";
-import { Kysely, SqliteDialect } from "kysely";
+
 import Database from "better-sqlite3";
+import { Kysely, SqliteDialect } from "kysely";
+
+import { createNamingResolver, type SqlNamingStrategy } from "../../../naming/sql-naming";
 import { schema, column, idColumn, referenceColumn } from "../../../schema/create";
-import { PostgreSQLQueryCompiler } from "./dialect/postgres";
-import { MySQLQueryCompiler } from "./dialect/mysql";
-import { SQLiteQueryCompiler } from "./dialect/sqlite";
 import {
   BetterSQLite3DriverConfig,
   NodePostgresDriverConfig,
   MySQL2DriverConfig,
 } from "../driver-config";
+import { MySQLQueryCompiler } from "./dialect/mysql";
+import { PostgreSQLQueryCompiler } from "./dialect/postgres";
+import { SQLiteQueryCompiler } from "./dialect/sqlite";
 
 // Test schema
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s
     .addTable("users", (t) => {
       return t
@@ -79,6 +82,23 @@ describe("SQLQueryCompiler", () => {
       );
     });
 
+    test("compileFindMany includes id when read tracking is enabled", () => {
+      const db = new Kysely({
+        dialect: new SqliteDialect({ database: new Database(":memory:") }),
+      });
+      const compiler = new PostgreSQLQueryCompiler(db, new NodePostgresDriverConfig());
+
+      const query = compiler.compileFindMany(testSchema.tables.users, {
+        select: ["email"],
+        limit: 10,
+        readTracking: true,
+      });
+
+      expect(query.sql).toMatchInlineSnapshot(
+        `"select "users"."email" as "email", "users"."id" as "id", "users"."_internalId" as "_internalId", "users"."_version" as "_version" from "users" limit ?"`,
+      );
+    });
+
     test("compileFindMany with orderBy", () => {
       const db = new Kysely({
         dialect: new SqliteDialect({ database: new Database(":memory:") }),
@@ -130,7 +150,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 +211,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();
+      }
+    });
   });
 });

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

@@ -8,14 +8,16 @@ import type {
 } from "kysely";
 import { sql } from "kysely";
 import type { SqlBool } from "kysely";
-import type { AnyColumn, AnyTable } from "../../../schema/create";
+
+import type { NamingResolver } from "../../../naming/sql-naming";
 import type { Condition } from "../../../query/condition-builder";
-import type { DriverConfig, SupportedDatabase } from "../driver-config";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
-import { buildWhere, fullSQLName } from "./where-builder";
-import { mapSelect, extendSelect } from "./select-builder";
 import type { CompiledJoin } from "../../../query/orm/orm";
+import type { AnyColumn, AnyTable } from "../../../schema/create";
+import type { DriverConfig, SupportedDatabase } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 import { UnitOfWorkEncoder } from "../uow-encoder";
+import { mapSelect, extendSelect } from "./select-builder";
+import { buildWhere, fullSQLName } from "./where-builder";
 
 /**
  * Type helpers for Kysely query builders.
@@ -44,12 +46,13 @@ export type AnyInsertQueryBuilder<O = any> = InsertQueryBuilder<any, any, O>;
  * Options for compiling a find operation
  */
 export interface FindManyCompilerOptions {
-  select: true | string[];
+  select: true | readonly string[];
   where?: Condition;
   orderBy?: [AnyColumn, "asc" | "desc"][];
   limit?: number;
   offset?: number;
   join?: CompiledJoin[];
+  readTracking?: boolean;
 }
 
 /**
@@ -84,6 +87,11 @@ export interface DeleteCompilerOptions {
   returning?: boolean;
 }
 
+export type JoinAliasInfo = {
+  table: AnyTable;
+  alias: string;
+};
+
 /**
  * Abstract base class for SQL query compilation.
  *
@@ -97,15 +105,22 @@ export abstract class SQLQueryCompiler {
   protected readonly db: AnyKysely;
   protected readonly driverConfig: DriverConfig;
   protected readonly database: SupportedDatabase;
-  protected readonly mapper?: TableNameMapper;
+  protected readonly resolver?: NamingResolver;
   protected readonly encoder: UnitOfWorkEncoder;
-
-  constructor(db: AnyKysely, driverConfig: DriverConfig, mapper?: TableNameMapper) {
+  protected readonly sqliteStorageMode?: SQLiteStorageMode;
+
+  constructor(
+    db: AnyKysely,
+    driverConfig: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
+  ) {
     this.db = db;
     this.driverConfig = driverConfig;
     this.database = driverConfig.databaseType;
-    this.mapper = mapper;
-    this.encoder = new UnitOfWorkEncoder(driverConfig, db, mapper);
+    this.resolver = resolver;
+    this.sqliteStorageMode = sqliteStorageMode;
+    this.encoder = new UnitOfWorkEncoder(driverConfig, db, sqliteStorageMode, resolver);
   }
 
   /**
@@ -133,14 +148,27 @@ export abstract class SQLQueryCompiler {
    * Get the physical table name, applying namespace mapping if provided.
    */
   protected getTableName(table: AnyTable): string {
-    return this.mapper ? this.mapper.toPhysical(table.name) : table.name;
+    return this.resolver ? this.resolver.getTableName(table.name) : table.name;
   }
 
   /**
    * Build WHERE clause from a condition tree.
    */
-  protected buildWhereClause(condition: Condition, eb: AnyExpressionBuilder, table: AnyTable) {
-    return buildWhere(condition, eb, this.driverConfig, this.mapper, table);
+  protected buildWhereClause(
+    condition: Condition,
+    eb: AnyExpressionBuilder,
+    table: AnyTable,
+    tableAlias?: string,
+  ) {
+    return buildWhere(
+      condition,
+      eb,
+      this.driverConfig,
+      this.sqliteStorageMode,
+      this.resolver,
+      table,
+      tableAlias,
+    );
   }
 
   /**
@@ -153,6 +181,8 @@ export abstract class SQLQueryCompiler {
     parentTableName: string,
     mappedSelect: string[],
     parentPath: string = "",
+    aliasCollector?: JoinAliasInfo[],
+    readTracking?: boolean,
   ): AnySelectQueryBuilder<O> {
     let result = query;
 
@@ -168,10 +198,17 @@ export abstract class SQLQueryCompiler {
       const fullPath = parentPath ? `${parentPath}:${relation.name}` : relation.name;
       // SQL table alias uses underscores (e.g., "author_inviter")
       const joinName = fullPath.replace(/:/g, "_");
+      if (aliasCollector) {
+        aliasCollector.push({ table: targetTable, alias: joinName });
+      }
 
-      // Update select
+      const joinSelectBuilder = extendSelect(joinOptions.select);
+      if (readTracking) {
+        joinSelectBuilder.extend(targetTable.getIdColumn().name);
+      }
+      const compiledJoinSelect = joinSelectBuilder.compile();
       mappedSelect.push(
-        ...mapSelect(joinOptions.select, targetTable, {
+        ...mapSelect(compiledJoinSelect.result, targetTable, this.resolver, {
           relation: fullPath, // Use full path with colons for column aliases
           tableName: joinName, // Use underscore version for table name
         }),
@@ -181,6 +218,10 @@ export abstract class SQLQueryCompiler {
         b.on((eb) => {
           const conditions = [];
           for (const [left, right] of relation.on) {
+            const leftCol = parentTable.columns[left];
+            const actualLeft =
+              leftCol?.role === "external-id" ? parentTable.getInternalIdColumn().name : left;
+            const actualLeftCol = parentTable.columns[actualLeft];
             // Foreign keys always use internal IDs
             // If the relation references an external ID column (any name), translate to "_internalId"
             const rightCol = targetTable.columns[right];
@@ -188,15 +229,31 @@ export abstract class SQLQueryCompiler {
 
             conditions.push(
               eb(
-                `${parentTableName}.${parentTable.columns[left].name}`,
+                `${parentTableName}.${
+                  this.resolver
+                    ? this.resolver.getColumnName(
+                        parentTable.name,
+                        actualLeftCol ? actualLeftCol.name : parentTable.columns[left].name,
+                      )
+                    : (actualLeftCol ?? parentTable.columns[left]).name
+                }`,
                 "=",
-                eb.ref(`${joinName}.${targetTable.columns[actualRight].name}`),
+                eb.ref(
+                  `${joinName}.${
+                    this.resolver
+                      ? this.resolver.getColumnName(
+                          targetTable.name,
+                          targetTable.columns[actualRight].name,
+                        )
+                      : targetTable.columns[actualRight].name
+                  }`,
+                ),
               ),
             );
           }
 
           if (joinOptions.where) {
-            conditions.push(this.buildWhereClause(joinOptions.where, eb, targetTable));
+            conditions.push(this.buildWhereClause(joinOptions.where, eb, targetTable, joinName));
           }
 
           return eb.and(conditions);
@@ -212,6 +269,8 @@ export abstract class SQLQueryCompiler {
           joinName,
           mappedSelect,
           fullPath,
+          aliasCollector,
+          readTracking,
         );
       }
     }
@@ -219,6 +278,33 @@ export abstract class SQLQueryCompiler {
     return result;
   }
 
+  /**
+   * Build a select query with joins applied, returning a list of table aliases used.
+   * Intended for conflict checks that need to mirror the join tree from queries.
+   */
+  buildJoinQuery(
+    table: AnyTable,
+    options: { where?: Condition; join?: CompiledJoin[] },
+  ): {
+    query: AnySelectQueryBuilder;
+    aliases: JoinAliasInfo[];
+  } {
+    const tableName = this.getTableName(table);
+    let query = this.db.selectFrom(tableName);
+    const aliases: JoinAliasInfo[] = [{ table, alias: tableName }];
+
+    if (options.where) {
+      query = query.where((eb) => this.buildWhereClause(options.where!, eb, table));
+    }
+
+    if (options.join && options.join.length > 0) {
+      const mappedSelect: string[] = [];
+      query = this.processJoins(query, options.join, table, tableName, mappedSelect, "", aliases);
+    }
+
+    return { query, aliases };
+  }
+
   /**
    * Compile a COUNT query.
    */
@@ -259,22 +345,36 @@ export abstract class SQLQueryCompiler {
     // Apply ORDER BY
     if (options.orderBy) {
       for (const [col, mode] of options.orderBy) {
-        query = query.orderBy(fullSQLName(col, this.mapper), mode);
+        query = query.orderBy(fullSQLName(col, this.resolver), mode);
       }
     }
 
     // Build SELECT with joins
     const selectBuilder = extendSelect(options.select);
+    if (options.readTracking) {
+      selectBuilder.extend(table.getIdColumn().name);
+    }
     const mappedSelect: string[] = [];
 
     // Process joins if provided
     if (options.join && options.join.length > 0) {
-      query = this.processJoins(query, options.join, table, this.getTableName(table), mappedSelect);
+      query = this.processJoins(
+        query,
+        options.join,
+        table,
+        this.getTableName(table),
+        mappedSelect,
+        "",
+        undefined,
+        options.readTracking,
+      );
     }
 
     const compiledSelect = selectBuilder.compile();
     mappedSelect.push(
-      ...mapSelect(compiledSelect.result, table, { tableName: this.getTableName(table) }),
+      ...mapSelect(compiledSelect.result, table, this.resolver, {
+        tableName: this.getTableName(table),
+      }),
     );
 
     return query.select(mappedSelect).compile();
@@ -297,7 +397,9 @@ export abstract class SQLQueryCompiler {
 
     // Apply RETURNING if supported
     if (this.driverConfig.supportsReturning) {
-      const columns = mapSelect(true, table, { tableName: this.getTableName(table) });
+      const columns = mapSelect(true, table, this.resolver, {
+        tableName: this.getTableName(table),
+      });
       insert = this.applyReturning(insert, columns);
     }
 
@@ -316,7 +418,10 @@ export abstract class SQLQueryCompiler {
 
     // Add version increment (must be added after encoding, as a raw SQL expression)
     const versionCol = table.getVersionColumn();
-    encoded[versionCol.name] = sql.raw(`COALESCE(${versionCol.name}, 0) + 1`);
+    const versionColumnName = this.resolver
+      ? this.resolver.getColumnName(table.name, versionCol.name)
+      : versionCol.name;
+    encoded[versionColumnName] = sql`coalesce(${sql.ref(versionColumnName)}, 0) + 1`;
 
     let query = this.db.updateTable(this.getTableName(table)).set(encoded);