@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/core/objects/trigger/trigger.model.ts

@@ -0,0 +1,291 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
+
+const TriggerEnabledSchema = z.enum([
+  "O", // ORIGIN - trigger fires in "origin" and "local" replica modes
+  "D", // DISABLED - trigger is disabled
+  "R", // REPLICA - trigger fires only in "replica" mode
+  "A", // ALWAYS - trigger fires regardless of replication mode
+]);
+
+const TriggerTableRelkindSchema = z.enum([
+  "r", // ordinary table
+  "p", // partitioned table
+  "f", // foreign table
+  "v", // view
+  "m", // materialized view
+]);
+
+const triggerPropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  table_name: z.string(),
+  table_relkind: TriggerTableRelkindSchema,
+  function_schema: z.string(),
+  function_name: z.string(),
+  trigger_type: z.number(),
+  enabled: TriggerEnabledSchema,
+  is_internal: z.boolean(),
+  deferrable: z.boolean(),
+  initially_deferred: z.boolean(),
+  argument_count: z.number(),
+  column_numbers: z.array(z.number()).nullable(),
+  arguments: z.array(z.string()),
+  when_condition: z.string().nullable(),
+  old_table: z.string().nullable(),
+  new_table: z.string().nullable(),
+  is_partition_clone: z.boolean(),
+  parent_trigger_name: z.string().nullable(),
+  parent_table_schema: z.string().nullable(),
+  parent_table_name: z.string().nullable(),
+  is_on_partitioned_table: z.boolean(),
+  owner: z.string(),
+  definition: z.string(),
+  comment: z.string().nullable(),
+});
+
+// pg_get_triggerdef(oid, pretty) can return NULL when the trigger (its
+// pg_trigger row) is dropped between catalog scan and resolution, or under
+// transient catalog state. An unreadable trigger cannot be diffed, so we
+// accept NULL here and filter the row out at extraction time rather than
+// crashing the whole catalog parse with a ZodError.
+const triggerRowSchema = triggerPropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
+export type TriggerProps = z.infer<typeof triggerPropsSchema>;
+
+export class Trigger extends BasePgModel {
+  public readonly schema: TriggerProps["schema"];
+  public readonly name: TriggerProps["name"];
+  public readonly table_name: TriggerProps["table_name"];
+  public readonly table_relkind: TriggerProps["table_relkind"];
+  public readonly function_schema: TriggerProps["function_schema"];
+  public readonly function_name: TriggerProps["function_name"];
+  public readonly trigger_type: TriggerProps["trigger_type"];
+  public readonly enabled: TriggerProps["enabled"];
+  public readonly is_internal: TriggerProps["is_internal"];
+  public readonly deferrable: TriggerProps["deferrable"];
+  public readonly initially_deferred: TriggerProps["initially_deferred"];
+  public readonly argument_count: TriggerProps["argument_count"];
+  public readonly column_numbers: TriggerProps["column_numbers"];
+  public readonly arguments: TriggerProps["arguments"];
+  public readonly when_condition: TriggerProps["when_condition"];
+  public readonly old_table: TriggerProps["old_table"];
+  public readonly new_table: TriggerProps["new_table"];
+  public readonly is_partition_clone: TriggerProps["is_partition_clone"];
+  public readonly parent_trigger_name: TriggerProps["parent_trigger_name"];
+  public readonly parent_table_schema: TriggerProps["parent_table_schema"];
+  public readonly parent_table_name: TriggerProps["parent_table_name"];
+  public readonly is_on_partitioned_table: TriggerProps["is_on_partitioned_table"];
+  public readonly owner: TriggerProps["owner"];
+  public readonly definition: TriggerProps["definition"];
+  public readonly comment: TriggerProps["comment"];
+
+  constructor(props: TriggerProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+    this.table_name = props.table_name;
+    this.table_relkind = props.table_relkind;
+
+    // Data fields
+    this.function_schema = props.function_schema;
+    this.function_name = props.function_name;
+    this.trigger_type = props.trigger_type;
+    this.enabled = props.enabled;
+    this.is_internal = props.is_internal;
+    this.deferrable = props.deferrable;
+    this.initially_deferred = props.initially_deferred;
+    this.argument_count = props.argument_count;
+    this.column_numbers = props.column_numbers;
+    this.arguments = props.arguments;
+    this.when_condition = props.when_condition;
+    this.old_table = props.old_table;
+    this.new_table = props.new_table;
+    this.is_partition_clone = props.is_partition_clone;
+    this.parent_trigger_name = props.parent_trigger_name;
+    this.parent_table_schema = props.parent_table_schema;
+    this.parent_table_name = props.parent_table_name;
+    this.is_on_partitioned_table = props.is_on_partitioned_table;
+    this.owner = props.owner;
+    this.definition = props.definition;
+    this.comment = props.comment;
+  }
+
+  get isConstraintTrigger(): boolean {
+    return /^CREATE\s+CONSTRAINT\s+TRIGGER/i.test(this.definition.trim());
+  }
+
+  get stableId(): `trigger:${string}` {
+    return `trigger:${this.schema}.${this.table_name}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+      table_name: this.table_name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      function_schema: this.function_schema,
+      function_name: this.function_name,
+      trigger_type: this.trigger_type,
+      enabled: this.enabled,
+      is_internal: this.is_internal,
+      deferrable: this.deferrable,
+      initially_deferred: this.initially_deferred,
+      argument_count: this.argument_count,
+      // column_numbers excluded: contains pg_trigger.tgattr attnums that differ
+      // between databases when physical column layouts diverge but logical
+      // (named) columns match. The definition field (pg_get_triggerdef) captures
+      // the UPDATE OF column list by name, so we compare by definition instead.
+      arguments: this.arguments,
+      when_condition: this.when_condition,
+      old_table: this.old_table,
+      new_table: this.new_table,
+      is_partition_clone: this.is_partition_clone,
+      parent_trigger_name: this.parent_trigger_name,
+      parent_table_schema: this.parent_table_schema,
+      parent_table_name: this.parent_table_name,
+      is_on_partitioned_table: this.is_on_partitioned_table,
+      owner: this.owner,
+      definition: this.definition,
+      comment: this.comment,
+    };
+  }
+}
+
+export async function extractTriggers(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Trigger[]> {
+  const triggerRows = await extractWithDefinitionRetry({
+    label: "triggers",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<TriggerProps>(sql`
+      with extension_trigger_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_trigger'::regclass
+      ),
+      extension_table_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_class'::regclass
+          and d.deptype    = 'e'
+      ),
+      extension_function_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid    = 'pg_proc'::regclass
+      )
+      select
+        tc.relnamespace::regnamespace::text as schema,
+        quote_ident(t.tgname)               as name,
+        quote_ident(tc.relname)             as table_name,
+        tc.relkind                          as table_relkind,
+
+        fc.pronamespace::regnamespace::text as function_schema,
+        quote_ident(fc.proname)             as function_name,
+
+        t.tgtype                            as trigger_type,
+        t.tgenabled                         as enabled,
+        t.tgisinternal                       as is_internal,
+        t.tgdeferrable                       as deferrable,
+        t.tginitdeferred                     as initially_deferred,
+        t.tgnargs                            as argument_count,
+        t.tgattr                             as column_numbers,
+
+        case when t.tgnargs > 0
+            then array_fill(''::text, array[t.tgnargs])
+            else array[]::text[]
+        end as arguments,
+
+        -- identify triggers cloned onto partitions (created/attached partitions)
+        (t.tgparentid <> 0::oid)            as is_partition_clone,
+        case when t.tgparentid <> 0::oid
+            then quote_ident(parent_t.tgname)
+            else null
+        end                                 as parent_trigger_name,
+        case when t.tgparentid <> 0::oid
+            then parent_tc.relnamespace::regnamespace::text
+            else null
+        end                                 as parent_table_schema,
+        case when t.tgparentid <> 0::oid
+            then quote_ident(parent_tc.relname)
+            else null
+        end                                 as parent_table_name,
+
+        (tc.relkind = 'p')                  as is_on_partitioned_table,
+
+        (
+          case
+            when strpos(defn.definition, ' WHEN (') > 0
+            and strpos(defn.definition, ') EXECUTE') >
+                strpos(defn.definition, ' WHEN (') + 7
+            then substr(
+                  defn.definition,
+                  strpos(defn.definition, ' WHEN (') + 7,
+                  strpos(defn.definition, ') EXECUTE')
+                    - (strpos(defn.definition, ' WHEN (') + 7)
+                )
+            else null
+          end
+        ) as when_condition,
+
+        t.tgoldtable                        as old_table,
+        t.tgnewtable                        as new_table,
+        tc.relowner::regrole::text          as owner,
+        defn.definition                     as definition,
+        obj_description(t.oid, 'pg_trigger') as comment
+
+      from pg_catalog.pg_trigger t
+      join pg_catalog.pg_class   tc on tc.oid = t.tgrelid
+      join pg_catalog.pg_proc    fc on fc.oid = t.tgfoid
+
+      -- compute trigger definition once
+      left join lateral (
+        select pg_get_triggerdef(t.oid, true) as definition
+      ) defn on true
+
+      -- parent trigger/table linkage for cloned (partition) triggers
+      left join pg_catalog.pg_trigger parent_t  on parent_t.oid  = t.tgparentid
+      left join pg_catalog.pg_class   parent_tc on parent_tc.oid = parent_t.tgrelid
+
+      left join extension_trigger_oids  e_trigger  on t.oid  = e_trigger.objid
+      left join extension_table_oids    e_table    on tc.oid = e_table.objid
+      left join extension_function_oids e_function on fc.oid = e_function.objid
+
+      where not tc.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e_trigger.objid is null
+        and e_table.objid is null
+        and e_function.objid is null
+        and not t.tgisinternal
+
+      order by 1, 2
+  `);
+      return result.rows.map((row: unknown) => triggerRowSchema.parse(row));
+    },
+  });
+  const validatedRows = triggerRows.filter(
+    (row): row is TriggerProps => row.definition !== null,
+  );
+  return validatedRows.map((row: TriggerProps) => new Trigger(row));
+}

package/src/core/objects/type/composite-type/changes/composite-type.alter.test.ts

@@ -0,0 +1,208 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import {
+  CompositeType,
+  type CompositeTypeProps,
+} from "../composite-type.model.ts";
+import {
+  AlterCompositeTypeAddAttribute,
+  AlterCompositeTypeAlterAttributeType,
+  AlterCompositeTypeChangeOwner,
+  AlterCompositeTypeDropAttribute,
+} from "./composite-type.alter.ts";
+
+describe.concurrent("composite-type", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: Omit<CompositeTypeProps, "owner"> = {
+        schema: "public",
+        name: "test_type",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: false,
+        replica_identity: "d",
+        is_partition: false,
+        options: null,
+        partition_bound: null,
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const main = new CompositeType({
+        ...props,
+        owner: "old_owner",
+      });
+      const change = new AlterCompositeTypeChangeOwner({
+        compositeType: main,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER TYPE public.test_type OWNER TO new_owner",
+      );
+    });
+  });
+
+  test("add attribute", async () => {
+    const base = {
+      schema: "public",
+      name: "ct",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "o1",
+      comment: null,
+      privileges: [],
+    } as const;
+    const branch = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          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,
+        },
+      ],
+      privileges: [],
+    });
+    const change = new AlterCompositeTypeAddAttribute({
+      compositeType: branch,
+      attribute: branch.columns[0],
+    });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER TYPE public.ct ADD ATTRIBUTE a text",
+    );
+  });
+
+  test("drop attribute", async () => {
+    const base = {
+      schema: "public",
+      name: "ct",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "o1",
+      comment: null,
+      privileges: [],
+    } as const;
+    const main = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          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,
+        },
+      ],
+      privileges: [],
+    });
+    const change = new AlterCompositeTypeDropAttribute({
+      compositeType: main,
+      attribute: main.columns[0],
+    });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("ALTER TYPE public.ct DROP ATTRIBUTE a");
+  });
+
+  test("alter attribute type and collation", async () => {
+    const base = {
+      schema: "public",
+      name: "ct",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "o1",
+      comment: null,
+      privileges: [],
+    } as const;
+    const branch = new CompositeType({
+      ...base,
+      columns: [
+        {
+          name: "a",
+          position: 1,
+          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: '"en_US"',
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    const change = new AlterCompositeTypeAlterAttributeType({
+      compositeType: branch,
+      attribute: branch.columns[0],
+    });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      'ALTER TYPE public.ct ALTER ATTRIBUTE a TYPE text COLLATE "en_US"',
+    );
+  });
+});

package/src/core/objects/type/composite-type/changes/composite-type.alter.ts

@@ -0,0 +1,175 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import type { CompositeType } from "../composite-type.model.ts";
+import { AlterCompositeTypeChange } from "./composite-type.base.ts";
+
+/**
+ * Alter a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altertype.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER TYPE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER TYPE name RENAME TO new_name
+ * ALTER TYPE name SET SCHEMA new_schema
+ * -- Attribute actions (composite types):
+ * ALTER TYPE name ADD ATTRIBUTE attribute_name data_type [ COLLATE collation ] [ CASCADE | RESTRICT ]
+ * ALTER TYPE name DROP ATTRIBUTE [ IF EXISTS ] attribute_name [ CASCADE | RESTRICT ]
+ * ALTER TYPE name ALTER ATTRIBUTE attribute_name [ SET DATA ] TYPE data_type [ COLLATE collation ] [ CASCADE | RESTRICT ]
+ * ```
+ */
+
+export type AlterCompositeType =
+  | AlterCompositeTypeAddAttribute
+  | AlterCompositeTypeAlterAttributeType
+  | AlterCompositeTypeChangeOwner
+  | AlterCompositeTypeDropAttribute;
+
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export class AlterCompositeTypeChangeOwner extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { compositeType: CompositeType; owner: string }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.compositeType.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER TYPE",
+      `${this.compositeType.schema}.${this.compositeType.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER TYPE ... ADD ATTRIBUTE ...
+ */
+export class AlterCompositeTypeAddAttribute extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly attribute: CompositeType["columns"][number];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    attribute: CompositeType["columns"][number];
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.attribute = props.attribute;
+  }
+
+  get creates() {
+    return [`${this.compositeType.stableId}:${this.attribute.name}`];
+  }
+
+  get requires() {
+    return [this.compositeType.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
+      "ALTER TYPE",
+      `${this.compositeType.schema}.${this.compositeType.name}`,
+      "ADD ATTRIBUTE",
+      this.attribute.name,
+      this.attribute.data_type_str,
+    ];
+    if (this.attribute.collation) {
+      parts.push("COLLATE", this.attribute.collation);
+    }
+    return parts.join(" ");
+  }
+}
+
+/**
+ * ALTER TYPE ... DROP ATTRIBUTE ...
+ */
+export class AlterCompositeTypeDropAttribute extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly attribute: CompositeType["columns"][number];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    attribute: CompositeType["columns"][number];
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.attribute = props.attribute;
+  }
+
+  get requires() {
+    return [
+      `${this.compositeType.stableId}:${this.attribute.name}`,
+      this.compositeType.stableId,
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER TYPE",
+      `${this.compositeType.schema}.${this.compositeType.name}`,
+      "DROP ATTRIBUTE",
+      this.attribute.name,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER TYPE ... ALTER ATTRIBUTE ... TYPE ... [ COLLATE ... ]
+ */
+export class AlterCompositeTypeAlterAttributeType extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly attribute: CompositeType["columns"][number];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    attribute: CompositeType["columns"][number];
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.attribute = props.attribute;
+  }
+
+  get requires() {
+    return [
+      `${this.compositeType.stableId}:${this.attribute.name}`,
+      this.compositeType.stableId,
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
+      "ALTER TYPE",
+      `${this.compositeType.schema}.${this.compositeType.name}`,
+      "ALTER ATTRIBUTE",
+      this.attribute.name,
+      "TYPE",
+      this.attribute.data_type_str,
+    ];
+    if (this.attribute.collation) {
+      parts.push("COLLATE", this.attribute.collation);
+    }
+    return parts.join(" ");
+  }
+}
+
+/**
+ * Replace a composite type by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TYPE change.
+ * Note: Attribute list changes are modeled as drop+create via diff.
+ */
+// NOTE: ReplaceCompositeType removed. Non-alterable changes are emitted as Drop + Create in composite-type.diff.ts.

package/src/core/objects/type/composite-type/changes/composite-type.base.ts

@@ -0,0 +1,24 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { CompositeType } from "../composite-type.model.ts";
+
+abstract class BaseCompositeTypeChange extends BaseChange {
+  abstract readonly compositeType: CompositeType;
+  abstract readonly scope:
+    | "object"
+    | "comment"
+    | "privilege"
+    | "security_label";
+  readonly objectType = "composite_type" as const;
+}
+
+export abstract class CreateCompositeTypeChange extends BaseCompositeTypeChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterCompositeTypeChange extends BaseCompositeTypeChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropCompositeTypeChange extends BaseCompositeTypeChange {
+  readonly operation = "drop" as const;
+}