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

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

@@ -1,11 +1,13 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } from "../base.privilege-diff.js";
+import { diffSecurityLabels } from "../security-label.types.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterProcedureChangeOwner, AlterProcedureSetConfig, AlterProcedureSetLeakproof, AlterProcedureSetParallel, AlterProcedureSetSecurity, AlterProcedureSetStrictness, AlterProcedureSetVolatility, } from "./changes/procedure.alter.js";
 import { CreateCommentOnProcedure, DropCommentOnProcedure, } from "./changes/procedure.comment.js";
 import { CreateProcedure } from "./changes/procedure.create.js";
 import { DropProcedure } from "./changes/procedure.drop.js";
 import { GrantProcedurePrivileges, RevokeGrantOptionProcedurePrivileges, RevokeProcedurePrivileges, } from "./changes/procedure.privilege.js";
+import { CreateSecurityLabelOnProcedure, DropSecurityLabelOnProcedure, } from "./changes/procedure.security-label.js";
 /**
  * Diff two sets of procedures from main and branch catalogs.
  *
@@ -17,8 +19,7 @@ import { GrantProcedurePrivileges, RevokeGrantOptionProcedurePrivileges, RevokeP
 export function diffProcedures(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    for (const procedureId of created) {
-        const proc = branch[procedureId];
+    const appendCreateProcedureChanges = (proc) => {
         changes.push(new CreateProcedure({ procedure: proc }));
         // OWNER: If the procedure should be owned by someone other than the current user,
         // emit ALTER FUNCTION/PROCEDURE ... OWNER TO after creation
@@ -31,12 +32,21 @@ export function diffProcedures(ctx, main, branch) {
         if (proc.comment !== null) {
             changes.push(new CreateCommentOnProcedure({ procedure: proc }));
         }
+        for (const label of proc.security_labels) {
+            changes.push(new CreateSecurityLabelOnProcedure({
+                procedure: proc,
+                securityLabel: label,
+            }));
+        }
         // 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, "procedure", proc.schema ?? "");
+        const creatorFilteredDefaults = proc.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // Filter out PUBLIC's built-in default EXECUTE privilege (PostgreSQL grants it automatically)
         // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
         // This prevents generating unnecessary "GRANT EXECUTE TO PUBLIC" statements
@@ -44,44 +54,15 @@ export function diffProcedures(ctx, main, branch) {
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Note: we use the final owner (proc.owner), not the
         // current user, because ownership change happens before privilege diffing.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, proc.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 GrantProcedurePrivileges({
-                        procedure: proc,
-                        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 RevokeProcedurePrivileges({
-                        procedure: proc,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionProcedurePrivileges({
-                    procedure: proc,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("procedure", creatorFilteredDefaults), desiredPrivileges, proc.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, proc, proc, "procedure", {
+            Grant: GrantProcedurePrivileges,
+            Revoke: RevokeProcedurePrivileges,
+            RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+        }, ctx.version));
+    };
+    for (const procedureId of created) {
+        appendCreateProcedureChanges(branch[procedureId]);
     }
     for (const procedureId of dropped) {
         changes.push(new DropProcedure({ procedure: main[procedureId] }));
@@ -89,22 +70,18 @@ export function diffProcedures(ctx, main, branch) {
     for (const procedureId of altered) {
         const mainProcedure = main[procedureId];
         const branchProcedure = branch[procedureId];
-        // Check if non-alterable properties have changed
-        // These require dropping and recreating the procedure
-        const NON_ALTERABLE_FIELDS = [
+        // Fields that are part of the function's identity/signature. PostgreSQL
+        // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+        // errors such as:
+        //   - cannot change return type of existing function
+        //   - cannot change name of input parameter "..."
+        //   - cannot change whether a procedure has output parameters
+        //   - cannot remove parameter defaults from existing function
+        // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+        const SIGNATURE_BREAKING_FIELDS = [
             "kind",
             "return_type",
             "return_type_schema",
-            "language",
-            // The following properties are alterable in SQL, but our generator may choose
-            // to replace on changes not covered by explicit ALTER actions. Keep them out here
-            // to allow ALTER for those we implement below.
-            // security_definer,
-            // volatility,
-            // parallel_safety,
-            // is_strict,
-            // leakproof,
-            // Returns-set is part of the signature and not alterable
             "returns_set",
             "argument_count",
             "argument_default_count",
@@ -113,21 +90,44 @@ export function diffProcedures(ctx, main, branch) {
             "all_argument_types",
             "argument_modes",
             "argument_defaults",
+        ];
+        // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+        // Other fields (security_definer, volatility, parallel_safety, is_strict,
+        // leakproof, config) are alterable via dedicated ALTER actions below.
+        const OR_REPLACEABLE_NON_ALTERABLE_FIELDS = [
+            "language",
             "source_code",
             "binary_path",
             "sql_body",
-            // config is alterable via SET/RESET
         ];
-        const nonAlterablePropsChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, NON_ALTERABLE_FIELDS, {
+        const signatureChanged = hasNonAlterableChanges(mainProcedure, branchProcedure, SIGNATURE_BREAKING_FIELDS, {
             argument_names: deepEqual,
             argument_types: deepEqual,
             all_argument_types: deepEqual,
             argument_modes: deepEqual,
-            config: deepEqual,
         });
-        if (nonAlterablePropsChanged) {
-            // Replace the entire procedure
+        const nonAlterablePropsChanged = signatureChanged ||
+            hasNonAlterableChanges(mainProcedure, branchProcedure, OR_REPLACEABLE_NON_ALTERABLE_FIELDS);
+        if (signatureChanged) {
+            // PostgreSQL cannot change an existing function's signature via
+            // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+            // `expandReplaceDependencies` will cascade the replacement to dependent
+            // objects (views, triggers, column defaults) via pg_depend edges.
+            changes.push(new DropProcedure({ procedure: mainProcedure }));
+            appendCreateProcedureChanges(branchProcedure);
+        }
+        else if (nonAlterablePropsChanged) {
+            // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+            // function OID and keeps dependent objects attached.
             changes.push(new CreateProcedure({ procedure: branchProcedure, orReplace: true }));
+            if (mainProcedure.comment !== branchProcedure.comment) {
+                if (branchProcedure.comment === null) {
+                    changes.push(new DropCommentOnProcedure({ procedure: mainProcedure }));
+                }
+                else {
+                    changes.push(new CreateCommentOnProcedure({ procedure: branchProcedure }));
+                }
+            }
         }
         else {
             // Only alterable properties changed - check each one
@@ -147,6 +147,14 @@ export function diffProcedures(ctx, main, branch) {
                     changes.push(new CreateCommentOnProcedure({ procedure: branchProcedure }));
                 }
             }
+            // SECURITY LABELS
+            changes.push(...diffSecurityLabels(mainProcedure.security_labels, branchProcedure.security_labels, (securityLabel) => new CreateSecurityLabelOnProcedure({
+                procedure: branchProcedure,
+                securityLabel,
+            }), (securityLabel) => new DropSecurityLabelOnProcedure({
+                procedure: mainProcedure,
+                securityLabel,
+            })));
             // SECURITY DEFINER/INVOKER
             if (mainProcedure.security_definer !== branchProcedure.security_definer) {
                 changes.push(new AlterProcedureSetSecurity({
@@ -238,44 +246,12 @@ export function diffProcedures(ctx, main, branch) {
             const branchPrivilegesFiltered = filterPublicBuiltInDefaults("procedure", branchProcedure.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(mainPrivilegesFiltered, branchPrivilegesFiltered, branchProcedure.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 GrantProcedurePrivileges({
-                            procedure: branchProcedure,
-                            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 RevokeProcedurePrivileges({
-                            procedure: mainProcedure,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionProcedurePrivileges({
-                        procedure: mainProcedure,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchProcedure.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchProcedure, mainProcedure, "procedure", {
+                Grant: GrantProcedurePrivileges,
+                Revoke: RevokeProcedurePrivileges,
+                RevokeGrantOption: RevokeGrantOptionProcedurePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

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

@@ -2,28 +2,30 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
+import { type SecurityLabelProps } from "../security-label.types.ts";
 declare const procedurePropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
     kind: z.ZodEnum<{
-        f: "f";
-        w: "w";
         a: "a";
+        w: "w";
         p: "p";
+        f: "f";
     }>;
     return_type: z.ZodString;
     return_type_schema: z.ZodString;
     language: z.ZodString;
     security_definer: z.ZodBoolean;
     volatility: z.ZodEnum<{
-        s: "s";
         i: "i";
+        s: "s";
         v: "v";
     }>;
     parallel_safety: z.ZodEnum<{
-        r: "r";
         u: "u";
         s: "s";
+        r: "r";
     }>;
     execution_cost: z.ZodNumber;
     result_rows: z.ZodNumber;
@@ -36,8 +38,8 @@ declare const procedurePropsSchema: z.ZodObject<{
     argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     all_argument_types: z.ZodNullable<z.ZodArray<z.ZodString>>;
     argument_modes: z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        o: "o";
         i: "i";
+        o: "o";
         b: "b";
         v: "v";
         t: "t";
@@ -56,6 +58,10 @@ declare const procedurePropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    security_labels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>>;
 }, z.z.core.$strip>;
 type ProcedurePrivilegeProps = PrivilegeProps;
 export type ProcedureProps = z.infer<typeof procedurePropsSchema>;
@@ -89,6 +95,7 @@ export declare class Procedure extends BasePgModel {
     readonly owner: ProcedureProps["owner"];
     readonly comment: ProcedureProps["comment"];
     readonly privileges: ProcedurePrivilegeProps[];
+    readonly security_labels: SecurityLabelProps[];
     constructor(props: ProcedureProps);
     get stableId(): `procedure:${string}`;
     get identityFields(): {
@@ -96,13 +103,13 @@ export declare class Procedure extends BasePgModel {
         name: string;
     };
     get dataFields(): {
-        kind: "f" | "w" | "a" | "p";
+        kind: "a" | "w" | "p" | "f";
         return_type: string;
         return_type_schema: string;
         language: string;
         security_definer: boolean;
-        volatility: "s" | "i" | "v";
-        parallel_safety: "r" | "u" | "s";
+        volatility: "i" | "s" | "v";
+        parallel_safety: "u" | "s" | "r";
         is_strict: boolean;
         leakproof: boolean;
         returns_set: boolean;
@@ -111,7 +118,7 @@ export declare class Procedure extends BasePgModel {
         argument_names: string[] | null;
         argument_types: string[] | null;
         all_argument_types: string[] | null;
-        argument_modes: ("o" | "i" | "b" | "v" | "t")[] | null;
+        argument_modes: ("i" | "o" | "b" | "v" | "t")[] | null;
         argument_defaults: string | null;
         source_code: string | null;
         binary_path: string | null;
@@ -126,7 +133,11 @@ export declare class Procedure extends BasePgModel {
             grantable: boolean;
             columns?: string[] | null | undefined;
         }[];
+        security_labels: {
+            provider: string;
+            label: string;
+        }[];
     };
 }
-export declare function extractProcedures(pool: Pool): Promise<Procedure[]>;
+export declare function extractProcedures(pool: Pool, options?: ExtractRetryOptions): Promise<Procedure[]>;
 export {};

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

@@ -2,6 +2,8 @@ import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
+import { securityLabelPropsSchema, } from "../security-label.types.js";
 const FunctionKindSchema = z.enum([
     "f", // function
     "p", // procedure
@@ -55,6 +57,15 @@ const procedurePropsSchema = z.object({
     owner: z.string(),
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
+    security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+});
+// pg_get_functiondef(oid) can return NULL when the function (its pg_proc
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable function cannot be diffed, so we accept NULL
+// here and filter the row out at extraction time rather than crashing the
+// whole catalog parse with a ZodError.
+const procedureRowSchema = procedurePropsSchema.extend({
+    definition: z.string().nullable(),
 });
 export class Procedure extends BasePgModel {
     schema;
@@ -86,6 +97,7 @@ export class Procedure extends BasePgModel {
     owner;
     comment;
     privileges;
+    security_labels;
     constructor(props) {
         super();
         // Identity fields
@@ -119,6 +131,7 @@ export class Procedure extends BasePgModel {
         this.owner = props.owner;
         this.comment = props.comment;
         this.privileges = props.privileges;
+        this.security_labels = props.security_labels ?? [];
     }
     get stableId() {
         const args = this.argument_types?.join(",") ?? "";
@@ -160,11 +173,17 @@ export class Procedure extends BasePgModel {
             owner: this.owner,
             comment: this.comment,
             privileges: this.privileges,
+            security_labels: this.security_labels,
         };
     }
 }
-export async function extractProcedures(pool) {
-    const { rows: procedureRows } = await pool.query(sql `
+export async function extractProcedures(pool, options) {
+    const procedureRows = await extractWithDefinitionRetry({
+        label: "procedures",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -222,9 +241,22 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(p.proacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
-  ) as privileges
+  ) as privileges,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = p.oid
+        and sl.classoid = 'pg_proc'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
 from
   pg_catalog.pg_proc p
   inner join pg_catalog.pg_language l on l.oid = p.prolang
@@ -236,7 +268,9 @@ from
 order by
   1, 2
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = procedureRows.map((row) => procedurePropsSchema.parse(row));
+            return result.rows.map((row) => procedureRowSchema.parse(row));
+        },
+    });
+    const validatedRows = procedureRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Procedure(row));
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Publication, PublicationTableProps } from "../publication.model.ts";
 import { AlterPublicationChange } from "./publication.base.ts";
 export declare class AlterPublicationSetOptions extends AlterPublicationChange {
@@ -11,16 +12,7 @@ export declare class AlterPublicationSetOptions extends AlterPublicationChange {
         setPublishViaPartitionRoot: boolean;
     });
     get requires(): `publication:${string}`[];
-    serialize(): string;
-}
-export declare class AlterPublicationSetForAllTables extends AlterPublicationChange {
-    readonly publication: Publication;
-    readonly scope: "object";
-    constructor(props: {
-        publication: Publication;
-    });
-    get requires(): `publication:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationSetList extends AlterPublicationChange {
     readonly publication: Publication;
@@ -29,7 +21,7 @@ export declare class AlterPublicationSetList extends AlterPublicationChange {
         publication: Publication;
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationAddTables extends AlterPublicationChange {
     readonly publication: Publication;
@@ -40,18 +32,19 @@ export declare class AlterPublicationAddTables extends AlterPublicationChange {
         tables: PublicationTableProps[];
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationDropTables extends AlterPublicationChange {
     readonly publication: Publication;
     readonly scope: "object";
-    private readonly tables;
+    readonly tables: PublicationTableProps[];
     constructor(props: {
         publication: Publication;
         tables: PublicationTableProps[];
     });
     get requires(): string[];
-    serialize(): string;
+    get drops(): `table:${string}.${string}`[];
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationAddSchemas extends AlterPublicationChange {
     readonly publication: Publication;
@@ -62,7 +55,7 @@ export declare class AlterPublicationAddSchemas extends AlterPublicationChange {
         schemas: string[];
     });
     get requires(): (`schema:${string}` | `publication:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationDropSchemas extends AlterPublicationChange {
     readonly publication: Publication;
@@ -73,7 +66,7 @@ export declare class AlterPublicationDropSchemas extends AlterPublicationChange
         schemas: string[];
     });
     get requires(): (`schema:${string}` | `publication:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class AlterPublicationSetOwner extends AlterPublicationChange {
     readonly publication: Publication;
@@ -84,5 +77,5 @@ export declare class AlterPublicationSetOwner extends AlterPublicationChange {
         owner: string;
     });
     get requires(): (`role:${string}` | `publication:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -15,7 +15,7 @@ export class AlterPublicationSetOptions extends AlterPublicationChange {
     get requires() {
         return [this.publication.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const assignments = [];
         if (this.setPublish) {
             const operations = getPublicationOperations(this.publication);
@@ -27,20 +27,6 @@ export class AlterPublicationSetOptions extends AlterPublicationChange {
         return `ALTER PUBLICATION ${this.publication.name} SET (${assignments.join(", ")})`;
     }
 }
-export class AlterPublicationSetForAllTables extends AlterPublicationChange {
-    publication;
-    scope = "object";
-    constructor(props) {
-        super();
-        this.publication = props.publication;
-    }
-    get requires() {
-        return [this.publication.stableId];
-    }
-    serialize() {
-        return `ALTER PUBLICATION ${this.publication.name} SET FOR ALL TABLES`;
-    }
-}
 export class AlterPublicationSetList extends AlterPublicationChange {
     publication;
     scope = "object";
@@ -64,7 +50,7 @@ export class AlterPublicationSetList extends AlterPublicationChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const clauses = formatPublicationObjects(this.publication.tables, this.publication.schemas);
         return `ALTER PUBLICATION ${this.publication.name} SET ${clauses.join(", ")}`;
     }
@@ -91,7 +77,7 @@ export class AlterPublicationAddTables extends AlterPublicationChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const clauses = this.tables.map((table) => formatPublicationTable(table));
         return `ALTER PUBLICATION ${this.publication.name} ADD ${clauses.join(", ")}`;
     }
@@ -113,7 +99,12 @@ export class AlterPublicationDropTables extends AlterPublicationChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    get drops() {
+        // Treat ALTER PUBLICATION ... DROP TABLE as a destructive change so it runs
+        // in the drop phase before DROP TABLE removes the referenced relation.
+        return this.tables.map((table) => stableId.table(table.schema, table.name));
+    }
+    serialize(_options) {
         const targets = this.tables.map((table) => `${table.schema}.${table.name}`);
         return `ALTER PUBLICATION ${this.publication.name} DROP TABLE ${targets.join(", ")}`;
     }
@@ -133,7 +124,7 @@ export class AlterPublicationAddSchemas extends AlterPublicationChange {
             ...this.schemas.map((schema) => stableId.schema(schema)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const clauses = this.schemas.map((schema) => `TABLES IN SCHEMA ${schema}`);
         return `ALTER PUBLICATION ${this.publication.name} ADD ${clauses.join(", ")}`;
     }
@@ -153,7 +144,7 @@ export class AlterPublicationDropSchemas extends AlterPublicationChange {
             ...this.schemas.map((schema) => stableId.schema(schema)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const clauses = this.schemas.map((schema) => `TABLES IN SCHEMA ${schema}`);
         return `ALTER PUBLICATION ${this.publication.name} DROP ${clauses.join(", ")}`;
     }
@@ -170,7 +161,7 @@ export class AlterPublicationSetOwner extends AlterPublicationChange {
     get requires() {
         return [this.publication.stableId, stableId.role(this.owner)];
     }
-    serialize() {
+    serialize(_options) {
         return `ALTER PUBLICATION ${this.publication.name} OWNER TO ${this.owner}`;
     }
 }

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

@@ -2,7 +2,7 @@ import { BaseChange } from "../../base.change.ts";
 import type { Publication } from "../publication.model.ts";
 declare abstract class BasePublicationChange extends BaseChange {
     abstract readonly publication: Publication;
-    abstract readonly scope: "object" | "comment";
+    abstract readonly scope: "object" | "comment" | "security_label";
     readonly objectType: "publication";
 }
 export declare abstract class CreatePublicationChange extends BasePublicationChange {

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Publication } from "../publication.model.ts";
 import { CreatePublicationChange, DropPublicationChange } from "./publication.base.ts";
 export type CommentPublication = CreateCommentOnPublication | DropCommentOnPublication;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnPublication extends CreatePublicationChange
     });
     get creates(): `comment:${string}`[];
     get requires(): `publication:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnPublication extends DropPublicationChange {
     readonly publication: Publication;
@@ -19,5 +20,5 @@ export declare class DropCommentOnPublication extends DropPublicationChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `publication:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnPublication extends CreatePublicationChange {
     get requires() {
         return [this.publication.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON PUBLICATION",
             this.publication.name,
@@ -40,7 +40,7 @@ export class DropCommentOnPublication extends DropPublicationChange {
             this.publication.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return `COMMENT ON PUBLICATION ${this.publication.name} IS NULL`;
     }
 }