@supabase/pg-delta 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/core/integrations/merge.js

@@ -0,0 +1,60 @@
+/**
+ * Integration merging — combines multiple IntegrationDSL objects.
+ *
+ * - Filters are AND-combined
+ * - Serialize rules are concatenated (earlier integrations first = higher priority)
+ * - emptyCatalog: most-specific (last) integration's value wins
+ */
+/**
+ * Merge an ordered list of integrations into a single IntegrationDSL.
+ *
+ * Integrations are ordered from base (first) to most-specific (last).
+ * - Filters: AND-combined (all must pass)
+ * - Serialize: concatenated (base rules first → higher priority, first-match-wins)
+ * - emptyCatalog: most-specific non-undefined value wins
+ *
+ * @param integrations - Ordered list of integrations (base first, most-specific last)
+ * @returns A single merged IntegrationDSL
+ */
+export function mergeIntegrations(integrations) {
+    if (integrations.length === 0)
+        return {};
+    if (integrations.length === 1)
+        return integrations[0];
+    // Collect all filters
+    const filters = [];
+    for (const integration of integrations) {
+        if (integration.filter) {
+            filters.push(integration.filter);
+        }
+    }
+    // Collect all serialize rules (base first = higher priority)
+    const serializeRules = [];
+    for (const integration of integrations) {
+        if (integration.serialize) {
+            serializeRules.push(...integration.serialize);
+        }
+    }
+    // emptyCatalog: most-specific (last) non-undefined wins
+    let emptyCatalog;
+    for (let i = integrations.length - 1; i >= 0; i--) {
+        if (integrations[i].emptyCatalog !== undefined) {
+            emptyCatalog = integrations[i].emptyCatalog;
+            break;
+        }
+    }
+    const merged = {};
+    if (filters.length === 1) {
+        merged.filter = filters[0];
+    }
+    else if (filters.length > 1) {
+        merged.filter = { and: filters };
+    }
+    if (serializeRules.length > 0) {
+        merged.serialize = serializeRules;
+    }
+    if (emptyCatalog !== undefined) {
+        merged.emptyCatalog = emptyCatalog;
+    }
+    return merged;
+}

package/dist/core/integrations/serialize/dsl.d.ts

@@ -27,8 +27,11 @@ type SerializeRule = {
     options: SerializeOptions;
 };
 /**
- * Serialization DSL - array of rules evaluated in order.
- * First matching rule's options are applied.
+ * Array of serialization rules evaluated in order. The first matching rule's
+ * options are passed to `change.serialize()`. If no rule matches, default
+ * serialization is used.
+ *
+ * @category Integration
  */
 export type SerializeDSL = SerializeRule[];
 /**
@@ -45,9 +48,9 @@ export type SerializeDSL = SerializeRule[];
  * const serializer = compileSerializeDSL([
  *   {
  *     when: {
- *       type: "schema",
+ *       objectType: "schema",
  *       operation: "create",
- *       owner: ["service_role"]
+ *       "schema/owner": ["service_role"]
  *     },
  *     options: { skipAuthorization: true }
  *   }

package/dist/core/integrations/serialize/dsl.js

@@ -18,9 +18,9 @@ import { evaluatePattern } from "../filter/dsl.js";
  * const serializer = compileSerializeDSL([
  *   {
  *     when: {
- *       type: "schema",
+ *       objectType: "schema",
  *       operation: "create",
- *       owner: ["service_role"]
+ *       "schema/owner": ["service_role"]
  *     },
  *     options: { skipAuthorization: true }
  *   }

package/dist/core/integrations/supabase.js

@@ -65,38 +65,53 @@ 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",
             },
+            // 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",
                                 },
                                 {
@@ -112,10 +127,10 @@ 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,

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,14 @@
 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.

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.

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

@@ -2,4 +2,5 @@ import type { AlterCollation } from "./collation.alter.ts";
 import type { CommentCollation } from "./collation.comment.ts";
 import type { CreateCollation } from "./collation.create.ts";
 import type { DropCollation } from "./collation.drop.ts";
+/** Union of all collation-related change variants (`objectType: "collation"`). @category Change Types */
 export type CollationChange = AlterCollation | CommentCollation | CreateCollation | DropCollation;

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

