@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/generic-sql/migration/sql-generator.ts

@@ -12,9 +12,10 @@ import type {
   ColumnOperation,
   MigrationOperation,
 } from "../../../migration-engine/shared";
-import { SETTINGS_TABLE_NAME } from "../../../fragments/internal-fragment";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
-import type { SupportedDatabase } from "../driver-config";
+import { SETTINGS_TABLE_NAME } from "../../../fragments/internal-fragment.schema";
+import type { NamingResolver } from "../../../naming/sql-naming";
+import type { DriverConfig, SupportedDatabase } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 import { createSQLTypeMapper } from "../../../schema/type-conversion/create-sql-type-mapper";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,11 +39,18 @@ export abstract class SQLGenerator {
   protected readonly db: KyselyAny;
   protected readonly database: SupportedDatabase;
   protected readonly typeMapper: ReturnType<typeof createSQLTypeMapper>;
-
-  constructor(db: KyselyAny, database: SupportedDatabase) {
+  protected readonly driverConfig?: DriverConfig;
+
+  constructor(
+    db: KyselyAny,
+    database: SupportedDatabase,
+    driverConfig?: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+  ) {
     this.db = db;
     this.database = database;
-    this.typeMapper = createSQLTypeMapper(database);
+    this.typeMapper = createSQLTypeMapper(database, sqliteStorageMode);
+    this.driverConfig = driverConfig;
   }
 
   /**
@@ -102,12 +110,17 @@ export abstract class SQLGenerator {
    * Compile migration operations to SQL statements.
    * This is the main entry point for SQL generation.
    */
-  compile(operations: MigrationOperation[], mapper?: TableNameMapper): CompiledQuery[] {
+  compile(operations: MigrationOperation[], resolver?: NamingResolver): CompiledQuery[] {
     const preprocessed = this.preprocess(operations);
     const queries: CompiledQuery[] = [];
 
+    const schemaName = resolver?.getSchemaName();
+    if (schemaName && this.database === "postgresql") {
+      queries.push(sql`CREATE SCHEMA IF NOT EXISTS ${sql.id(schemaName)}`.compile(this.db));
+    }
+
     for (const operation of preprocessed) {
-      const compiled = this.compileOperation(operation, mapper);
+      const compiled = this.compileOperation(operation, resolver);
       if (Array.isArray(compiled)) {
         queries.push(...compiled);
       } else {
@@ -123,25 +136,25 @@ export abstract class SQLGenerator {
    */
   protected compileOperation(
     operation: MigrationOperation,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
     switch (operation.type) {
       case "create-table":
-        return this.compileCreateTable(operation, mapper);
+        return this.compileCreateTable(operation, resolver);
       case "rename-table":
-        return this.compileRenameTable(operation, mapper);
+        return this.compileRenameTable(operation, resolver);
       case "alter-table":
-        return this.compileAlterTable(operation, mapper);
+        return this.compileAlterTable(operation, resolver);
       case "drop-table":
-        return this.compileDropTable(operation, mapper);
+        return this.compileDropTable(operation, resolver);
       case "add-foreign-key":
-        return this.compileAddForeignKey(operation, mapper);
+        return this.compileAddForeignKey(operation, resolver);
       case "drop-foreign-key":
-        return this.compileDropForeignKey(operation, mapper);
+        return this.compileDropForeignKey(operation, resolver);
       case "add-index":
-        return this.compileAddIndex(operation, mapper);
+        return this.compileAddIndex(operation, resolver);
       case "drop-index":
-        return this.compileDropIndex(operation, mapper);
+        return this.compileDropIndex(operation, resolver);
       case "custom":
         return this.compileCustom(operation);
     }
@@ -153,19 +166,20 @@ export abstract class SQLGenerator {
    */
   protected compileCreateTable(
     operation: Extract<MigrationOperation, { type: "create-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const tableName = this.getTableName(operation.name, mapper);
-    let builder: CreateTableBuilderAny = this.db.schema.createTable(tableName);
+    const tableName = this.getTableName(operation.name, resolver);
+    let builder: CreateTableBuilderAny = this.getSchemaBuilder(resolver).createTable(tableName);
 
     for (const col of operation.columns) {
-      builder = builder.addColumn(col.name, sql.raw(this.getDBType(col)), (b) =>
+      const columnName = this.getColumnName(col.name, operation.name, resolver);
+      builder = builder.addColumn(columnName, sql.raw(this.getDBType(col)), (b) =>
         this.buildColumn(col, b),
       );
     }
 
     // Allow subclasses to add inline foreign keys
-    builder = this.addInlineForeignKeys(builder, operation, mapper);
+    builder = this.addInlineForeignKeys(builder, operation, resolver);
 
     return builder.compile();
   }
@@ -177,7 +191,7 @@ export abstract class SQLGenerator {
   protected addInlineForeignKeys(
     builder: CreateTableBuilderAny,
     _operation: Extract<MigrationOperation, { type: "create-table" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CreateTableBuilderAny {
     return builder;
   }
@@ -187,11 +201,11 @@ export abstract class SQLGenerator {
    */
   protected compileRenameTable(
     operation: Extract<MigrationOperation, { type: "rename-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    return this.db.schema
-      .alterTable(this.getTableName(operation.from, mapper))
-      .renameTo(this.getTableName(operation.to, mapper))
+    return this.getSchemaBuilder(resolver)
+      .alterTable(this.getTableName(operation.from, resolver))
+      .renameTo(this.getTableName(operation.to, resolver))
       .compile();
   }
 
@@ -200,13 +214,13 @@ export abstract class SQLGenerator {
    */
   protected compileAlterTable(
     operation: Extract<MigrationOperation, { type: "alter-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery[] {
     const queries: CompiledQuery[] = [];
-    const tableName = this.getTableName(operation.name, mapper);
+    const tableName = this.getTableName(operation.name, resolver);
 
     for (const columnOp of operation.value) {
-      const compiled = this.compileColumnOperation(tableName, columnOp);
+      const compiled = this.compileColumnOperation(tableName, operation.name, columnOp, resolver);
       if (Array.isArray(compiled)) {
         queries.push(...compiled);
       } else {
@@ -223,26 +237,39 @@ export abstract class SQLGenerator {
    */
   protected compileColumnOperation(
     tableName: string,
+    logicalTableName: string,
     operation: ColumnOperation,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
-    const alter = () => this.db.schema.alterTable(tableName);
+    const alter = () => this.getSchemaBuilder(resolver).alterTable(tableName);
 
     switch (operation.type) {
       case "rename-column":
-        return alter().renameColumn(operation.from, operation.to).compile();
+        return alter()
+          .renameColumn(
+            this.getColumnName(operation.from, logicalTableName, resolver),
+            this.getColumnName(operation.to, logicalTableName, resolver),
+          )
+          .compile();
 
       case "drop-column":
-        return alter().dropColumn(operation.name).compile();
+        return alter()
+          .dropColumn(this.getColumnName(operation.name, logicalTableName, resolver))
+          .compile();
 
       case "create-column": {
         const col = operation.value;
         return alter()
-          .addColumn(col.name, sql.raw(this.getDBType(col)), (b) => this.buildColumn(col, b))
+          .addColumn(
+            this.getColumnName(col.name, logicalTableName, resolver),
+            sql.raw(this.getDBType(col)),
+            (b) => this.buildColumn(col, b),
+          )
           .compile();
       }
 
       case "update-column":
-        return this.compileUpdateColumn(tableName, operation);
+        return this.compileUpdateColumn(tableName, logicalTableName, operation, resolver);
     }
   }
 
@@ -252,7 +279,9 @@ export abstract class SQLGenerator {
    */
   protected abstract compileUpdateColumn(
     tableName: string,
+    logicalTableName: string,
     operation: Extract<ColumnOperation, { type: "update-column" }>,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[];
 
   /**
@@ -260,9 +289,11 @@ export abstract class SQLGenerator {
    */
   protected compileDropTable(
     operation: Extract<MigrationOperation, { type: "drop-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    return this.db.schema.dropTable(this.getTableName(operation.name, mapper)).compile();
+    return this.getSchemaBuilder(resolver)
+      .dropTable(this.getTableName(operation.name, resolver))
+      .compile();
   }
 
   /**
@@ -271,16 +302,18 @@ export abstract class SQLGenerator {
    */
   protected compileAddForeignKey(
     operation: Extract<MigrationOperation, { type: "add-foreign-key" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
     const { table, value } = operation;
-    return this.db.schema
-      .alterTable(this.getTableName(table, mapper))
+    return this.getSchemaBuilder(resolver)
+      .alterTable(this.getTableName(table, resolver))
       .addForeignKeyConstraint(
-        value.name,
-        value.columns,
-        this.getTableName(value.referencedTable, mapper),
-        value.referencedColumns,
+        this.getForeignKeyName(value.name, table, value.referencedTable, resolver),
+        value.columns.map((columnName) => this.getColumnName(columnName, table, resolver)),
+        this.getTableName(value.referencedTable, resolver),
+        value.referencedColumns.map((columnName) =>
+          this.getColumnName(columnName, value.referencedTable, resolver),
+        ),
         (b) => b.onUpdate("restrict").onDelete("restrict"),
       )
       .compile();
@@ -292,12 +325,12 @@ export abstract class SQLGenerator {
    */
   protected compileDropForeignKey(
     operation: Extract<MigrationOperation, { type: "drop-foreign-key" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const { table, name } = operation;
-    return this.db.schema
-      .alterTable(this.getTableName(table, mapper))
-      .dropConstraint(name)
+    const { table, name, referencedTable } = operation;
+    return this.getSchemaBuilder(resolver)
+      .alterTable(this.getTableName(table, resolver))
+      .dropConstraint(this.getForeignKeyName(name, table, referencedTable, resolver))
       .ifExists()
       .compile();
   }
@@ -307,11 +340,22 @@ export abstract class SQLGenerator {
    */
   protected compileAddIndex(
     operation: Extract<MigrationOperation, { type: "add-index" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const tableName = this.getTableName(operation.table, mapper);
-    const indexName = this.getIndexName(operation.name, operation.table, mapper);
-    let builder = this.db.schema.createIndex(indexName).on(tableName).columns(operation.columns);
+    const tableName = this.getTableName(operation.table, resolver);
+    const indexName = this.getIndexName(
+      operation.name,
+      operation.table,
+      resolver,
+      operation.unique,
+    );
+    const columnNames = operation.columns.map((columnName) =>
+      this.getColumnName(columnName, operation.table, resolver),
+    );
+    let builder = this.getSchemaBuilder(resolver)
+      .createIndex(indexName)
+      .on(tableName)
+      .columns(columnNames);
 
     if (operation.unique) {
       builder = builder.unique();
@@ -325,11 +369,11 @@ export abstract class SQLGenerator {
    */
   protected compileDropIndex(
     operation: Extract<MigrationOperation, { type: "drop-index" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const tableName = this.getTableName(operation.table, mapper);
-    const indexName = this.getIndexName(operation.name, operation.table, mapper);
-    return this.db.schema.dropIndex(indexName).ifExists().on(tableName).compile();
+    const tableName = this.getTableName(operation.table, resolver);
+    const indexName = this.getIndexName(operation.name, operation.table, resolver);
+    return this.getSchemaBuilder(resolver).dropIndex(indexName).ifExists().on(tableName).compile();
   }
 
   /**
@@ -375,11 +419,11 @@ export abstract class SQLGenerator {
    * Get table name, applying namespace mapping if provided.
    * Settings table is never namespaced.
    */
-  protected getTableName(tableName: string, mapper?: TableNameMapper): string {
+  protected getTableName(tableName: string, resolver?: NamingResolver): string {
     if (tableName === SETTINGS_TABLE_NAME) {
       return tableName;
     }
-    return mapper ? mapper.toPhysical(tableName) : tableName;
+    return resolver ? resolver.getTableName(tableName) : tableName;
   }
 
   /**
@@ -387,14 +431,47 @@ export abstract class SQLGenerator {
    * Index names must be globally unique in most databases, so we namespace them
    * to avoid collisions when multiple fragments use the same logical index names.
    */
-  protected getIndexName(indexName: string, tableName: string, mapper?: TableNameMapper): string {
-    if (!mapper) {
+  protected getIndexName(
+    indexName: string,
+    tableName: string,
+    resolver?: NamingResolver,
+    unique?: boolean,
+  ): string {
+    if (!resolver) {
       return indexName;
     }
-    // Create a unique index name by including the physical table name
-    // This ensures index names are unique across namespaces
-    const physicalTable = mapper.toPhysical(tableName);
-    return `${indexName}_${physicalTable}`;
+    return unique
+      ? resolver.getUniqueIndexName(indexName, tableName)
+      : resolver.getIndexName(indexName, tableName);
+  }
+
+  protected getForeignKeyName(
+    name: string,
+    tableName: string,
+    referencedTable: string,
+    resolver?: NamingResolver,
+  ): string {
+    if (!resolver) {
+      return name;
+    }
+    return resolver.getForeignKeyName({
+      logicalTable: tableName,
+      logicalReferencedTable: referencedTable || tableName,
+      referenceName: name,
+    });
+  }
+
+  protected getColumnName(
+    columnName: string,
+    tableName: string,
+    resolver?: NamingResolver,
+  ): string {
+    return resolver ? resolver.getColumnName(tableName, columnName) : columnName;
+  }
+
+  protected getSchemaBuilder(resolver?: NamingResolver) {
+    const schemaName = resolver?.getSchemaName();
+    return schemaName ? this.db.schema.withSchema(schemaName) : this.db.schema;
   }
 
   /**

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

@@ -1,5 +1,6 @@
 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 { SQLQueryCompiler, type AnyKysely } from "./sql-query-compiler";
 import { PostgreSQLQueryCompiler } from "./dialect/postgres";
 import { MySQLQueryCompiler } from "./dialect/mysql";
@@ -13,21 +14,23 @@ import { SQLiteQueryCompiler } from "./dialect/sqlite";
  *
  * @param db - Kysely database instance
  * @param driverConfig - Driver configuration with database type and capabilities
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param sqliteStorageMode - Optional SQLite storage mode override
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @returns Dialect-specific SQLQueryCompiler instance
  */
 export function createSQLQueryCompiler(
   db: AnyKysely,
   driverConfig: DriverConfig,
-  mapper?: TableNameMapper,
+  sqliteStorageMode?: SQLiteStorageMode,
+  resolver?: NamingResolver,
 ): SQLQueryCompiler {
   switch (driverConfig.databaseType) {
     case "postgresql":
-      return new PostgreSQLQueryCompiler(db, driverConfig, mapper);
+      return new PostgreSQLQueryCompiler(db, driverConfig, sqliteStorageMode, resolver);
     case "mysql":
-      return new MySQLQueryCompiler(db, driverConfig, mapper);
+      return new MySQLQueryCompiler(db, driverConfig, sqliteStorageMode, resolver);
     case "sqlite":
-      return new SQLiteQueryCompiler(db, driverConfig, mapper);
+      return new SQLiteQueryCompiler(db, driverConfig, sqliteStorageMode, resolver);
     default: {
       const exhaustiveCheck: never = driverConfig.databaseType;
       throw new Error(`Unsupported database type: ${exhaustiveCheck}`);

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

@@ -0,0 +1,271 @@
+import { describe, expect, it } from "vitest";
+import { column, idColumn, schema } from "../../../schema/create";
+import { Cursor } from "../../../query/cursor";
+import type { Condition } from "../../../query/condition-builder";
+import { NodePostgresDriverConfig } from "../driver-config";
+import { buildCursorCondition } from "./cursor-utils";
+
+const testSchema = schema("workflow", (s) => {
+  return s.addTable("workflow_step", (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("workflowName", column("string"))
+      .addColumn("instanceId", column("string"))
+      .addColumn("runNumber", column("integer"))
+      .addColumn("createdAt", column("timestamp"));
+  });
+});
+
+const table = testSchema.tables.workflow_step;
+const indexColumns = [
+  table.columns.workflowName,
+  table.columns.instanceId,
+  table.columns.runNumber,
+  table.columns.createdAt,
+];
+
+type NormalizedCondition =
+  | { type: "compare"; column: string; operator: string; value: unknown }
+  | { type: "and" | "or"; items: NormalizedCondition[] }
+  | { type: "not"; item: NormalizedCondition };
+
+const normalizeCondition = (condition?: Condition): NormalizedCondition | null => {
+  if (!condition) {
+    return null;
+  }
+
+  switch (condition.type) {
+    case "compare":
+      return {
+        type: "compare",
+        column: condition.a.name,
+        operator: condition.operator,
+        value: condition.b,
+      };
+    case "and":
+    case "or":
+      return {
+        type: condition.type,
+        items: condition.items.map((item) => normalizeCondition(item) as NormalizedCondition),
+      };
+    case "not":
+      return {
+        type: "not",
+        item: normalizeCondition(condition.item) as NormalizedCondition,
+      };
+    default: {
+      const exhaustiveCheck: never = condition;
+      throw new Error(`Unsupported condition type: ${JSON.stringify(exhaustiveCheck)}`);
+    }
+  }
+};
+
+describe("buildCursorCondition", () => {
+  it("builds lexicographic conditions for composite asc cursors", () => {
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const cursor = new Cursor({
+      indexName: "idx_workflow_step_history_createdAt",
+      orderDirection: "asc",
+      pageSize: 10,
+      indexValues: {
+        workflowName: "wf",
+        instanceId: "inst",
+        runNumber: 2,
+        createdAt,
+      },
+    });
+
+    const condition = buildCursorCondition(
+      cursor,
+      indexColumns,
+      "asc",
+      true,
+      new NodePostgresDriverConfig(),
+    );
+
+    expect(normalizeCondition(condition)).toEqual({
+      type: "or",
+      items: [
+        {
+          type: "compare",
+          column: "workflowName",
+          operator: ">",
+          value: "wf",
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: ">",
+              value: "inst",
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: ">",
+              value: 2,
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "=",
+              value: 2,
+            },
+            {
+              type: "compare",
+              column: "createdAt",
+              operator: ">",
+              value: createdAt,
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it("builds lexicographic conditions for composite desc cursors", () => {
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const cursor = new Cursor({
+      indexName: "idx_workflow_step_history_createdAt",
+      orderDirection: "desc",
+      pageSize: 10,
+      indexValues: {
+        workflowName: "wf",
+        instanceId: "inst",
+        runNumber: 2,
+        createdAt,
+      },
+    });
+
+    const condition = buildCursorCondition(
+      cursor,
+      indexColumns,
+      "desc",
+      true,
+      new NodePostgresDriverConfig(),
+    );
+
+    expect(normalizeCondition(condition)).toEqual({
+      type: "or",
+      items: [
+        {
+          type: "compare",
+          column: "workflowName",
+          operator: "<",
+          value: "wf",
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "<",
+              value: "inst",
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "<",
+              value: 2,
+            },
+          ],
+        },
+        {
+          type: "and",
+          items: [
+            {
+              type: "compare",
+              column: "workflowName",
+              operator: "=",
+              value: "wf",
+            },
+            {
+              type: "compare",
+              column: "instanceId",
+              operator: "=",
+              value: "inst",
+            },
+            {
+              type: "compare",
+              column: "runNumber",
+              operator: "=",
+              value: 2,
+            },
+            {
+              type: "compare",
+              column: "createdAt",
+              operator: "<",
+              value: createdAt,
+            },
+          ],
+        },
+      ],
+    });
+  });
+});