@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -46,7 +46,7 @@ export class CreateMaterializedView extends CreateMaterializedViewChange {
         // for existing objects. For new objects, parsing the SQL definition would be complex.
         return Array.from(dependencies);
     }
-    serialize() {
+    serialize(_options) {
         const parts = ["CREATE MATERIALIZED VIEW"];
         // Add schema and name
         parts.push(`${this.materializedView.schema}.${this.materializedView.name}`);

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { MaterializedView } from "../materialized-view.model.ts";
 import { DropMaterializedViewChange } from "./materialized-view.base.ts";
 /**
@@ -22,5 +23,5 @@ export declare class DropMaterializedView extends DropMaterializedViewChange {
     });
     get drops(): (`column:${string}.${string}.${string}` | `materializedView:${string}`)[];
     get requires(): (`column:${string}.${string}.${string}` | `materializedView:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/materialized-view/changes/materialized-view.drop.js

@@ -33,7 +33,7 @@ export class DropMaterializedView extends DropMaterializedViewChange {
             ...this.materializedView.columns.map((column) => stableId.column(this.materializedView.schema, this.materializedView.name, column.name)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return [
             "DROP MATERIALIZED VIEW",
             `${this.materializedView.schema}.${this.materializedView.name}`,

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { MaterializedView } from "../materialized-view.model.ts";
 import { AlterMaterializedViewChange } from "./materialized-view.base.ts";
 export type MaterializedViewPrivilege = GrantMaterializedViewPrivileges | RevokeMaterializedViewPrivileges | RevokeGrantOptionMaterializedViewPrivileges;
@@ -37,7 +38,7 @@ export declare class GrantMaterializedViewPrivileges extends AlterMaterializedVi
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `materializedView:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a materialized view.
@@ -77,7 +78,7 @@ export declare class RevokeMaterializedViewPrivileges extends AlterMaterializedV
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `materializedView:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a materialized view.
@@ -101,5 +102,5 @@ export declare class RevokeGrantOptionMaterializedViewPrivileges extends AlterMa
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `materializedView:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/materialized-view/changes/materialized-view.privilege.js

@@ -38,7 +38,7 @@ export class GrantMaterializedViewPrivileges extends AlterMaterializedViewChange
     get requires() {
         return [this.materializedView.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) {
@@ -99,7 +99,7 @@ export class RevokeMaterializedViewPrivileges extends AlterMaterializedViewChang
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("MATERIALIZED VIEW");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("MATERIALIZED VIEW", list, this.version);
@@ -140,7 +140,7 @@ export class RevokeGrantOptionMaterializedViewPrivileges extends AlterMaterializ
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("MATERIALIZED VIEW");
         const privSql = formatObjectPrivilegeList("MATERIALIZED VIEW", this.privilegeNames, this.version);
         const materializedViewName = `${this.materializedView.schema}.${this.materializedView.name}`;

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

@@ -0,0 +1,28 @@
+import type { SecurityLabelProps } from "../../security-label.types.ts";
+import type { MaterializedView } from "../materialized-view.model.ts";
+import { CreateMaterializedViewChange, DropMaterializedViewChange } from "./materialized-view.base.ts";
+export type SecurityLabelMaterializedView = CreateSecurityLabelOnMaterializedView | DropSecurityLabelOnMaterializedView;
+export declare class CreateSecurityLabelOnMaterializedView extends CreateMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        materializedView: MaterializedView;
+        securityLabel: SecurityLabelProps;
+    });
+    get creates(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): `materializedView:${string}`[];
+    serialize(): string;
+}
+export declare class DropSecurityLabelOnMaterializedView extends DropMaterializedViewChange {
+    readonly materializedView: MaterializedView;
+    readonly securityLabel: SecurityLabelProps;
+    readonly scope: "security_label";
+    constructor(props: {
+        materializedView: MaterializedView;
+        securityLabel: SecurityLabelProps;
+    });
+    get drops(): `securityLabel:${string}::provider:${string}`[];
+    get requires(): (`securityLabel:${string}::provider:${string}` | `materializedView:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/materialized-view/changes/materialized-view.security-label.js

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateMaterializedViewChange, DropMaterializedViewChange, } from "./materialized-view.base.js";
+export class CreateSecurityLabelOnMaterializedView extends CreateMaterializedViewChange {
+    materializedView;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.securityLabel = props.securityLabel;
+    }
+    get creates() {
+        return [
+            stableId.securityLabel(this.materializedView.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [this.materializedView.stableId];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+            "IS",
+            quoteLiteral(this.securityLabel.label),
+        ].join(" ");
+    }
+}
+export class DropSecurityLabelOnMaterializedView extends DropMaterializedViewChange {
+    materializedView;
+    securityLabel;
+    scope = "security_label";
+    constructor(props) {
+        super();
+        this.materializedView = props.materializedView;
+        this.securityLabel = props.securityLabel;
+    }
+    get drops() {
+        return [
+            stableId.securityLabel(this.materializedView.stableId, this.securityLabel.provider),
+        ];
+    }
+    get requires() {
+        return [
+            stableId.securityLabel(this.materializedView.stableId, this.securityLabel.provider),
+            this.materializedView.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "SECURITY LABEL FOR",
+            this.securityLabel.provider,
+            "ON MATERIALIZED VIEW",
+            `${this.materializedView.schema}.${this.materializedView.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -3,4 +3,6 @@ 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";
-export type MaterializedViewChange = AlterMaterializedView | CommentMaterializedView | CreateMaterializedView | DropMaterializedView | MaterializedViewPrivilege;
+import type { SecurityLabelMaterializedView } from "./materialized-view.security-label.ts";
+/** Union of all materialized-view-related change variants (`objectType: "materialized_view"`). @category Change Types */
+export type MaterializedViewChange = AlterMaterializedView | CommentMaterializedView | CreateMaterializedView | DropMaterializedView | MaterializedViewPrivilege | SecurityLabelMaterializedView;

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

@@ -1,7 +1,7 @@
-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 { 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.
  *
@@ -10,9 +10,4 @@ import type { MaterializedView } from "./materialized-view.model.ts";
  * @param branch - The materialized views in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffMaterializedViews(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, MaterializedView>, branch: Record<string, MaterializedView>): MaterializedViewChange[];
+export declare function diffMaterializedViews(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, MaterializedView>, branch: Record<string, MaterializedView>): MaterializedViewChange[];

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

@@ -1,11 +1,70 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
+import { diffSecurityLabels } from "../security-label.types.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterMaterializedViewChangeOwner, AlterMaterializedViewSetStorageParams, } from "./changes/materialized-view.alter.js";
 import { CreateCommentOnMaterializedView, CreateCommentOnMaterializedViewColumn, DropCommentOnMaterializedView, DropCommentOnMaterializedViewColumn, } from "./changes/materialized-view.comment.js";
 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.
  *
@@ -18,123 +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,
-                }));
-            }
-        }
-        // 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 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(effectiveDefaults, desiredPrivileges, mv.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantMaterializedViewPrivileges({
-                            materializedView: mv,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    // For revoke grant option, we need to find the columns from the effective defaults
-                    const originalPriv = effectiveDefaults.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionMaterializedViewPrivileges({
-                        materializedView: mv,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        changes.push(...buildCreateMaterializedViewChanges(ctx, branch[materializedViewId]));
     }
     for (const materializedViewId of dropped) {
         changes.push(new DropMaterializedView({ materializedView: main[materializedViewId] }));
@@ -160,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
@@ -225,6 +166,14 @@ export function diffMaterializedViews(ctx, main, branch) {
                     }));
                 }
             }
