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

package/dist/core/objects/type/composite-type/changes/composite-type.privilege.js

@@ -0,0 +1,131 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterCompositeTypeChange } from "./composite-type.base.js";
+/**
+ * Grant privileges on a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantCompositeTypePrivileges extends AlterCompositeTypeChange {
+    compositeType;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.compositeType = props.compositeType;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.compositeType.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.compositeType.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantCompositeTypePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+        const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a composite type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeCompositeTypePrivileges extends AlterCompositeTypeChange {
+    compositeType;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.compositeType = props.compositeType;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        // Return ACL ID for dependency tracking, even though this is an ALTER operation
+        // Phase assignment now uses operation type, so this won't affect phase placement
+        return [stableId.acl(this.compositeType.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.compositeType.stableId, this.grantee),
+            this.compositeType.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+        const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a composite type.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionCompositeTypePrivileges extends AlterCompositeTypeChange {
+    compositeType;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.compositeType = props.compositeType;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.compositeType.stableId, this.grantee),
+            this.compositeType.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const privSql = formatObjectPrivilegeList("TYPE", this.privilegeNames, this.version);
+        const typeName = `${this.compositeType.schema}.${this.compositeType.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/type/composite-type/changes/composite-type.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterCompositeType } from "./composite-type.alter.ts";
+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";
+export type CompositeTypeChange = AlterCompositeType | CommentCompositeType | CreateCompositeType | DropCompositeType | CompositeTypePrivilege;

package/dist/core/objects/type/composite-type/changes/composite-type.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/objects/type/composite-type/composite-type.diff.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import type { Role } from "../../role/role.model.ts";
+import type { CompositeTypeChange } from "./changes/composite-type.types.ts";
+import type { CompositeType } from "./composite-type.model.ts";
+/**
+ * Diff two sets of composite types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The composite types in the main catalog.
+ * @param branch - The composite types in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffCompositeTypes(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, CompositeType>, branch: Record<string, CompositeType>): CompositeTypeChange[];

package/dist/core/objects/type/composite-type/composite-type.diff.js

@@ -0,0 +1,250 @@
+import { diffObjects } from "../../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { deepEqual, hasNonAlterableChanges } from "../../utils.js";
+import { AlterCompositeTypeAddAttribute, AlterCompositeTypeAlterAttributeType, AlterCompositeTypeChangeOwner, AlterCompositeTypeDropAttribute, } from "./changes/composite-type.alter.js";
+import { CreateCommentOnCompositeType, CreateCommentOnCompositeTypeAttribute, DropCommentOnCompositeType, DropCommentOnCompositeTypeAttribute, } from "./changes/composite-type.comment.js";
+import { CreateCompositeType } from "./changes/composite-type.create.js";
+import { DropCompositeType } from "./changes/composite-type.drop.js";
+import { GrantCompositeTypePrivileges, RevokeCompositeTypePrivileges, RevokeGrantOptionCompositeTypePrivileges, } from "./changes/composite-type.privilege.js";
+/**
+ * Diff two sets of composite types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The composite types in the main catalog.
+ * @param branch - The composite types in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffCompositeTypes(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const compositeTypeId of created) {
+        const ct = branch[compositeTypeId];
+        changes.push(new CreateCompositeType({ compositeType: ct }));
+        // OWNER: If the composite type should be owned by someone other than the current user,
+        // emit ALTER TYPE ... OWNER TO after creation
+        if (ct.owner !== ctx.currentUser) {
+            changes.push(new AlterCompositeTypeChangeOwner({
+                compositeType: ct,
+                owner: ct.owner,
+            }));
+        }
+        // Type comment on creation
+        if (ct.comment !== null) {
+            changes.push(new CreateCommentOnCompositeType({ compositeType: ct }));
+        }
+        // Attribute comments on creation
+        for (const attr of ct.columns) {
+            if (attr.comment !== null) {
+                changes.push(new CreateCommentOnCompositeTypeAttribute({
+                    compositeType: ct,
+                    attribute: attr,
+                }));
+            }
+        }
+        // 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, "composite_type", ct.schema ?? "");
+        // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
+        // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
+        // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
+        const desiredPrivileges = filterPublicBuiltInDefaults("composite_type", ct.privileges);
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the composite type owner as the reference.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, ct.owner);
+        // Generate grant changes
+        for (const [grantee, result] of privilegeResults) {
+            if (result.grants.length > 0) {
+                const grantGroups = groupPrivilegesByGrantable(result.grants);
+                for (const [grantable, list] of grantGroups) {
+                    void grantable;
+                    changes.push(new GrantCompositeTypePrivileges({
+                        compositeType: ct,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke changes
+            if (result.revokes.length > 0) {
+                const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                for (const [grantable, list] of revokeGroups) {
+                    void grantable;
+                    changes.push(new RevokeCompositeTypePrivileges({
+                        compositeType: ct,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionCompositeTypePrivileges({
+                    compositeType: ct,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const compositeTypeId of dropped) {
+        changes.push(new DropCompositeType({ compositeType: main[compositeTypeId] }));
+    }
+    for (const compositeTypeId of altered) {
+        const mainCompositeType = main[compositeTypeId];
+        const branchCompositeType = branch[compositeTypeId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the composite type
+        const NON_ALTERABLE_FIELDS = [
+            "row_security",
+            "force_row_security",
+            "has_indexes",
+            "has_rules",
+            "has_triggers",
+            "has_subclasses",
+            "is_populated",
+            "replica_identity",
+            "is_partition",
+            "options",
+            "partition_bound",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainCompositeType, branchCompositeType, NON_ALTERABLE_FIELDS, { options: deepEqual });
+        if (nonAlterablePropsChanged) {
+            // Replacement is not performed automatically for composite types
+            // to avoid destructive operations; keep changes minimal.
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // OWNER
+            if (mainCompositeType.owner !== branchCompositeType.owner) {
+                changes.push(new AlterCompositeTypeChangeOwner({
+                    compositeType: mainCompositeType,
+                    owner: branchCompositeType.owner,
+                }));
+            }
+            // TYPE COMMENT (create/drop when comment changes)
+            if (mainCompositeType.comment !== branchCompositeType.comment) {
+                if (branchCompositeType.comment === null) {
+                    changes.push(new DropCommentOnCompositeType({
+                        compositeType: mainCompositeType,
+                    }));
+                }
+                else {
+                    changes.push(new CreateCommentOnCompositeType({
+                        compositeType: branchCompositeType,
+                    }));
+                }
+            }
+            // ATTRIBUTE diffs
+            const mainAttrs = new Map(mainCompositeType.columns.map((c) => [c.name, c]));
+            const branchAttrs = new Map(branchCompositeType.columns.map((c) => [c.name, c]));
+            // Added attributes
+            for (const [name, attr] of branchAttrs) {
+                if (!mainAttrs.has(name)) {
+                    changes.push(new AlterCompositeTypeAddAttribute({
+                        compositeType: branchCompositeType,
+                        attribute: attr,
+                    }));
+                    if (attr.comment !== null) {
+                        changes.push(new CreateCommentOnCompositeTypeAttribute({
+                            compositeType: branchCompositeType,
+                            attribute: attr,
+                        }));
+                    }
+                }
+            }
+            // Dropped attributes
+            for (const [name, attr] of mainAttrs) {
+                if (!branchAttrs.has(name)) {
+                    changes.push(new AlterCompositeTypeDropAttribute({
+                        compositeType: mainCompositeType,
+                        attribute: attr,
+                    }));
+                }
+            }
+            // Altered attribute type/collation
+            for (const [name, mainAttr] of mainAttrs) {
+                const branchAttr = branchAttrs.get(name);
+                if (!branchAttr)
+                    continue;
+                if (mainAttr.data_type_str !== branchAttr.data_type_str ||
+                    mainAttr.collation !== branchAttr.collation) {
+                    changes.push(new AlterCompositeTypeAlterAttributeType({
+                        compositeType: branchCompositeType,
+                        attribute: branchAttr,
+                    }));
+                }
+                // COMMENT change on attribute
+                if (mainAttr.comment !== branchAttr.comment) {
+                    if (branchAttr.comment === null) {
+                        changes.push(new DropCommentOnCompositeTypeAttribute({
+                            compositeType: mainCompositeType,
+                            attribute: mainAttr,
+                        }));
+                    }
+                    else {
+                        changes.push(new CreateCommentOnCompositeTypeAttribute({
+                            compositeType: branchCompositeType,
+                            attribute: branchAttr,
+                        }));
+                    }
+                }
+            }
+            // PRIVILEGES
+            // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+            // (PostgreSQL grants it automatically, so we shouldn't compare it)
+            const mainPrivilegesFiltered = filterPublicBuiltInDefaults("composite_type", mainCompositeType.privileges);
+            // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+            const branchPrivilegesFiltered = filterPublicBuiltInDefaults("composite_type", branchCompositeType.privileges);
+            // Filter out owner privileges - owner always has ALL privileges implicitly
+            // and shouldn't be compared. Use branch owner as the reference.
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchCompositeType.owner, ctx.mainRoles);
+            for (const [grantee, result] of privilegeResults) {
+                // Generate grant changes
+                if (result.grants.length > 0) {
+                    const grantGroups = groupPrivilegesByGrantable(result.grants);
+                    for (const [grantable, list] of grantGroups) {
+                        void grantable;
+                        changes.push(new GrantCompositeTypePrivileges({
+                            compositeType: branchCompositeType,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke changes
+                if (result.revokes.length > 0) {
+                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                    for (const [grantable, list] of revokeGroups) {
+                        void grantable;
+                        changes.push(new RevokeCompositeTypePrivileges({
+                            compositeType: mainCompositeType,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke grant option changes
+                if (result.revokeGrantOption.length > 0) {
+                    changes.push(new RevokeGrantOptionCompositeTypePrivileges({
+                        compositeType: mainCompositeType,
+                        grantee,
+                        privilegeNames: result.revokeGrantOption,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Note: Composite type renaming would also use ALTER TYPE ... RENAME TO ...
+            // But since our CompositeType model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+        }
+    }
+    return changes;
+}

package/dist/core/objects/type/composite-type/composite-type.model.d.ts

@@ -0,0 +1,148 @@
+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 compositeTypePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: 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 CompositeTypePrivilegeProps = PrivilegeProps;
+export type CompositeTypeProps = z.infer<typeof compositeTypePropsSchema>;
+export declare class CompositeType extends BasePgModel implements TableLikeObject {
+    readonly schema: CompositeTypeProps["schema"];
+    readonly name: CompositeTypeProps["name"];
+    readonly row_security: CompositeTypeProps["row_security"];
+    readonly force_row_security: CompositeTypeProps["force_row_security"];
+    readonly has_indexes: CompositeTypeProps["has_indexes"];
+    readonly has_rules: CompositeTypeProps["has_rules"];
+    readonly has_triggers: CompositeTypeProps["has_triggers"];
+    readonly has_subclasses: CompositeTypeProps["has_subclasses"];
+    readonly is_populated: CompositeTypeProps["is_populated"];
+    readonly replica_identity: CompositeTypeProps["replica_identity"];
+    readonly is_partition: CompositeTypeProps["is_partition"];
+    readonly options: CompositeTypeProps["options"];
+    readonly partition_bound: CompositeTypeProps["partition_bound"];
+    readonly owner: CompositeTypeProps["owner"];
+    readonly comment: CompositeTypeProps["comment"];
+    readonly columns: CompositeTypeProps["columns"];
+    readonly privileges: CompositeTypePrivilegeProps[];
+    constructor(props: CompositeTypeProps);
+    get stableId(): `type:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        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;
+            }[];
+            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 extractCompositeTypes(sql: Sql): Promise<CompositeType[]>;
+export {};