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

package/src/core/objects/role/changes/role.alter.test.ts

@@ -0,0 +1,362 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Role, type RoleProps } from "../role.model.ts";
+import { AlterRoleSetOptions } from "./role.alter.ts";
+
+describe.concurrent("role", () => {
+  describe("alter", () => {
+    test("alter SUPERUSER", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["SUPERUSER"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH SUPERUSER");
+    });
+
+    test("alter NOSUPERUSER", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: true,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["NOSUPERUSER"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOSUPERUSER");
+    });
+
+    test("alter NOCREATEDB", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: true,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["NOCREATEDB"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOCREATEDB");
+    });
+
+    test("alter NOCREATEROLE", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: true,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["NOCREATEROLE"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOCREATEROLE");
+    });
+
+    test("alter INHERIT", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: false,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["INHERIT"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH INHERIT");
+    });
+
+    test("alter LOGIN", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["LOGIN"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH LOGIN");
+    });
+
+    test("alter NOREPLICATION", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: true,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["NOREPLICATION"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOREPLICATION");
+    });
+
+    test("alter NOBYPASSRLS", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: true,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["NOBYPASSRLS"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOBYPASSRLS");
+    });
+
+    test("alter CREATEROLE", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["CREATEROLE"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH CREATEROLE");
+    });
+
+    test("alter NOINHERIT", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["NOINHERIT"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOINHERIT");
+    });
+
+    test("alter NOLOGIN", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: true,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["NOLOGIN"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH NOLOGIN");
+    });
+
+    test("alter REPLICATION", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["REPLICATION"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH REPLICATION");
+    });
+
+    test("alter BYPASSRLS", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({ role, options: ["BYPASSRLS"] });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER ROLE r WITH BYPASSRLS");
+    });
+
+    test("alter multiple options ordering", async () => {
+      const role = new Role({
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_create_databases: false,
+        can_login: false,
+        can_replicate: false,
+        connection_limit: null,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: [
+          "SUPERUSER",
+          "CREATEDB",
+          "CREATEROLE",
+          "NOINHERIT",
+          "LOGIN",
+          "REPLICATION",
+          "BYPASSRLS",
+          "CONNECTION LIMIT 10",
+        ],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe(
+        "ALTER ROLE r WITH SUPERUSER CREATEDB CREATEROLE NOINHERIT LOGIN REPLICATION BYPASSRLS CONNECTION LIMIT 10",
+      );
+    });
+    test("alter flags and connection limit", async () => {
+      const props: Omit<
+        RoleProps,
+        "can_create_databases" | "connection_limit"
+      > = {
+        name: "r",
+        is_superuser: false,
+        can_inherit: true,
+        can_create_roles: false,
+        can_login: false,
+        can_replicate: false,
+        can_bypass_rls: false,
+        config: null,
+        comment: null,
+        members: [],
+        default_privileges: [],
+      };
+      const role = new Role({
+        ...props,
+        can_create_databases: false,
+        connection_limit: null,
+      });
+      const change = new AlterRoleSetOptions({
+        role,
+        options: ["CREATEDB", "CONNECTION LIMIT 3"],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe(
+        "ALTER ROLE r WITH CREATEDB CONNECTION LIMIT 3",
+      );
+    });
+  });
+});

package/src/core/objects/role/changes/role.alter.ts

@@ -0,0 +1,110 @@
+import { formatConfigValue } from "../../procedure/utils.ts";
+import type { Role } from "../role.model.ts";
+import { AlterRoleChange } from "./role.base.ts";
+
+/**
+ * Alter a role.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterrole.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER ROLE role_name [ WITH ] option [ ... ]
+ * where option can be:
+ *     SUPERUSER | NOSUPERUSER
+ *     | CREATEDB | NOCREATEDB
+ *     | CREATEROLE | NOCREATEROLE
+ *     | INHERIT | NOINHERIT
+ *     | LOGIN | NOLOGIN
+ *     | REPLICATION | NOREPLICATION
+ *     | BYPASSRLS | NOBYPASSRLS
+ *     | CONNECTION LIMIT connlimit
+ *     | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ *     | VALID UNTIL 'timestamp'
+ *     | IN ROLE role_name [, ...]
+ *     | IN GROUP role_name [, ...]
+ *     | ROLE role_name [, ...]
+ *     | ADMIN role_name [, ...]
+ *     | USER role_name [, ...]
+ *     | SYSID uid
+ *
+ * ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter { TO | = } { value | DEFAULT }
+ * ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] SET configuration_parameter FROM CURRENT
+ * ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] RESET configuration_parameter
+ * ALTER ROLE { role_specification | ALL } [ IN DATABASE database_name ] RESET ALL
+ * ```
+ */
+
+export type AlterRole = AlterRoleSetConfig | AlterRoleSetOptions;
+
+/**
+ * ALTER ROLE ... WITH option [...]
+ * Emits only options that differ between main and branch.
+ */
+export class AlterRoleSetOptions extends AlterRoleChange {
+  public readonly role: Role;
+  public readonly options: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: { role: Role; options: string[] }) {
+    super();
+    this.role = props.role;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.role.stableId];
+  }
+
+  serialize(): string {
+    const parts: string[] = ["ALTER ROLE", this.role.name];
+    return [...parts, "WITH", this.options.join(" ")].join(" ");
+  }
+}
+
+/**
+ * ALTER ROLE ... SET/RESET configuration_parameter (single statement)
+ * Represents one action: SET key TO value, RESET key, or RESET ALL.
+ */
+export class AlterRoleSetConfig extends AlterRoleChange {
+  public readonly role: Role;
+  public readonly action: "set" | "reset" | "reset_all";
+  public readonly key?: string;
+  public readonly value?: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { role: Role; action: "set"; key: string; value: string });
+  constructor(props: { role: Role; action: "reset"; key: string });
+  constructor(props: { role: Role; action: "reset_all" });
+  constructor(props: {
+    role: Role;
+    action: "set" | "reset" | "reset_all";
+    key?: string;
+    value?: string;
+  }) {
+    super();
+    this.role = props.role;
+    this.action = props.action;
+    this.key = props.key;
+    this.value = props.value;
+  }
+
+  get requires() {
+    return [this.role.stableId];
+  }
+
+  serialize(): string {
+    const head = ["ALTER ROLE", this.role.name].join(" ");
+    if (this.action === "reset_all") {
+      return `${head} RESET ALL`;
+    }
+    if (this.action === "reset") {
+      return `${head} RESET ${this.key}`;
+    }
+    const formatted = formatConfigValue(
+      this.key as string,
+      this.value as string,
+    );
+    return `${head} SET ${this.key} TO ${formatted}`;
+  }
+}

