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

package/dist/core/objects/schema/changes/schema.privilege.js

@@ -0,0 +1,131 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
+import { stableId } from "../../utils.js";
+import { AlterSchemaChange } from "./schema.base.js";
+/**
+ * Grant privileges on a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { CREATE | USAGE } [, ...] | ALL [ PRIVILEGES ] }
+ *    ON SCHEMA schema_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantSchemaPrivileges extends AlterSchemaChange {
+    schema;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.schema.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.schema.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantSchemaPrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("SCHEMA");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SCHEMA", list, this.version);
+        const schemaName = this.schema.name;
+        return `GRANT ${privSql} ${kindPrefix} ${schemaName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { CREATE | USAGE } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON SCHEMA schema_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeSchemaPrivileges extends AlterSchemaChange {
+    schema;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        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.schema.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.schema.stableId, this.grantee),
+            this.schema.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("SCHEMA");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("SCHEMA", list, this.version);
+        const schemaName = this.schema.name;
+        return `REVOKE ${privSql} ${kindPrefix} ${schemaName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a schema.
+ *
+ * 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 RevokeGrantOptionSchemaPrivileges extends AlterSchemaChange {
+    schema;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.schema = props.schema;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.schema.stableId, this.grantee),
+            this.schema.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("SCHEMA");
+        const privSql = formatObjectPrivilegeList("SCHEMA", this.privilegeNames, this.version);
+        const schemaName = this.schema.name;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${schemaName} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/schema/changes/schema.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterSchema } from "./schema.alter.ts";
+import type { CommentSchema } from "./schema.comment.ts";
+import type { CreateSchema } from "./schema.create.ts";
+import type { DropSchema } from "./schema.drop.ts";
+import type { SchemaPrivilege } from "./schema.privilege.ts";
+export type SchemaChange = AlterSchema | CommentSchema | CreateSchema | DropSchema | SchemaPrivilege;

package/dist/core/objects/schema/changes/schema.types.js

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

package/dist/core/objects/schema/schema.diff.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
+import type { Role } from "../role/role.model.ts";
+import type { SchemaChange } from "./changes/schema.types.ts";
+import type { Schema } from "./schema.model.ts";
+/**
+ * Diff two sets of schemas from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The schemas in the main catalog.
+ * @param branch - The schemas in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffSchemas(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, Schema>, branch: Record<string, Schema>): SchemaChange[];

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

@@ -0,0 +1,142 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { AlterSchemaChangeOwner } from "./changes/schema.alter.js";
+import { CreateCommentOnSchema, DropCommentOnSchema, } from "./changes/schema.comment.js";
+import { CreateSchema } from "./changes/schema.create.js";
+import { DropSchema } from "./changes/schema.drop.js";
+import { GrantSchemaPrivileges, RevokeGrantOptionSchemaPrivileges, RevokeSchemaPrivileges, } from "./changes/schema.privilege.js";
+/**
+ * Diff two sets of schemas from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The schemas in the main catalog.
+ * @param branch - The schemas in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffSchemas(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const schemaId of created) {
+        const sc = branch[schemaId];
+        changes.push(new CreateSchema({ schema: sc }));
+        if (sc.comment !== null) {
+            changes.push(new CreateCommentOnSchema({ schema: sc }));
+        }
+        // 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.
+        // Note: Schemas don't have a schema property, so we pass empty string
+        const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "schema", "");
+        const desiredPrivileges = sc.privileges;
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the schema owner as the reference.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, sc.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 GrantSchemaPrivileges({
+                        schema: sc,
+                        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 RevokeSchemaPrivileges({
+                        schema: sc,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionSchemaPrivileges({
+                    schema: sc,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const schemaId of dropped) {
+        changes.push(new DropSchema({ schema: main[schemaId] }));
+    }
+    for (const schemaId of altered) {
+        const mainSchema = main[schemaId];
+        const branchSchema = branch[schemaId];
+        // OWNER
+        if (mainSchema.owner !== branchSchema.owner) {
+            changes.push(new AlterSchemaChangeOwner({
+                schema: mainSchema,
+                owner: branchSchema.owner,
+            }));
+        }
+        // COMMENT
+        if (mainSchema.comment !== branchSchema.comment) {
+            if (branchSchema.comment === null) {
+                changes.push(new DropCommentOnSchema({ schema: mainSchema }));
+            }
+            else {
+                changes.push(new CreateCommentOnSchema({ schema: branchSchema }));
+            }
+        }
+        // PRIVILEGES
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use branch owner as the reference.
+        const privilegeResults = diffPrivileges(mainSchema.privileges, branchSchema.privileges, branchSchema.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 GrantSchemaPrivileges({
+                        schema: branchSchema,
+                        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 RevokeSchemaPrivileges({
+                        schema: mainSchema,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionSchemaPrivileges({
+                    schema: mainSchema,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+        // Note: Schema renaming would also use ALTER SCHEMA ... RENAME TO ...
+        // But since our Schema model uses 'schema' as the identity field,
+        // a name change would be handled as drop + create by diffObjects()
+    }
+    return changes;
+}

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

@@ -0,0 +1,47 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+/**
+ * All properties exposed by CREATE SCHEMA statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createschema.html
+ *
+ * ALTER SCHEMA statement can be generated for all properties.
+ * https://www.postgresql.org/docs/current/sql-alterschema.html
+ */
+declare const schemaPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    owner: 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>>;
+}, z.z.core.$strip>;
+type SchemaPrivilegeProps = PrivilegeProps;
+export type SchemaProps = z.infer<typeof schemaPropsSchema>;
+export declare class Schema extends BasePgModel {
+    readonly name: SchemaProps["name"];
+    readonly owner: SchemaProps["owner"];
+    readonly comment: SchemaProps["comment"];
+    readonly privileges: SchemaPrivilegeProps[];
+    constructor(props: SchemaProps);
+    get stableId(): `schema:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+export declare function extractSchemas(sql: Sql): Promise<Schema[]>;
+export {};

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

@@ -0,0 +1,91 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+import { privilegePropsSchema, } from "../base.privilege-diff.js";
+/**
+ * All properties exposed by CREATE SCHEMA statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createschema.html
+ *
+ * ALTER SCHEMA statement can be generated for all properties.
+ * https://www.postgresql.org/docs/current/sql-alterschema.html
+ */
+const schemaPropsSchema = z.object({
+    name: z.string(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Schema extends BasePgModel {
+    name;
+    owner;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.name = props.name;
+        // Data fields
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `schema:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            owner: this.owner,
+            comment: this.comment,
+            privileges: this.privileges,
+        };
+    }
+}
+export async function extractSchemas(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const schemaRows = await sql `
+    with extension_oids as (
+      select
+        objid
+      from
+        pg_depend d
+      where
+        d.refclassid = 'pg_extension'::regclass
+        and d.classid = 'pg_namespace'::regclass
+    )
+    select
+      quote_ident(nspname) as name,
+      nspowner::regrole::text as owner,
+      obj_description(oid, 'pg_namespace') 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(nspacl) as x(grantor, grantee, privilege_type, is_grantable)
+        ), '[]'
+      ) as privileges
+    from
+      pg_catalog.pg_namespace
+      left outer join extension_oids e on e.objid = oid
+      -- <EXCLUDE_INTERNAL>
+      where not nspname like any(array['pg\\_%', 'information\\_schema'])
+      and e.objid is null
+      -- </EXCLUDE_INTERNAL>
+    order by
+      1;
+  `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = schemaRows.map((row) => schemaPropsSchema.parse(row));
+        return validatedRows.map((row) => new Schema(row));
+    });
+}

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

