@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -3,18 +3,19 @@ import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
 export declare const ReplicaIdentitySchema: z.ZodEnum<{
-    f: "f";
     n: "n";
     i: "i";
     d: "d";
+    f: "f";
 }>;
 declare const tableConstraintPropsSchema: z.ZodObject<{
     name: z.ZodString;
     constraint_type: z.ZodEnum<{
-        f: "f";
         u: "u";
-        p: "p";
+        t: "t";
         c: "c";
+        p: "p";
+        f: "f";
         x: "x";
     }>;
     deferrable: z.ZodBoolean;
@@ -22,6 +23,7 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     validated: z.ZodBoolean;
     is_local: z.ZodBoolean;
     no_inherit: z.ZodBoolean;
+    is_temporal: z.ZodBoolean;
     is_partition_clone: z.ZodBoolean;
     parent_constraint_schema: z.ZodNullable<z.ZodString>;
     parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -37,24 +39,24 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     foreign_key_effective_schema: z.ZodNullable<z.ZodString>;
     foreign_key_effective_table: z.ZodNullable<z.ZodString>;
     on_update: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         n: "n";
         a: "a";
+        r: "r";
         d: "d";
         c: "c";
     }>>;
     on_delete: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         n: "n";
         a: "a";
+        r: "r";
         d: "d";
         c: "c";
     }>>;
     match_type: z.ZodNullable<z.ZodEnum<{
-        f: "f";
         u: "u";
         s: "s";
         p: "p";
+        f: "f";
     }>>;
     check_expression: z.ZodNullable<z.ZodString>;
     owner: z.ZodString;
