@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+
 import {
   type ColumnDefinitionBuilder,
   type CompiledQuery,
@@ -6,16 +8,17 @@ import {
   type RawBuilder,
   sql,
 } from "kysely";
-import { createHash } from "node:crypto";
+
+import { SETTINGS_TABLE_NAME } from "../../../fragments/internal-fragment.schema";
 import type {
   ColumnInfo,
   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 type { NamingResolver } from "../../../naming/sql-naming";
 import { createSQLTypeMapper } from "../../../schema/type-conversion/create-sql-type-mapper";
+import type { DriverConfig, SupportedDatabase } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
@@ -38,11 +41,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 +112,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 +138,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 +168,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 +193,7 @@ export abstract class SQLGenerator {
   protected addInlineForeignKeys(
     builder: CreateTableBuilderAny,
     _operation: Extract<MigrationOperation, { type: "create-table" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CreateTableBuilderAny {
     return builder;
   }
@@ -187,11 +203,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 +216,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 +239,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 +281,9 @@ export abstract class SQLGenerator {
    */
   protected abstract compileUpdateColumn(
     tableName: string,
+    logicalTableName: string,
     operation: Extract<ColumnOperation, { type: "update-column" }>,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[];
 
   /**
@@ -260,9 +291,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 +304,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 +327,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 +342,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 +371,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 +421,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 +433,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,9 +1,10 @@
+import type { NamingResolver } from "../../../naming/sql-naming";
 import type { DriverConfig } from "../driver-config";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
-import { SQLQueryCompiler, type AnyKysely } from "./sql-query-compiler";
-import { PostgreSQLQueryCompiler } from "./dialect/postgres";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 import { MySQLQueryCompiler } from "./dialect/mysql";
+import { PostgreSQLQueryCompiler } from "./dialect/postgres";
 import { SQLiteQueryCompiler } from "./dialect/sqlite";
+import { SQLQueryCompiler, type AnyKysely } from "./sql-query-compiler";
 
 /**
  * Factory function to create a dialect-specific SQL query compiler.
@@ -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}`);