@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

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

@@ -0,0 +1,335 @@
+import { diffObjects } from "../base.diff.js";
+import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.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";
+/**
+ * Diff two sets of materialized views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The materialized views in the main catalog.
+ * @param branch - The materialized views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+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,
+                    }));
+                }
+            }
+        }
+    }
+    for (const materializedViewId of dropped) {
+        changes.push(new DropMaterializedView({ materializedView: main[materializedViewId] }));
+    }
+    for (const materializedViewId of altered) {
+        const mainMaterializedView = main[materializedViewId];
+        const branchMaterializedView = branch[materializedViewId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the materialized view
+        const NON_ALTERABLE_FIELDS = [
+            "definition",
+            "row_security",
+            "force_row_security",
+            "has_indexes",
+            "has_rules",
+            "has_triggers",
+            "has_subclasses",
+            "is_populated",
+            "replica_identity",
+            "is_partition",
+            "partition_bound",
+        ];
+        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,
+            }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // OWNER
+            if (mainMaterializedView.owner !== branchMaterializedView.owner) {
+                changes.push(new AlterMaterializedViewChangeOwner({
+                    materializedView: mainMaterializedView,
+                    owner: branchMaterializedView.owner,
+                }));
+            }
+            // STORAGE PARAMETERS (reloptions)
+            // Emit a combined SET/RESET change similar to indexes
+            if (!deepEqual(mainMaterializedView.options, branchMaterializedView.options)) {
+                const parseOptions = (options) => {
+                    const map = new Map();
+                    if (!options)
+                        return map;
+                    for (const opt of options) {
+                        const eqIndex = opt.indexOf("=");
+                        const key = opt.slice(0, eqIndex).trim();
+                        const value = opt.slice(eqIndex + 1).trim();
+                        map.set(key, value);
+                    }
+                    return map;
+                };
+                const mainMap = parseOptions(mainMaterializedView.options);
+                const branchMap = parseOptions(branchMaterializedView.options);
+                const keysToReset = [];
+                for (const key of mainMap.keys()) {
+                    if (!branchMap.has(key))
+                        keysToReset.push(key);
+                }
+                const paramsToSet = [];
+                for (const [key, newValue] of branchMap.entries()) {
+                    const oldValue = mainMap.get(key);
+                    const changed = oldValue !== newValue;
+                    if (changed) {
+                        paramsToSet.push(newValue === undefined ? key : `${key}=${newValue}`);
+                    }
+                }
+                changes.push(new AlterMaterializedViewSetStorageParams({
+                    materializedView: mainMaterializedView,
+                    paramsToSet,
+                    keysToReset,
+                }));
+            }
+            // Note: Materialized view renaming would also use ALTER MATERIALIZED VIEW ... RENAME TO ...
+            // But since our MaterializedView model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+            // MATERIALIZED VIEW COMMENT (create/drop when comment changes)
+            if (mainMaterializedView.comment !== branchMaterializedView.comment) {
+                if (branchMaterializedView.comment === null) {
+                    changes.push(new DropCommentOnMaterializedView({
+                        materializedView: mainMaterializedView,
+                    }));
+                }
+                else {
+                    changes.push(new CreateCommentOnMaterializedView({
+                        materializedView: branchMaterializedView,
+                    }));
+                }
+            }
+            // 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]));
+            for (const [name, branchCol] of branchCols) {
+                const mainCol = mainCols.get(name);
+                if (!mainCol)
+                    continue;
+                if (mainCol.comment !== branchCol.comment) {
+                    if (branchCol.comment === null) {
+                        changes.push(new DropCommentOnMaterializedViewColumn({
+                            materializedView: mainMaterializedView,
+                            column: mainCol,
+                        }));
+                    }
+                    else {
+                        changes.push(new CreateCommentOnMaterializedViewColumn({
+                            materializedView: branchMaterializedView,
+                            column: branchCol,
+                        }));
+                    }
+                }
+            }
+            // 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,
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,152 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel, type TableLikeObject } from "../base.model.ts";
+import { type PrivilegeProps } from "../base.privilege-diff.ts";
+declare const materializedViewPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    definition: z.ZodString;
+    row_security: z.ZodBoolean;
+    force_row_security: z.ZodBoolean;
+    has_indexes: z.ZodBoolean;
+    has_rules: z.ZodBoolean;
+    has_triggers: z.ZodBoolean;
+    has_subclasses: z.ZodBoolean;
+    is_populated: z.ZodBoolean;
+    replica_identity: z.ZodEnum<{
+        n: "n";
+        i: "i";
+        d: "d";
+        f: "f";
+    }>;
+    is_partition: z.ZodBoolean;
+    options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    partition_bound: z.ZodNullable<z.ZodString>;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        position: z.ZodNumber;
+        data_type: z.ZodString;
+        data_type_str: z.ZodString;
+        is_custom_type: z.ZodBoolean;
+        custom_type_type: z.ZodNullable<z.ZodString>;
+        custom_type_category: z.ZodNullable<z.ZodString>;
+        custom_type_schema: z.ZodNullable<z.ZodString>;
+        custom_type_name: z.ZodNullable<z.ZodString>;
+        not_null: z.ZodBoolean;
+        is_identity: z.ZodBoolean;
+        is_identity_always: z.ZodBoolean;
+        is_generated: z.ZodBoolean;
+        collation: z.ZodNullable<z.ZodString>;
+        default: z.ZodNullable<z.ZodString>;
+        comment: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strip>>;
+    privileges: z.ZodArray<z.ZodObject<{
+        grantee: z.ZodString;
+        privilege: z.ZodString;
+        grantable: z.ZodBoolean;
+        columns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.z.core.$strip>>;
+}, z.z.core.$strip>;
+type MaterializedViewPrivilegeProps = PrivilegeProps;
+export type MaterializedViewProps = z.infer<typeof materializedViewPropsSchema>;
+export declare class MaterializedView extends BasePgModel implements TableLikeObject {
+    readonly schema: MaterializedViewProps["schema"];
+    readonly name: MaterializedViewProps["name"];
+    readonly definition: MaterializedViewProps["definition"];
+    readonly row_security: MaterializedViewProps["row_security"];
+    readonly force_row_security: MaterializedViewProps["force_row_security"];
+    readonly has_indexes: MaterializedViewProps["has_indexes"];
+    readonly has_rules: MaterializedViewProps["has_rules"];
+    readonly has_triggers: MaterializedViewProps["has_triggers"];
+    readonly has_subclasses: MaterializedViewProps["has_subclasses"];
+    readonly is_populated: MaterializedViewProps["is_populated"];
+    readonly replica_identity: MaterializedViewProps["replica_identity"];
+    readonly is_partition: MaterializedViewProps["is_partition"];
+    readonly options: MaterializedViewProps["options"];
+    readonly partition_bound: MaterializedViewProps["partition_bound"];
+    readonly owner: MaterializedViewProps["owner"];
+    readonly comment: MaterializedViewProps["comment"];
+    readonly columns: MaterializedViewProps["columns"];
+    readonly privileges: MaterializedViewPrivilegeProps[];
+    constructor(props: MaterializedViewProps);
+    get stableId(): `materializedView:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        definition: string;
+        row_security: boolean;
+        force_row_security: boolean;
+        has_indexes: boolean;
+        has_rules: boolean;
+        has_triggers: boolean;
+        has_subclasses: boolean;
+        is_populated: boolean;
+        replica_identity: "n" | "i" | "d" | "f";
+        is_partition: boolean;
+        options: string[] | null;
+        partition_bound: string | null;
+        owner: string;
+        comment: string | null;
+        columns: {
+            name: string;
+            position: number;
+            data_type: string;
+            data_type_str: string;
+            is_custom_type: boolean;
+            custom_type_type: string | null;
+            custom_type_category: string | null;
+            custom_type_schema: string | null;
+            custom_type_name: string | null;
+            not_null: boolean;
+            is_identity: boolean;
+            is_identity_always: boolean;
+            is_generated: boolean;
+            collation: string | null;
+            default: string | null;
+            comment: string | null;
+        }[];
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+    stableSnapshot(): {
+        identity: {
+            schema: string;
+            name: string;
+        };
+        data: {
+            columns: {
+                [x: string]: unknown;
+            }[];
+            definition: string;
+            row_security: boolean;
+            force_row_security: boolean;
+            has_indexes: boolean;
+            has_rules: boolean;
+            has_triggers: boolean;
+            has_subclasses: boolean;
+            is_populated: boolean;
+            replica_identity: "n" | "i" | "d" | "f";
+            is_partition: boolean;
+            options: string[] | null;
+            partition_bound: string | null;
+            owner: string;
+            comment: string | null;
+            privileges: {
+                grantee: string;
+                privilege: string;
+                grantable: boolean;
+                columns?: string[] | null | undefined;
+            }[];
+        };
+    };
+}
+export declare function extractMaterializedViews(sql: Sql): Promise<MaterializedView[]>;
+export {};