package/src/core/objects/role/changes/role.base.ts

@@ -0,0 +1,24 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Role } from "../role.model.ts";
+
+abstract class BaseRoleChange extends BaseChange {
+  abstract readonly role: Role;
+  abstract readonly scope:
+    | "object"
+    | "comment"
+    | "membership"
+    | "default_privilege";
+  readonly objectType: "role" = "role";
+}
+
+export abstract class CreateRoleChange extends BaseRoleChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterRoleChange extends BaseRoleChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropRoleChange extends BaseRoleChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/role/changes/role.comment.ts

@@ -0,0 +1,55 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Role } from "../role.model.ts";
+import { CreateRoleChange, DropRoleChange } from "./role.base.ts";
+
+export type CommentRole = CreateCommentOnRole | DropCommentOnRole;
+
+export class CreateCommentOnRole extends CreateRoleChange {
+  public readonly role: Role;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { role: Role }) {
+    super();
+    this.role = props.role;
+  }
+
+  get creates() {
+    return [stableId.comment(this.role.stableId)];
+  }
+
+  get requires() {
+    return [this.role.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON ROLE",
+      this.role.name,
+      "IS",
+      quoteLiteral(this.role.comment as string),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnRole extends DropRoleChange {
+  public readonly role: Role;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { role: Role }) {
+    super();
+    this.role = props.role;
+  }
+
+  get drops() {
+    return [stableId.comment(this.role.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.role.stableId), this.role.stableId];
+  }
+
+  serialize(): string {
+    return ["COMMENT ON ROLE", this.role.name, "IS NULL"].join(" ");
+  }
+}

package/src/core/objects/role/changes/role.create.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Role } from "../role.model.ts";
+import { CreateRole } from "./role.create.ts";
+
+describe("role", () => {
+  test("create minimal (omit defaults)", async () => {
+    const role = new Role({
+      name: "test_role",
+      is_superuser: false,
+      can_inherit: true,
+      can_create_roles: false,
+      can_create_databases: false,
+      can_login: true,
+      can_replicate: false,
+      connection_limit: null,
+      can_bypass_rls: false,
+      config: null,
+      comment: null,
+      members: [],
+      default_privileges: [],
+    });
+
+    const change = new CreateRole({
+      role,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("CREATE ROLE test_role WITH LOGIN");
+  });
+
+  test("create with all options (non-defaults only)", async () => {
+    const role = new Role({
+      name: "r_all",
+      is_superuser: true,
+      can_inherit: false,
+      can_create_roles: true,
+      can_create_databases: true,
+      can_login: true,
+      can_replicate: true,
+      connection_limit: 5,
+      can_bypass_rls: true,
+      config: null,
+      comment: null,
+      members: [],
+      default_privileges: [],
+    });
+
+    const change = new CreateRole({ role });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE ROLE r_all WITH SUPERUSER CREATEDB CREATEROLE NOINHERIT LOGIN REPLICATION BYPASSRLS CONNECTION LIMIT 5",
+    );
+  });
+});

package/src/core/objects/role/changes/role.create.ts

@@ -0,0 +1,102 @@
+import type { Role } from "../role.model.ts";
+import { CreateRoleChange } from "./role.base.ts";
+
+/**
+ * Create a role.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createrole.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE ROLE name [ [ WITH ] option [ ... ] ]
+ * where option can be:
+ *     SUPERUSER | NOSUPERUSER
+ *     | CREATEDB | NOCREATEDB
+ *     | CREATEROLE | NOCREATEROLE
+ *     | INHERIT | NOINHERIT
+ *     | LOGIN | NOLOGIN
+ *     | REPLICATION | NOREPLICATION
+ *     | BYPASSRLS | NOBYPASSRLS
+ *     | CONNECTION LIMIT connlimit
+ *     | [ ENCRYPTED ] PASSWORD 'password' | PASSWORD NULL
+ *     | VALID UNTIL 'timestamp'
+ *     | IN ROLE role_name [, ...]
+ *     | IN GROUP role_name [, ...]
+ *     | ROLE role_name [, ...]
+ *     | ADMIN role_name [, ...]
+ *     | USER role_name [, ...]
+ *     | SYSID uid
+ * ```
+ */
+export class CreateRole extends CreateRoleChange {
+  public readonly role: Role;
+  public readonly scope = "object" as const;
+
+  constructor(props: { role: Role }) {
+    super();
+    this.role = props.role;
+  }
+
+  get creates() {
+    return [this.role.stableId];
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE ROLE"];
+
+    // Add role name
+    parts.push(this.role.name);
+
+    // Add options (only non-default values)
+    const options: string[] = [];
+
+    // SUPERUSER (default is NOSUPERUSER)
+    if (this.role.is_superuser) {
+      options.push("SUPERUSER");
+    }
+
+    // CREATEDB (default is NOCREATEDB)
+    if (this.role.can_create_databases) {
+      options.push("CREATEDB");
+    }
+
+    // CREATEROLE (default is NOCREATEROLE)
+    if (this.role.can_create_roles) {
+      options.push("CREATEROLE");
+    }
+
+    // INHERIT (default is INHERIT, so only print if false)
+    if (!this.role.can_inherit) {
+      options.push("NOINHERIT");
+    }
+
+    // LOGIN (default is NOLOGIN)
+    if (this.role.can_login) {
+      options.push("LOGIN");
+    }
+
+    // REPLICATION (default is NOREPLICATION)
+    if (this.role.can_replicate) {
+      options.push("REPLICATION");
+    }
+
+    // BYPASSRLS (default is NOBYPASSRLS)
+    if (this.role.can_bypass_rls) {
+      options.push("BYPASSRLS");
+    }
+
+    // CONNECTION LIMIT
+    if (
+      this.role.connection_limit !== null &&
+      this.role.connection_limit !== -1
+    ) {
+      options.push(`CONNECTION LIMIT ${this.role.connection_limit}`);
+    }
+
+    if (options.length > 0) {
+      parts.push("WITH", options.join(" "));
+    }
+
+    return parts.join(" ");
+  }
+}