@@ -78,10 +80,10 @@ declare const tablePropsSchema: z.ZodObject<{
     has_subclasses: z.ZodBoolean;
     is_populated: z.ZodBoolean;
     replica_identity: z.ZodEnum<{
-        f: "f";
         n: "n";
         i: "i";
         d: "d";
+        f: "f";
     }>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
@@ -112,10 +114,11 @@ declare const tablePropsSchema: z.ZodObject<{
     constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         constraint_type: z.ZodEnum<{
-            f: "f";
             u: "u";
-            p: "p";
+            t: "t";
             c: "c";
+            p: "p";
+            f: "f";
             x: "x";
         }>;
         deferrable: z.ZodBoolean;
@@ -123,6 +126,7 @@ declare const tablePropsSchema: z.ZodObject<{
         validated: z.ZodBoolean;
         is_local: z.ZodBoolean;
         no_inherit: z.ZodBoolean;
+        is_temporal: z.ZodBoolean;
         is_partition_clone: z.ZodBoolean;
         parent_constraint_schema: z.ZodNullable<z.ZodString>;
         parent_constraint_name: z.ZodNullable<z.ZodString>;
@@ -138,24 +142,24 @@ declare const tablePropsSchema: z.ZodObject<{
         foreign_key_effective_schema: z.ZodNullable<z.ZodString>;
         foreign_key_effective_table: z.ZodNullable<z.ZodString>;
         on_update: z.ZodNullable<z.ZodEnum<{
-            r: "r";
             n: "n";
             a: "a";
+            r: "r";
             d: "d";
             c: "c";
         }>>;
         on_delete: z.ZodNullable<z.ZodEnum<{
-            r: "r";
             n: "n";
             a: "a";
+            r: "r";
             d: "d";
             c: "c";
         }>>;
         match_type: z.ZodNullable<z.ZodEnum<{
-            f: "f";
             u: "u";
             s: "s";
             p: "p";
+            f: "f";
         }>>;
         check_expression: z.ZodNullable<z.ZodString>;
         owner: z.ZodString;
@@ -204,7 +208,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         persistence: "u" | "t" | "p";
         row_security: boolean;
         force_row_security: boolean;
-        replica_identity: "f" | "n" | "i" | "d";
+        replica_identity: "n" | "i" | "d" | "f";
         options: string[] | null;
         parent_schema: string | null;
         parent_name: string | null;
@@ -231,12 +235,13 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         }[];
         constraints: {
             name: string;
-            constraint_type: "f" | "u" | "p" | "c" | "x";
+            constraint_type: "u" | "t" | "c" | "p" | "f" | "x";
             deferrable: boolean;
             initially_deferred: boolean;
             validated: boolean;
             is_local: boolean;
             no_inherit: boolean;
+            is_temporal: boolean;
             is_partition_clone: boolean;
             parent_constraint_schema: string | null;
             parent_constraint_name: string | null;
@@ -251,9 +256,9 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             foreign_key_parent_table: string | null;
             foreign_key_effective_schema: string | null;
             foreign_key_effective_table: string | null;
-            on_update: "r" | "n" | "a" | "d" | "c" | null;
-            on_delete: "r" | "n" | "a" | "d" | "c" | null;
-            match_type: "f" | "u" | "s" | "p" | null;
+            on_update: "n" | "a" | "r" | "d" | "c" | null;
+            on_delete: "n" | "a" | "r" | "d" | "c" | null;
+            match_type: "u" | "s" | "p" | "f" | null;
             check_expression: string | null;
             owner: string;
             definition: string;
@@ -292,12 +297,13 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             options: string[] | null;
             constraints: {
                 name: string;
-                constraint_type: "f" | "u" | "p" | "c" | "x";
+                constraint_type: "u" | "t" | "c" | "p" | "f" | "x";
                 deferrable: boolean;
                 initially_deferred: boolean;
                 validated: boolean;
                 is_local: boolean;
                 no_inherit: boolean;
+                is_temporal: boolean;
                 is_partition_clone: boolean;
                 parent_constraint_schema: string | null;
                 parent_constraint_name: string | null;
@@ -312,9 +318,9 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 foreign_key_parent_table: string | null;
                 foreign_key_effective_schema: string | null;
                 foreign_key_effective_table: string | null;
-                on_update: "r" | "n" | "a" | "d" | "c" | null;
-                on_delete: "r" | "n" | "a" | "d" | "c" | null;
-                match_type: "f" | "u" | "s" | "p" | null;
+                on_update: "n" | "a" | "r" | "d" | "c" | null;
+                on_delete: "n" | "a" | "r" | "d" | "c" | null;
+                match_type: "u" | "s" | "p" | "f" | null;
                 check_expression: string | null;
                 owner: string;
                 definition: string;
@@ -324,11 +330,12 @@ export declare class Table extends BasePgModel implements TableLikeObject {
                 grantee: string;
                 privilege: string;
                 grantable: boolean;
+                columns: string[] | null | undefined;
             }[];
             persistence: "u" | "t" | "p";
             row_security: boolean;
             force_row_security: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
             parent_schema: string | null;
             parent_name: string | null;
             partition_bound: string | null;

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

@@ -33,6 +33,7 @@ const tableConstraintPropsSchema = z.object({
         "c", // CHECK constraint
         "f", // FOREIGN KEY constraint
         "p", // PRIMARY KEY constraint
+        "t", // TRIGGER constraint
         "u", // UNIQUE constraint
         "x", // EXCLUDE constraint
     ]),
@@ -41,6 +42,7 @@ const tableConstraintPropsSchema = z.object({
     validated: z.boolean(),
     is_local: z.boolean(),
     no_inherit: z.boolean(),
+    is_temporal: z.boolean(),
     is_partition_clone: z.boolean(),
     parent_constraint_schema: z.string().nullable(),
     parent_constraint_name: z.string().nullable(),
@@ -252,6 +254,7 @@ select
           'validated', c.convalidated,
           'is_local', c.conislocal,
           'no_inherit', c.connoinherit,
+          'is_temporal', coalesce((to_jsonb(c)->>'conperiod')::boolean, false),
 
           -- NEW: propagated-to-partition tagging (PG15+)
           'is_partition_clone', (c.conparentid <> 0::oid),
@@ -338,6 +341,8 @@ select
       and de.refclassid = 'pg_extension'::regclass
 
       where c.conrelid = t.oid
+        -- Skip constraint triggers and PG18 NOT NULL constraints; they are modeled elsewhere
+        and c.contype not in ('t', 'n')
         and not c.connamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
         and de.objid is null
     ),
@@ -394,7 +399,7 @@ select
       from (
         -- one row for object ACL + one row per column ACL
         select null::name as attname, t.oid as relacl_oid, (
-          select c_rel.relacl from pg_class c_rel where c_rel.oid = t.oid
+          select COALESCE(c_rel.relacl, acldefault('r', c_rel.relowner)) from pg_class c_rel where c_rel.oid = t.oid
         ) as acl
         union all
         select a2.attname, t.oid as relacl_oid, a2.attacl

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { TableLikeObject } from "../../base.model.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { AlterTriggerChange } from "./trigger.base.ts";
@@ -25,5 +26,5 @@ export declare class ReplaceTrigger extends AlterTriggerChange {
         indexableObject?: TableLikeObject;
     });
     get requires(): `trigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -1,5 +1,7 @@
+import { quoteLiteral } from "../../base.change.js";
 import { AlterTriggerChange } from "./trigger.base.js";
 import { CreateTrigger } from "./trigger.create.js";
+import { DropTrigger } from "./trigger.drop.js";
 /**
  * Replace a trigger by dropping and recreating it.
  * This is used when properties that cannot be altered via ALTER TRIGGER change.
@@ -16,7 +18,28 @@ export class ReplaceTrigger extends AlterTriggerChange {
     get requires() {
         return [this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
+        if (this.trigger.isConstraintTrigger) {
+            const dropChange = new DropTrigger({ trigger: this.trigger });
+            const createChange = new CreateTrigger({
+                trigger: this.trigger,
+                indexableObject: this.indexableObject,
+                orReplace: false,
+            });
+            const commentSql = this.trigger.comment !== null
+                ? [
+                    "COMMENT ON TRIGGER",
+                    this.trigger.name,
+                    "ON",
+                    `${this.trigger.schema}.${this.trigger.table_name}`,
+                    "IS",
+                    quoteLiteral(this.trigger.comment),
+                ].join(" ")
+                : null;
+            return [dropChange.serialize(), createChange.serialize(), commentSql]
+                .filter(Boolean)
+                .join(";\n");
+        }
         const createChange = new CreateTrigger({
             trigger: this.trigger,
             indexableObject: this.indexableObject,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { CreateTriggerChange, DropTriggerChange } from "./trigger.base.ts";
 export type CommentTrigger = CreateCommentOnTrigger | DropCommentOnTrigger;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnTrigger extends CreateTriggerChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `trigger:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnTrigger extends DropTriggerChange {
     readonly trigger: Trigger;
@@ -19,5 +20,5 @@ export declare class DropCommentOnTrigger extends DropTriggerChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `trigger:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnTrigger extends CreateTriggerChange {
     get requires() {
         return [this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TRIGGER",
             this.trigger.name,
@@ -39,7 +39,7 @@ export class DropCommentOnTrigger extends DropTriggerChange {
     get requires() {
         return [stableId.comment(this.trigger.stableId), this.trigger.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TRIGGER",
             this.trigger.name,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { TableLikeObject } from "../../base.model.ts";
 import type { Trigger } from "../trigger.model.ts";
 import { CreateTriggerChange } from "./trigger.base.ts";
@@ -37,5 +38,5 @@ export declare class CreateTrigger extends CreateTriggerChange {
     });
     get creates(): `trigger:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -45,17 +45,16 @@ export class CreateTrigger extends CreateTriggerChange {
         // Table dependency
         dependencies.add(stableId.table(this.trigger.schema, this.trigger.table_name));
         // Function dependency
-        // Note: We can't build the exact procedure stableId without argument types.
-        // The trigger definition contains the full function call, but parsing it would be complex.
-        // For now, we rely on pg_depend extraction for procedure dependencies.
-        // If needed, we could parse the trigger definition to extract the full function signature.
+        // Trigger functions always have signature () RETURNS trigger, so no arguments.
+        dependencies.add(stableId.procedure(this.trigger.function_schema, this.trigger.function_name));
         // Owner dependency
         dependencies.add(stableId.role(this.trigger.owner));
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         let definition = this.trigger.definition.trim();
-        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
+        const isConstraintTrigger = this.trigger.isConstraintTrigger;
+        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace && !isConstraintTrigger ? "OR REPLACE " : ""}`);
         return definition;
     }
 }

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

@@ -5,6 +5,13 @@ 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 +44,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 +67,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 +83,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,6 +93,7 @@ export declare class Trigger extends BasePgModel {
         parent_table_name: string | null;
         is_on_partitioned_table: boolean;
         owner: string;
+        definition: string;
         comment: string | null;
     };
 }

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

@@ -7,10 +7,18 @@ const TriggerEnabledSchema = z.enum([
     "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(),
@@ -37,6 +45,7 @@ export class Trigger extends BasePgModel {
     schema;
     name;
     table_name;
+    table_relkind;
     function_schema;
     function_name;
     trigger_type;
@@ -64,6 +73,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 +97,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 +120,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,6 +134,7 @@ 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,
         };
     }
@@ -147,6 +164,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,

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.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;
 }