@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/core/objects/type/composite-type/composite-type.diff.ts

@@ -0,0 +1,310 @@
+import { diffObjects } from "../../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
+import { deepEqual, hasNonAlterableChanges } from "../../utils.ts";
+import {
+  AlterCompositeTypeAddAttribute,
+  AlterCompositeTypeAlterAttributeType,
+  AlterCompositeTypeChangeOwner,
+  AlterCompositeTypeDropAttribute,
+} from "./changes/composite-type.alter.ts";
+import {
+  CreateCommentOnCompositeType,
+  CreateCommentOnCompositeTypeAttribute,
+  DropCommentOnCompositeType,
+  DropCommentOnCompositeTypeAttribute,
+} from "./changes/composite-type.comment.ts";
+import { CreateCompositeType } from "./changes/composite-type.create.ts";
+import { DropCompositeType } from "./changes/composite-type.drop.ts";
+import {
+  GrantCompositeTypePrivileges,
+  RevokeCompositeTypePrivileges,
+  RevokeGrantOptionCompositeTypePrivileges,
+} from "./changes/composite-type.privilege.ts";
+import type { CompositeTypeChange } from "./changes/composite-type.types.ts";
+import type { CompositeType } from "./composite-type.model.ts";
+
+/**
+ * Diff two sets of composite types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The composite types in the main catalog.
+ * @param branch - The composite types in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffCompositeTypes(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, CompositeType>,
+  branch: Record<string, CompositeType>,
+): CompositeTypeChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: CompositeTypeChange[] = [];
+
+  for (const compositeTypeId of created) {
+    const ct = branch[compositeTypeId];
+    changes.push(new CreateCompositeType({ compositeType: ct }));
+
+    // OWNER: If the composite type should be owned by someone other than the current user,
+    // emit ALTER TYPE ... OWNER TO after creation
+    if (ct.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterCompositeTypeChangeOwner({
+          compositeType: ct,
+          owner: ct.owner,
+        }),
+      );
+    }
+
+    // Type comment on creation
+    if (ct.comment !== null) {
+      changes.push(new CreateCommentOnCompositeType({ compositeType: ct }));
+    }
+    // Attribute comments on creation
+    for (const attr of ct.columns) {
+      if (attr.comment !== null) {
+        changes.push(
+          new CreateCommentOnCompositeTypeAttribute({
+            compositeType: ct,
+            attribute: attr,
+          }),
+        );
+      }
+    }
+
+    // PRIVILEGES: For created objects, compare against default privileges state
+    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+    // so objects are created with the default privileges state in effect.
+    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+    // needed to reach the final desired state.
+    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+      ctx.currentUser,
+      "composite_type",
+      ct.schema ?? "",
+    );
+    const creatorFilteredDefaults =
+      ct.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
+    // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
+    // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
+    const desiredPrivileges = filterPublicBuiltInDefaults(
+      "composite_type",
+      ct.privileges,
+    );
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Use the composite type owner as the reference.
+    const privilegeResults = diffPrivileges(
+      filterPublicBuiltInDefaults("composite_type", creatorFilteredDefaults),
+      desiredPrivileges,
+      ct.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        ct,
+        ct,
+        "compositeType",
+        {
+          Grant: GrantCompositeTypePrivileges,
+          Revoke: RevokeCompositeTypePrivileges,
+          RevokeGrantOption: RevokeGrantOptionCompositeTypePrivileges,
+        },
+        ctx.version,
+      ) as CompositeTypeChange[]),
+    );
+  }
+
+  for (const compositeTypeId of dropped) {
+    changes.push(
+      new DropCompositeType({ compositeType: main[compositeTypeId] }),
+    );
+  }
+
+  for (const compositeTypeId of altered) {
+    const mainCompositeType = main[compositeTypeId];
+    const branchCompositeType = branch[compositeTypeId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the composite type
+    const NON_ALTERABLE_FIELDS: Array<keyof CompositeType> = [
+      "row_security",
+      "force_row_security",
+      "has_indexes",
+      "has_rules",
+      "has_triggers",
+      "has_subclasses",
+      "is_populated",
+      "replica_identity",
+      "is_partition",
+      "options",
+      "partition_bound",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainCompositeType,
+      branchCompositeType,
+      NON_ALTERABLE_FIELDS,
+      { options: deepEqual },
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replacement is not performed automatically for composite types
+      // to avoid destructive operations; keep changes minimal.
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainCompositeType.owner !== branchCompositeType.owner) {
+        changes.push(
+          new AlterCompositeTypeChangeOwner({
+            compositeType: mainCompositeType,
+            owner: branchCompositeType.owner,
+          }),
+        );
+      }
+
+      // TYPE COMMENT (create/drop when comment changes)
+      if (mainCompositeType.comment !== branchCompositeType.comment) {
+        if (branchCompositeType.comment === null) {
+          changes.push(
+            new DropCommentOnCompositeType({
+              compositeType: mainCompositeType,
+            }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnCompositeType({
+              compositeType: branchCompositeType,
+            }),
+          );
+        }
+      }
+
+      // ATTRIBUTE diffs
+      const mainAttrs = new Map(
+        mainCompositeType.columns.map((c) => [c.name, c]),
+      );
+      const branchAttrs = new Map(
+        branchCompositeType.columns.map((c) => [c.name, c]),
+      );
+
+      // Added attributes
+      for (const [name, attr] of branchAttrs) {
+        if (!mainAttrs.has(name)) {
+          changes.push(
+            new AlterCompositeTypeAddAttribute({
+              compositeType: branchCompositeType,
+              attribute: attr,
+            }),
+          );
+          if (attr.comment !== null) {
+            changes.push(
+              new CreateCommentOnCompositeTypeAttribute({
+                compositeType: branchCompositeType,
+                attribute: attr,
+              }),
+            );
+          }
+        }
+      }
+
+      // Dropped attributes
+      for (const [name, attr] of mainAttrs) {
+        if (!branchAttrs.has(name)) {
+          changes.push(
+            new AlterCompositeTypeDropAttribute({
+              compositeType: mainCompositeType,
+              attribute: attr,
+            }),
+          );
+        }
+      }
+
+      // Altered attribute type/collation
+      for (const [name, mainAttr] of mainAttrs) {
+        const branchAttr = branchAttrs.get(name);
+        if (!branchAttr) continue;
+        if (
+          mainAttr.data_type_str !== branchAttr.data_type_str ||
+          mainAttr.collation !== branchAttr.collation
+        ) {
+          changes.push(
+            new AlterCompositeTypeAlterAttributeType({
+              compositeType: branchCompositeType,
+              attribute: branchAttr,
+            }),
+          );
+        }
+
+        // COMMENT change on attribute
+        if (mainAttr.comment !== branchAttr.comment) {
+          if (branchAttr.comment === null) {
+            changes.push(
+              new DropCommentOnCompositeTypeAttribute({
+                compositeType: mainCompositeType,
+                attribute: mainAttr,
+              }),
+            );
+          } else {
+            changes.push(
+              new CreateCommentOnCompositeTypeAttribute({
+                compositeType: branchCompositeType,
+                attribute: branchAttr,
+              }),
+            );
+          }
+        }
+      }
+
+      // PRIVILEGES
+      // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+      // (PostgreSQL grants it automatically, so we shouldn't compare it)
+      const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "composite_type",
+        mainCompositeType.privileges,
+      );
+      // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+      const branchPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "composite_type",
+        branchCompositeType.privileges,
+      );
+      // Filter out owner privileges - owner always has ALL privileges implicitly
+      // and shouldn't be compared. Use branch owner as the reference.
+      const privilegeResults = diffPrivileges(
+        mainPrivilegesFiltered,
+        branchPrivilegesFiltered,
+        branchCompositeType.owner,
+      );
+
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchCompositeType,
+          mainCompositeType,
+          "compositeType",
+          {
+            Grant: GrantCompositeTypePrivileges,
+            Revoke: RevokeCompositeTypePrivileges,
+            RevokeGrantOption: RevokeGrantOptionCompositeTypePrivileges,
+          },
+          ctx.version,
+        ) as CompositeTypeChange[]),
+      );
+
+      // Note: Composite type renaming would also use ALTER TYPE ... RENAME TO ...
+      // But since our CompositeType model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+    }
+  }
+
+  return changes;
+}

package/src/core/objects/type/composite-type/composite-type.model.ts

@@ -0,0 +1,253 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import {
+  BasePgModel,
+  columnPropsSchema,
+  type TableLikeObject,
+} from "../../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../../base.privilege-diff.ts";
+import { ReplicaIdentitySchema } from "../../table/table.model.ts";
+
+const compositeTypePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  row_security: z.boolean(),
+  force_row_security: z.boolean(),
+  has_indexes: z.boolean(),
+  has_rules: z.boolean(),
+  has_triggers: z.boolean(),
+  has_subclasses: z.boolean(),
+  is_populated: z.boolean(),
+  replica_identity: ReplicaIdentitySchema,
+  is_partition: z.boolean(),
+  options: z.array(z.string()).nullable(),
+  partition_bound: z.string().nullable(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+  columns: z.array(columnPropsSchema),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type CompositeTypePrivilegeProps = PrivilegeProps;
+export type CompositeTypeProps = z.infer<typeof compositeTypePropsSchema>;
+
+export class CompositeType extends BasePgModel implements TableLikeObject {
+  public readonly schema: CompositeTypeProps["schema"];
+  public readonly name: CompositeTypeProps["name"];
+  public readonly row_security: CompositeTypeProps["row_security"];
+  public readonly force_row_security: CompositeTypeProps["force_row_security"];
+  public readonly has_indexes: CompositeTypeProps["has_indexes"];
+  public readonly has_rules: CompositeTypeProps["has_rules"];
+  public readonly has_triggers: CompositeTypeProps["has_triggers"];
+  public readonly has_subclasses: CompositeTypeProps["has_subclasses"];
+  public readonly is_populated: CompositeTypeProps["is_populated"];
+  public readonly replica_identity: CompositeTypeProps["replica_identity"];
+  public readonly is_partition: CompositeTypeProps["is_partition"];
+  public readonly options: CompositeTypeProps["options"];
+  public readonly partition_bound: CompositeTypeProps["partition_bound"];
+  public readonly owner: CompositeTypeProps["owner"];
+  public readonly comment: CompositeTypeProps["comment"];
+  public readonly columns: CompositeTypeProps["columns"];
+  public readonly privileges: CompositeTypePrivilegeProps[];
+
+  constructor(props: CompositeTypeProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.row_security = props.row_security;
+    this.force_row_security = props.force_row_security;
+    this.has_indexes = props.has_indexes;
+    this.has_rules = props.has_rules;
+    this.has_triggers = props.has_triggers;
+    this.has_subclasses = props.has_subclasses;
+    this.is_populated = props.is_populated;
+    this.replica_identity = props.replica_identity;
+    this.is_partition = props.is_partition;
+    this.options = props.options;
+    this.partition_bound = props.partition_bound;
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.columns = props.columns;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `type:${string}` {
+    return `type:${this.schema}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      row_security: this.row_security,
+      force_row_security: this.force_row_security,
+      has_indexes: this.has_indexes,
+      has_rules: this.has_rules,
+      has_triggers: this.has_triggers,
+      has_subclasses: this.has_subclasses,
+      is_populated: this.is_populated,
+      replica_identity: this.replica_identity,
+      is_partition: this.is_partition,
+      options: this.options,
+      partition_bound: this.partition_bound,
+      owner: this.owner,
+      comment: this.comment,
+      columns: this.columns,
+      privileges: this.privileges,
+    };
+  }
+
+  override stableSnapshot() {
+    const normalizeColumns = () =>
+      [...this.columns]
+        .map((col) => {
+          const { position: _pos, ...rest } = col as unknown as Record<
+            string,
+            unknown
+          >;
+          return rest;
+        })
+        .sort((a, b) => {
+          const nameA = (a.name as string | undefined) ?? "";
+          const nameB = (b.name as string | undefined) ?? "";
+          return nameA.localeCompare(nameB);
+        });
+
+    return {
+      identity: this.identityFields,
+      data: {
+        ...this.dataFields,
+        columns: normalizeColumns(),
+      },
+    };
+  }
+}
+
+export async function extractCompositeTypes(
+  pool: Pool,
+): Promise<CompositeType[]> {
+  const { rows: compositeTypeRows } = await pool.query<CompositeTypeProps>(sql`
+      WITH extension_oids AS (
+        SELECT objid
+        FROM pg_depend d
+        WHERE d.refclassid = 'pg_extension'::regclass
+          AND d.classid    = 'pg_type'::regclass
+      ),
+      composite_types AS (
+        SELECT
+          c.relnamespace::regnamespace::text AS schema,
+          quote_ident(c.relname)              AS name,
+          c.relrowsecurity                    AS row_security,
+          c.relforcerowsecurity               AS force_row_security,
+          c.relhasindex                       AS has_indexes,
+          c.relhasrules                       AS has_rules,
+          c.relhastriggers                    AS has_triggers,
+          c.relhassubclass                    AS has_subclasses,
+          c.relispopulated                    AS is_populated,
+          c.relreplident                      AS replica_identity,
+          c.relispartition                    AS is_partition,
+          c.reloptions                        AS options,
+          pg_get_expr(c.relpartbound, c.oid)  AS partition_bound,
+          c.relowner::regrole::text           AS owner,
+          obj_description(c.reltype, 'pg_type') AS comment,
+          c.relacl                            AS relacl,    -- used by privileges LATERAL
+          c.relowner                          AS relowner,
+          c.oid                                AS oid
+        FROM pg_catalog.pg_class c
+        LEFT JOIN extension_oids e ON c.reltype = e.objid
+        WHERE NOT c.relnamespace::regnamespace::text LIKE ANY (ARRAY['pg\\_%', 'information\\_schema'])
+          AND e.objid IS NULL
+          AND c.relkind = 'c'
+      )
+      SELECT
+        ct.schema,
+        ct.name,
+        ct.row_security,
+        ct.force_row_security,
+        ct.has_indexes,
+        ct.has_rules,
+        ct.has_triggers,
+        ct.has_subclasses,
+        ct.is_populated,
+        ct.replica_identity,
+        ct.is_partition,
+        ct.options,
+        ct.partition_bound,
+        ct.owner,
+        ct.comment,
+        COALESCE(priv.privileges, '[]') AS privileges,
+        COALESCE(cols.columns, '[]')    AS columns
+      FROM composite_types ct
+
+      -- privileges as a per-row LATERAL subquery
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+                json_build_object(
+                  'grantee',   CASE WHEN x.grantee = 0 THEN 'PUBLIC' ELSE x.grantee::regrole::text END,
+                  'privilege', x.privilege_type,
+                  'grantable', x.is_grantable
+                )
+                ORDER BY x.grantee, x.privilege_type
+              ) AS privileges
+        FROM LATERAL aclexplode(COALESCE(ct.relacl, acldefault('T', ct.relowner))) AS x(grantor, grantee, privilege_type, is_grantable)
+      ) priv ON TRUE
+
+      -- columns as a per-row LATERAL subquery (so no GROUP BY needed)
+      LEFT JOIN LATERAL (
+        SELECT json_agg(
+                json_build_object(
+                  'name',                 quote_ident(a.attname),
+                  'position',             a.attnum,
+                  'data_type',            a.atttypid::regtype::text,
+                  'data_type_str',        format_type(a.atttypid, a.atttypmod),
+                  'is_custom_type',       ty.typnamespace::regnamespace::text NOT IN ('pg_catalog','information_schema'),
+                  'custom_type_type',     CASE WHEN ty.typnamespace::regnamespace::text NOT IN ('pg_catalog','information_schema') THEN ty.typtype    ELSE NULL END,
+                  'custom_type_category', CASE WHEN ty.typnamespace::regnamespace::text NOT IN ('pg_catalog','information_schema') THEN ty.typcategory ELSE NULL END,
+                  'custom_type_schema',   CASE WHEN ty.typnamespace::regnamespace::text NOT IN ('pg_catalog','information_schema') THEN ty.typnamespace::regnamespace ELSE NULL END,
+                  'custom_type_name',     CASE WHEN ty.typnamespace::regnamespace::text NOT IN ('pg_catalog','information_schema') THEN quote_ident(ty.typname) ELSE NULL END,
+                  'not_null',             a.attnotnull,
+                  'is_identity',          a.attidentity <> '',
+                  'is_identity_always',   a.attidentity = 'a',
+                  'is_generated',         a.attgenerated <> '',
+                  'collation', (
+                    SELECT quote_ident(c2.collname)
+                    FROM pg_collation c2, pg_type t2
+                    WHERE c2.oid = a.attcollation
+                      AND t2.oid = a.atttypid
+                      AND a.attcollation <> t2.typcollation
+                  ),
+                  'default',              pg_get_expr(ad.adbin, ad.adrelid),
+                  'comment',              col_description(a.attrelid, a.attnum)
+                )
+                ORDER BY a.attnum
+              ) AS columns
+        FROM pg_attribute a
+        LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
+        LEFT JOIN pg_type    ty ON ty.oid     = a.atttypid
+        WHERE a.attrelid = ct.oid
+          AND a.attnum > 0
+          AND NOT a.attisdropped
+      ) cols ON TRUE
+
+      ORDER BY ct.schema, ct.name
+  `);
+
+  // Validate and parse each row using the Zod schema
+  const validatedRows = compositeTypeRows.map((row: unknown) =>
+    compositeTypePropsSchema.parse(row),
+  );
+  return validatedRows.map((row: CompositeTypeProps) => new CompositeType(row));
+}

package/src/core/objects/type/enum/changes/enum.alter.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Enum, type EnumProps } from "../enum.model.ts";
+import { AlterEnumAddValue, AlterEnumChangeOwner } from "./enum.alter.ts";
+
+describe.concurrent("enum", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: Omit<EnumProps, "owner"> = {
+        schema: "public",
+        name: "test_enum",
+        labels: [
+          { sort_order: 1, label: "value1" },
+          { sort_order: 2, label: "value2" },
+        ],
+        comment: null,
+        privileges: [],
+      };
+      const main = new Enum({
+        ...props,
+        owner: "old_owner",
+      });
+      const change = new AlterEnumChangeOwner({
+        enum: main,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER TYPE public.test_enum OWNER TO new_owner",
+      );
+    });
+
+    test("add value", async () => {
+      const props: EnumProps = {
+        schema: "public",
+        name: "test_enum",
+        owner: "test",
+        labels: [
+          { sort_order: 1, label: "value1" },
+          { sort_order: 2, label: "value2" },
+        ],
+        comment: null,
+        privileges: [],
+      };
+      const main = new Enum(props);
+      const change = new AlterEnumAddValue({ enum: main, newValue: "value3" });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER TYPE public.test_enum ADD VALUE 'value3'",
+      );
+    });
+
+    test("add value before", async () => {
+      const props: EnumProps = {
+        schema: "public",
+        name: "test_enum",
+        owner: "test",
+        labels: [
+          { sort_order: 1, label: "value1" },
+          { sort_order: 2, label: "value2" },
+        ],
+        comment: null,
+        privileges: [],
+      };
+      const main = new Enum(props);
+      const change = new AlterEnumAddValue({
+        enum: main,
+        newValue: "value1_5",
+        position: { before: "value2" },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER TYPE public.test_enum ADD VALUE 'value1_5' BEFORE 'value2'",
+      );
+    });
+
+    test("add value after", async () => {
+      const props: EnumProps = {
+        schema: "public",
+        name: "test_enum",
+        owner: "test",
+        labels: [
+          { sort_order: 1, label: "value1" },
+          { sort_order: 2, label: "value2" },
+        ],
+        comment: null,
+        privileges: [],
+      };
+      const main = new Enum(props);
+      const change = new AlterEnumAddValue({
+        enum: main,
+        newValue: "value1_5",
+        position: { after: "value1" },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER TYPE public.test_enum ADD VALUE 'value1_5' AFTER 'value1'",
+      );
+    });
+
+    test("complex enum changes are not auto-replaced", async () => {
+      expect(1).toBe(1);
+    });
+  });
+});