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

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

@@ -0,0 +1,95 @@
+import { isUserDefinedTypeSchema, stableId } from "../../../utils.ts";
+import type { CompositeType } from "../composite-type.model.ts";
+import { CreateCompositeTypeChange } from "./composite-type.base.ts";
+
+/**
+ * Create a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS
+ *     ( [ attribute_name data_type [ COLLATE collation ] [, ... ] ] )
+ * ```
+ */
+export class CreateCompositeType extends CreateCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly scope = "object" as const;
+
+  constructor(props: { compositeType: CompositeType }) {
+    super();
+    this.compositeType = props.compositeType;
+  }
+
+  get creates() {
+    return [this.compositeType.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.compositeType.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.compositeType.owner));
+
+    // Column type dependencies (user-defined types only)
+    for (const col of this.compositeType.columns) {
+      if (
+        col.is_custom_type &&
+        col.custom_type_schema &&
+        col.custom_type_name
+      ) {
+        dependencies.add(
+          stableId.type(col.custom_type_schema, col.custom_type_name),
+        );
+      }
+
+      // Collation dependency (if non-default)
+      if (col.collation) {
+        const unquotedCollation = col.collation.replace(/^"|"$/g, "");
+        const collationParts = unquotedCollation.split(".");
+        if (collationParts.length === 2) {
+          const [collationSchema, collationName] = collationParts;
+          if (isUserDefinedTypeSchema(collationSchema)) {
+            dependencies.add(
+              stableId.collation(collationSchema, collationName),
+            );
+          }
+        }
+      }
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE TYPE"];
+
+    // Add schema and name
+    parts.push(`${this.compositeType.schema}.${this.compositeType.name}`);
+
+    // Add AS keyword
+    parts.push("AS");
+
+    parts.push(
+      `(${this.compositeType.columns
+        .map((column) => {
+          const tokens: string[] = [];
+          // attribute name and data type
+          tokens.push(column.name);
+          tokens.push(column.data_type_str);
+          // Collation (only when non-default, already filtered by extractor)
+          if (column.collation) {
+            tokens.push("COLLATE", column.collation);
+          }
+          return tokens.join(" ");
+        })
+        .join(", ")})`,
+    );
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { CompositeType } from "../composite-type.model.ts";
+import { DropCompositeType } from "./composite-type.drop.ts";
+
+describe("composite-type", () => {
+  test("drop", () => {
+    const compositeType = new CompositeType({
+      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,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new DropCompositeType({
+      compositeType,
+    });
+
+    expect(change.serialize()).toBe("DROP TYPE public.test_type");
+  });
+});

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

@@ -0,0 +1,37 @@
+import type { CompositeType } from "../composite-type.model.ts";
+import { DropCompositeTypeChange } from "./composite-type.base.ts";
+
+/**
+ * Drop a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptype.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TYPE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropCompositeType extends DropCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly scope = "object" as const;
+
+  constructor(props: { compositeType: CompositeType }) {
+    super();
+    this.compositeType = props.compositeType;
+  }
+
+  get drops() {
+    return [this.compositeType.stableId];
+  }
+
+  get requires() {
+    return [this.compositeType.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "DROP TYPE",
+      `${this.compositeType.schema}.${this.compositeType.name}`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,175 @@
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../../base.privilege.ts";
+import { stableId } from "../../../utils.ts";
+import type { CompositeType } from "../composite-type.model.ts";
+import { AlterCompositeTypeChange } from "./composite-type.base.ts";
+
+export type CompositeTypePrivilege =
+  | GrantCompositeTypePrivileges
+  | RevokeCompositeTypePrivileges
+  | RevokeGrantOptionCompositeTypePrivileges;
+
+/**
+ * Grant privileges on a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantCompositeTypePrivileges extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.compositeType.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.compositeType.stableId, stableId.role(this.grantee)];
+  }
+
+  serialize(): string {
+    const hasGrantable = this.privileges.some((p) => p.grantable);
+    const hasBase = this.privileges.some((p) => !p.grantable);
+    if (hasGrantable && hasBase) {
+      throw new Error(
+        "GrantCompositeTypePrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+    const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+    return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeCompositeTypePrivileges extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get drops() {
+    // Return ACL ID for dependency tracking, even though this is an ALTER operation
+    // Phase assignment now uses operation type, so this won't affect phase placement
+    return [stableId.acl(this.compositeType.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.compositeType.stableId, this.grantee),
+      this.compositeType.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+    const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+    return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a composite type.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionCompositeTypePrivileges extends AlterCompositeTypeChange {
+  public readonly compositeType: CompositeType;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    compositeType: CompositeType;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.compositeType = props.compositeType;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.compositeType.stableId, this.grantee),
+      this.compositeType.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("TYPE");
+    const privSql = formatObjectPrivilegeList(
+      "TYPE",
+      this.privilegeNames,
+      this.version,
+    );
+    const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { AlterCompositeType } from "./composite-type.alter.ts";
+import type { CommentCompositeType } from "./composite-type.comment.ts";
+import type { CreateCompositeType } from "./composite-type.create.ts";
+import type { DropCompositeType } from "./composite-type.drop.ts";
+import type { CompositeTypePrivilege } from "./composite-type.privilege.ts";
+
+export type CompositeTypeChange =
+  | AlterCompositeType
+  | CommentCompositeType
+  | CreateCompositeType
+  | DropCompositeType
+  | CompositeTypePrivilege;

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

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import {
+  AlterCompositeTypeAddAttribute,
+  AlterCompositeTypeAlterAttributeType,
+  AlterCompositeTypeChangeOwner,
+  AlterCompositeTypeDropAttribute,
+} from "./changes/composite-type.alter.ts";
+import { CreateCompositeType } from "./changes/composite-type.create.ts";
+import { DropCompositeType } from "./changes/composite-type.drop.ts";
+import { diffCompositeTypes } from "./composite-type.diff.ts";
+import {
+  CompositeType,
+  type CompositeTypeProps,
+} from "./composite-type.model.ts";
+
+const base: CompositeTypeProps = {
+  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: true,
+  replica_identity: "d",
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  owner: "o1",
+  comment: null,
+  columns: [],
+  privileges: [],
+};
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("composite-type.diff", () => {
+  test("create and drop", () => {
+    const ct = new CompositeType(base);
+    const created = diffCompositeTypes(testContext, {}, { [ct.stableId]: ct });
+    expect(created[0]).toBeInstanceOf(CreateCompositeType);
+    const dropped = diffCompositeTypes(testContext, { [ct.stableId]: ct }, {});
+    expect(dropped[0]).toBeInstanceOf(DropCompositeType);
+  });
+
+  test("alter owner", () => {
+    const main = new CompositeType(base);
+    const branch = new CompositeType({ ...base, owner: "o2" });
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterCompositeTypeChangeOwner);
+  });
+
+  test("add attribute", () => {
+    const main = new CompositeType(base);
+    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 changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterCompositeTypeAddAttribute),
+    ).toBe(true);
+  });
+
+  test("drop attribute", () => {
+    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,
+        },
+      ],
+    });
+    const branch = new CompositeType(base);
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterCompositeTypeDropAttribute),
+    ).toBe(true);
+  });
+
+  test("alter attribute type/collation", () => {
+    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,
+        },
+      ],
+    });
+    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,
+        },
+      ],
+    });
+    const changes = diffCompositeTypes(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterCompositeTypeAlterAttributeType),
+    ).toBe(true);
+  });
+});