@@ -24,7 +24,7 @@ export declare class CreateDomain extends CreateDomainChange {
     constructor(props: {
         domain: Domain;
     });
-    get creates(): `domain:${string}`[];
+    get creates(): (`constraint:${string}.${string}.${string}` | `domain:${string}`)[];
     get requires(): string[];
     serialize(): string;
 }

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

@@ -26,7 +26,13 @@ export class CreateDomain extends CreateDomainChange {
         this.domain = props.domain;
     }
     get creates() {
-        return [this.domain.stableId];
+        const creates = [this.domain.stableId];
+        for (const constraint of this.domain.constraints) {
+            if (constraint.check_expression && constraint.validated) {
+                creates.push(stableId.constraint(this.domain.schema, this.domain.name, constraint.name));
+            }
+        }
+        return creates;
     }
     get requires() {
         const dependencies = new Set();

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

@@ -3,4 +3,5 @@ import type { CommentDomain } from "./domain.comment.ts";
 import type { CreateDomain } from "./domain.create.ts";
 import type { DropDomain } from "./domain.drop.ts";
 import type { DomainPrivilege } from "./domain.privilege.ts";
+/** Union of all domain-related change variants (`objectType: "domain"`). @category Change Types */
 export type DomainChange = AlterDomain | CommentDomain | CreateDomain | DropDomain | DomainPrivilege;

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

@@ -2,4 +2,5 @@ import type { AlterEventTrigger } from "./event-trigger.alter.ts";
 import type { CommentEventTrigger } from "./event-trigger.comment.ts";
 import type { CreateEventTrigger } from "./event-trigger.create.ts";
 import type { DropEventTrigger } from "./event-trigger.drop.ts";
+/** Union of all event-trigger-related change variants (`objectType: "event_trigger"`). @category Change Types */
 export type EventTriggerChange = AlterEventTrigger | CommentEventTrigger | CreateEventTrigger | DropEventTrigger;

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

@@ -2,4 +2,5 @@ import type { AlterExtension } from "./extension.alter.ts";
 import type { CommentExtension } from "./extension.comment.ts";
 import type { CreateExtension } from "./extension.create.ts";
 import type { DropExtension } from "./extension.drop.ts";
+/** Union of all extension-related change variants (`objectType: "extension"`). @category Change Types */
 export type ExtensionChange = AlterExtension | CommentExtension | CreateExtension | DropExtension;

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentForeignDataWrapper } from "./foreign-data-wrapper.comment.t
 import type { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
 import type { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
 import type { ForeignDataWrapperPrivilege } from "./foreign-data-wrapper.privilege.ts";
+/** Union of all FDW wrapper-level change variants (`objectType: "foreign_data_wrapper"`). @category Change Types */
 export type ForeignDataWrapperChange = AlterForeignDataWrapper | CommentForeignDataWrapper | CreateForeignDataWrapper | DropForeignDataWrapper | ForeignDataWrapperPrivilege;

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper.types.d.ts

@@ -2,4 +2,5 @@ import type { ForeignDataWrapperChange as FDWChange } from "./foreign-data-wrapp
 import type { ForeignTableChange } from "./foreign-table/changes/foreign-table.types.ts";
 import type { ServerChange } from "./server/changes/server.types.ts";
 import type { UserMappingChange } from "./user-mapping/changes/user-mapping.types.ts";
+/** Union of all foreign-data-wrapper-related change variants (`objectType: "foreign_data_wrapper" | "server" | "foreign_table" | "user_mapping"`). @category Change Types */
 export type ForeignDataWrapperChange = FDWChange | ServerChange | UserMappingChange | ForeignTableChange;

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentForeignTable } from "./foreign-table.comment.ts";
 import type { CreateForeignTable } from "./foreign-table.create.ts";
 import type { DropForeignTable } from "./foreign-table.drop.ts";
 import type { ForeignTablePrivilege } from "./foreign-table.privilege.ts";
+/** Union of all foreign-table-related change variants (`objectType: "foreign_table"`). @category Change Types */
 export type ForeignTableChange = AlterForeignTable | CommentForeignTable | CreateForeignTable | DropForeignTable | ForeignTablePrivilege;

package/dist/core/objects/foreign-data-wrapper/server/changes/server.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentServer } from "./server.comment.ts";
 import type { CreateServer } from "./server.create.ts";
 import type { DropServer } from "./server.drop.ts";
 import type { ServerPrivilege } from "./server.privilege.ts";