@@ -0,0 +1,59 @@
+import type { Sequence } from "../sequence.model.ts";
+import { AlterSequenceChange } from "./sequence.base.ts";
+/**
+ * Alter a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altersequence.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SEQUENCE [ IF EXISTS ] name [ INCREMENT [ BY ] increment ]
+ *     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ *     [ START [ WITH ] start ] [ RESTART [ [ WITH ] restart ] ]
+ *     [ CACHE cache ] [ [ NO ] CYCLE ] [ OWNED BY { table_name.column_name | NONE } ]
+ * ```
+ */
+export type AlterSequence = AlterSequenceSetOptions | AlterSequenceSetOwnedBy;
+/**
+ * ALTER SEQUENCE ... OWNED BY ... | OWNED BY NONE
+ */
+export declare class AlterSequenceSetOwnedBy extends AlterSequenceChange {
+    readonly sequence: Sequence;
+    readonly ownedBy: {
+        schema: string;
+        table: string;
+        column: string;
+    } | null;
+    readonly scope: "object";
+    constructor(props: {
+        sequence: Sequence;
+        ownedBy: {
+            schema: string;
+            table: string;
+            column: string;
+        } | null;
+    });
+    get creates(): never[];
+    get requires(): (`column:${string}.${string}.${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}
+/**
+ * ALTER SEQUENCE ... set options ...
+ * Emits only changed options, in a stable order.
+ */
+export declare class AlterSequenceSetOptions extends AlterSequenceChange {
+    readonly sequence: Sequence;
+    readonly options: string[];
+    readonly scope: "object";
+    constructor(props: {
+        sequence: Sequence;
+        options: string[];
+    });
+    get creates(): never[];
+    get requires(): `sequence:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a sequence by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SEQUENCE change.
+ */

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

@@ -0,0 +1,75 @@
+import { stableId } from "../../utils.js";
+import { AlterSequenceChange } from "./sequence.base.js";
+/**
+ * ALTER SEQUENCE ... OWNED BY ... | OWNED BY NONE
+ */
+export class AlterSequenceSetOwnedBy extends AlterSequenceChange {
+    sequence;
+    ownedBy;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.ownedBy = props.ownedBy;
+    }
+    get creates() {
+        return [];
+    }
+    get requires() {
+        return [
+            this.sequence.stableId,
+            ...(this.ownedBy
+                ? [
+                    stableId.column(this.ownedBy.schema, this.ownedBy.table, this.ownedBy.column),
+                ]
+                : []),
+        ];
+    }
+    serialize() {
+        const head = [
+            "ALTER SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+        ];
+        if (this.ownedBy) {
+            return [
+                ...head,
+                "OWNED BY",
+                `${this.ownedBy.schema}.${this.ownedBy.table}.${this.ownedBy.column}`,
+            ].join(" ");
+        }
+        return [...head, "OWNED BY NONE"].join(" ");
+    }
+}
+/**
+ * ALTER SEQUENCE ... set options ...
+ * Emits only changed options, in a stable order.
+ */
+export class AlterSequenceSetOptions extends AlterSequenceChange {
+    sequence;
+    options;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+        this.options = props.options;
+    }
+    get creates() {
+        return [];
+    }
+    get requires() {
+        return [this.sequence.stableId];
+    }
+    // Note: default max computation moved to diff when building options
+    serialize() {
+        const parts = [
+            "ALTER SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+        ];
+        return [...parts, ...this.options].join(" ");
+    }
+}
+/**
+ * Replace a sequence by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SEQUENCE change.
+ */
+// NOTE: ReplaceSequence removed. Non-alterable changes are emitted as Drop + Create in sequence.diff.ts.

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Sequence } from "../sequence.model.ts";
+declare abstract class BaseSequenceChange extends BaseChange {
+    abstract readonly sequence: Sequence;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "sequence";
+}
+export declare abstract class CreateSequenceChange extends BaseSequenceChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterSequenceChange extends BaseSequenceChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropSequenceChange extends BaseSequenceChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseSequenceChange extends BaseChange {
+    objectType = "sequence";
+}
+export class CreateSequenceChange extends BaseSequenceChange {
+    operation = "create";
+}
+export class AlterSequenceChange extends BaseSequenceChange {
+    operation = "alter";
+}
+export class DropSequenceChange extends BaseSequenceChange {
+    operation = "drop";
+}

package/dist/core/objects/sequence/changes/sequence.comment.d.ts

@@ -0,0 +1,23 @@
+import type { Sequence } from "../sequence.model.ts";
+import { CreateSequenceChange, DropSequenceChange } from "./sequence.base.ts";
+export type CommentSequence = CreateCommentOnSequence | DropCommentOnSequence;
+export declare class CreateCommentOnSequence extends CreateSequenceChange {
+    readonly sequence: Sequence;
+    readonly scope: "comment";
+    constructor(props: {
+        sequence: Sequence;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `sequence:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnSequence extends DropSequenceChange {
+    readonly sequence: Sequence;
+    readonly scope: "comment";
+    constructor(props: {
+        sequence: Sequence;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `sequence:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/sequence/changes/sequence.comment.js

@@ -0,0 +1,47 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateSequenceChange, DropSequenceChange } from "./sequence.base.js";
+export class CreateCommentOnSequence extends CreateSequenceChange {
+    sequence;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+    }
+    get creates() {
+        return [stableId.comment(this.sequence.stableId)];
+    }
+    get requires() {
+        return [this.sequence.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: sequence comment is not nullable in this case
+            quoteLiteral(this.sequence.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnSequence extends DropSequenceChange {
+    sequence;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.sequence = props.sequence;
+    }
+    get drops() {
+        return [stableId.comment(this.sequence.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.sequence.stableId), this.sequence.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON SEQUENCE",
+            `${this.sequence.schema}.${this.sequence.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}