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

package/dist/core/objects/sequence/sequence.diff.js

@@ -0,0 +1,258 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { hasNonAlterableChanges } from "../utils.js";
+import { AlterSequenceSetOptions, AlterSequenceSetOwnedBy, } from "./changes/sequence.alter.js";
+import { CreateCommentOnSequence, DropCommentOnSequence, } from "./changes/sequence.comment.js";
+import { CreateSequence } from "./changes/sequence.create.js";
+import { DropSequence } from "./changes/sequence.drop.js";
+import { GrantSequencePrivileges, RevokeGrantOptionSequencePrivileges, RevokeSequencePrivileges, } from "./changes/sequence.privilege.js";
+/**
+ * Diff two sets of sequences from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The sequences in the main catalog.
+ * @param branch - The sequences in the branch catalog.
+ * @param branchTables - The tables in the branch catalog (used to check if owning tables are being dropped).
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffSequences(ctx, main, branch, branchTables = {}) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const sequenceId of created) {
+        const createdSeq = branch[sequenceId];
+        changes.push(new CreateSequence({ sequence: createdSeq }));
+        if (createdSeq.comment !== null) {
+            changes.push(new CreateCommentOnSequence({ sequence: createdSeq }));
+        }
+        // If the created sequence is OWNED BY a column, emit an ALTER to set it
+        if (createdSeq.owned_by_schema !== null &&
+            createdSeq.owned_by_table !== null &&
+            createdSeq.owned_by_column !== null) {
+            changes.push(new AlterSequenceSetOwnedBy({
+                sequence: createdSeq,
+                ownedBy: {
+                    schema: createdSeq.owned_by_schema,
+                    table: createdSeq.owned_by_table,
+                    column: createdSeq.owned_by_column,
+                },
+            }));
+        }
+        // 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, "sequence", createdSeq.schema ?? "");
+        const desiredPrivileges = createdSeq.privileges;
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the sequence owner as the reference.
+        // Superuser privileges are filtered inside diffPrivileges.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdSeq.owner, ctx.mainRoles);
+        // Generate grant changes
+        for (const [grantee, result] of privilegeResults) {
+            if (result.grants.length > 0) {
+                const grantGroups = groupPrivilegesByGrantable(result.grants);
+                for (const [grantable, list] of grantGroups) {
+                    void grantable;
+                    changes.push(new GrantSequencePrivileges({
+                        sequence: createdSeq,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke changes
+            if (result.revokes.length > 0) {
+                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                for (const [grantable, list] of revokeGroups) {
+                    void grantable;
+                    changes.push(new RevokeSequencePrivileges({
+                        sequence: createdSeq,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionSequencePrivileges({
+                    sequence: createdSeq,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const sequenceId of dropped) {
+        const sequence = main[sequenceId];
+        // Skip generating DROP SEQUENCE if the sequence is owned by a table that's being dropped.
+        // PostgreSQL automatically drops sequences owned by tables when the table is dropped,
+        // so generating DROP SEQUENCE would cause an error (sequence doesn't exist).
+        if (sequence.owned_by_schema &&
+            sequence.owned_by_table &&
+            sequence.owned_by_column) {
+            const ownedByTableId = `table:${sequence.owned_by_schema}.${sequence.owned_by_table}`;
+            // If the owning table doesn't exist in branch catalog, it's being dropped
+            // and will auto-drop this sequence, so skip generating DROP SEQUENCE
+            if (!(ownedByTableId in branchTables)) {
+                continue;
+            }
+        }
+        changes.push(new DropSequence({ sequence }));
+    }
+    for (const sequenceId of altered) {
+        const mainSequence = main[sequenceId];
+        const branchSequence = branch[sequenceId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the sequence
+        const NON_ALTERABLE_FIELDS = [
+            "data_type",
+            "persistence",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainSequence, branchSequence, NON_ALTERABLE_FIELDS);
+        if (nonAlterablePropsChanged) {
+            // Replace the entire sequence (drop + create)
+            changes.push(new DropSequence({ sequence: mainSequence }), new CreateSequence({ sequence: branchSequence }));
+            // Re-apply OWNED BY if present on branch
+            if (branchSequence.owned_by_schema !== null &&
+                branchSequence.owned_by_table !== null &&
+                branchSequence.owned_by_column !== null) {
+                changes.push(new AlterSequenceSetOwnedBy({
+                    sequence: branchSequence,
+                    ownedBy: {
+                        schema: branchSequence.owned_by_schema,
+                        table: branchSequence.owned_by_table,
+                        column: branchSequence.owned_by_column,
+                    },
+                }));
+            }
+            else if (mainSequence.owned_by_schema !== null ||
+                mainSequence.owned_by_table !== null ||
+                mainSequence.owned_by_column !== null) {
+                // If main had ownership but branch removed it, emit OWNED BY NONE
+                changes.push(new AlterSequenceSetOwnedBy({
+                    sequence: mainSequence,
+                    ownedBy: null,
+                }));
+            }
+        }
+        else {
+            // Only alterable properties changed - emit ALTER for options/owner
+            const optionsChanged = mainSequence.increment !== branchSequence.increment ||
+                mainSequence.minimum_value !== branchSequence.minimum_value ||
+                mainSequence.maximum_value !== branchSequence.maximum_value ||
+                mainSequence.start_value !== branchSequence.start_value ||
+                mainSequence.cache_size !== branchSequence.cache_size ||
+                mainSequence.cycle_option !== branchSequence.cycle_option;
+            if (optionsChanged) {
+                const options = [];
+                if (mainSequence.increment !== branchSequence.increment) {
+                    options.push("INCREMENT BY", String(branchSequence.increment));
+                }
+                if (mainSequence.minimum_value !== branchSequence.minimum_value) {
+                    const defaultMin = BigInt(1);
+                    if (branchSequence.minimum_value === defaultMin) {
+                        options.push("NO MINVALUE");
+                    }
+                    else {
+                        options.push("MINVALUE", branchSequence.minimum_value.toString());
+                    }
+                }
+                if (mainSequence.maximum_value !== branchSequence.maximum_value) {
+                    const defaultMax = branchSequence.data_type === "integer"
+                        ? BigInt("2147483647")
+                        : BigInt("9223372036854775807");
+                    if (branchSequence.maximum_value === defaultMax) {
+                        options.push("NO MAXVALUE");
+                    }
+                    else {
+                        options.push("MAXVALUE", branchSequence.maximum_value.toString());
+                    }
+                }
+                if (mainSequence.start_value !== branchSequence.start_value) {
+                    options.push("START WITH", String(branchSequence.start_value));
+                }
+                if (mainSequence.cache_size !== branchSequence.cache_size) {
+                    options.push("CACHE", String(branchSequence.cache_size));
+                }
+                if (mainSequence.cycle_option !== branchSequence.cycle_option) {
+                    options.push(branchSequence.cycle_option ? "CYCLE" : "NO CYCLE");
+                }
+                changes.push(new AlterSequenceSetOptions({ sequence: mainSequence, options }));
+            }
+            const ownedByChanged = mainSequence.owned_by_schema !== branchSequence.owned_by_schema ||
+                mainSequence.owned_by_table !== branchSequence.owned_by_table ||
+                mainSequence.owned_by_column !== branchSequence.owned_by_column;
+            if (ownedByChanged) {
+                const ownedBy = branchSequence.owned_by_schema &&
+                    branchSequence.owned_by_table &&
+                    branchSequence.owned_by_column
+                    ? {
+                        schema: branchSequence.owned_by_schema,
+                        table: branchSequence.owned_by_table,
+                        column: branchSequence.owned_by_column,
+                    }
+                    : null;
+                changes.push(new AlterSequenceSetOwnedBy({ sequence: mainSequence, ownedBy }));
+            }
+            // COMMENT
+            if (mainSequence.comment !== branchSequence.comment) {
+                if (branchSequence.comment === null) {
+                    changes.push(new DropCommentOnSequence({ sequence: mainSequence }));
+                }
+                else {
+                    changes.push(new CreateCommentOnSequence({ sequence: branchSequence }));
+                }
+            }
+            // PRIVILEGES
+            // Filter out owner privileges - owner always has ALL privileges implicitly
+            // and shouldn't be compared. Use branch owner as the reference.
+            // Superuser privileges are filtered inside diffPrivileges.
+            const privilegeResults = diffPrivileges(mainSequence.privileges, branchSequence.privileges, branchSequence.owner, ctx.mainRoles);
+            for (const [grantee, result] of privilegeResults) {
+                // Generate grant changes
+                if (result.grants.length > 0) {
+                    const grantGroups = groupPrivilegesByGrantable(result.grants);
+                    for (const [grantable, list] of grantGroups) {
+                        void grantable;
+                        changes.push(new GrantSequencePrivileges({
+                            sequence: branchSequence,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke changes
+                if (result.revokes.length > 0) {
+                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                    for (const [grantable, list] of revokeGroups) {
+                        void grantable;
+                        changes.push(new RevokeSequencePrivileges({
+                            sequence: mainSequence,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke grant option changes
+                if (result.revokeGrantOption.length > 0) {
+                    changes.push(new RevokeGrantOptionSequencePrivileges({
+                        sequence: mainSequence,
+                        grantee,
+                        privilegeNames: result.revokeGrantOption,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Note: Sequence renaming would also use ALTER SEQUENCE ... RENAME TO ...
+            // But since our Sequence model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+        }
+    }
+    return changes;
+}

package/dist/core/objects/sequence/sequence.model.d.ts

@@ -0,0 +1,76 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const sequencePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    data_type: z.ZodString;
+    start_value: z.ZodNumber;
+    minimum_value: z.ZodBigInt;
+    maximum_value: z.ZodBigInt;
+    increment: z.ZodNumber;
+    cycle_option: z.ZodBoolean;
+    cache_size: z.ZodNumber;
+    persistence: z.ZodString;
+    owned_by_schema: z.ZodNullable<z.ZodString>;
+    owned_by_table: z.ZodNullable<z.ZodString>;
+    owned_by_column: z.ZodNullable<z.ZodString>;
+    comment: z.ZodNullable<z.ZodString>;
+    privileges: z.ZodArray<z.ZodObject<{
+        grantee: z.ZodString;
+        privilege: z.ZodString;
+        grantable: z.ZodBoolean;
+        columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.z.core.$strip>>;
+    owner: z.ZodString;
+}, z.z.core.$strip>;
+type SequencePrivilegeProps = PrivilegeProps;
+export type SequenceProps = z.infer<typeof sequencePropsSchema>;
+export declare class Sequence extends BasePgModel {
+    readonly schema: SequenceProps["schema"];
+    readonly name: SequenceProps["name"];
+    readonly data_type: SequenceProps["data_type"];
+    readonly start_value: SequenceProps["start_value"];
+    readonly minimum_value: SequenceProps["minimum_value"];
+    readonly maximum_value: SequenceProps["maximum_value"];
+    readonly increment: SequenceProps["increment"];
+    readonly cycle_option: SequenceProps["cycle_option"];
+    readonly cache_size: SequenceProps["cache_size"];
+    readonly persistence: SequenceProps["persistence"];
+    readonly owned_by_schema: SequenceProps["owned_by_schema"];
+    readonly owned_by_table: SequenceProps["owned_by_table"];
+    readonly owned_by_column: SequenceProps["owned_by_column"];
+    readonly comment: SequenceProps["comment"];
+    readonly privileges: SequencePrivilegeProps[];
+    readonly owner: SequenceProps["owner"];
+    constructor(props: SequenceProps);
+    get stableId(): `sequence:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        data_type: string;
+        start_value: number;
+        minimum_value: bigint;
+        maximum_value: bigint;
+        increment: number;
+        cycle_option: boolean;
+        cache_size: number;
+        persistence: string;
+        owned_by_schema: string | null;
+        owned_by_table: string | null;
+        owned_by_column: string | null;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+        owner: string;
+    };
+}
+export declare function extractSequences(sql: Sql): Promise<Sequence[]>;
+export {};

package/dist/core/objects/sequence/sequence.model.js

@@ -0,0 +1,169 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+const sequencePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    data_type: z.string(),
+    start_value: z.number(),
+    minimum_value: z.bigint(),
+    maximum_value: z.bigint(),
+    increment: z.number(),
+    cycle_option: z.boolean(),
+    cache_size: z.number(),
+    persistence: z.string(),
+    owned_by_schema: z.string().nullable(),
+    owned_by_table: z.string().nullable(),
+    owned_by_column: z.string().nullable(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+    owner: z.string(),
+});
+export class Sequence extends BasePgModel {
+    schema;
+    name;
+    data_type;
+    start_value;
+    minimum_value;
+    maximum_value;
+    increment;
+    cycle_option;
+    cache_size;
+    persistence;
+    owned_by_schema;
+    owned_by_table;
+    owned_by_column;
+    comment;
+    privileges;
+    owner;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.data_type = props.data_type;
+        this.start_value = props.start_value;
+        this.minimum_value = props.minimum_value;
+        this.maximum_value = props.maximum_value;
+        this.increment = props.increment;
+        this.cycle_option = props.cycle_option;
+        this.cache_size = props.cache_size;
+        this.persistence = props.persistence;
+        this.owned_by_schema = props.owned_by_schema;
+        this.owned_by_table = props.owned_by_table;
+        this.owned_by_column = props.owned_by_column;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+        this.owner = props.owner;
+    }
+    get stableId() {
+        return `sequence:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            data_type: this.data_type,
+            start_value: this.start_value,
+            minimum_value: this.minimum_value,
+            maximum_value: this.maximum_value,
+            increment: this.increment,
+            cycle_option: this.cycle_option,
+            cache_size: this.cache_size,
+            persistence: this.persistence,
+            owned_by_schema: this.owned_by_schema,
+            owned_by_table: this.owned_by_table,
+            owned_by_column: this.owned_by_column,
+            comment: this.comment,
+            privileges: this.privileges,
+            owner: this.owner,
+        };
+    }
+}
+export async function extractSequences(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const sequenceRows = await sql `
+with extension_sequence_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_class'::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
+  c.relnamespace::regnamespace::text as schema,
+  quote_ident(c.relname) as name,
+  format_type(s.seqtypid, null) as data_type,
+  s.seqstart::int as start_value,
+  s.seqmin as minimum_value,
+  s.seqmax as maximum_value,
+  s.seqincrement::int as increment,
+  s.seqcycle as cycle_option,
+  s.seqcache::int as cache_size,
+  c.relpersistence as persistence,
+  quote_ident(t_ns.nspname) as owned_by_schema,
+  case when t.relname is not null then quote_ident(t.relname) else null end as owned_by_table,
+  case when att.attname is not null then quote_ident(att.attname) else null end as owned_by_column,
+  obj_description(c.oid, 'pg_class') as comment,
+  coalesce(
+    (
+      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
+      )
+      from lateral aclexplode(c.relacl) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges,
+  c.relowner::regrole::text as owner
+from
+  pg_catalog.pg_class c
+  inner join pg_catalog.pg_sequence s on s.seqrelid = c.oid
+  left join pg_depend d on d.classid = 'pg_class'::regclass and d.objid = c.oid and d.refclassid = 'pg_class'::regclass and d.deptype = 'a'
+  left join pg_class t on t.oid = d.refobjid
+  left join pg_namespace t_ns on t.relnamespace = t_ns.oid
+  left join pg_attribute att on att.attrelid = t.oid and att.attnum = d.refobjsubid and d.refobjsubid > 0
+  left outer join extension_sequence_oids e_seq on c.oid = e_seq.objid
+  left outer join extension_table_oids e_table on t.oid = e_table.objid
+  where not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e_seq.objid is null
+  and (t.oid is null or e_table.objid is null)
+  and c.relkind = 'S'
+  -- exclude sequences that are tied to an IDENTITY column
+  and not exists (
+    select 1
+    from pg_depend di
+    where di.classid = 'pg_class'::regclass
+      and di.objid = c.oid
+      and di.refclassid = 'pg_class'::regclass
+      and di.deptype = 'i'
+  )
+order by
+  1, 2;
+  `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = sequenceRows.map((row) => sequencePropsSchema.parse(row));
+        return validatedRows.map((row) => new Sequence(row));
+    });
+}

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

@@ -0,0 +1,56 @@
+import type { Subscription } from "../subscription.model.ts";
+import { type SubscriptionSettableOption } from "../utils.ts";
+import { AlterSubscriptionChange } from "./subscription.base.ts";
+export declare class AlterSubscriptionSetConnection extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    serialize(): string;
+}
+export declare class AlterSubscriptionSetPublication extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    serialize(): string;
+}
+export declare class AlterSubscriptionEnable extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    serialize(): string;
+}
+export declare class AlterSubscriptionDisable extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    constructor(props: {
+        subscription: Subscription;
+    });
+    serialize(): string;
+}
+export declare class AlterSubscriptionSetOptions extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    private readonly options;
+    constructor(props: {
+        subscription: Subscription;
+        options: SubscriptionSettableOption[];
+    });
+    serialize(): string;
+}
+export declare class AlterSubscriptionSetOwner extends AlterSubscriptionChange {
+    readonly subscription: Subscription;
+    readonly scope: "object";
+    readonly owner: string;
+    constructor(props: {
+        subscription: Subscription;
+        owner: string;
+    });
+    get requires(): `role:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,82 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { formatSubscriptionOption, } from "../utils.js";
+import { AlterSubscriptionChange } from "./subscription.base.js";
+export class AlterSubscriptionSetConnection extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    serialize() {
+        return `ALTER SUBSCRIPTION ${this.subscription.name} CONNECTION ${quoteLiteral(this.subscription.conninfo)}`;
+    }
+}
+export class AlterSubscriptionSetPublication extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    serialize() {
+        const base = `ALTER SUBSCRIPTION ${this.subscription.name} SET PUBLICATION ${this.subscription.publications.join(", ")}`;
+        if (!this.subscription.enabled) {
+            return `${base} WITH (refresh = false)`;
+        }
+        return base;
+    }
+}
+export class AlterSubscriptionEnable extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    serialize() {
+        return `ALTER SUBSCRIPTION ${this.subscription.name} ENABLE`;
+    }
+}
+export class AlterSubscriptionDisable extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+    }
+    serialize() {
+        return `ALTER SUBSCRIPTION ${this.subscription.name} DISABLE`;
+    }
+}
+export class AlterSubscriptionSetOptions extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    options;
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+        this.options = props.options;
+    }
+    serialize() {
+        const assignments = this.options.map((option) => formatSubscriptionOption(this.subscription, option));
+        return `ALTER SUBSCRIPTION ${this.subscription.name} SET (${assignments.join(", ")})`;
+    }
+}
+export class AlterSubscriptionSetOwner extends AlterSubscriptionChange {
+    subscription;
+    scope = "object";
+    owner;
+    constructor(props) {
+        super();
+        this.subscription = props.subscription;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [stableId.role(this.owner)];
+    }
+    serialize() {
+        return `ALTER SUBSCRIPTION ${this.subscription.name} OWNER TO ${this.owner}`;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Subscription } from "../subscription.model.ts";
+declare abstract class BaseSubscriptionChange extends BaseChange {
+    abstract readonly subscription: Subscription;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "subscription";
+}
+export declare abstract class CreateSubscriptionChange extends BaseSubscriptionChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterSubscriptionChange extends BaseSubscriptionChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropSubscriptionChange extends BaseSubscriptionChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/subscription/changes/subscription.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseSubscriptionChange extends BaseChange {
+    objectType = "subscription";
+}
+export class CreateSubscriptionChange extends BaseSubscriptionChange {
+    operation = "create";
+}
+export class AlterSubscriptionChange extends BaseSubscriptionChange {
+    operation = "alter";
+}
+export class DropSubscriptionChange extends BaseSubscriptionChange {
+    operation = "drop";
+}