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

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);
+    });
+  });
+});

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

@@ -0,0 +1,92 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import type { Enum } from "../enum.model.ts";
+import { AlterEnumChange } from "./enum.base.ts";
+
+/**
+ * Alter an enum.
+ *
+ * @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 ADD VALUE [ IF NOT EXISTS ] new_enum_value [ { BEFORE | AFTER } neighbor_enum_value ]
+ * ALTER TYPE name RENAME VALUE existing_enum_value TO new_enum_value
+ * ```
+ */
+
+export type AlterEnum = AlterEnumAddValue | AlterEnumChangeOwner;
+
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export class AlterEnumChangeOwner extends AlterEnumChange {
+  public readonly enum: Enum;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { enum: Enum; owner: string }) {
+    super();
+    this.enum = props.enum;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "ALTER TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER TYPE ... ADD VALUE ...
+ */
+export class AlterEnumAddValue extends AlterEnumChange {
+  public readonly enum: Enum;
+  public readonly newValue: string;
+  public readonly position?: { before?: string; after?: string };
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    enum: Enum;
+    newValue: string;
+    position?: { before?: string; after?: string };
+  }) {
+    super();
+    this.enum = props.enum;
+    this.newValue = props.newValue;
+    this.position = props.position;
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
+      "ALTER TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "ADD VALUE",
+      quoteLiteral(this.newValue),
+    ];
+
+    if (this.position?.before) {
+      parts.push("BEFORE", quoteLiteral(this.position.before));
+    } else if (this.position?.after) {
+      parts.push("AFTER", quoteLiteral(this.position.after));
+    }
+
+    return parts.join(" ");
+  }
+}
+
+// NOTE: ReplaceEnum removed. Complex enum changes should be handled in diff with Drop + Create when needed.

package/src/core/objects/type/enum/changes/enum.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { Enum } from "../enum.model.ts";
+
+abstract class BaseEnumChange extends BaseChange {
+  abstract readonly enum: Enum;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "enum" = "enum";
+}
+
+export abstract class CreateEnumChange extends BaseEnumChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterEnumChange extends BaseEnumChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropEnumChange extends BaseEnumChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/type/enum/changes/enum.comment.ts

@@ -0,0 +1,65 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { Enum } from "../enum.model.ts";
+import { CreateEnumChange, DropEnumChange } from "./enum.base.ts";
+
+/**
+ * Create/drop comments on enum types.
+ */
+
+export type CommentEnum = CreateCommentOnEnum | DropCommentOnEnum;
+
+export class CreateCommentOnEnum extends CreateEnumChange {
+  public readonly enum: Enum;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { enum: Enum }) {
+    super();
+    this.enum = props.enum;
+  }
+
+  get creates() {
+    return [stableId.comment(this.enum.stableId)];
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: enum comment is not nullable in this case
+      quoteLiteral(this.enum.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnEnum extends DropEnumChange {
+  public readonly enum: Enum;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { enum: Enum }) {
+    super();
+    this.enum = props.enum;
+  }
+
+  get drops() {
+    return [stableId.comment(this.enum.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.enum.stableId), this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON TYPE",
+      `${this.enum.schema}.${this.enum.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Enum } from "../enum.model.ts";
+import { CreateEnum } from "./enum.create.ts";
+
+describe("enum", () => {
+  test("create", async () => {
+    const enumType = new Enum({
+      schema: "public",
+      name: "test_enum",
+      owner: "test",
+      labels: [
+        { sort_order: 1, label: "value1" },
+        { sort_order: 2, label: "value2" },
+        { sort_order: 3, label: "value3" },
+      ],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateEnum({
+      enum: enumType,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE TYPE public.test_enum AS ENUM ('value1', 'value2', 'value3')",
+    );
+  });
+});

package/src/core/objects/type/enum/changes/enum.create.ts

@@ -0,0 +1,57 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { Enum } from "../enum.model.ts";
+import { CreateEnumChange } from "./enum.base.ts";
+
+/**
+ * Create an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS ENUM ( [ label [, ...] ] )
+ * ```
+ */
+export class CreateEnum extends CreateEnumChange {
+  public readonly enum: Enum;
+  public readonly scope = "object" as const;
+
+  constructor(props: { enum: Enum }) {
+    super();
+    this.enum = props.enum;
+  }
+
+  get creates() {
+    return [this.enum.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.enum.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.enum.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts: string[] = ["CREATE TYPE"];
+
+    // Add schema and name
+    parts.push(`${this.enum.schema}.${this.enum.name}`);
+
+    // Add AS ENUM
+    parts.push("AS ENUM");
+
+    // Add labels
+    const labels = this.enum.labels.map((label) => quoteLiteral(label.label));
+    parts.push(`(${labels.join(", ")})`);
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Enum } from "../enum.model.ts";
+import { DropEnum } from "./enum.drop.ts";
+
+describe("enum", () => {
+  test("drop", async () => {
+    const enumType = new Enum({
+      schema: "public",
+      name: "test_enum",
+      owner: "test",
+      labels: [
+        { sort_order: 1, label: "value1" },
+        { sort_order: 2, label: "value2" },
+      ],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropEnum({
+      enum: enumType,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP TYPE public.test_enum");
+  });
+});

package/src/core/objects/type/enum/changes/enum.drop.ts

@@ -0,0 +1,35 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import type { Enum } from "../enum.model.ts";
+import { DropEnumChange } from "./enum.base.ts";
+
+/**
+ * Drop an enum.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptype.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropEnum extends DropEnumChange {
+  public readonly enum: Enum;
+  public readonly scope = "object" as const;
+
+  constructor(props: { enum: Enum }) {
+    super();
+    this.enum = props.enum;
+  }
+
+  get drops() {
+    return [this.enum.stableId];
+  }
+
+  get requires() {
+    return [this.enum.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return ["DROP TYPE", `${this.enum.schema}.${this.enum.name}`].join(" ");
+  }
+}