@supabase/pg-delta 1.0.0-alpha.26 → 1.0.0-alpha.28

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

@@ -52,6 +52,8 @@ declare const foreignTablePropsSchema: z.ZodObject<{
         provider: z.ZodString;
         label: z.ZodString;
     }, z.z.core.$strip>>>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 type ForeignTablePrivilegeProps = PrivilegeProps;
 export type ForeignTableProps = z.infer<typeof foreignTablePropsSchema>;
@@ -65,6 +67,8 @@ export declare class ForeignTable extends BasePgModel implements TableLikeObject
     readonly columns: ForeignTableProps["columns"];
     readonly privileges: ForeignTablePrivilegeProps[];
     readonly security_labels: SecurityLabelProps[];
+    readonly wrapper_handler: ForeignTableProps["wrapper_handler"];
+    readonly wrapper_validator: ForeignTableProps["wrapper_validator"];
     constructor(props: ForeignTableProps);
     get stableId(): `foreignTable:${string}`;
     get identityFields(): {

package/dist/core/objects/foreign-data-wrapper/foreign-table/foreign-table.model.js

@@ -23,6 +23,9 @@ const foreignTablePropsSchema = z.object({
     columns: z.array(columnPropsSchema),
     privileges: z.array(privilegePropsSchema),
     security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class ForeignTable extends BasePgModel {
     schema;
@@ -34,6 +37,8 @@ export class ForeignTable extends BasePgModel {
     columns;
     privileges;
     security_labels;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -47,6 +52,8 @@ export class ForeignTable extends BasePgModel {
         this.columns = props.columns;
         this.privileges = props.privileges;
         this.security_labels = props.security_labels ?? [];
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `foreignTable:${this.schema}.${this.name}`;
@@ -114,12 +121,22 @@ export async function extractForeignTables(pool) {
           c.relowner::regrole::text as owner,
           quote_ident(srv.srvname) as server,
           coalesce(ft.ftoptions, array[]::text[]) as options,
-          c.oid as oid
+          c.oid as oid,
+          case
+            when fdw.fdwhandler = 0 then null
+            else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+          end as wrapper_handler,
+          case
+            when fdw.fdwvalidator = 0 then null
+            else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+          end as wrapper_validator
         from
           pg_class c
           inner join pg_foreign_table ft on ft.ftrelid = c.oid
           inner join pg_foreign_server srv on srv.oid = ft.ftserver
           inner join pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+          left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+          left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
           left outer join extension_oids e1 on c.oid = e1.objid
         where
           c.relkind = 'f'
@@ -133,6 +150,8 @@ export async function extractForeignTables(pool) {
         ft.owner,
         ft.server,
         ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator,
         obj_description(ft.oid, 'pg_class') as comment,
         coalesce(json_agg(
           case when a.attname is not null then
@@ -218,7 +237,14 @@ export async function extractForeignTables(pool) {
         left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
         left join pg_type ty on ty.oid = a.atttypid
       group by
-        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+        ft.oid,
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator
       order by
         ft.schema, ft.name
   `);

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

@@ -26,6 +26,8 @@ declare const serverPropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 type ServerPrivilegeProps = PrivilegeProps;
 export type ServerProps = z.infer<typeof serverPropsSchema>;
@@ -38,6 +40,8 @@ export declare class Server extends BasePgModel {
     readonly options: ServerProps["options"];
     readonly comment: ServerProps["comment"];
     readonly privileges: ServerPrivilegeProps[];
+    readonly wrapper_handler: ServerProps["wrapper_handler"];
+    readonly wrapper_validator: ServerProps["wrapper_validator"];
     constructor(props: ServerProps);
     get stableId(): `server:${string}`;
     get identityFields(): {

package/dist/core/objects/foreign-data-wrapper/server/server.model.js

@@ -21,6 +21,9 @@ const serverPropsSchema = z.object({
     options: z.array(z.string()).nullable(),
     comment: z.string().nullable(),
     privileges: z.array(privilegePropsSchema),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class Server extends BasePgModel {
     name;
@@ -31,6 +34,8 @@ export class Server extends BasePgModel {
     options;
     comment;
     privileges;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -43,6 +48,8 @@ export class Server extends BasePgModel {
         this.options = props.options;
         this.comment = props.comment;
         this.privileges = props.privileges;
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `server:${this.name}`;
@@ -96,10 +103,20 @@ export async function extractServers(pool) {
             )
             from lateral aclexplode(srv.srvacl) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
-        ) as privileges
+        ) as privileges,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_foreign_server srv
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

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

@@ -16,12 +16,16 @@ declare const userMappingPropsSchema: z.ZodObject<{
     user: z.ZodString;
     server: z.ZodString;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    wrapper_handler: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wrapper_validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.z.core.$strip>;
 export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
 export declare class UserMapping extends BasePgModel {
     readonly user: UserMappingProps["user"];
     readonly server: UserMappingProps["server"];
     readonly options: UserMappingProps["options"];
+    readonly wrapper_handler: UserMappingProps["wrapper_handler"];
+    readonly wrapper_validator: UserMappingProps["wrapper_validator"];
     constructor(props: UserMappingProps);
     get stableId(): `userMapping:${string}:${string}`;
     get identityFields(): {

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.js

@@ -16,11 +16,16 @@ const userMappingPropsSchema = z.object({
     user: z.string(),
     server: z.string(),
     options: z.array(z.string()).nullable(),
+    // Parent FDW handler/validator — filter metadata only, not in dataFields.
+    wrapper_handler: z.string().nullable().optional(),
+    wrapper_validator: z.string().nullable().optional(),
 });
 export class UserMapping extends BasePgModel {
     user;
     server;
     options;
+    wrapper_handler;
+    wrapper_validator;
     constructor(props) {
         super();
         // Identity fields
@@ -28,6 +33,8 @@ export class UserMapping extends BasePgModel {
         this.server = props.server;
         // Data fields
         this.options = props.options;
+        this.wrapper_handler = props.wrapper_handler ?? null;
+        this.wrapper_validator = props.wrapper_validator ?? null;
     }
     get stableId() {
         return `userMapping:${this.server}:${this.user}`;
@@ -62,11 +69,21 @@ export async function extractUserMappings(pool) {
           else um.umuser::regrole::text
         end as user,
         quote_ident(srv.srvname) as server,
-        coalesce(um.umoptions, array[]::text[]) as options
+        coalesce(um.umoptions, array[]::text[]) as options,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_user_mapping um
         inner join pg_catalog.pg_foreign_server srv on srv.oid = um.umserver
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

package/dist/core/objects/materialized-view/materialized-view.diff.d.ts

@@ -1,6 +1,7 @@
 import type { ObjectDiffContext } from "../diff-context.ts";
 import type { MaterializedViewChange } from "./changes/materialized-view.types.ts";
 import type { MaterializedView } from "./materialized-view.model.ts";
+export declare function buildCreateMaterializedViewChanges(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, mv: MaterializedView): MaterializedViewChange[];
 /**
  * Diff two sets of materialized views from main and branch catalogs.
  *

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

@@ -8,6 +8,63 @@ import { CreateMaterializedView } from "./changes/materialized-view.create.js";
 import { DropMaterializedView } from "./changes/materialized-view.drop.js";
 import { GrantMaterializedViewPrivileges, RevokeGrantOptionMaterializedViewPrivileges, RevokeMaterializedViewPrivileges, } from "./changes/materialized-view.privilege.js";
 import { CreateSecurityLabelOnMaterializedView, DropSecurityLabelOnMaterializedView, } from "./changes/materialized-view.security-label.js";
+export function buildCreateMaterializedViewChanges(ctx, mv) {
+    const changes = [
+        new CreateMaterializedView({
+            materializedView: mv,
+        }),
+    ];
+    // OWNER: If the materialized view should be owned by someone other than the current user,
+    // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
+    if (mv.owner !== ctx.currentUser) {
+        changes.push(new AlterMaterializedViewChangeOwner({
+            materializedView: mv,
+            owner: mv.owner,
+        }));
+    }
+    // Materialized view comment on creation
+    if (mv.comment !== null) {
+        changes.push(new CreateCommentOnMaterializedView({
+            materializedView: mv,
+        }));
+    }
+    // Column comments on creation
+    for (const col of mv.columns) {
+        if (col.comment !== null) {
+            changes.push(new CreateCommentOnMaterializedViewColumn({
+                materializedView: mv,
+                column: col,
+            }));
+        }
+    }
+    // Security labels on the matview itself (columns of matviews are not
+    // supported targets of SECURITY LABEL, so we only label the relation).
+    for (const label of mv.security_labels) {
+        changes.push(new CreateSecurityLabelOnMaterializedView({
+            materializedView: mv,
+            securityLabel: label,
+        }));
+    }
+    // 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, "materialized_view", mv.schema ?? "");
+    const creatorFilteredDefaults = mv.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    const desiredPrivileges = mv.privileges;
+    // Filter out owner privileges - owner always has ALL privileges implicitly
+    // and shouldn't be compared. Use the materialized view owner as the reference.
+    const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, mv.owner);
+    changes.push(...emitColumnPrivilegeChanges(privilegeResults, mv, mv, "materializedView", {
+        Grant: GrantMaterializedViewPrivileges,
+        Revoke: RevokeMaterializedViewPrivileges,
+        RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+    }, effectiveDefaults, ctx.version));
+    return changes;
+}
 /**
  * Diff two sets of materialized views from main and branch catalogs.
  *
@@ -20,62 +77,7 @@ export function diffMaterializedViews(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
     for (const materializedViewId of created) {
-        const mv = branch[materializedViewId];
-        changes.push(new CreateMaterializedView({
-            materializedView: mv,
-        }));
-        // OWNER: If the materialized view should be owned by someone other than the current user,
-        // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
-        if (mv.owner !== ctx.currentUser) {
-            changes.push(new AlterMaterializedViewChangeOwner({
-                materializedView: mv,
-                owner: mv.owner,
-            }));
-        }
-        // Note: RLS (row_security, force_row_security) is a non-alterable property for materialized views.
-        // If RLS needs to be enabled, the materialized view must be dropped and recreated, which is
-        // handled in the "altered" section when non-alterable properties change.
-        // Materialized view comment on creation
-        if (mv.comment !== null) {
-            changes.push(new CreateCommentOnMaterializedView({
-                materializedView: mv,
-            }));
-        }
-        // Column comments on creation
-        for (const col of mv.columns) {
-            if (col.comment !== null) {
-                changes.push(new CreateCommentOnMaterializedViewColumn({
-                    materializedView: mv,
-                    column: col,
-                }));
-            }
-        }
-        // Security labels on the matview itself (columns of matviews are not
-        // supported targets of SECURITY LABEL, so we only label the relation).
-        for (const label of mv.security_labels) {
-            changes.push(new CreateSecurityLabelOnMaterializedView({
-                materializedView: mv,
-                securityLabel: label,
-            }));
-        }
-        // 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, "materialized_view", mv.schema ?? "");
-        const creatorFilteredDefaults = mv.owner !== ctx.currentUser
-            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
-            : effectiveDefaults;
-        const desiredPrivileges = mv.privileges;
-        // Filter out owner privileges - owner always has ALL privileges implicitly
-        // and shouldn't be compared. Use the materialized view owner as the reference.
-        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, mv.owner);
-        changes.push(...emitColumnPrivilegeChanges(privilegeResults, mv, mv, "materializedView", {
-            Grant: GrantMaterializedViewPrivileges,
-            Revoke: RevokeMaterializedViewPrivileges,
-            RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
-        }, effectiveDefaults, ctx.version));
+        changes.push(...buildCreateMaterializedViewChanges(ctx, branch[materializedViewId]));
     }
     for (const materializedViewId of dropped) {
         changes.push(new DropMaterializedView({ materializedView: main[materializedViewId] }));
@@ -101,9 +103,7 @@ export function diffMaterializedViews(ctx, main, branch) {
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainMaterializedView, branchMaterializedView, NON_ALTERABLE_FIELDS, { options: deepEqual });
         if (nonAlterablePropsChanged) {
             // Replace the entire materialized view (drop + create)
-            changes.push(new DropMaterializedView({ materializedView: mainMaterializedView }), new CreateMaterializedView({
-                materializedView: branchMaterializedView,
-            }));
+            changes.push(new DropMaterializedView({ materializedView: mainMaterializedView }), ...buildCreateMaterializedViewChanges(ctx, branchMaterializedView));
         }
         else {
             // Only alterable properties changed - check each one

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

@@ -285,6 +285,7 @@ export declare class AlterTableAlterColumnType extends AlterTableChange {
         previousColumn?: ColumnProps;
     });
     get requires(): `column:${string}.${string}.${string}`[];
+    get invalidates(): `column:${string}.${string}.${string}`[];
     serialize(_options?: SerializeOptions): string;
 }
 /**

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

@@ -452,6 +452,14 @@ export class AlterTableAlterColumnType extends AlterTableChange {
             stableId.column(this.table.schema, this.table.name, this.column.name),
         ];
     }
+    get invalidates() {
+        // ALTER COLUMN ... TYPE rewrites the column in place. The column keeps its
+        // identity, but anything bound to its old type (views, rules, etc.) must be
+        // dropped before the rewrite and rebuilt after, so report it as invalidated.
+        return [
+            stableId.column(this.table.schema, this.table.name, this.column.name),
+        ];
+    }
     serialize(_options) {
         // previousColumn is optional so direct serializer tests/fixtures can keep
         // emitting canonical ALTER TYPE SQL without forcing a USING expression.

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

@@ -1,6 +1,7 @@
 import type { ObjectDiffContext } from "../diff-context.ts";
 import type { ViewChange } from "./changes/view.types.ts";
 import type { View } from "./view.model.ts";
+export declare function buildCreateViewChanges(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, view: View): ViewChange[];
 /**
  * Diff two sets of views from main and branch catalogs.
  *

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

@@ -9,6 +9,39 @@ import { CreateView } from "./changes/view.create.js";
 import { DropView } from "./changes/view.drop.js";
 import { GrantViewPrivileges, RevokeGrantOptionViewPrivileges, RevokeViewPrivileges, } from "./changes/view.privilege.js";
 import { CreateSecurityLabelOnView, DropSecurityLabelOnView, } from "./changes/view.security-label.js";
+export function buildCreateViewChanges(ctx, view) {
+    const changes = [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 (view.owner !== ctx.currentUser) {
+        changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
+    }
+    if (view.comment !== null) {
+        changes.push(new CreateCommentOnView({ view }));
+    }
+    for (const label of view.security_labels) {
+        changes.push(new CreateSecurityLabelOnView({ view, securityLabel: label }));
+    }
+    // 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", view.schema ?? "");
+    const creatorFilteredDefaults = view.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    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, view.owner);
+    changes.push(...emitColumnPrivilegeChanges(privilegeResults, view, view, "view", {
+        Grant: GrantViewPrivileges,
+        Revoke: RevokeViewPrivileges,
+        RevokeGrantOption: RevokeGrantOptionViewPrivileges,
+    }, effectiveDefaults, ctx.version));
+    return changes;
+}
 /**
  * Diff two sets of views from main and branch catalogs.
  *
@@ -20,40 +53,8 @@ import { CreateSecurityLabelOnView, DropSecurityLabelOnView, } from "./changes/v
 export function diffViews(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    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 (view.owner !== ctx.currentUser) {
-            changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
-        }
-        if (view.comment !== null) {
-            changes.push(new CreateCommentOnView({ view }));
-        }
-        for (const label of view.security_labels) {
-            changes.push(new CreateSecurityLabelOnView({ view, securityLabel: label }));
-        }
-        // 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", view.schema ?? "");
-        const creatorFilteredDefaults = view.owner !== ctx.currentUser
-            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
-            : effectiveDefaults;
-        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, 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]);
+        changes.push(...buildCreateViewChanges(ctx, branch[viewId]));
     }
     for (const viewId of dropped) {
         changes.push(new DropView({ view: main[viewId] }));
@@ -83,7 +84,7 @@ export function diffViews(ctx, main, branch) {
         // 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);
+            changes.push(...buildCreateViewChanges(ctx, branchView));
         }
         else if (nonAlterablePropsChanged) {
             // Replace the entire view using CREATE OR REPLACE to avoid drop when possible

package/dist/core/sort/graph-builder.js

@@ -119,6 +119,12 @@ export function buildGraphData(phaseChanges, options) {
             for (const droppedId of changeItem.drops ?? []) {
                 createdIds.add(droppedId);
             }
+            // In-place mutations keep the object identity but invalidate
+            // dependents, so for drop-phase ordering they behave like producers of
+            // the invalidated ids without changing Change.drops.
+            for (const invalidatedId of changeItem.invalidates) {
+                createdIds.add(invalidatedId);
+            }
         }
         return createdIds;
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.26",
+  "version": "1.0.0-alpha.28",
   "description": "PostgreSQL migrations made easy",
   "keywords": [
     "diff",

package/src/cli/commands/catalog-export.ts

@@ -4,11 +4,13 @@
 
 import { writeFile } from "node:fs/promises";
 import { buildCommand, type CommandContext } from "@stricli/core";
+import { filterCatalog } from "../../core/catalog.filter.ts";
 import { extractCatalog } from "../../core/catalog.model.ts";
 import {
   serializeCatalog,
   stringifyCatalogSnapshot,
 } from "../../core/catalog.snapshot.ts";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
 import { createManagedPool } from "../../core/postgres-config.ts";
 
 export const catalogExportCommand = buildCommand({
@@ -30,6 +32,21 @@ export const catalogExportCommand = buildCommand({
         parse: String,
         optional: true,
       },
+      filter: {
+        kind: "parsed",
+        brief:
+          'Filter DSL as inline JSON to filter changes (e.g., \'{"*/schema": "app"}\').',
+        parse: (value: string): FilterDSL => {
+          try {
+            return JSON.parse(value) as FilterDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid filter JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
     },
     aliases: {
       t: "target",
@@ -48,6 +65,10 @@ Use cases:
   - Snapshot template1 for use as an empty-database baseline
   - Snapshot a production database to generate revert migrations
   - Snapshot any state for reproducible offline diffs
+
+Pass --filter to scope the snapshot to a subset of the catalog (same
+Filter DSL accepted by plan/sync). Useful when committing a baseline
+snapshot to a repo and only one schema's drift is interesting.
     `.trim(),
   },
   async func(
@@ -56,6 +77,7 @@ Use cases:
       target: string;
       output: string;
       role?: string;
+      filter?: FilterDSL;
     },
   ) {
     const { pool, close } = await createManagedPool(flags.target, {
@@ -65,7 +87,10 @@ Use cases:
 
     try {
       const catalog = await extractCatalog(pool);
-      const snapshot = serializeCatalog(catalog);
+      const scoped = flags.filter
+        ? await filterCatalog(catalog, flags.filter)
+        : catalog;
+      const snapshot = serializeCatalog(scoped);
       const json = stringifyCatalogSnapshot(snapshot);
       await writeFile(flags.output, json, "utf-8");
       this.process.stdout.write(