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

package/dist/core/objects/type/enum/enum.diff.js

@@ -1,5 +1,5 @@
 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 { AlterEnumAddValue, AlterEnumChangeOwner, } from "./changes/enum.alter.js";
 import { CreateCommentOnEnum, DropCommentOnEnum, } from "./changes/enum.comment.js";
 import { CreateEnum } from "./changes/enum.create.js";
@@ -36,50 +36,21 @@ export function diffEnums(ctx, main, branch) {
         // 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, "enum", createdEnum.schema ?? "");
+        const creatorFilteredDefaults = createdEnum.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
         // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
         // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
         const desiredPrivileges = filterPublicBuiltInDefaults("enum", createdEnum.privileges);
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the enum owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdEnum.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 GrantEnumPrivileges({
-                        enum: createdEnum,
-                        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 RevokeEnumPrivileges({
-                        enum: createdEnum,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionEnumPrivileges({
-                    enum: createdEnum,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("enum", creatorFilteredDefaults), desiredPrivileges, createdEnum.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdEnum, createdEnum, "enum", {
+            Grant: GrantEnumPrivileges,
+            Revoke: RevokeEnumPrivileges,
+            RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        }, ctx.version));
     }
     for (const enumId of dropped) {
         changes.push(new DropEnum({ enum: main[enumId] }));
@@ -105,42 +76,16 @@ export function diffEnums(ctx, main, branch) {
                 changes.push(new CreateCommentOnEnum({ enum: branchEnum }));
             }
             const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "enum", branchEnum.schema ?? "");
+            const creatorFilteredDefaults = branchEnum.owner !== ctx.currentUser
+                ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+                : effectiveDefaults;
             const desiredPrivileges = filterPublicBuiltInDefaults("enum", branchEnum.privileges);
-            const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, branchEnum.owner, ctx.mainRoles);
-            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 GrantEnumPrivileges({
-                            enum: branchEnum,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                    for (const [grantable, list] of revokeGroups) {
-                        void grantable;
-                        changes.push(new RevokeEnumPrivileges({
-                            enum: branchEnum,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionEnumPrivileges({
-                        enum: branchEnum,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("enum", creatorFilteredDefaults), desiredPrivileges, branchEnum.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchEnum, branchEnum, "enum", {
+                Grant: GrantEnumPrivileges,
+                Revoke: RevokeEnumPrivileges,
+                RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+            }, ctx.version));
             continue;
         }
         // OWNER
@@ -169,44 +114,12 @@ export function diffEnums(ctx, main, branch) {
         const branchPrivilegesFiltered = filterPublicBuiltInDefaults("enum", branchEnum.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, branchEnum.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 GrantEnumPrivileges({
-                        enum: branchEnum,
-                        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 RevokeEnumPrivileges({
-                        enum: mainEnum,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionEnumPrivileges({
-                    enum: mainEnum,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchEnum.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchEnum, mainEnum, "enum", {
+            Grant: GrantEnumPrivileges,
+            Revoke: RevokeEnumPrivileges,
+            RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        }, ctx.version));
         // Note: Enum renaming would also use ALTER TYPE ... RENAME TO ...
         // But since our Enum model uses 'name' as the identity field,
         // a name change would be handled as drop + create by diffObjects()

package/dist/core/objects/type/enum/enum.model.js

@@ -119,7 +119,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from

package/dist/core/objects/type/range/changes/range.alter.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { Range } from "../range.model.ts";
 import { AlterRangeChange } from "./range.base.ts";
 /**
@@ -25,7 +26,7 @@ export declare class AlterRangeChangeOwner extends AlterRangeChange {
         owner: string;
     });
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Replace a range type by dropping and recreating it.

package/dist/core/objects/type/range/changes/range.alter.js

@@ -14,7 +14,7 @@ export class AlterRangeChangeOwner extends AlterRangeChange {
     get requires() {
         return [this.range.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER TYPE",
             `${this.range.schema}.${this.range.name}`,

package/dist/core/objects/type/range/changes/range.comment.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { Range } from "../range.model.ts";
 import { CreateRangeChange, DropRangeChange } from "./range.base.ts";
 /**
@@ -12,7 +13,7 @@ export declare class CreateCommentOnRange extends CreateRangeChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `type:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnRange extends DropRangeChange {
     readonly range: Range;
@@ -22,5 +23,5 @@ export declare class DropCommentOnRange extends DropRangeChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/range/changes/range.comment.js

@@ -14,7 +14,7 @@ export class CreateCommentOnRange extends CreateRangeChange {
     get requires() {
         return [this.range.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TYPE",
             `${this.range.schema}.${this.range.name}`,
@@ -37,7 +37,7 @@ export class DropCommentOnRange extends DropRangeChange {
     get requires() {
         return [stableId.comment(this.range.stableId), this.range.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON TYPE",
             `${this.range.schema}.${this.range.name}`,

package/dist/core/objects/type/range/changes/range.create.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { Range } from "../range.model.ts";
 import { CreateRangeChange } from "./range.base.ts";
 /**
@@ -27,5 +28,5 @@ export declare class CreateRange extends CreateRangeChange {
     });
     get creates(): `type:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/range/changes/range.create.js

@@ -1,4 +1,4 @@
-import { isUserDefinedTypeSchema, parseProcedureReference, stableId, } from "../../../utils.js";
+import { isUserDefinedTypeSchema, parseProcedureReference, parseTypeString, stableId, } from "../../../utils.js";
 import { CreateRangeChange } from "./range.base.js";
 /**
  * Create a range type.
@@ -70,12 +70,15 @@ export class CreateRange extends CreateRangeChange {
         }
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const name = `${this.range.schema}.${this.range.name}`;
         const prefix = ["CREATE TYPE", name, "AS RANGE"].join(" ");
         const opts = [];
-        // Required subtype
-        const subtypeQualified = this.range.subtype_schema && this.range.subtype_schema !== "pg_catalog"
+        // Required subtype (format_type may already return schema-qualified name)
+        const alreadyQualified = parseTypeString(this.range.subtype_str);
+        const subtypeQualified = !alreadyQualified &&
+            this.range.subtype_schema &&
+            this.range.subtype_schema !== "pg_catalog"
             ? `${this.range.subtype_schema}.${this.range.subtype_str}`
             : this.range.subtype_str;
         opts.push(`SUBTYPE = ${subtypeQualified}`);

package/dist/core/objects/type/range/changes/range.drop.d.ts

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

package/dist/core/objects/type/range/changes/range.drop.js

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

package/dist/core/objects/type/range/changes/range.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
 import type { Range } from "../range.model.ts";
 import { AlterRangeChange } from "./range.base.ts";
 export type RangePrivilege = GrantRangePrivileges | RevokeRangePrivileges | RevokeGrantOptionRangePrivileges;
@@ -34,7 +35,7 @@ export declare class GrantRangePrivileges extends AlterRangeChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a range type.
@@ -71,7 +72,7 @@ export declare class RevokeRangePrivileges extends AlterRangeChange {
     });
     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 range type.
@@ -93,5 +94,5 @@ export declare class RevokeGrantOptionRangePrivileges extends AlterRangeChange {
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/type/range/changes/range.privilege.js

@@ -33,7 +33,7 @@ export class GrantRangePrivileges extends AlterRangeChange {
     get requires() {
         return [this.range.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 RevokeRangePrivileges extends AlterRangeChange {
             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 RevokeGrantOptionRangePrivileges extends AlterRangeChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("TYPE");
         const privSql = formatObjectPrivilegeList("TYPE", this.privilegeNames, this.version);
         const typeName = `${this.range.schema}.${this.range.name}`;

package/dist/core/objects/type/range/changes/range.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentRange } from "./range.comment.ts";
 import type { CreateRange } from "./range.create.ts";
 import type { DropRange } from "./range.drop.ts";
 import type { RangePrivilege } from "./range.privilege.ts";
+/** Union of all range-related change variants (`objectType: "range"`). @category Change Types */
 export type RangeChange = AlterRange | CommentRange | CreateRange | DropRange | RangePrivilege;

package/dist/core/objects/type/range/range.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 { RangeChange } from "./changes/range.types.ts";
 import type { Range } from "./range.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Range } from "./range.model.ts";
  * @param branch - The ranges in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffRanges(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Range>, branch: Record<string, Range>): RangeChange[];
+export declare function diffRanges(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Range>, branch: Record<string, Range>): RangeChange[];

package/dist/core/objects/type/range/range.diff.js

@@ -1,5 +1,5 @@
 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 { hasNonAlterableChanges } from "../../utils.js";
 import { AlterRangeChangeOwner } from "./changes/range.alter.js";
 import { CreateCommentOnRange, DropCommentOnRange, } from "./changes/range.comment.js";
@@ -37,50 +37,21 @@ export function diffRanges(ctx, main, branch) {
         // 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, "range", createdRange.schema ?? "");
+        const creatorFilteredDefaults = createdRange.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
         // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
         // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
         const desiredPrivileges = filterPublicBuiltInDefaults("range", createdRange.privileges);
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the range owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdRange.owner);
-        // 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 GrantRangePrivileges({
-                        range: createdRange,
-                        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 RevokeRangePrivileges({
-                        range: createdRange,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionRangePrivileges({
-                    range: createdRange,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("range", creatorFilteredDefaults), desiredPrivileges, createdRange.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdRange, createdRange, "range", {
+            Grant: GrantRangePrivileges,
+            Revoke: RevokeRangePrivileges,
+            RevokeGrantOption: RevokeGrantOptionRangePrivileges,
+        }, ctx.version));
     }
     for (const id of dropped) {
         changes.push(new DropRange({ range: main[id] }));
@@ -128,44 +99,12 @@ export function diffRanges(ctx, main, branch) {
             const branchPrivilegesFiltered = filterPublicBuiltInDefaults("range", branchRange.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, branchRange.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 GrantRangePrivileges({
-                            range: branchRange,
-                            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 RevokeRangePrivileges({
-                            range: mainRange,
-                            grantee,
-                            privileges: list,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    changes.push(new RevokeGrantOptionRangePrivileges({
-                        range: mainRange,
-                        grantee,
-                        privilegeNames: result.revokeGrantOption,
-                        version: ctx.version,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchRange.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchRange, mainRange, "range", {
+                Grant: GrantRangePrivileges,
+                Revoke: RevokeRangePrivileges,
+                RevokeGrantOption: RevokeGrantOptionRangePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

package/dist/core/objects/type/range/range.model.js

@@ -140,7 +140,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from pg_catalog.pg_range r

package/dist/core/objects/type/type.types.d.ts

@@ -1,4 +1,5 @@
 import type { CompositeTypeChange } from "./composite-type/changes/composite-type.types.ts";
 import type { EnumChange } from "./enum/changes/enum.types.ts";
 import type { RangeChange } from "./range/changes/range.types.ts";
+/** Union of all type-related change variants (`objectType: "composite_type" | "enum" | "range"`). @category Change Types */
 export type TypeChange = CompositeTypeChange | EnumChange | RangeChange;

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { View } from "../view.model.ts";
 import { AlterViewChange } from "./view.base.ts";
 /**
@@ -30,7 +31,7 @@ export declare class AlterViewChangeOwner extends AlterViewChange {
         owner: string;
     });
     get requires(): `view:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER VIEW ... SET ( ... )
@@ -44,7 +45,7 @@ export declare class AlterViewSetOptions extends AlterViewChange {
         options: string[];
     });
     get requires(): `view:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * ALTER VIEW ... RESET ( ... )
@@ -58,5 +59,5 @@ export declare class AlterViewResetOptions extends AlterViewChange {
         params: string[];
     });
     get requires(): `view:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class AlterViewChangeOwner extends AlterViewChange {
     get requires() {
         return [this.view.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER VIEW",
             `${this.view.schema}.${this.view.name}`,
@@ -39,7 +39,7 @@ export class AlterViewSetOptions extends AlterViewChange {
     get requires() {
         return [this.view.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const opts = this.options.join(", ");
         return [
             "ALTER VIEW",
@@ -64,7 +64,7 @@ export class AlterViewResetOptions extends AlterViewChange {
     get requires() {
         return [this.view.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "ALTER VIEW",
             `${this.view.schema}.${this.view.name}`,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { View } from "../view.model.ts";
 import { CreateViewChange, DropViewChange } from "./view.base.ts";
 export type CommentView = CreateCommentOnView | DropCommentOnView;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnView extends CreateViewChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `view:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnView extends DropViewChange {
     readonly view: View;
@@ -19,5 +20,5 @@ export declare class DropCommentOnView extends DropViewChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `view:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnView extends CreateViewChange {
     get requires() {
         return [this.view.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON VIEW",
             `${this.view.schema}.${this.view.name}`,
@@ -36,7 +36,7 @@ export class DropCommentOnView extends DropViewChange {
     get requires() {
         return [stableId.comment(this.view.stableId), this.view.stableId];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "COMMENT ON VIEW",
             `${this.view.schema}.${this.view.name}`,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { View } from "../view.model.ts";
 import { CreateViewChange } from "./view.base.ts";
 /**
@@ -23,5 +24,5 @@ export declare class CreateView extends CreateViewChange {
     });
     get creates(): (`column:${string}.${string}.${string}` | `view:${string}`)[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -40,7 +40,7 @@ export class CreateView extends CreateViewChange {
         // for those dependencies.
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = [
             `CREATE${this.orReplace ? " OR REPLACE" : ""} VIEW`,
         ];