+/** Union of all server-related change variants (`objectType: "server"`). @category Change Types */
 export type ServerChange = AlterServer | CommentServer | CreateServer | DropServer | ServerPrivilege;

package/dist/core/objects/foreign-data-wrapper/user-mapping/changes/user-mapping.types.d.ts

@@ -1,4 +1,5 @@
 import type { AlterUserMapping } from "./user-mapping.alter.ts";
 import type { CreateUserMapping } from "./user-mapping.create.ts";
 import type { DropUserMapping } from "./user-mapping.drop.ts";
+/** Union of all user-mapping-related change variants (`objectType: "user_mapping"`). @category Change Types */
 export type UserMappingChange = AlterUserMapping | CreateUserMapping | DropUserMapping;

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

@@ -2,4 +2,5 @@ import type { AlterIndex } from "./index.alter.ts";
 import type { CommentIndex } from "./index.comment.ts";
 import type { CreateIndex } from "./index.create.ts";
 import type { DropIndex } from "./index.drop.ts";
+/** Union of all index-related change variants (`objectType: "index"`). @category Change Types */
 export type IndexChange = AlterIndex | CommentIndex | CreateIndex | DropIndex;

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

@@ -3,4 +3,5 @@ import type { CommentLanguage } from "./language.comment.ts";
 import type { CreateLanguage } from "./language.create.ts";
 import type { DropLanguage } from "./language.drop.ts";
 import type { LanguagePrivilege } from "./language.privilege.ts";
+/** Union of all language-related change variants (`objectType: "language"`). @category Change Types */
 export type LanguageChange = AlterLanguage | CommentLanguage | CreateLanguage | DropLanguage | LanguagePrivilege;

package/dist/core/objects/materialized-view/changes/materialized-view.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentMaterializedView } from "./materialized-view.comment.ts";
 import type { CreateMaterializedView } from "./materialized-view.create.ts";
 import type { DropMaterializedView } from "./materialized-view.drop.ts";
 import type { MaterializedViewPrivilege } from "./materialized-view.privilege.ts";
+/** Union of all materialized-view-related change variants (`objectType: "materialized_view"`). @category Change Types */
 export type MaterializedViewChange = AlterMaterializedView | CommentMaterializedView | CreateMaterializedView | DropMaterializedView | MaterializedViewPrivilege;

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

@@ -3,4 +3,5 @@ import type { CommentProcedure } from "./procedure.comment.ts";
 import type { CreateProcedure } from "./procedure.create.ts";
 import type { DropProcedure } from "./procedure.drop.ts";
 import type { ProcedurePrivilege } from "./procedure.privilege.ts";
+/** Union of all procedure-related change variants (`objectType: "procedure"`). @category Change Types */
 export type ProcedureChange = AlterProcedure | CommentProcedure | CreateProcedure | DropProcedure | ProcedurePrivilege;

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

