@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

package/dist/core/objects/rls-policy/changes/rls-policy.comment.d.ts

@@ -0,0 +1,23 @@
+import type { RlsPolicy } from "../rls-policy.model.ts";
+import { CreateRlsPolicyChange, DropRlsPolicyChange } from "./rls-policy.base.ts";
+export type CommentRlsPolicy = CreateCommentOnRlsPolicy | DropCommentOnRlsPolicy;
+export declare class CreateCommentOnRlsPolicy extends CreateRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly scope: "comment";
+    constructor(props: {
+        policy: RlsPolicy;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `rlsPolicy:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnRlsPolicy extends DropRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly scope: "comment";
+    constructor(props: {
+        policy: RlsPolicy;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `rlsPolicy:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/rls-policy/changes/rls-policy.comment.js

@@ -0,0 +1,51 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateRlsPolicyChange, DropRlsPolicyChange, } from "./rls-policy.base.js";
+export class CreateCommentOnRlsPolicy extends CreateRlsPolicyChange {
+    policy;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+    }
+    get creates() {
+        return [stableId.comment(this.policy.stableId)];
+    }
+    get requires() {
+        return [this.policy.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON POLICY",
+            this.policy.name,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: rls policy comment is not nullable in this case
+            quoteLiteral(this.policy.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnRlsPolicy extends DropRlsPolicyChange {
+    policy;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+    }
+    get drops() {
+        return [stableId.comment(this.policy.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.policy.stableId), this.policy.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON POLICY",
+            this.policy.name,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/rls-policy/changes/rls-policy.create.d.ts

@@ -0,0 +1,27 @@
+import type { RlsPolicy } from "../rls-policy.model.ts";
+import { CreateRlsPolicyChange } from "./rls-policy.base.ts";
+/**
+ * Create an RLS policy.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createpolicy.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE POLICY name ON table_name
+ *     [ AS { PERMISSIVE | RESTRICTIVE } ]
+ *     [ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ]
+ *     [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ]
+ *     [ USING ( using_expression ) ]
+ *     [ WITH CHECK ( with_check_expression ) ]
+ * ```
+ */
+export declare class CreateRlsPolicy extends CreateRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly scope: "object";
+    constructor(props: {
+        policy: RlsPolicy;
+    });
+    get creates(): `rlsPolicy:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/rls-policy/changes/rls-policy.create.js

@@ -0,0 +1,79 @@
+import { stableId } from "../../utils.js";
+import { CreateRlsPolicyChange } from "./rls-policy.base.js";
+/**
+ * Create an RLS policy.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createpolicy.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE POLICY name ON table_name
+ *     [ AS { PERMISSIVE | RESTRICTIVE } ]
+ *     [ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ]
+ *     [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | SESSION_USER } [, ...] ]
+ *     [ USING ( using_expression ) ]
+ *     [ WITH CHECK ( with_check_expression ) ]
+ * ```
+ */
+export class CreateRlsPolicy extends CreateRlsPolicyChange {
+    policy;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+    }
+    get creates() {
+        return [this.policy.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.policy.schema));
+        // Table dependency
+        dependencies.add(stableId.table(this.policy.schema, this.policy.table_name));
+        // Owner dependency
+        dependencies.add(stableId.role(this.policy.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE POLICY"];
+        // Add policy name
+        parts.push(this.policy.name);
+        // Add ON table
+        parts.push("ON", `${this.policy.schema}.${this.policy.table_name}`);
+        // Add AS RESTRICTIVE only if false (default is PERMISSIVE)
+        if (!this.policy.permissive) {
+            parts.push("AS RESTRICTIVE");
+        }
+        // Add FOR command
+        const commandMap = {
+            r: "FOR SELECT",
+            a: "FOR INSERT",
+            w: "FOR UPDATE",
+            d: "FOR DELETE",
+            "*": "FOR ALL",
+        };
+        // Default is FOR ALL; only print when not default
+        if (this.policy.command && this.policy.command !== "*") {
+            parts.push(commandMap[this.policy.command]);
+        }
+        // Add TO roles
+        // Default is TO PUBLIC; avoid printing explicit PUBLIC in CREATE
+        if (this.policy.roles && this.policy.roles.length > 0) {
+            const onlyPublic = this.policy.roles.length === 1 &&
+                this.policy.roles[0].toLowerCase() === "public";
+            if (!onlyPublic) {
+                parts.push("TO", this.policy.roles.join(", "));
+            }
+        }
+        // Add USING expression
+        if (this.policy.using_expression) {
+            parts.push("USING", `(${this.policy.using_expression})`);
+        }
+        // Add WITH CHECK expression
+        if (this.policy.with_check_expression) {
+            parts.push("WITH CHECK", `(${this.policy.with_check_expression})`);
+        }
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/rls-policy/changes/rls-policy.drop.d.ts

@@ -0,0 +1,22 @@
+import type { RlsPolicy } from "../rls-policy.model.ts";
+import { DropRlsPolicyChange } from "./rls-policy.base.ts";
+/**
+ * Drop an RLS policy.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droppolicy.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP POLICY [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropRlsPolicy extends DropRlsPolicyChange {
+    readonly policy: RlsPolicy;
+    readonly scope: "object";
+    constructor(props: {
+        policy: RlsPolicy;
+    });
+    get drops(): `rlsPolicy:${string}`[];
+    get requires(): `rlsPolicy:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/rls-policy/changes/rls-policy.drop.js

@@ -0,0 +1,33 @@
+import { DropRlsPolicyChange } from "./rls-policy.base.js";
+/**
+ * Drop an RLS policy.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droppolicy.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP POLICY [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropRlsPolicy extends DropRlsPolicyChange {
+    policy;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.policy = props.policy;
+    }
+    get drops() {
+        return [this.policy.stableId];
+    }
+    get requires() {
+        return [this.policy.stableId];
+    }
+    serialize() {
+        return [
+            "DROP POLICY",
+            this.policy.name,
+            "ON",
+            `${this.policy.schema}.${this.policy.table_name}`,
+        ].join(" ");
+    }
+}

package/dist/core/objects/rls-policy/changes/rls-policy.types.d.ts

@@ -0,0 +1,5 @@
+import type { AlterRlsPolicy } from "./rls-policy.alter.ts";
+import type { CommentRlsPolicy } from "./rls-policy.comment.ts";
+import type { CreateRlsPolicy } from "./rls-policy.create.ts";
+import type { DropRlsPolicy } from "./rls-policy.drop.ts";
+export type RlsPolicyChange = AlterRlsPolicy | CommentRlsPolicy | CreateRlsPolicy | DropRlsPolicy;

package/dist/core/objects/rls-policy/changes/rls-policy.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/objects/rls-policy/rls-policy.diff.d.ts

@@ -0,0 +1,10 @@
+import type { RlsPolicyChange } from "./changes/rls-policy.types.ts";
+import type { RlsPolicy } from "./rls-policy.model.ts";
+/**
+ * Diff two sets of RLS policies from main and branch catalogs.
+ *
+ * @param main - The RLS policies in the main catalog.
+ * @param branch - The RLS policies in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffRlsPolicies(main: Record<string, RlsPolicy>, branch: Record<string, RlsPolicy>): RlsPolicyChange[];

package/dist/core/objects/rls-policy/rls-policy.diff.js

@@ -0,0 +1,80 @@
+import { diffObjects } from "../base.diff.js";
+import { deepEqual, hasNonAlterableChanges } from "../utils.js";
+import { AlterRlsPolicySetRoles, AlterRlsPolicySetUsingExpression, AlterRlsPolicySetWithCheckExpression, } from "./changes/rls-policy.alter.js";
+import { CreateCommentOnRlsPolicy, DropCommentOnRlsPolicy, } from "./changes/rls-policy.comment.js";
+import { CreateRlsPolicy } from "./changes/rls-policy.create.js";
+import { DropRlsPolicy } from "./changes/rls-policy.drop.js";
+/**
+ * Diff two sets of RLS policies from main and branch catalogs.
+ *
+ * @param main - The RLS policies in the main catalog.
+ * @param branch - The RLS policies in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffRlsPolicies(main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const rlsPolicyId of created) {
+        const policy = branch[rlsPolicyId];
+        changes.push(new CreateRlsPolicy({ policy: policy }));
+        if (policy.comment !== null) {
+            changes.push(new CreateCommentOnRlsPolicy({ policy }));
+        }
+    }
+    for (const rlsPolicyId of dropped) {
+        changes.push(new DropRlsPolicy({ policy: main[rlsPolicyId] }));
+    }
+    for (const rlsPolicyId of altered) {
+        const mainRlsPolicy = main[rlsPolicyId];
+        const branchRlsPolicy = branch[rlsPolicyId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the RLS policy
+        // These attributes require drop+create (Postgres has no ALTER for them)
+        const NON_ALTERABLE_FIELDS = [
+            "command",
+            "permissive",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainRlsPolicy, branchRlsPolicy, NON_ALTERABLE_FIELDS, {});
+        if (nonAlterablePropsChanged) {
+            // Replace the entire RLS policy (drop + create)
+            changes.push(new DropRlsPolicy({ policy: mainRlsPolicy }), new CreateRlsPolicy({ policy: branchRlsPolicy }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // ROLES (TO ...)
+            const rolesEqual = deepEqual(mainRlsPolicy.roles, branchRlsPolicy.roles);
+            if (!rolesEqual) {
+                changes.push(new AlterRlsPolicySetRoles({
+                    policy: mainRlsPolicy,
+                    roles: branchRlsPolicy.roles,
+                }));
+            }
+            // USING expression
+            if (mainRlsPolicy.using_expression !== branchRlsPolicy.using_expression) {
+                changes.push(new AlterRlsPolicySetUsingExpression({
+                    policy: mainRlsPolicy,
+                    usingExpression: branchRlsPolicy.using_expression,
+                }));
+            }
+            // WITH CHECK expression
+            if (mainRlsPolicy.with_check_expression !==
+                branchRlsPolicy.with_check_expression) {
+                changes.push(new AlterRlsPolicySetWithCheckExpression({
+                    policy: mainRlsPolicy,
+                    withCheckExpression: branchRlsPolicy.with_check_expression,
+                }));
+            }
+            // COMMENT
+            if (mainRlsPolicy.comment !== branchRlsPolicy.comment) {
+                if (branchRlsPolicy.comment === null) {
+                    changes.push(new DropCommentOnRlsPolicy({ policy: mainRlsPolicy }));
+                }
+                else {
+                    changes.push(new CreateCommentOnRlsPolicy({ policy: branchRlsPolicy }));
+                }
+            }
+            // Note: RLS policy renaming would require drop+create due to identity fields
+        }
+    }
+    return changes;
+}

package/dist/core/objects/rls-policy/rls-policy.model.d.ts

@@ -0,0 +1,52 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+declare const rlsPolicyPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    table_name: z.ZodString;
+    command: z.ZodEnum<{
+        a: "a";
+        r: "r";
+        w: "w";
+        d: "d";
+        "*": "*";
+    }>;
+    permissive: z.ZodBoolean;
+    roles: z.ZodArray<z.ZodString>;
+    using_expression: z.ZodNullable<z.ZodString>;
+    with_check_expression: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strip>;
+export type RlsPolicyProps = z.infer<typeof rlsPolicyPropsSchema>;
+export declare class RlsPolicy extends BasePgModel {
+    readonly schema: RlsPolicyProps["schema"];
+    readonly name: RlsPolicyProps["name"];
+    readonly table_name: RlsPolicyProps["table_name"];
+    readonly command: RlsPolicyProps["command"];
+    readonly permissive: RlsPolicyProps["permissive"];
+    readonly roles: RlsPolicyProps["roles"];
+    readonly using_expression: RlsPolicyProps["using_expression"];
+    readonly with_check_expression: RlsPolicyProps["with_check_expression"];
+    readonly owner: RlsPolicyProps["owner"];
+    readonly comment: RlsPolicyProps["comment"];
+    constructor(props: RlsPolicyProps);
+    get stableId(): `rlsPolicy:${string}`;
+    get identityFields(): {
+        schema: string;
+        table_name: string;
+        name: string;
+    };
+    get dataFields(): {
+        command: "a" | "r" | "w" | "d" | "*";
+        permissive: boolean;
+        roles: string[];
+        using_expression: string | null;
+        with_check_expression: string | null;
+        owner: string;
+        comment: string | null;
+    };
+}
+export declare function extractRlsPolicies(sql: Sql): Promise<RlsPolicy[]>;
+export {};

package/dist/core/objects/rls-policy/rls-policy.model.js

@@ -0,0 +1,127 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+const RlsPolicyCommandSchema = z.enum([
+    "r", // SELECT command
+    "a", // INSERT command (add)
+    "w", // UPDATE command (write)
+    "d", // DELETE command
+    "*", // ALL commands
+]);
+const rlsPolicyPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    table_name: z.string(),
+    command: RlsPolicyCommandSchema,
+    permissive: z.boolean(),
+    roles: z.array(z.string()),
+    using_expression: z.string().nullable(),
+    with_check_expression: z.string().nullable(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+});
+export class RlsPolicy extends BasePgModel {
+    schema;
+    name;
+    table_name;
+    command;
+    permissive;
+    roles;
+    using_expression;
+    with_check_expression;
+    owner;
+    comment;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        this.table_name = props.table_name;
+        // Data fields
+        this.command = props.command;
+        this.permissive = props.permissive;
+        this.roles = props.roles;
+        this.using_expression = props.using_expression;
+        this.with_check_expression = props.with_check_expression;
+        this.owner = props.owner;
+        this.comment = props.comment;
+    }
+    get stableId() {
+        return `rlsPolicy:${this.schema}.${this.table_name}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            table_name: this.table_name,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            command: this.command,
+            permissive: this.permissive,
+            roles: this.roles,
+            using_expression: this.using_expression,
+            with_check_expression: this.with_check_expression,
+            owner: this.owner,
+            comment: this.comment,
+        };
+    }
+}
+export async function extractRlsPolicies(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const policyRows = await sql `
+with extension_policy_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_policy'::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'
+)
+select
+  tc.relnamespace::regnamespace::text as schema,
+  quote_ident(p.polname) as name,
+  quote_ident(tc.relname) as table_name,
+  p.polcmd as command,
+  p.polpermissive as permissive,
+  case
+    when p.polroles = '{0}' then array['public']::text[]
+    else array(
+      select quote_ident(rolname)
+      from pg_catalog.pg_roles
+      where oid = any(p.polroles)
+      order by rolname
+    )
+  end as roles,
+  pg_get_expr(p.polqual, p.polrelid) as using_expression,
+  pg_get_expr(p.polwithcheck, p.polrelid) as with_check_expression,
+  tc.relowner::regrole::text as owner,
+  obj_description(p.oid, 'pg_policy') as comment
+from
+  pg_catalog.pg_policy p
+  inner join pg_catalog.pg_class tc on tc.oid = p.polrelid
+  left outer join extension_policy_oids e_policy on p.oid = e_policy.objid
+  left outer join extension_table_oids e_table on tc.oid = e_table.objid
+  where not tc.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e_policy.objid is null
+  and e_table.objid is null
+order by
+  1, 2;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = policyRows.map((row) => rlsPolicyPropsSchema.parse(row));
+        return validatedRows.map((row) => new RlsPolicy(row));
+    });
+}

package/dist/core/objects/role/changes/role.alter.d.ts

@@ -0,0 +1,78 @@
+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 declare class AlterRoleSetOptions extends AlterRoleChange {
+    readonly role: Role;
+    readonly options: string[];
+    readonly scope: "object";
+    constructor(props: {
+        role: Role;
+        options: string[];
+    });
+    get requires(): `role:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER ROLE ... SET/RESET configuration_parameter (single statement)
+ * Represents one action: SET key TO value, RESET key, or RESET ALL.
+ */
+export declare class AlterRoleSetConfig extends AlterRoleChange {
+    readonly role: Role;
+    readonly action: "set" | "reset" | "reset_all";
+    readonly key?: string;
+    readonly value?: string;
+    readonly scope: "object";
+    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";
+    });
+    get requires(): `role:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/role/changes/role.alter.js

@@ -0,0 +1,55 @@
+import { formatConfigValue } from "../../procedure/utils.js";
+import { AlterRoleChange } from "./role.base.js";
+/**
+ * ALTER ROLE ... WITH option [...]
+ * Emits only options that differ between main and branch.
+ */
+export class AlterRoleSetOptions extends AlterRoleChange {
+    role;
+    options;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.role = props.role;
+        this.options = props.options;
+    }
+    get requires() {
+        return [this.role.stableId];
+    }
+    serialize() {
+        const parts = ["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 {
+    role;
+    action;
+    key;
+    value;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.role = props.role;
+        this.action = props.action;
+        this.key = props.key;
+        this.value = props.value;
+    }
+    get requires() {
+        return [this.role.stableId];
+    }
+    serialize() {
+        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, this.value);
+        return `${head} SET ${this.key} TO ${formatted}`;
+    }
+}

package/dist/core/objects/role/changes/role.base.d.ts

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