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

package/dist/core/integrations/supabase.d.ts

@@ -7,4 +7,12 @@
  * - Skips authorization for schema creates owned by Supabase system roles
  */
 import type { IntegrationDSL } from "./integration-dsl.ts";
+/**
+ * To generate the emptyCatalog snapshot, run catalog-export against a fresh
+ * supabase/postgres container:
+ *
+ *   pgdelta catalog-export --target postgres://postgres:postgres@localhost:54322/postgres --output supabase-baseline.json
+ *
+ * Then import and assign the JSON content to the emptyCatalog field below.
+ */
 export declare const supabase: IntegrationDSL;

package/dist/core/integrations/supabase.js

@@ -13,6 +13,7 @@ const SUPABASE_SYSTEM_SCHEMAS = [
     "_supavisor",
     "auth",
     "cron",
+    "etl",
     "extensions",
     "graphql",
     "graphql_public",
@@ -35,6 +36,7 @@ const SUPABASE_SYSTEM_ROLES = [
     "anon",
     "authenticated",
     "authenticator",
+    "cli_login_postgres",
     "dashboard_user",
     "pgbouncer",
     "pgsodium_keyholder",
@@ -50,42 +52,73 @@ const SUPABASE_SYSTEM_ROLES = [
     "supabase_realtime_admin",
     "supabase_replication_admin",
     "supabase_storage_admin",
+    "supabase_superuser",
 ];
+/**
+ * To generate the emptyCatalog snapshot, run catalog-export against a fresh
+ * supabase/postgres container:
+ *
+ *   pgdelta catalog-export --target postgres://postgres:postgres@localhost:54322/postgres --output supabase-baseline.json
+ *
+ * Then import and assign the JSON content to the emptyCatalog field below.
+ */
 export const supabase = {
+    // TODO: emptyCatalog: undefined -- populate by running catalog-export on a clean Supabase container
     filter: {
         or: [
+            // Include user schema CREATE operations (only schemas not in system list)
             {
                 and: [
                     {
-                        type: "schema",
+                        objectType: "schema",
                         operation: "create",
                         scope: "object",
                     },
                     {
                         not: {
-                            schema: [...SUPABASE_SYSTEM_SCHEMAS],
+                            // Schema objects have name, not schema — use schema/name
+                            "schema/name": [...SUPABASE_SYSTEM_SCHEMAS],
                         },
                     },
                 ],
             },
+            // Include extension CREATEs
             {
-                type: "extension",
+                objectType: "extension",
                 operation: "create",
                 scope: "object",
             },
+            // Include extension DROPs used to disable some extensions (eg: pg-net)
+            {
+                objectType: "extension",
+                operation: "drop",
+                scope: "object",
+            },
+            // Exclude system objects
             {
                 not: {
                     or: [
+                        // Objects in system schemas (*/schema matches table/schema, view/schema, etc.)
                         {
-                            schema: [...SUPABASE_SYSTEM_SCHEMAS],
+                            "*/schema": [...SUPABASE_SYSTEM_SCHEMAS],
                         },
+                        // Schema objects whose own name is a system schema
                         {
-                            owner: [...SUPABASE_SYSTEM_ROLES],
+                            "schema/name": [...SUPABASE_SYSTEM_SCHEMAS],
                         },
+                        // Objects owned by system roles (*/owner matches table/owner, schema/owner, etc.)
+                        {
+                            "*/owner": [...SUPABASE_SYSTEM_ROLES],
+                        },
+                        // Role objects whose own name is a system role
+                        {
+                            "role/name": [...SUPABASE_SYSTEM_ROLES],
+                        },
+                        // Membership changes for system roles
                         {
                             and: [
                                 {
-                                    type: "role",
+                                    objectType: "role",
                                     scope: "membership",
                                 },
                                 {
@@ -101,14 +134,42 @@ export const supabase = {
     serialize: [
         {
             when: {
-                type: "schema",
+                objectType: "schema",
                 operation: "create",
                 scope: "object",
-                owner: [...SUPABASE_SYSTEM_ROLES],
+                "schema/owner": [...SUPABASE_SYSTEM_ROLES],
             },
             options: {
                 skipAuthorization: true,
             },
         },
+        // Extensions whose install script creates its own target schema cannot
+        // tolerate `CREATE EXTENSION … WITH SCHEMA <self>` against a fresh
+        // database: Postgres resolves WITH SCHEMA before running the extension's
+        // script, so the schema referenced by the clause does not exist yet.
+        // These extensions also install into schemas listed in
+        // SUPABASE_SYSTEM_SCHEMAS, so pg-delta filters their CREATE SCHEMA out
+        // of the declarative plan — nothing else will pre-create the schema.
+        // Emitting a bare `CREATE EXTENSION <name>` lets the extension's own
+        // install script create the schema it expects.
+        //
+        // Note: other extensions install into SUPABASE_SYSTEM_SCHEMAS too
+        // (`pg_graphql` → `graphql`, `supabase_vault` → `vault`,
+        // `uuid-ossp`/`pgcrypto`/`pg_net`/`pg_stat_statements` → `extensions`),
+        // but those schemas are created by the supabase/postgres image baseline
+        // and survive `DROP EXTENSION … CASCADE`, so `CREATE EXTENSION … WITH
+        // SCHEMA <schema>` finds the schema and succeeds. Only the three below
+        // have self-created schemas that are absent from the baseline.
+        {
+            when: {
+                objectType: "extension",
+                operation: "create",
+                scope: "object",
+                "extension/schema": ["pgmq", "pgsodium", "pgtle"],
+            },
+            options: {
+                skipSchema: true,
+            },
+        },
     ],
 };

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

@@ -1,10 +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 { Aggregate } from "./aggregate.model.ts";
 import type { AggregateChange } from "./changes/aggregate.types.ts";
-export declare function diffAggregates(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Aggregate>, branch: Record<string, Aggregate>): AggregateChange[];
+export declare function diffAggregates(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Aggregate>, branch: Record<string, Aggregate>): AggregateChange[];

package/dist/core/objects/aggregate/aggregate.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 { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterAggregateChangeOwner } from "./changes/aggregate.alter.js";
 import { CreateCommentOnAggregate, DropCommentOnAggregate, } from "./changes/aggregate.comment.js";
@@ -29,48 +29,21 @@ export function diffAggregates(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, "aggregate", aggregate.schema ?? "");
+        const creatorFilteredDefaults = aggregate.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
         const desiredPrivileges = filterPublicBuiltInDefaults("aggregate", aggregate.privileges);
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the aggregate owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, aggregate.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [, list] of grantGroups) {
-                    changes.push(new GrantAggregatePrivileges({
-                        aggregate,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [, list] of revokeGroups) {
-                    changes.push(new RevokeAggregatePrivileges({
-                        aggregate,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionAggregatePrivileges({
-                    aggregate,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("aggregate", creatorFilteredDefaults), desiredPrivileges, aggregate.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, aggregate, aggregate, "aggregate", {
+            Grant: GrantAggregatePrivileges,
+            Revoke: RevokeAggregatePrivileges,
+            RevokeGrantOption: RevokeGrantOptionAggregatePrivileges,
+        }, ctx.version));
     }
     for (const aggregateId of dropped) {
         changes.push(new DropAggregate({ aggregate: main[aggregateId] }));
@@ -148,39 +121,12 @@ export function diffAggregates(ctx, main, branch) {
         const branchPrivilegesFiltered = filterPublicBuiltInDefaults("aggregate", branchAggregate.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, branchAggregate.owner, ctx.mainRoles);
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByGrantable(result.grants);
-                for (const [, list] of grantGroups) {
-                    changes.push(new GrantAggregatePrivileges({
-                        aggregate: branchAggregate,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-                for (const [, list] of revokeGroups) {
-                    changes.push(new RevokeAggregatePrivileges({
-                        aggregate: mainAggregate,
-                        grantee,
-                        privileges: list,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            if (result.revokeGrantOption.length > 0) {
-                changes.push(new RevokeGrantOptionAggregatePrivileges({
-                    aggregate: mainAggregate,
-                    grantee,
-                    privilegeNames: result.revokeGrantOption,
-                    version: ctx.version,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchAggregate.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchAggregate, mainAggregate, "aggregate", {
+            Grant: GrantAggregatePrivileges,
+            Revoke: RevokeAggregatePrivileges,
+            RevokeGrantOption: RevokeGrantOptionAggregatePrivileges,
+        }, ctx.version));
     }
     return changes;
 }

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

@@ -16,9 +16,9 @@ declare const aggregatePropsSchema: z.ZodObject<{
     return_type: z.ZodString;
     return_type_schema: z.ZodNullable<z.ZodString>;
     parallel_safety: z.ZodEnum<{
-        r: "r";
         u: "u";
         s: "s";
+        r: "r";
     }>;
     is_strict: z.ZodBoolean;
     transition_function: z.ZodString;
@@ -28,8 +28,8 @@ declare const aggregatePropsSchema: z.ZodObject<{
     final_function: z.ZodNullable<z.ZodString>;
     final_function_extra_args: z.ZodBoolean;
     final_function_modify: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         s: "s";
+        r: "r";
         w: "w";
     }>>;
     combine_function: z.ZodNullable<z.ZodString>;
@@ -44,8 +44,8 @@ declare const aggregatePropsSchema: z.ZodObject<{
     moving_final_function: z.ZodNullable<z.ZodString>;
     moving_final_function_extra_args: z.ZodBoolean;
     moving_final_function_modify: z.ZodNullable<z.ZodEnum<{
-        r: "r";
         s: "s";
+        r: "r";
         w: "w";
     }>>;
     moving_initial_condition: z.ZodNullable<z.ZodString>;
@@ -56,8 +56,8 @@ declare const aggregatePropsSchema: 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";
@@ -129,7 +129,7 @@ export declare class Aggregate extends BasePgModel {
         num_direct_args: number;
         return_type: string;
         return_type_schema: string | null;
-        parallel_safety: "r" | "u" | "s";
+        parallel_safety: "u" | "s" | "r";
         is_strict: boolean;
         transition_function: string;
         state_data_type: string;
@@ -137,7 +137,7 @@ export declare class Aggregate extends BasePgModel {
         state_data_space: number;
         final_function: string | null;
         final_function_extra_args: boolean;
-        final_function_modify: "r" | "s" | "w" | null;
+        final_function_modify: "s" | "r" | "w" | null;
         combine_function: string | null;
         serial_function: string | null;
         deserial_function: string | null;
@@ -149,7 +149,7 @@ export declare class Aggregate extends BasePgModel {
         moving_state_data_space: number | null;
         moving_final_function: string | null;
         moving_final_function_extra_args: boolean;
-        moving_final_function_modify: "r" | "s" | "w" | null;
+        moving_final_function_modify: "s" | "r" | "w" | null;
         moving_initial_condition: string | null;
         sort_operator: string | null;
         argument_count: number;
@@ -157,7 +157,7 @@ export declare class Aggregate 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;
         identity_arguments: string;
         owner: string;

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

@@ -273,7 +273,7 @@ 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
 from

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { AlterAggregateChange } from "./aggregate.base.ts";
 export type AlterAggregate = AlterAggregateChangeOwner;
@@ -15,5 +16,5 @@ export declare class AlterAggregateChangeOwner extends AlterAggregateChange {
         owner: string;
     });
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -16,7 +16,7 @@ export class AlterAggregateChangeOwner extends AlterAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { CreateAggregateChange, DropAggregateChange } from "./aggregate.base.ts";
 export type CommentAggregate = CreateCommentOnAggregate | DropCommentOnAggregate;
@@ -9,7 +10,7 @@ export declare class CreateCommentOnAggregate extends CreateAggregateChange {
     });
     get creates(): `comment:${string}`[];
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class DropCommentOnAggregate extends DropAggregateChange {
     readonly aggregate: Aggregate;
@@ -19,5 +20,5 @@ export declare class DropCommentOnAggregate extends DropAggregateChange {
     });
     get drops(): `comment:${string}`[];
     get requires(): (`comment:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -14,7 +14,7 @@ export class CreateCommentOnAggregate extends CreateAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";
@@ -35,7 +35,7 @@ export class DropCommentOnAggregate extends DropAggregateChange {
     get requires() {
         return [stableId.comment(this.aggregate.stableId), this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const withArgs = signature.length > 0 ? `(${signature})` : "()";

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { CreateAggregateChange } from "./aggregate.base.ts";
 /**
@@ -15,5 +16,5 @@ export declare class CreateAggregate extends CreateAggregateChange {
     });
     get creates(): `aggregate:${string}`[];
     get requires(): string[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -110,7 +110,7 @@ export class CreateAggregate extends CreateAggregateChange {
         // may reference types/functions). For now, we rely on pg_depend for these.
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
         const head = [
@@ -183,7 +183,7 @@ export class CreateAggregate extends CreateAggregateChange {
             clauses.push(`SORTOP = ${formatOperator(this.aggregate.sort_operator)}`);
         }
         if (this.aggregate.parallel_safety !== "u") {
-            clauses.push(`PARALLEL ${formatParallel(this.aggregate.parallel_safety)}`);
+            clauses.push(`PARALLEL = ${formatParallel(this.aggregate.parallel_safety)}`);
         }
         if (this.aggregate.is_strict) {
             clauses.push("STRICT");

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { DropAggregateChange } from "./aggregate.base.ts";
 /**
@@ -13,5 +14,5 @@ export declare class DropAggregate extends DropAggregateChange {
     });
     get drops(): `aggregate:${string}`[];
     get requires(): `aggregate:${string}`[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -17,10 +17,10 @@ export class DropAggregate extends DropAggregateChange {
     get requires() {
         return [this.aggregate.stableId];
     }
-    serialize() {
+    serialize(_options) {
         const signature = this.aggregate.identityArguments;
         const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
-        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        const withArgs = signature.length > 0 ? `(${signature})` : "(*)";
         return `DROP AGGREGATE ${qualifiedName}${withArgs}`;
     }
 }

package/dist/core/objects/aggregate/changes/aggregate.privilege.d.ts

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { Aggregate } from "../aggregate.model.ts";
 import { AlterAggregateChange } from "./aggregate.base.ts";
 export type AggregatePrivilege = GrantAggregatePrivileges | RevokeAggregatePrivileges | RevokeGrantOptionAggregatePrivileges;
@@ -21,7 +22,7 @@ export declare class GrantAggregatePrivileges extends AlterAggregateChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class RevokeAggregatePrivileges extends AlterAggregateChange {
     readonly aggregate: Aggregate;
@@ -43,7 +44,7 @@ export declare class RevokeAggregatePrivileges extends AlterAggregateChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 export declare class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
     readonly aggregate: Aggregate;
@@ -58,5 +59,5 @@ export declare class RevokeGrantOptionAggregatePrivileges extends AlterAggregate
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

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

@@ -20,7 +20,7 @@ export class GrantAggregatePrivileges extends AlterAggregateChange {
     get requires() {
         return [this.aggregate.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) {
@@ -61,7 +61,7 @@ export class RevokeAggregatePrivileges extends AlterAggregateChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("FUNCTION");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
@@ -91,7 +91,7 @@ export class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("FUNCTION");
         const privSql = formatObjectPrivilegeList("FUNCTION", this.privilegeNames, this.version);
         const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;

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

@@ -3,4 +3,5 @@ import type { CommentAggregate } from "./aggregate.comment.ts";
 import type { CreateAggregate } from "./aggregate.create.ts";
 import type { DropAggregate } from "./aggregate.drop.ts";
 import type { AggregatePrivilege } from "./aggregate.privilege.ts";
+/** Union of all aggregate-related change variants (`objectType: "aggregate"`). @category Change Types */
 export type AggregateChange = AlterAggregate | CommentAggregate | CreateAggregate | DropAggregate | AggregatePrivilege;

package/dist/core/objects/base.change.d.ts

@@ -1,4 +1,15 @@
+import type { SerializeOptions } from "../integrations/serialize/serialize.types.ts";
 type ChangeOperation = "create" | "alter" | "drop";
+/**
+ * Abstract base class for all change objects.
+ *
+ * Every concrete change (e.g. `CreateTable`, `AlterView`) extends this class and
+ * provides an `operation`, `objectType`, and `scope`. The filter DSL flattens
+ * these properties — along with the model sub-object — into path/value pairs
+ * for pattern matching.
+ *
+ * @category Base
+ */
 export declare abstract class BaseChange {
     /**
      * The operation of the change.
@@ -37,7 +48,7 @@ export declare abstract class BaseChange {
     /**
      * Serialize the change into a single SQL statement.
      */
-    abstract serialize(options?: Record<string, unknown>): string;
+    abstract serialize(options?: SerializeOptions): string;
 }
 /**
  * Port of string literal quoting: doubles single quotes inside and wraps with single quotes

package/dist/core/objects/base.change.js

@@ -1,3 +1,13 @@
+/**
+ * Abstract base class for all change objects.
+ *
+ * Every concrete change (e.g. `CreateTable`, `AlterView`) extends this class and
+ * provides an `operation`, `objectType`, and `scope`. The filter DSL flattens
+ * these properties — along with the model sub-object — into path/value pairs
+ * for pattern matching.
+ *
+ * @category Base
+ */
 export class BaseChange {
     /**
      * A unique identifier for the change.

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

@@ -60,7 +60,10 @@ export declare abstract class BasePgModel {
      */
     abstract get dataFields(): Record<string, unknown>;
     /**
-     * Compare this object with another BasePgModel for equality based on stableId and dataFields.
+     * Compare this object with another BasePgModel for equality based on the stableId and
+     * the data portion of the stable snapshot. By default, the snapshot's `data` comes
+     * from {@link dataFields}, but subclasses may override {@link stableSnapshot} to
+     * normalize or otherwise transform the data used for equality.
      */
     equals(other: BasePgModel): boolean;
     /**

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

@@ -28,11 +28,14 @@ export function normalizeColumns(columns) {
 }
 export class BasePgModel {
     /**
-     * Compare this object with another BasePgModel for equality based on stableId and dataFields.
+     * Compare this object with another BasePgModel for equality based on the stableId and
+     * the data portion of the stable snapshot. By default, the snapshot's `data` comes
+     * from {@link dataFields}, but subclasses may override {@link stableSnapshot} to
+     * normalize or otherwise transform the data used for equality.
      */
     equals(other) {
         return (this.stableId === other.stableId &&
-            deepEqual(this.dataFields, other.dataFields));
+            deepEqual(this.stableSnapshot().data, other.stableSnapshot().data));
     }
     /**
      * Stable representation used for equality/fingerprints.