@fragno-dev/db 0.1.14 → 0.2.0

package/src/adapters/generic-sql/migration/dialect/postgres.ts

@@ -0,0 +1,113 @@
+import { type ColumnDefinitionBuilder, type CompiledQuery, type RawBuilder, sql } from "kysely";
+import type {
+  ColumnInfo,
+  ColumnOperation,
+  MigrationOperation,
+} from "../../../../migration-engine/shared";
+import { isUpdated } from "../../../../migration-engine/shared";
+import { SQLGenerator } from "../sql-generator";
+
+const errors = {
+  IdColumnUpdate:
+    "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
+} as const;
+
+/**
+ * PostgreSQL-specific SQL generator.
+ * Uses USING clauses for type conversion and SERIAL for auto-increment.
+ */
+export class PostgresSQLGenerator extends SQLGenerator {
+  /**
+   * PostgreSQL doesn't need preprocessing - it handles FKs normally.
+   */
+  override preprocess(operations: MigrationOperation[]): MigrationOperation[] {
+    return operations;
+  }
+
+  /**
+   * PostgreSQL uses SERIAL/BIGSERIAL types for auto-increment,
+   * which is already handled in PostgreSQLTypeMapper. No builder modification needed.
+   */
+  override applyAutoIncrement(builder: ColumnDefinitionBuilder): ColumnDefinitionBuilder {
+    return builder;
+  }
+
+  override getDefaultValue(column: ColumnInfo): RawBuilder<unknown> | undefined {
+    const value = column.default;
+    if (!value) {
+      return undefined;
+    }
+
+    if ("value" in value && value.value !== undefined) {
+      return sql.lit(value.value);
+    }
+
+    if ("dbSpecial" in value && value.dbSpecial === "now") {
+      return sql`CURRENT_TIMESTAMP`;
+    }
+
+    // Runtime defaults are handled in application code, not SQL
+    if ("runtime" in value) {
+      return undefined;
+    }
+
+    return undefined;
+  }
+
+  /**
+   * PostgreSQL update-column uses USING clause for type conversion.
+   */
+  protected override compileUpdateColumn(
+    tableName: string,
+    operation: Extract<ColumnOperation, { type: "update-column" }>,
+  ): CompiledQuery | CompiledQuery[] {
+    const col = operation.value;
+
+    if (col.role === "external-id" || col.role === "internal-id") {
+      throw new Error(errors.IdColumnUpdate);
+    }
+
+    if (!isUpdated(operation)) {
+      return [];
+    }
+
+    const queries: CompiledQuery[] = [];
+    const alter = () => this.db.schema.alterTable(tableName);
+
+    // PostgreSQL: Use explicit USING clause for type conversion
+    if (operation.updateDataType) {
+      const dbType = sql.raw(this.getDBType(col));
+      queries.push(
+        sql`ALTER TABLE ${sql.ref(tableName)} ALTER COLUMN ${sql.ref(operation.name)} TYPE ${dbType} USING (${sql.ref(operation.name)}::${dbType})`.compile(
+          this.db,
+        ),
+      );
+    }
+
+    if (operation.updateNullable) {
+      queries.push(
+        alter()
+          .alterColumn(operation.name, (build) =>
+            col.isNullable ? build.dropNotNull() : build.setNotNull(),
+          )
+          .compile(),
+      );
+    }
+
+    if (operation.updateDefault) {
+      const defaultValue = this.getDefaultValue(col);
+      queries.push(
+        alter()
+          .alterColumn(operation.name, (build) => {
+            if (!defaultValue) {
+              return build.dropDefault();
+            }
+            return build.setDefault(defaultValue);
+          })
+          .compile(),
+      );
+    }
+
+    return queries;
+  }
+}