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

package/dist/core/objects/trigger/changes/trigger.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { DropTriggerChange } from "./trigger.base.ts";
 /**
@@ -18,5 +19,5 @@ export declare class DropTrigger extends DropTriggerChange {
     });
     get drops(): `trigger:${string}`[];
     get requires(): `trigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/trigger/changes/trigger.drop.js

@@ -22,7 +22,7 @@ export class DropTrigger extends DropTriggerChange {
     get requires() {
         return [this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "DROP TRIGGER",
             this.trigger.name,

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

@@ -2,4 +2,5 @@ import type { AlterTrigger } from "./trigger.alter.ts";
 import type { CommentTrigger } from "./trigger.comment.ts";
 import type { CreateTrigger } from "./trigger.create.ts";
 import type { DropTrigger } from "./trigger.drop.ts";
+/** Union of all trigger-related change variants (`objectType: "trigger"`). @category Change Types */
 export type TriggerChange = AlterTrigger | CommentTrigger | CreateTrigger | DropTrigger;

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

@@ -44,6 +44,11 @@ export function diffTriggers(main, branch, branchIndexableObjects) {
         if (mainTrigger.is_partition_clone || branchTrigger.is_partition_clone) {
             continue;
         }
+        // Note: column_numbers is excluded because it contains pg_trigger.tgattr
+        // attnums that differ between databases when physical column layouts
+        // diverge but logical (named) columns match. The definition field
+        // (pg_get_triggerdef) already captures the UPDATE OF column list by name,
+        // so we compare by definition instead.
         const NON_ALTERABLE_FIELDS = [
             "function_schema",
             "function_name",
@@ -53,14 +58,14 @@ export function diffTriggers(main, branch, branchIndexableObjects) {
             "deferrable",
             "initially_deferred",
             "argument_count",
-            "column_numbers",
             "arguments",
             "when_condition",
             "old_table",
             "new_table",
             "owner",
+            "definition", // Compare by definition instead of column_numbers (tgattr)
         ];
-        const shouldReplace = hasNonAlterableChanges(mainTrigger, branchTrigger, NON_ALTERABLE_FIELDS, { column_numbers: deepEqual, arguments: deepEqual });
+        const shouldReplace = hasNonAlterableChanges(mainTrigger, branchTrigger, NON_ALTERABLE_FIELDS, { arguments: deepEqual });
         if (shouldReplace) {
             const tableStableId = stableId.table(branchTrigger.schema, branchTrigger.table_name);
             changes.push(new ReplaceTrigger({

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

@@ -1,10 +1,18 @@
 import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../base.model.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
 declare const triggerPropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
     table_name: z.ZodString;
+    table_relkind: z.ZodEnum<{
+        r: "r";
+        v: "v";
+        m: "m";
+        p: "p";
+        f: "f";
+    }>;
     function_schema: z.ZodString;
     function_name: z.ZodString;
     trigger_type: z.ZodNumber;
@@ -37,6 +45,7 @@ export declare class Trigger extends BasePgModel {
     readonly schema: TriggerProps["schema"];
     readonly name: TriggerProps["name"];
     readonly table_name: TriggerProps["table_name"];
+    readonly table_relkind: TriggerProps["table_relkind"];
     readonly function_schema: TriggerProps["function_schema"];
     readonly function_name: TriggerProps["function_name"];
     readonly trigger_type: TriggerProps["trigger_type"];
@@ -59,6 +68,7 @@ export declare class Trigger extends BasePgModel {
     readonly definition: TriggerProps["definition"];
     readonly comment: TriggerProps["comment"];
     constructor(props: TriggerProps);
+    get isConstraintTrigger(): boolean;
     get stableId(): `trigger:${string}`;
     get identityFields(): {
         schema: string;
@@ -74,7 +84,6 @@ export declare class Trigger extends BasePgModel {
         deferrable: boolean;
         initially_deferred: boolean;
         argument_count: number;
-        column_numbers: number[] | null;
         arguments: string[];
         when_condition: string | null;
         old_table: string | null;
@@ -85,8 +94,9 @@ export declare class Trigger extends BasePgModel {
         parent_table_name: string | null;
         is_on_partitioned_table: boolean;
         owner: string;
+        definition: string;
         comment: string | null;
     };
 }
-export declare function extractTriggers(pool: Pool): Promise<Trigger[]>;
+export declare function extractTriggers(pool: Pool, options?: ExtractRetryOptions): Promise<Trigger[]>;
 export {};

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

@@ -1,16 +1,25 @@
 import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../base.model.js";
+import { extractWithDefinitionRetry, } from "../extract-with-retry.js";
 const TriggerEnabledSchema = z.enum([
     "O", // ORIGIN - trigger fires in "origin" and "local" replica modes
     "D", // DISABLED - trigger is disabled
     "R", // REPLICA - trigger fires only in "replica" mode
     "A", // ALWAYS - trigger fires regardless of replication mode
 ]);
+const TriggerTableRelkindSchema = z.enum([
+    "r", // ordinary table
+    "p", // partitioned table
+    "f", // foreign table
+    "v", // view
+    "m", // materialized view
+]);
 const triggerPropsSchema = z.object({
     schema: z.string(),
     name: z.string(),
     table_name: z.string(),
+    table_relkind: TriggerTableRelkindSchema,
     function_schema: z.string(),
     function_name: z.string(),
     trigger_type: z.number(),
@@ -33,10 +42,19 @@ const triggerPropsSchema = z.object({
     definition: z.string(),
     comment: z.string().nullable(),
 });
+// pg_get_triggerdef(oid, pretty) can return NULL when the trigger (its
+// pg_trigger row) is dropped between catalog scan and resolution, or under
+// transient catalog state. An unreadable trigger 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 triggerRowSchema = triggerPropsSchema.extend({
+    definition: z.string().nullable(),
+});
 export class Trigger extends BasePgModel {
     schema;
     name;
     table_name;
+    table_relkind;
     function_schema;
     function_name;
     trigger_type;
@@ -64,6 +82,7 @@ export class Trigger extends BasePgModel {
         this.schema = props.schema;
         this.name = props.name;
         this.table_name = props.table_name;
+        this.table_relkind = props.table_relkind;
         // Data fields
         this.function_schema = props.function_schema;
         this.function_name = props.function_name;
@@ -87,6 +106,9 @@ export class Trigger extends BasePgModel {
         this.definition = props.definition;
         this.comment = props.comment;
     }
+    get isConstraintTrigger() {
+        return /^CREATE\s+CONSTRAINT\s+TRIGGER/i.test(this.definition.trim());
+    }
     get stableId() {
         return `trigger:${this.schema}.${this.table_name}.${this.name}`;
     }
@@ -107,7 +129,10 @@ export class Trigger extends BasePgModel {
             deferrable: this.deferrable,
             initially_deferred: this.initially_deferred,
             argument_count: this.argument_count,
-            column_numbers: this.column_numbers,
+            // column_numbers excluded: contains pg_trigger.tgattr attnums that differ
+            // between databases when physical column layouts diverge but logical
+            // (named) columns match. The definition field (pg_get_triggerdef) captures
+            // the UPDATE OF column list by name, so we compare by definition instead.
             arguments: this.arguments,
             when_condition: this.when_condition,
             old_table: this.old_table,
@@ -118,12 +143,18 @@ export class Trigger extends BasePgModel {
             parent_table_name: this.parent_table_name,
             is_on_partitioned_table: this.is_on_partitioned_table,
             owner: this.owner,
+            definition: this.definition,
             comment: this.comment,
         };
     }
 }
-export async function extractTriggers(pool) {
-    const { rows: triggerRows } = await pool.query(sql `
+export async function extractTriggers(pool, options) {
+    const triggerRows = await extractWithDefinitionRetry({
+        label: "triggers",
+        options,
+        hasNullDefinition: (row) => row.definition === null,
+        query: async () => {
+            const result = await pool.query(sql `
       with extension_trigger_oids as (
         select objid
         from pg_depend d
@@ -147,6 +178,7 @@ export async function extractTriggers(pool) {
         tc.relnamespace::regnamespace::text as schema,
         quote_ident(t.tgname)               as name,
         quote_ident(tc.relname)             as table_name,
+        tc.relkind                          as table_relkind,
 
         fc.pronamespace::regnamespace::text as function_schema,
         quote_ident(fc.proname)             as function_name,
@@ -227,7 +259,9 @@ export async function extractTriggers(pool) {
 
       order by 1, 2
   `);
-    // Validate and parse each row using the Zod schema
-    const validatedRows = triggerRows.map((row) => triggerPropsSchema.parse(row));
+            return result.rows.map((row) => triggerRowSchema.parse(row));
+        },
+    });
+    const validatedRows = triggerRows.filter((row) => row.definition !== null);
     return validatedRows.map((row) => new Trigger(row));
 }

package/dist/core/objects/type/composite-type/changes/composite-type.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 import { AlterCompositeTypeChange } from "./composite-type.base.ts";
 /**
@@ -29,7 +30,7 @@ export declare class AlterCompositeTypeChangeOwner extends AlterCompositeTypeCha
         owner: string;
     });
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER TYPE ... ADD ATTRIBUTE ...
@@ -44,7 +45,7 @@ export declare class AlterCompositeTypeAddAttribute extends AlterCompositeTypeCh
     });
     get creates(): string[];
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER TYPE ... DROP ATTRIBUTE ...
@@ -58,7 +59,7 @@ export declare class AlterCompositeTypeDropAttribute extends AlterCompositeTypeC
         attribute: CompositeType["columns"][number];
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER TYPE ... ALTER ATTRIBUTE ... TYPE ... [ COLLATE ... ]
@@ -72,7 +73,7 @@ export declare class AlterCompositeTypeAlterAttributeType extends AlterComposite
         attribute: CompositeType["columns"][number];
     });
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Replace a composite type by dropping and recreating it.

package/dist/core/objects/type/composite-type/changes/composite-type.alter.js

@@ -14,7 +14,7 @@ export class AlterCompositeTypeChangeOwner extends AlterCompositeTypeChange {
     get requires() {
         return [this.compositeType.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,
@@ -41,7 +41,7 @@ export class AlterCompositeTypeAddAttribute extends AlterCompositeTypeChange {
     get requires() {
         return [this.compositeType.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const parts = [
             "ALTER TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,
@@ -73,7 +73,7 @@ export class AlterCompositeTypeDropAttribute extends AlterCompositeTypeChange {
             this.compositeType.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,
@@ -100,7 +100,7 @@ export class AlterCompositeTypeAlterAttributeType extends AlterCompositeTypeChan
             this.compositeType.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         const parts = [
             "ALTER TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,

package/dist/core/objects/type/composite-type/changes/composite-type.base.d.ts

@@ -2,7 +2,7 @@ import { BaseChange } from "../../../base.change.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 declare abstract class BaseCompositeTypeChange extends BaseChange {
     abstract readonly compositeType: CompositeType;
-    abstract readonly scope: "object" | "comment" | "privilege";
+    abstract readonly scope: "object" | "comment" | "privilege" | "security_label";
     readonly objectType: "composite_type";
 }
 export declare abstract class CreateCompositeTypeChange extends BaseCompositeTypeChange {

package/dist/core/objects/type/composite-type/changes/composite-type.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { ColumnProps } from "../../../base.model.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 import { CreateCompositeTypeChange, DropCompositeTypeChange } from "./composite-type.base.ts";
@@ -15,7 +16,7 @@ export declare class CreateCommentOnCompositeType extends CreateCompositeTypeCha
     });
     get creates(): `comment:${string}`[];
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnCompositeType extends DropCompositeTypeChange {
     readonly compositeType: CompositeType;
@@ -25,7 +26,7 @@ export declare class DropCommentOnCompositeType extends DropCompositeTypeChange
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class CreateCommentOnCompositeTypeAttribute extends CreateCompositeTypeChange {
     readonly compositeType: CompositeType;
@@ -37,7 +38,7 @@ export declare class CreateCommentOnCompositeTypeAttribute extends CreateComposi
     });
     get creates(): `comment:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnCompositeTypeAttribute extends DropCompositeTypeChange {
     readonly compositeType: CompositeType;
@@ -49,5 +50,5 @@ export declare class DropCommentOnCompositeTypeAttribute extends DropCompositeTy
     });
     get drops(): `comment:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/composite-type/changes/composite-type.comment.js

@@ -14,7 +14,7 @@ export class CreateCommentOnCompositeType extends CreateCompositeTypeChange {
     get requires() {
         return [this.compositeType.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,
@@ -40,7 +40,7 @@ export class DropCommentOnCompositeType extends DropCompositeTypeChange {
             this.compositeType.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,
@@ -67,7 +67,7 @@ export class CreateCommentOnCompositeTypeAttribute extends CreateCompositeTypeCh
             this.compositeType.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON COLUMN",
             `${this.compositeType.schema}.${this.compositeType.name}.${this.attribute.name}`,
@@ -98,7 +98,7 @@ export class DropCommentOnCompositeTypeAttribute extends DropCompositeTypeChange
             this.compositeType.stableId,
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON COLUMN",
             `${this.compositeType.schema}.${this.compositeType.name}.${this.attribute.name}`,

package/dist/core/objects/type/composite-type/changes/composite-type.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 import { CreateCompositeTypeChange } from "./composite-type.base.ts";
 /**
@@ -19,5 +20,5 @@ export declare class CreateCompositeType extends CreateCompositeTypeChange {
     });
     get creates(): `type:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/composite-type/changes/composite-type.create.js

@@ -48,7 +48,7 @@ export class CreateCompositeType extends CreateCompositeTypeChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = ["CREATE TYPE"];
         // Add schema and name
         parts.push(`${this.compositeType.schema}.${this.compositeType.name}`);

package/dist/core/objects/type/composite-type/changes/composite-type.drop.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 import { DropCompositeTypeChange } from "./composite-type.base.ts";
 /**
@@ -18,5 +19,5 @@ export declare class DropCompositeType extends DropCompositeTypeChange {
     });
     get drops(): `type:${string}`[];
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/composite-type/changes/composite-type.drop.js

@@ -22,7 +22,7 @@ export class DropCompositeType extends DropCompositeTypeChange {
     get requires() {
         return [this.compositeType.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "DROP TYPE",
             `${this.compositeType.schema}.${this.compositeType.name}`,

package/dist/core/objects/type/composite-type/changes/composite-type.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { CompositeType } from "../composite-type.model.ts";
 import { AlterCompositeTypeChange } from "./composite-type.base.ts";
 export type CompositeTypePrivilege = GrantCompositeTypePrivileges | RevokeCompositeTypePrivileges | RevokeGrantOptionCompositeTypePrivileges;
@@ -34,7 +35,7 @@ export declare class GrantCompositeTypePrivileges extends AlterCompositeTypeChan
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a composite type.
@@ -71,7 +72,7 @@ export declare class RevokeCompositeTypePrivileges extends AlterCompositeTypeCha
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a composite type.
@@ -93,5 +94,5 @@ export declare class RevokeGrantOptionCompositeTypePrivileges extends AlterCompo
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/composite-type/changes/composite-type.privilege.js

@@ -33,7 +33,7 @@ export class GrantCompositeTypePrivileges extends AlterCompositeTypeChange {
     get requires() {
         return [this.compositeType.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -87,7 +87,7 @@ export class RevokeCompositeTypePrivileges extends AlterCompositeTypeChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("TYPE");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
@@ -122,7 +122,7 @@ export class RevokeGrantOptionCompositeTypePrivileges extends AlterCompositeType
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("TYPE");
         const privSql = formatObjectPrivilegeList("TYPE", this.privilegeNames, this.version);
         const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;

package/dist/core/objects/type/composite-type/changes/composite-type.security-label.d.ts

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../../security-label.types.ts";
+import type { CompositeType } from "../composite-type.model.ts";
+import { CreateCompositeTypeChange, DropCompositeTypeChange } from "./composite-type.base.ts";
+export type SecurityLabelCompositeType = CreateSecurityLabelOnCompositeType | DropSecurityLabelOnCompositeType;
+export declare class CreateSecurityLabelOnCompositeType extends CreateCompositeTypeChange {
+    readonly compositeType: CompositeType;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        compositeType: CompositeType;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnCompositeType extends DropCompositeTypeChange {
+    readonly compositeType: CompositeType;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        compositeType: CompositeType;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `type:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/type/composite-type/changes/composite-type.security-label.js

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateCompositeTypeChange, DropCompositeTypeChange, } from "./composite-type.base.js";
+export class CreateSecurityLabelOnCompositeType extends CreateCompositeTypeChange {
+    compositeType;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.compositeType = props.compositeType;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.compositeType.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.compositeType.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON TYPE",
+            `${this.compositeType.schema}.${this.compositeType.name}`,
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnCompositeType extends DropCompositeTypeChange {
+    compositeType;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.compositeType = props.compositeType;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.compositeType.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.compositeType.stableId, this.securityLabel.provider),
+            this.compositeType.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON TYPE",
+            `${this.compositeType.schema}.${this.compositeType.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/type/composite-type/changes/composite-type.types.d.ts

@@ -3,4 +3,6 @@ import type { CommentCompositeType } from "./composite-type.comment.ts";
 import type { CreateCompositeType } from "./composite-type.create.ts";
 import type { DropCompositeType } from "./composite-type.drop.ts";
 import type { CompositeTypePrivilege } from "./composite-type.privilege.ts";
-export type CompositeTypeChange = AlterCompositeType | CommentCompositeType | CreateCompositeType | DropCompositeType | CompositeTypePrivilege;
+import type { SecurityLabelCompositeType } from "./composite-type.security-label.ts";
+/** Union of all composite-type-related change variants (`objectType: "composite_type"`). @category Change Types */
+export type CompositeTypeChange = AlterCompositeType | CommentCompositeType | CreateCompositeType | DropCompositeType | CompositeTypePrivilege | SecurityLabelCompositeType;

package/dist/core/objects/type/composite-type/composite-type.diff.d.ts

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
-import type { Role } from "../../role/role.model.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
 import type { CompositeTypeChange } from "./changes/composite-type.types.ts";
 import type { CompositeType } from "./composite-type.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { CompositeType } from "./composite-type.model.ts";
  * @param branch - The composite types in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffCompositeTypes(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, CompositeType>, branch: Record<string, CompositeType>): CompositeTypeChange[];
+export declare function diffCompositeTypes(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, CompositeType>, branch: Record<string, CompositeType>): CompositeTypeChange[];