@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.21

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.ts

@@ -0,0 +1,11 @@
+import type { ForeignDataWrapperChange as FDWChange } from "./foreign-data-wrapper/changes/foreign-data-wrapper.types.ts";
+import type { ForeignTableChange } from "./foreign-table/changes/foreign-table.types.ts";
+import type { ServerChange } from "./server/changes/server.types.ts";
+import type { UserMappingChange } from "./user-mapping/changes/user-mapping.types.ts";
+
+/** Union of all foreign-data-wrapper-related change variants (`objectType: "foreign_data_wrapper" | "server" | "foreign_table" | "user_mapping"`). @category Change Types */
+export type ForeignDataWrapperChange =
+  | FDWChange
+  | ServerChange
+  | UserMappingChange
+  | ForeignTableChange;

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.alter.test.ts

@@ -0,0 +1,340 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import {
+  ForeignTable,
+  type ForeignTableProps,
+} from "../foreign-table.model.ts";
+import {
+  AlterForeignTableAddColumn,
+  AlterForeignTableAlterColumnDropDefault,
+  AlterForeignTableAlterColumnDropNotNull,
+  AlterForeignTableAlterColumnSetDefault,
+  AlterForeignTableAlterColumnSetNotNull,
+  AlterForeignTableAlterColumnType,
+  AlterForeignTableChangeOwner,
+  AlterForeignTableDropColumn,
+  AlterForeignTableSetOptions,
+} from "./foreign-table.alter.ts";
+
+describe.concurrent("foreign-table", () => {
+  describe("alter", () => {
+    const baseTableProps: ForeignTableProps = {
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: null,
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    };
+
+    test("change owner", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableChangeOwner({
+        foreignTable,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table OWNER TO new_owner",
+      );
+    });
+
+    test("add column", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAddColumn({
+        foreignTable,
+        column: {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text",
+      );
+    });
+
+    test("add column with NOT NULL", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAddColumn({
+        foreignTable,
+        column: {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: true,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text NOT NULL",
+      );
+    });
+
+    test("add column with DEFAULT", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAddColumn({
+        foreignTable,
+        column: {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "'default_value'",
+          comment: null,
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text DEFAULT 'default_value'",
+      );
+    });
+
+    test("add column with NOT NULL and DEFAULT", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAddColumn({
+        foreignTable,
+        column: {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: true,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "'default_value'",
+          comment: null,
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ADD COLUMN name text NOT NULL DEFAULT 'default_value'",
+      );
+    });
+
+    test("drop column", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableDropColumn({
+        foreignTable,
+        columnName: "id",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table DROP COLUMN id",
+      );
+    });
+
+    test("alter column type", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAlterColumnType({
+        foreignTable,
+        columnName: "id",
+        dataType: "bigint",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id TYPE bigint",
+      );
+    });
+
+    test("alter column set default", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAlterColumnSetDefault({
+        foreignTable,
+        columnName: "id",
+        defaultValue: "0",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id SET DEFAULT 0",
+      );
+    });
+
+    test("alter column drop default", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAlterColumnDropDefault({
+        foreignTable,
+        columnName: "id",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id DROP DEFAULT",
+      );
+    });
+
+    test("alter column set not null", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAlterColumnSetNotNull({
+        foreignTable,
+        columnName: "id",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id SET NOT NULL",
+      );
+    });
+
+    test("alter column drop not null", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableAlterColumnDropNotNull({
+        foreignTable,
+        columnName: "id",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table ALTER COLUMN id DROP NOT NULL",
+      );
+    });
+
+    test("set options ADD", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableSetOptions({
+        foreignTable,
+        options: [
+          { action: "ADD", option: "schema_name", value: "remote_schema" },
+          { action: "ADD", option: "table_name", value: "remote_table" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table OPTIONS (ADD schema_name 'remote_schema', ADD table_name 'remote_table')",
+      );
+    });
+
+    test("set options SET", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableSetOptions({
+        foreignTable,
+        options: [
+          { action: "SET", option: "schema_name", value: "new_schema" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table OPTIONS (SET schema_name 'new_schema')",
+      );
+    });
+
+    test("set options DROP", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableSetOptions({
+        foreignTable,
+        options: [{ action: "DROP", option: "schema_name" }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table OPTIONS (DROP schema_name)",
+      );
+    });
+
+    test("set options mixed ADD/SET/DROP", async () => {
+      const foreignTable = new ForeignTable(baseTableProps);
+      const change = new AlterForeignTableSetOptions({
+        foreignTable,
+        options: [
+          { action: "ADD", option: "new_option", value: "new_value" },
+          { action: "SET", option: "existing_option", value: "updated_value" },
+          { action: "DROP", option: "old_option" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN TABLE public.test_table OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
+      );
+    });
+  });
+});

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.alter.ts

@@ -0,0 +1,342 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import type { ColumnProps } from "../../../base.model.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { AlterForeignTableChange } from "./foreign-table.base.ts";
+
+/**
+ * Alter a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER FOREIGN TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
+ *     action [, ... ]
+ * where action is one of:
+ *     ADD [ COLUMN ] [ IF NOT EXISTS ] column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ]
+ *     DROP [ COLUMN ] [ IF EXISTS ] column_name [ RESTRICT | CASCADE ]
+ *     ALTER [ COLUMN ] column_name [ SET DATA ] TYPE data_type [ COLLATE collation ]
+ *     ALTER [ COLUMN ] column_name SET DEFAULT expression
+ *     ALTER [ COLUMN ] column_name DROP DEFAULT
+ *     ALTER [ COLUMN ] column_name { SET | DROP } NOT NULL
+ *     ALTER [ COLUMN ] column_name OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ *     OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ * ```
+ */
+
+export type AlterForeignTable =
+  | AlterForeignTableChangeOwner
+  | AlterForeignTableAddColumn
+  | AlterForeignTableDropColumn
+  | AlterForeignTableAlterColumnType
+  | AlterForeignTableAlterColumnSetDefault
+  | AlterForeignTableAlterColumnDropDefault
+  | AlterForeignTableAlterColumnSetNotNull
+  | AlterForeignTableAlterColumnDropNotNull
+  | AlterForeignTableSetOptions;
+
+/**
+ * ALTER FOREIGN TABLE ... OWNER TO ...
+ */
+export class AlterForeignTableChangeOwner extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; owner: string }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId, stableId.role(this.owner)];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ADD COLUMN ...
+ */
+export class AlterForeignTableAddColumn extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly column: ColumnProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; column: ColumnProps }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.column = props.column;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ADD COLUMN",
+      this.column.name,
+      this.column.data_type_str,
+    ];
+
+    if (this.column.not_null) {
+      parts.push("NOT NULL");
+    }
+
+    if (this.column.default) {
+      parts.push("DEFAULT", this.column.default);
+    }
+
+    return parts.join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... DROP COLUMN ...
+ */
+export class AlterForeignTableDropColumn extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; columnName: string }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "DROP COLUMN",
+      this.columnName,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... TYPE ...
+ */
+export class AlterForeignTableAlterColumnType extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly dataType: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    columnName: string;
+    dataType: string;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+    this.dataType = props.dataType;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ALTER COLUMN",
+      this.columnName,
+      "TYPE",
+      this.dataType,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET DEFAULT ...
+ */
+export class AlterForeignTableAlterColumnSetDefault extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly defaultValue: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    columnName: string;
+    defaultValue: string;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+    this.defaultValue = props.defaultValue;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ALTER COLUMN",
+      this.columnName,
+      "SET DEFAULT",
+      this.defaultValue,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP DEFAULT
+ */
+export class AlterForeignTableAlterColumnDropDefault extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; columnName: string }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ALTER COLUMN",
+      this.columnName,
+      "DROP DEFAULT",
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... SET NOT NULL
+ */
+export class AlterForeignTableAlterColumnSetNotNull extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; columnName: string }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ALTER COLUMN",
+      this.columnName,
+      "SET NOT NULL",
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... ALTER COLUMN ... DROP NOT NULL
+ */
+export class AlterForeignTableAlterColumnDropNotNull extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly columnName: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable; columnName: string }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.columnName = props.columnName;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "ALTER COLUMN",
+      this.columnName,
+      "DROP NOT NULL",
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER FOREIGN TABLE ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterForeignTableSetOptions extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly options: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }>;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    options: Array<{
+      action: "ADD" | "SET" | "DROP";
+      option: string;
+      value?: string;
+    }>;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const optionParts: string[] = [];
+    for (const opt of this.options) {
+      if (opt.action === "DROP") {
+        optionParts.push(`DROP ${opt.option}`);
+      } else {
+        const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+        optionParts.push(`${opt.action} ${opt.option} ${value}`);
+      }
+    }
+
+    return [
+      "ALTER FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "OPTIONS",
+      `(${optionParts.join(", ")})`,
+    ].join(" ");
+  }
+}

package/src/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+
+abstract class BaseForeignTableChange extends BaseChange {
+  abstract readonly foreignTable: ForeignTable;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "foreign_table" = "foreign_table";
+}
+
+export abstract class CreateForeignTableChange extends BaseForeignTableChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterForeignTableChange extends BaseForeignTableChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropForeignTableChange extends BaseForeignTableChange {
+  readonly operation = "drop" as const;
+}