@fragno-dev/db 0.0.1 → 0.1.0

package/src/adapters/kysely/migration/execute.ts

@@ -0,0 +1,382 @@
+import {
+  type ColumnBuilderCallback,
+  type Compilable,
+  type CreateTableBuilder,
+  type Kysely,
+  type RawBuilder,
+  sql,
+} from "kysely";
+import {
+  type CustomOperation,
+  isUpdated,
+  type ColumnOperation,
+  type MigrationOperation,
+  type ColumnInfo,
+} from "../../../migration-engine/shared";
+import type { SQLProvider } from "../../../shared/providers";
+import { schemaToDBType } from "../../../schema/serialize";
+import type { KyselyConfig } from "../kysely-adapter";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type KyselyAny = Kysely<any>;
+
+export type ExecuteNode = Compilable & {
+  execute(): Promise<unknown>;
+};
+
+const errors = {
+  IdColumnUpdate:
+    "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
+  SQLiteUpdateColumn: "SQLite doesn't support updating columns. Recreate the table instead.",
+  SQLiteUpdateForeignKeys:
+    "SQLite doesn't support modifying foreign keys directly. Use `recreate-table` instead.",
+} as const;
+
+/**
+ * Returns the appropriate foreign key action based on the provider.
+ * MSSQL doesn't support RESTRICT, so we use NO ACTION (functionally equivalent).
+ */
+function getForeignKeyAction(provider: SQLProvider): "restrict" | "no action" {
+  return provider === "mssql" ? "no action" : "restrict";
+}
+
+/**
+ * Generates MSSQL default constraint name following the DF_tableName_columnName pattern.
+ */
+function getMssqlDefaultConstraintName(tableName: string, columnName: string): string {
+  const MSSQL_DEFAULT_CONSTRAINT_PREFIX = "DF" as const;
+  return `${MSSQL_DEFAULT_CONSTRAINT_PREFIX}_${tableName}_${columnName}`;
+}
+
+function createUniqueIndex(
+  db: KyselyAny,
+  name: string,
+  tableName: string,
+  cols: string[],
+  provider: SQLProvider,
+) {
+  const query = db.schema.createIndex(name).on(tableName).columns(cols).unique();
+
+  if (provider === "mssql") {
+    // MSSQL: ignore null values in unique indexes by default
+    return query.where((b) => {
+      return b.and(cols.map((col) => b(col, "is not", null)));
+    });
+  }
+
+  return query;
+}
+
+function dropUniqueIndex(db: KyselyAny, name: string, tableName: string, provider: SQLProvider) {
+  let query = db.schema.dropIndex(name).ifExists();
+
+  if (provider === "cockroachdb") {
+    query = query.cascade();
+  }
+
+  if (provider === "mssql") {
+    query = query.on(tableName);
+  }
+
+  return query;
+}
+
+function executeColumn(
+  tableName: string,
+  operation: ColumnOperation,
+  config: KyselyConfig,
+): ExecuteNode[] {
+  const { db, provider } = config;
+  const next = () => db.schema.alterTable(tableName);
+  const results: ExecuteNode[] = [];
+
+  switch (operation.type) {
+    case "rename-column":
+      results.push(next().renameColumn(operation.from, operation.to));
+      return results;
+
+    case "drop-column":
+      results.push(next().dropColumn(operation.name));
+
+      return results;
+    case "create-column": {
+      const col = operation.value;
+
+      results.push(
+        next().addColumn(
+          col.name,
+          sql.raw(schemaToDBType(col, provider)),
+          getColumnBuilderCallback(col, provider),
+        ),
+      );
+
+      return results;
+    }
+    case "update-column": {
+      const col = operation.value;
+
+      if (col.role === "external-id" || col.role === "internal-id") {
+        throw new Error(errors.IdColumnUpdate);
+      }
+      if (provider === "sqlite") {
+        throw new Error(errors.SQLiteUpdateColumn);
+      }
+
+      if (!isUpdated(operation)) {
+        return results;
+      }
+      if (provider === "mysql") {
+        results.push(
+          next().modifyColumn(
+            operation.name,
+            sql.raw(schemaToDBType(col, provider)),
+            getColumnBuilderCallback(col, provider),
+          ),
+        );
+        return results;
+      }
+
+      // MSSQL requires dropping and recreating default constraints when changing data type or default value
+      const mssqlRecreateDefaultConstraint = operation.updateDataType || operation.updateDefault;
+
+      if (provider === "mssql" && mssqlRecreateDefaultConstraint) {
+        results.push(rawToNode(db, mssqlDropDefaultConstraint(tableName, col.name)));
+      }
+
+      // TODO: We should maybe do some of these operations in a single query
+
+      if (operation.updateDataType) {
+        const dbType = sql.raw(schemaToDBType(col, provider));
+
+        if (provider === "postgresql" || provider === "cockroachdb") {
+          // PostgreSQL/CockroachDB: Use explicit USING clause for type conversion
+          results.push(
+            rawToNode(
+              db,
+              sql`ALTER TABLE ${sql.ref(tableName)} ALTER COLUMN ${sql.ref(operation.name)} TYPE ${dbType} USING (${sql.ref(operation.name)}::${dbType})`,
+            ),
+          );
+        } else {
+          results.push(next().alterColumn(operation.name, (b) => b.setDataType(dbType)));
+        }
+      }
+
+      if (operation.updateNullable) {
+        results.push(
+          next().alterColumn(operation.name, (build) =>
+            col.isNullable ? build.dropNotNull() : build.setNotNull(),
+          ),
+        );
+      }
+
+      if (provider === "mssql" && mssqlRecreateDefaultConstraint) {
+        const defaultValue = defaultValueToDB(col, provider);
+
+        if (defaultValue) {
+          const constraintName = getMssqlDefaultConstraintName(tableName, col.name);
+
+          results.push(
+            rawToNode(
+              db,
+              sql`ALTER TABLE ${sql.ref(tableName)} ADD CONSTRAINT ${sql.ref(constraintName)} DEFAULT ${defaultValue} FOR ${sql.ref(col.name)}`,
+            ),
+          );
+        }
+      } else if (operation.updateDefault) {
+        const defaultValue = defaultValueToDB(col, provider);
+
+        results.push(
+          next().alterColumn(operation.name, (build) => {
+            if (!defaultValue) {
+              return build.dropDefault();
+            }
+            return build.setDefault(defaultValue);
+          }),
+        );
+      }
+
+      return results;
+    }
+  }
+}
+
+export function execute(
+  operation: MigrationOperation,
+  config: KyselyConfig,
+  onCustomNode: (op: CustomOperation) => ExecuteNode | ExecuteNode[],
+): ExecuteNode | ExecuteNode[] {
+  const { db, provider } = config;
+
+  function createTable(tableName: string, columns: ColumnInfo[]) {
+    let builder = db.schema.createTable(tableName) as CreateTableBuilder<string, string>;
+
+    // Add columns from the column info array
+    for (const columnInfo of columns) {
+      builder = builder.addColumn(
+        columnInfo.name,
+        sql.raw(schemaToDBType(columnInfo, provider)),
+        getColumnBuilderCallback(columnInfo, provider),
+      );
+    }
+
+    return builder;
+  }
+
+  switch (operation.type) {
+    case "create-table":
+      return createTable(operation.name, operation.columns);
+    case "rename-table":
+      if (provider === "mssql") {
+        return rawToNode(
+          db,
+          sql`EXEC sp_rename ${sql.lit(operation.from)}, ${sql.lit(operation.to)}`,
+        );
+      }
+
+      return db.schema.alterTable(operation.from).renameTo(operation.to);
+    case "alter-table": {
+      const results: ExecuteNode[] = [];
+
+      for (const op of operation.value) {
+        results.push(...executeColumn(operation.name, op, config));
+      }
+
+      return results;
+    }
+    case "drop-table":
+      return db.schema.dropTable(operation.name);
+    case "custom":
+      return onCustomNode(operation);
+    case "add-foreign-key": {
+      if (provider === "sqlite") {
+        throw new Error(errors.SQLiteUpdateForeignKeys);
+      }
+
+      const { table, value } = operation;
+      const action = getForeignKeyAction(provider);
+
+      return db.schema
+        .alterTable(table)
+        .addForeignKeyConstraint(
+          value.name,
+          value.columns,
+          value.referencedTable,
+          value.referencedColumns,
+          (b) => b.onUpdate(action).onDelete(action),
+        );
+    }
+    case "drop-foreign-key": {
+      if (provider === "sqlite") {
+        throw new Error(errors.SQLiteUpdateForeignKeys);
+      }
+
+      const { table, name } = operation;
+      let query = db.schema.alterTable(table).dropConstraint(name);
+
+      // MySQL doesn't support IF EXISTS for dropping constraints
+      if (provider !== "mysql") {
+        query = query.ifExists();
+      }
+
+      return query;
+    }
+    case "add-index": {
+      if (operation.unique) {
+        return createUniqueIndex(db, operation.name, operation.table, operation.columns, provider);
+      }
+      return db.schema.createIndex(operation.name).on(operation.table).columns(operation.columns);
+    }
+    case "drop-index": {
+      return dropUniqueIndex(db, operation.name, operation.table, provider);
+    }
+  }
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function getColumnBuilderCallback(col: ColumnInfo, provider: SQLProvider): ColumnBuilderCallback {
+  return (build) => {
+    if (!col.isNullable) {
+      build = build.notNull();
+    }
+
+    // Internal ID is the primary key with auto-increment
+    if (col.role === "internal-id") {
+      build = build.primaryKey();
+      // Auto-increment for internal ID
+      if (provider === "postgresql" || provider === "cockroachdb") {
+        // SERIAL/BIGSERIAL handles auto-increment
+        // Already handled in schemaToDBType
+      } else if (provider === "mysql") {
+        build = build.autoIncrement();
+      } else if (provider === "sqlite") {
+        build = build.autoIncrement();
+      } else if (provider === "mssql") {
+        build = build.identity();
+      }
+    }
+
+    // External ID must be unique
+    if (col.role === "external-id") {
+      build = build.unique();
+    }
+
+    const defaultValue = defaultValueToDB(col, provider);
+    if (defaultValue) {
+      build = build.defaultTo(defaultValue);
+    }
+    return build;
+  };
+}
+
+function rawToNode(db: KyselyAny, raw: RawBuilder<unknown>): ExecuteNode {
+  return {
+    compile() {
+      return raw.compile(db);
+    },
+    execute() {
+      return raw.execute(db);
+    },
+  };
+}
+
+function mssqlDropDefaultConstraint(tableName: string, columnName: string) {
+  return sql`
+DECLARE @ConstraintName NVARCHAR(200);
+
+SELECT @ConstraintName = dc.name
+FROM sys.default_constraints dc
+JOIN sys.columns c ON dc.parent_object_id = c.object_id AND dc.parent_column_id = c.column_id
+JOIN sys.tables t ON t.object_id = c.object_id
+JOIN sys.schemas s ON t.schema_id = s.schema_id
+WHERE s.name = 'dbo' AND t.name = ${sql.lit(tableName)} AND c.name = ${sql.lit(columnName)};
+
+IF @ConstraintName IS NOT NULL
+BEGIN
+    EXEC('ALTER TABLE [dbo].[' + ${sql.lit(tableName)} + '] DROP CONSTRAINT [' + @ConstraintName + ']');
+END`;
+}
+
+function defaultValueToDB(column: ColumnInfo, provider: SQLProvider) {
+  const value = column.default;
+  if (!value) {
+    return undefined;
+  }
+
+  // MySQL doesn't support default values for TEXT columns
+  if (provider === "mysql" && column.type === "string") {
+    return undefined;
+  }
+
+  if ("runtime" in value && value.runtime === "now") {
+    return sql`CURRENT_TIMESTAMP`;
+  }
+
+  if ("value" in value && value.value !== undefined) {
+    return sql.lit(value.value);
+  }
+
+  return undefined;
+}

package/src/adapters/kysely/migration/kysely-migrator.test.ts

@@ -0,0 +1,197 @@
+import { Kysely, PostgresDialect } from "kysely";
+import { describe, expect, beforeAll, test } from "vitest";
+import { KyselyAdapter } from "../kysely-adapter";
+import { column, idColumn, schema } from "../../../schema/create";
+
+describe("KyselyMigrator", () => {
+  const testSchema = schema((s) => {
+    return s
+      .addTable("users", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      })
+      .alterTable("users", (t) => {
+        return t
+          .addColumn("age", column("integer").nullable())
+          .createIndex("name_idx", ["name"])
+          .createIndex("age_idx", ["age"]);
+      })
+      .addTable("posts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("title", column("string"))
+          .addColumn("user_id", column("string"));
+      })
+      .addReference("author", {
+        type: "one",
+        from: { table: "posts", column: "user_id" },
+        to: { table: "users", column: "id" },
+      });
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let db: Kysely<any>;
+  let adapter: KyselyAdapter;
+
+  beforeAll(async () => {
+    // Create a Kysely instance with a PostgresDialect, but not actually connected to a database
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    db = new Kysely({ dialect: new PostgresDialect({} as any) });
+    adapter = new KyselyAdapter({ db, provider: "postgresql" });
+  });
+
+  test("generate SQL for migration 0 -> 1 (create users table)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(1, {
+      updateSettings: true,
+      fromVersion: 0,
+    });
+
+    expect(preparedMigration.operations.length).toBeGreaterThan(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toMatchInlineSnapshot(`
+      "create table "fragno_db_settings" ("key" varchar(255) primary key, "value" text not null);
+
+      insert into "fragno_db_settings" ("key", "value") values ('test_namespace.schema_version', '1');
+
+      create table "users" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);"
+    `);
+  });
+
+  test("generate SQL for migration 0 -> 2 (create users table and add age)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(2, {
+      updateSettings: true,
+      fromVersion: 0,
+    });
+
+    expect(preparedMigration.operations.length).toBeGreaterThan(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toMatchInlineSnapshot(`
+      "create table "fragno_db_settings" ("key" varchar(255) primary key, "value" text not null);
+
+      insert into "fragno_db_settings" ("key", "value") values ('test_namespace.schema_version', '2');
+
+      create table "users" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+
+      alter table "users" add column "age" integer;
+
+      create index "name_idx" on "users" ("name");
+
+      create index "age_idx" on "users" ("age");"
+    `);
+  });
+
+  test("generate SQL for migration 1 -> 2 (add age column and indexes)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(2, {
+      updateSettings: true,
+      fromVersion: 1,
+    });
+
+    expect(preparedMigration.operations.length).toBeGreaterThan(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toMatchInlineSnapshot(`
+      "update "fragno_db_settings" set "value" = '2' where "key" = 'test_namespace.schema_version';
+
+      alter table "users" add column "age" integer;
+
+      create index "name_idx" on "users" ("name");
+
+      create index "age_idx" on "users" ("age");"
+    `);
+  });
+
+  test("generate SQL for migration 0 -> 3 (full schema)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(3, {
+      updateSettings: true,
+      fromVersion: 0,
+    });
+
+    expect(preparedMigration.operations.length).toBeGreaterThan(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toMatchInlineSnapshot(`
+      "create table "fragno_db_settings" ("key" varchar(255) primary key, "value" text not null);
+
+      insert into "fragno_db_settings" ("key", "value") values ('test_namespace.schema_version', '3');
+
+      create table "users" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+
+      alter table "users" add column "age" integer;
+
+      create index "name_idx" on "users" ("name");
+
+      create index "age_idx" on "users" ("age");
+
+      create table "posts" ("id" varchar(30) not null unique, "title" text not null, "user_id" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);"
+    `);
+  });
+
+  test("generate SQL for migration 2 -> 3 (add posts table)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(3, {
+      updateSettings: true,
+      fromVersion: 2,
+    });
+
+    expect(preparedMigration.operations.length).toBeGreaterThan(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toMatchInlineSnapshot(`
+      "update "fragno_db_settings" set "value" = '3' where "key" = 'test_namespace.schema_version';
+
+      create table "posts" ("id" varchar(30) not null unique, "title" text not null, "user_id" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);"
+    `);
+  });
+
+  test("generate empty SQL for migration 2 -> 2 (no changes)", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+    const preparedMigration = await migrator.prepareMigrationTo(2, {
+      updateSettings: true,
+      fromVersion: 2,
+    });
+
+    expect(preparedMigration.operations.length).toBe(0);
+    const sql = preparedMigration.getSQL?.();
+    expect(sql).toBeDefined();
+    expect(sql).toBe("");
+  });
+
+  test("throw error for backward migration", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+
+    await expect(
+      migrator.prepareMigrationTo(1, {
+        updateSettings: true,
+        fromVersion: 2,
+      }),
+    ).rejects.toThrow("Cannot migrate backwards");
+  });
+
+  test("throw error for version beyond schema", async () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+
+    await expect(
+      migrator.prepareMigrationTo(10, {
+        updateSettings: true,
+        fromVersion: 0,
+      }),
+    ).rejects.toThrow("schema only has version 4");
+  });
+
+  test("getDefaultFileName returns correct format", () => {
+    const migrator = adapter.createMigrationEngine(testSchema, "test_namespace");
+
+    expect(migrator.getDefaultFileName).toBeDefined();
+
+    if (migrator.getDefaultFileName) {
+      const filename = migrator.getDefaultFileName("my-fragment", 0, 1);
+      // Should match format: YYYYMMDD_namespace_migration_0_to_1.sql
+      expect(filename).toMatch(/^\d{8}_my-fragment_migration_0_to_1\.sql$/);
+    }
+  });
+});