@@ -2,4 +2,5 @@ import type { AlterPublicationAddSchemas, AlterPublicationAddTables, AlterPublic
 import type { CommentPublication } from "./publication.comment.ts";
 import type { CreatePublication } from "./publication.create.ts";
 import type { DropPublication } from "./publication.drop.ts";
+/** Union of all publication-related change variants (`objectType: "publication"`). @category Change Types */
 export type PublicationChange = AlterPublicationAddSchemas | AlterPublicationAddTables | AlterPublicationDropSchemas | AlterPublicationDropTables | AlterPublicationSetList | AlterPublicationSetOptions | AlterPublicationSetOwner | CommentPublication | CreatePublication | DropPublication;

package/dist/core/objects/rls-policy/changes/rls-policy.types.d.ts

@@ -2,4 +2,5 @@ import type { AlterRlsPolicy } from "./rls-policy.alter.ts";
 import type { CommentRlsPolicy } from "./rls-policy.comment.ts";
 import type { CreateRlsPolicy } from "./rls-policy.create.ts";
 import type { DropRlsPolicy } from "./rls-policy.drop.ts";
+/** Union of all RLS policy-related change variants (`objectType: "rls_policy"`). @category Change Types */
 export type RlsPolicyChange = AlterRlsPolicy | CommentRlsPolicy | CreateRlsPolicy | DropRlsPolicy;

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

@@ -3,4 +3,5 @@ import type { CommentRole } from "./role.comment.ts";
 import type { CreateRole } from "./role.create.ts";
 import type { DropRole } from "./role.drop.ts";
 import type { RolePrivilege } from "./role.privilege.ts";
+/** Union of all role-related change variants (`objectType: "role"`). @category Change Types */
 export type RoleChange = AlterRole | CommentRole | CreateRole | DropRole | RolePrivilege;

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

@@ -2,4 +2,5 @@ import type { ReplaceRule, SetRuleEnabledState } from "./rule.alter.ts";
 import type { CreateCommentOnRule, DropCommentOnRule } from "./rule.comment.ts";
 import type { CreateRule } from "./rule.create.ts";
 import type { DropRule } from "./rule.drop.ts";
+/** Union of all rule-related change variants (`objectType: "rule"`). @category Change Types */
 export type RuleChange = CreateRule | DropRule | ReplaceRule | SetRuleEnabledState | CreateCommentOnRule | DropCommentOnRule;

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

@@ -3,4 +3,5 @@ import type { CommentSchema } from "./schema.comment.ts";
 import type { CreateSchema } from "./schema.create.ts";
 import type { DropSchema } from "./schema.drop.ts";
 import type { SchemaPrivilege } from "./schema.privilege.ts";
+/** Union of all schema-related change variants (`objectType: "schema"`). @category Change Types */
 export type SchemaChange = AlterSchema | CommentSchema | CreateSchema | DropSchema | SchemaPrivilege;

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

@@ -3,4 +3,5 @@ import type { CommentSequence } from "./sequence.comment.ts";
 import type { CreateSequence } from "./sequence.create.ts";
 import type { DropSequence } from "./sequence.drop.ts";
 import type { SequencePrivilege } from "./sequence.privilege.ts";
+/** Union of all sequence-related change variants (`objectType: "sequence"`). @category Change Types */
 export type SequenceChange = AlterSequence | CommentSequence | CreateSequence | DropSequence | SequencePrivilege;

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

@@ -2,4 +2,5 @@ import type { AlterSubscriptionDisable, AlterSubscriptionEnable, AlterSubscripti
 import type { CommentSubscription } from "./subscription.comment.ts";
 import type { CreateSubscription } from "./subscription.create.ts";
 import type { DropSubscription } from "./subscription.drop.ts";
+/** Union of all subscription-related change variants (`objectType: "subscription"`). @category Change Types */
 export type SubscriptionChange = CreateSubscription | DropSubscription | AlterSubscriptionSetConnection | AlterSubscriptionSetPublication | AlterSubscriptionEnable | AlterSubscriptionDisable | AlterSubscriptionSetOptions | AlterSubscriptionSetOwner | CommentSubscription;

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

@@ -3,4 +3,5 @@ import type { CommentTable } from "./table.comment.ts";
 import type { CreateTable } from "./table.create.ts";
 import type { DropTable } from "./table.drop.ts";
 import type { TablePrivilege } from "./table.privilege.ts";
+/** Union of all table-related change variants (`objectType: "table"`). @category Change Types */
 export type TableChange = AlterTable | CommentTable | CreateTable | DropTable | TablePrivilege;

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/type/composite-type/changes/composite-type.types.d.ts

@@ -3,4 +3,5 @@ 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";
+/** Union of all composite-type-related change variants (`objectType: "composite_type"`). @category Change Types */
 export type CompositeTypeChange = AlterCompositeType | CommentCompositeType | CreateCompositeType | DropCompositeType | CompositeTypePrivilege;

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

@@ -3,4 +3,5 @@ import type { CommentEnum } from "./enum.comment.ts";
 import type { CreateEnum } from "./enum.create.ts";
 import type { DropEnum } from "./enum.drop.ts";
 import type { EnumPrivilege } from "./enum.privilege.ts";
+/** Union of all enum-related change variants (`objectType: "enum"`). @category Change Types */
 export type EnumChange = AlterEnum | CommentEnum | CreateEnum | DropEnum | EnumPrivilege;

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/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.types.d.ts

@@ -3,4 +3,5 @@ import type { CommentView } from "./view.comment.ts";
 import type { CreateView } from "./view.create.ts";
 import type { DropView } from "./view.drop.ts";
 import type { ViewPrivilege } from "./view.privilege.ts";
+/** Union of all view-related change variants (`objectType: "view"`). @category Change Types */
 export type ViewChange = AlterView | CommentView | CreateView | DropView | ViewPrivilege;

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

@@ -1,4 +1,5 @@
 import { diffObjects } from "../base.diff.js";
+import { normalizeColumns } from "../base.model.js";
 import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterViewChangeOwner, AlterViewResetOptions, AlterViewSetOptions, } from "./changes/view.alter.js";
@@ -17,35 +18,37 @@ import { GrantViewPrivileges, RevokeGrantOptionViewPrivileges, RevokeViewPrivile
 export function diffViews(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    for (const viewId of created) {
-        const v = branch[viewId];
-        changes.push(new CreateView({ view: v }));
+    const appendCreateViewChanges = (view) => {
+        changes.push(new CreateView({ view }));
         // OWNER: If the view should be owned by someone other than the current user,
         // emit ALTER VIEW ... OWNER TO after creation
-        if (v.owner !== ctx.currentUser) {
-            changes.push(new AlterViewChangeOwner({ view: v, owner: v.owner }));
+        if (view.owner !== ctx.currentUser) {
+            changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
         }
-        if (v.comment !== null) {
-            changes.push(new CreateCommentOnView({ view: v }));
+        if (view.comment !== null) {
+            changes.push(new CreateCommentOnView({ view }));
         }
         // PRIVILEGES: For created objects, compare against default privileges state
         // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
         // so objects are created with the default privileges state in effect.
         // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
         // needed to reach the final desired state.
-        const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "view", v.schema ?? "");
-        const creatorFilteredDefaults = v.owner !== ctx.currentUser
+        const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "view", view.schema ?? "");
+        const creatorFilteredDefaults = view.owner !== ctx.currentUser
             ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
             : effectiveDefaults;
-        const desiredPrivileges = v.privileges;
+        const desiredPrivileges = view.privileges;
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the view owner as the reference.
-        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, v.owner);
-        changes.push(...emitColumnPrivilegeChanges(privilegeResults, v, v, "view", {
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, view.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, view, view, "view", {
             Grant: GrantViewPrivileges,
             Revoke: RevokeViewPrivileges,
             RevokeGrantOption: RevokeGrantOptionViewPrivileges,
         }, effectiveDefaults, ctx.version));
+    };
+    for (const viewId of created) {
+        appendCreateViewChanges(branch[viewId]);
     }
     for (const viewId of dropped) {
         changes.push(new DropView({ view: main[viewId] }));
@@ -69,7 +72,15 @@ export function diffViews(ctx, main, branch) {
             "partition_bound",
         ];
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainView, branchView, NON_ALTERABLE_FIELDS, { options: deepEqual });
-        if (nonAlterablePropsChanged) {
+        // Normalize columns (strip position, sort by name) to match stableSnapshot().
+        // Position-only differences are safe to ignore here because column order in a
+        // view is determined by its definition, which is already checked above via
+        // NON_ALTERABLE_FIELDS - a position change always implies a definition change.
+        if (!deepEqual(normalizeColumns(mainView.columns), normalizeColumns(branchView.columns))) {
+            changes.push(new DropView({ view: mainView }));
+            appendCreateViewChanges(branchView);
+        }
+        else if (nonAlterablePropsChanged) {
             // Replace the entire view using CREATE OR REPLACE to avoid drop when possible
             changes.push(new CreateView({ view: branchView, orReplace: true }));
         }

package/dist/core/postgres-config.d.ts

@@ -1,14 +1,14 @@
 /**
  * PostgreSQL connection configuration with custom type handlers.
  */
-import type { PoolClient, PoolConfig } from "pg";
+import type { ClientBase, PoolClient, PoolConfig } from "pg";
 import { Pool } from "pg";
 /**
  * Options for creating a Pool with event listeners.
  */
 interface CreatePoolOptions extends Partial<PoolConfig> {
     /** Called when a new client connects to the pool */
-    onConnect?: (client: PoolClient) => void | Promise<void>;
+    onConnect?: (client: ClientBase) => void | Promise<void>;
     /** Called when an idle client emits an error */
     onError?: (err: Error, client: PoolClient) => void;
     /** Called when a client is acquired from the pool */

package/dist/core/sort/custom-constraints.js

@@ -1,4 +1,4 @@
-import { getSchema } from "../integrations/filter/extractors.js";
+import { getSchema } from "../change-utils.js";
 import { GrantRoleDefaultPrivileges, RevokeRoleDefaultPrivileges, } from "../objects/role/changes/role.privilege.js";
 /**
  * Maps object type names to PostgreSQL default privilege objtype codes.

package/dist/core/sort/logical-sort.js

@@ -8,7 +8,7 @@
  * It groups related changes together while preserving the ability for the dependency
  * resolver to reorder within groups when necessary.
  */
-import { getSchema } from "../integrations/filter/extractors.js";
+import { getSchema } from "../change-utils.js";
 import { getExecutionPhase, isMetadataStableId } from "./utils.js";
 /**
  * Object type ordering for logical grouping.
@@ -287,27 +287,6 @@ function getParentStableId(change) {
     // Fallback: return first requires if available
     return requires.length > 0 ? requires[0] : null;
 }
-/**
- * Extract schema name from a change.
- * Returns the schema name if present, or null for non-schema objects.
- *
- * Uses the getSchema helper which directly accesses schema properties from change objects.
- * For default_privilege changes, accesses the inSchema property directly.
- * For event_trigger changes, groups by their function's schema.
- */
-function extractSchemaFromChange(change) {
-    // Handle default_privilege changes specially (they have inSchema property)
-    if (change.scope === "default_privilege") {
-        // TypeScript doesn't know about inSchema, but we know it exists for default_privilege changes
-        return change.inSchema ?? null;
-    }
-    // Handle event_trigger changes specially - group by their function's schema
-    if (change.objectType === "event_trigger") {
-        return change.eventTrigger.function_schema;
-    }
-    // Use the getSchema helper for all other changes
-    return getSchema(change);
-}
 /**
  * Get the effective object type for sorting purposes.
  * For sub-entities, returns the parent's object type (table/view/materialized_view).
@@ -399,8 +378,8 @@ function sortPhase(changes, phase) {
         const changeA = a.change;
         const changeB = b.change;
         // 1. Compare schemas (group objects by schema)
-        const schemaA = extractSchemaFromChange(changeA);
-        const schemaB = extractSchemaFromChange(changeB);
+        const schemaA = getSchema(changeA);
+        const schemaB = getSchema(changeB);
         // Non-schema objects (roles, languages, extensions, etc.) sort first
         // Use a special prefix to ensure they come before schema objects
         const schemaKeyA = schemaA === null ? "::" : schemaA;