+            // SECURITY LABELS
+            changes.push(...diffSecurityLabels(mainMaterializedView.security_labels, branchMaterializedView.security_labels, (securityLabel) => new CreateSecurityLabelOnMaterializedView({
+                materializedView: branchMaterializedView,
+                securityLabel,
+            }), (securityLabel) => new DropSecurityLabelOnMaterializedView({
+                materializedView: mainMaterializedView,
+                securityLabel,
+            })));
             // COMMENT changes on columns
             const mainCols = new Map(mainMaterializedView.columns.map((c) => [c.name, c]));
             const branchCols = new Map(branchMaterializedView.columns.map((c) => [c.name, c]));
@@ -250,85 +199,12 @@ export function diffMaterializedViews(ctx, main, branch) {
             // PRIVILEGES (unified object and column 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(mainMaterializedView.privileges, branchMaterializedView.privileges, branchMaterializedView.owner, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByColumns(result.grants);
-                    for (const [, group] of grantGroups) {
-                        for (const [grantable, privSet] of group.byGrant) {
-                            const privileges = Array.from(privSet).map((priv) => ({
-                                privilege: priv,
-                                grantable,
-                            }));
-                            changes.push(new GrantMaterializedViewPrivileges({
-                                materializedView: branchMaterializedView,
-                                grantee,
-                                privileges,
-                                columns: group.columns,
-                                version: ctx.version,
-                            }));
-                        }
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                    for (const [, group] of revokeGroups) {
-                        // Collapse all grantable groups into a single revoke (grantable: false)
-                        const allPrivileges = new Set();
-                        for (const [, privSet] of group.byGrant) {
-                            for (const priv of privSet) {
-                                allPrivileges.add(priv);
-                            }
-                        }
-                        const privileges = Array.from(allPrivileges).map((priv) => ({
-                            privilege: priv,
-                            grantable: false,
-                        }));
-                        changes.push(new RevokeMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    const revokeGrantGroups = new Map();
-                    for (const r of result.revokeGrantOption) {
-                        // For revoke grant option, we need to find the columns from the original privilege
-                        const originalPriv = mainMaterializedView.privileges.find((p) => p.grantee === grantee && p.privilege === r);
-                        const key = originalPriv?.columns
-                            ? originalPriv.columns.sort().join(",")
-                            : "";
-                        if (!revokeGrantGroups.has(key)) {
-                            revokeGrantGroups.set(key, {
-                                columns: originalPriv?.columns
-                                    ? [...originalPriv.columns]
-                                    : undefined,
-                                privileges: new Set(),
-                            });
-                        }
-                        const group = revokeGrantGroups.get(key);
-                        if (!group)
-                            continue;
-                        group.privileges.add(r);
-                    }
-                    for (const [, group] of revokeGrantGroups) {
-                        const privilegeNames = Array.from(group.privileges);
-                        changes.push(new RevokeGrantOptionMaterializedViewPrivileges({
-                            materializedView: mainMaterializedView,
-                            grantee,
-                            privilegeNames,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
+            const privilegeResults = diffPrivileges(mainMaterializedView.privileges, branchMaterializedView.privileges, branchMaterializedView.owner);
+            changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchMaterializedView, mainMaterializedView, "materializedView", {
+                Grant: GrantMaterializedViewPrivileges,
+                Revoke: RevokeMaterializedViewPrivileges,
+                RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+            }, mainMaterializedView.privileges, ctx.version));
         }
     }
     return changes;

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

@@ -2,6 +2,8 @@ import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
+import { type ExtractRetryOptions } from "../extract-with-retry.ts";
+import { type SecurityLabelProps } from "../security-label.types.ts";
 declare const materializedViewPropsSchema: z.ZodObject<{
     schema: z.ZodString;
     name: z.ZodString;
@@ -14,10 +16,10 @@ declare const materializedViewPropsSchema: z.ZodObject<{
     has_subclasses: z.ZodBoolean;
     is_populated: z.ZodBoolean;
     replica_identity: z.ZodEnum<{
-        f: "f";
         n: "n";
         i: "i";
         d: "d";
+        f: "f";
     }>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
@@ -41,6 +43,10 @@ declare const materializedViewPropsSchema: z.ZodObject<{
         collation: z.ZodNullable<z.ZodString>;
         default: z.ZodNullable<z.ZodString>;
         comment: z.ZodNullable<z.ZodString>;
+        security_labels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            label: z.ZodString;
+        }, z.z.core.$strip>>>;
     }, z.z.core.$strip>>;
     privileges: z.ZodArray<z.ZodObject<{
         grantee: z.ZodString;
@@ -48,6 +54,10 @@ declare const materializedViewPropsSchema: z.ZodObject<{
         grantable: z.ZodBoolean;
         columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     }, z.z.core.$strip>>;
+    security_labels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        label: z.ZodString;
+    }, z.z.core.$strip>>>>;
 }, z.z.core.$strip>;
 type MaterializedViewPrivilegeProps = PrivilegeProps;
 export type MaterializedViewProps = z.infer<typeof materializedViewPropsSchema>;
@@ -70,6 +80,7 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
     readonly comment: MaterializedViewProps["comment"];
     readonly columns: MaterializedViewProps["columns"];
     readonly privileges: MaterializedViewPrivilegeProps[];
+    readonly security_labels: SecurityLabelProps[];
     constructor(props: MaterializedViewProps);
     get stableId(): `materializedView:${string}`;
     get identityFields(): {
@@ -85,7 +96,7 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         has_triggers: boolean;
         has_subclasses: boolean;
         is_populated: boolean;
-        replica_identity: "f" | "n" | "i" | "d";
+        replica_identity: "n" | "i" | "d" | "f";
         is_partition: boolean;
         options: string[] | null;
         partition_bound: string | null;
@@ -108,6 +119,10 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
             collation: string | null;
             default: string | null;
             comment: string | null;
+            security_labels?: {
+                provider: string;
+                label: string;
+            }[] | undefined;
         }[];
         privileges: {
             grantee: string;
@@ -115,6 +130,10 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
             grantable: boolean;
             columns?: string[] | null | undefined;
         }[];
+        security_labels: {
+            provider: string;
+            label: string;
+        }[];
     };
     stableSnapshot(): {
         identity: {
@@ -125,6 +144,10 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
             columns: {
                 [x: string]: unknown;
             }[];
+            security_labels: {
+                provider: string;
+                label: string;
+            }[];
             definition: string;
             row_security: boolean;
             force_row_security: boolean;
@@ -133,7 +156,7 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
             has_triggers: boolean;
             has_subclasses: boolean;
             is_populated: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
             is_partition: boolean;
             options: string[] | null;
             partition_bound: string | null;
@@ -148,5 +171,5 @@ export declare class MaterializedView extends BasePgModel implements TableLikeOb
         };
     };
 }
-export declare function extractMaterializedViews(pool: Pool): Promise<MaterializedView[]>;
+export declare function extractMaterializedViews(pool: Pool, options?: ExtractRetryOptions): Promise<MaterializedView[]>;
 export {};