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

package/dist/core/objects/type/enum/changes/enum.privilege.js

@@ -0,0 +1,131 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterEnumChange } from "./enum.base.js";
+/**
+ * Grant privileges on an enum 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 GrantEnumPrivileges extends AlterEnumChange {
+    enum;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.enum.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.enum.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("GrantEnumPrivileges 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.enum.schema}.${this.enum.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on an enum 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 RevokeEnumPrivileges extends AlterEnumChange {
+    enum;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+        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.enum.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.enum.stableId, this.grantee),
+            this.enum.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.enum.schema}.${this.enum.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on an enum 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 RevokeGrantOptionEnumPrivileges extends AlterEnumChange {
+    enum;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.enum = props.enum;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.enum.stableId, this.grantee),
+            this.enum.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const privSql = formatObjectPrivilegeList("TYPE", this.privilegeNames, this.version);
+        const typeName = `${this.enum.schema}.${this.enum.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { AlterEnum } from "./enum.alter.ts";
+import type { CommentEnum } from "./enum.comment.ts";
+import type { CreateEnum } from "./enum.create.ts";
+import type { DropEnum } from "./enum.drop.ts";
+import type { EnumPrivilege } from "./enum.privilege.ts";
+export type EnumChange = AlterEnum | CommentEnum | CreateEnum | DropEnum | EnumPrivilege;

package/dist/core/objects/type/enum/changes/enum.types.js

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

package/dist/core/objects/type/enum/enum.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 { EnumChange } from "./changes/enum.types.ts";
+import type { Enum } from "./enum.model.ts";
+/**
+ * Diff two sets of enums from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The enums in the main catalog.
+ * @param branch - The enums in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffEnums(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, Enum>, branch: Record<string, Enum>): EnumChange[];

package/dist/core/objects/type/enum/enum.diff.js

@@ -0,0 +1,268 @@
+import { diffObjects } from "../../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { AlterEnumAddValue, AlterEnumChangeOwner, } from "./changes/enum.alter.js";
+import { CreateCommentOnEnum, DropCommentOnEnum, } from "./changes/enum.comment.js";
+import { CreateEnum } from "./changes/enum.create.js";
+import { DropEnum } from "./changes/enum.drop.js";
+import { GrantEnumPrivileges, RevokeEnumPrivileges, RevokeGrantOptionEnumPrivileges, } from "./changes/enum.privilege.js";
+/**
+ * Diff two sets of enums from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The enums in the main catalog.
+ * @param branch - The enums in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffEnums(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const enumId of created) {
+        const createdEnum = branch[enumId];
+        changes.push(new CreateEnum({ enum: createdEnum }));
+        // OWNER: If the enum should be owned by someone other than the current user,
+        // emit ALTER TYPE ... OWNER TO after creation
+        if (createdEnum.owner !== ctx.currentUser) {
+            changes.push(new AlterEnumChangeOwner({
+                enum: createdEnum,
+                owner: createdEnum.owner,
+            }));
+        }
+        if (createdEnum.comment !== null) {
+            changes.push(new CreateCommentOnEnum({ enum: createdEnum }));
+        }
+        // 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, "enum", createdEnum.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("enum", createdEnum.privileges);
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the enum owner as the reference.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdEnum.owner, ctx.mainRoles);
+        // 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 GrantEnumPrivileges({
+                        enum: createdEnum,
+                        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 RevokeEnumPrivileges({
+                        enum: createdEnum,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionEnumPrivileges({
+                    enum: createdEnum,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const enumId of dropped) {
+        changes.push(new DropEnum({ enum: main[enumId] }));
+    }
+    for (const enumId of altered) {
+        const mainEnum = main[enumId];
+        const branchEnum = branch[enumId];
+        // If labels were removed (branch is missing labels present in main),
+        // recreate the enum to avoid relying on unsupported DROP VALUE operations.
+        const removedLabels = mainEnum.labels
+            .map((l) => l.label)
+            .filter((label) => !branchEnum.labels.some((b) => b.label === label));
+        if (removedLabels.length > 0) {
+            changes.push(new DropEnum({ enum: mainEnum }));
+            changes.push(new CreateEnum({ enum: branchEnum }));
+            if (branchEnum.owner !== ctx.currentUser) {
+                changes.push(new AlterEnumChangeOwner({
+                    enum: branchEnum,
+                    owner: branchEnum.owner,
+                }));
+            }
+            if (branchEnum.comment !== null) {
+                changes.push(new CreateCommentOnEnum({ enum: branchEnum }));
+            }
+            const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "enum", branchEnum.schema ?? "");
+            const desiredPrivileges = filterPublicBuiltInDefaults("enum", branchEnum.privileges);
+            const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, branchEnum.owner, ctx.mainRoles);
+            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 GrantEnumPrivileges({
+                            enum: branchEnum,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                if (result.revokes.length > 0) {
+                    const revokeGroups = groupPrivilegesByGrantable(result.revokes);
+                    for (const [grantable, list] of revokeGroups) {
+                        void grantable;
+                        changes.push(new RevokeEnumPrivileges({
+                            enum: branchEnum,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                if (result.revokeGrantOption.length > 0) {
+                    changes.push(new RevokeGrantOptionEnumPrivileges({
+                        enum: branchEnum,
+                        grantee,
+                        privilegeNames: result.revokeGrantOption,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            continue;
+        }
+        // OWNER
+        if (mainEnum.owner !== branchEnum.owner) {
+            changes.push(new AlterEnumChangeOwner({ enum: mainEnum, owner: branchEnum.owner }));
+        }
+        // LABELS (enum values)
+        if (JSON.stringify(mainEnum.labels) !== JSON.stringify(branchEnum.labels)) {
+            const labelChanges = diffEnumLabels(mainEnum, branchEnum);
+            changes.push(...labelChanges);
+        }
+        // COMMENT
+        if (mainEnum.comment !== branchEnum.comment) {
+            if (branchEnum.comment === null) {
+                changes.push(new DropCommentOnEnum({ enum: mainEnum }));
+            }
+            else {
+                changes.push(new CreateCommentOnEnum({ enum: branchEnum }));
+            }
+        }
+        // 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("enum", mainEnum.privileges);
+        // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+        const branchPrivilegesFiltered = filterPublicBuiltInDefaults("enum", branchEnum.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, branchEnum.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 GrantEnumPrivileges({
+                        enum: branchEnum,
+                        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 RevokeEnumPrivileges({
+                        enum: mainEnum,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionEnumPrivileges({
+                    enum: mainEnum,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+        // Note: Enum renaming would also use ALTER TYPE ... RENAME TO ...
+        // But since our Enum model uses 'name' as the identity field,
+        // a name change would be handled as drop + create by diffObjects()
+    }
+    return changes;
+}
+/**
+ * Diff enum labels to determine what ALTER TYPE statements are needed.
+ * This implementation properly handles enum value positioning using sort_order.
+ * Note: We cannot reliably detect renames, so we only handle additions.
+ */
+function diffEnumLabels(mainEnum, branchEnum) {
+    const changes = [];
+    // Create maps for efficient lookup
+    const mainLabelMap = new Map(mainEnum.labels.map((label) => [label.label, label.sort_order]));
+    const branchLabelMap = new Map(branchEnum.labels.map((label) => [label.label, label.sort_order]));
+    // Find added values (values in branch but not in main)
+    const addedValues = Array.from(branchLabelMap.keys()).filter((label) => !mainLabelMap.has(label));
+    // Maintain a working list of labels (by name) to calculate correct BEFORE/AFTER
+    // anchors as we simulate applying the additions in order.
+    const branchOrdered = [...branchEnum.labels].sort((a, b) => a.sort_order - b.sort_order);
+    const workingLabels = [...mainEnum.labels].map((l) => l.label);
+    for (const newValue of addedValues) {
+        const branchIdx = branchOrdered.findIndex((l) => l.label === newValue);
+        if (branchIdx === -1)
+            continue;
+        const prevBranch = branchOrdered[branchIdx - 1]?.label;
+        const nextBranch = branchOrdered[branchIdx + 1]?.label;
+        let position;
+        // Prefer AFTER when prevBranch exists in workingLabels (more natural for sequential additions)
+        // Use BEFORE only when we need to insert before the first value or when prevBranch doesn't exist
+        if (prevBranch && workingLabels.includes(prevBranch)) {
+            position = { after: prevBranch };
+            // Insert after the previous label in our working list
+            const prevIdx = workingLabels.indexOf(prevBranch);
+            workingLabels.splice(prevIdx + 1, 0, newValue);
+        }
+        else if (nextBranch && workingLabels.includes(nextBranch)) {
+            // Insert before nextBranch when prevBranch doesn't exist (e.g., adding at beginning)
+            position = { before: nextBranch };
+            const nextIdx = workingLabels.indexOf(nextBranch);
+            workingLabels.splice(nextIdx, 0, newValue);
+        }
+        else if (nextBranch) {
+            // nextBranch exists but not in workingLabels yet (shouldn't happen in normal flow)
+            position = { before: nextBranch };
+            workingLabels.push(newValue);
+        }
+        else {
+            // Fallback: append to the end
+            position = { after: workingLabels[workingLabels.length - 1] };
+            workingLabels.push(newValue);
+        }
+        changes.push(new AlterEnumAddValue({ enum: mainEnum, newValue, position }));
+    }
+    // Complex changes (removals, resorting) are currently not auto-handled.
+    // We intentionally avoid emitting drop+create to prevent data loss.
+    return changes;
+}

package/dist/core/objects/type/enum/enum.model.d.ts

@@ -0,0 +1,66 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+import { type PrivilegeProps } from "../../base.privilege-diff.ts";
+/**
+ * All properties exposed by CREATE TYPE AS ENUM statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createtype.html
+ *
+ * ALTER TYPE statement can be generated for changes to the following properties:
+ *  - name, owner, schema, add or rename value
+ * https://www.postgresql.org/docs/current/sql-altertype.html
+ *
+ * Sort order of values may be negative or fractional.
+ * https://www.postgresql.org/docs/current/catalog-pg-enum.html
+ *
+ * Type ACL will be supported separately.
+ * https://www.postgresql.org/docs/current/ddl-priv.html
+ */
+declare const enumPropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    labels: z.ZodArray<z.ZodObject<{
+        sort_order: z.ZodNumber;
+        label: z.ZodString;
+    }, z.z.core.$strip>>;
+    comment: z.ZodNullable<z.ZodString>;
+    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 EnumPrivilegeProps = PrivilegeProps;
+export type EnumProps = z.infer<typeof enumPropsSchema>;
+export declare class Enum extends BasePgModel {
+    readonly schema: EnumProps["schema"];
+    readonly name: EnumProps["name"];
+    readonly owner: EnumProps["owner"];
+    readonly labels: EnumProps["labels"];
+    readonly comment: EnumProps["comment"];
+    readonly privileges: EnumPrivilegeProps[];
+    constructor(props: EnumProps);
+    get stableId(): `type:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        labels: {
+            sort_order: number;
+            label: string;
+        }[];
+        comment: string | null;
+        privileges: {
+            columns: string[] | null | undefined;
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+        }[];
+    };
+}
+export declare function extractEnums(sql: Sql): Promise<Enum[]>;
+export {};

package/dist/core/objects/type/enum/enum.model.js

@@ -0,0 +1,154 @@
+import z from "zod";
+import { BasePgModel } from "../../base.model.js";
+import { privilegePropsSchema, } from "../../base.privilege-diff.js";
+const enumLabelSchema = z.object({
+    sort_order: z.number(),
+    label: z.string(),
+});
+/**
+ * All properties exposed by CREATE TYPE AS ENUM statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createtype.html
+ *
+ * ALTER TYPE statement can be generated for changes to the following properties:
+ *  - name, owner, schema, add or rename value
+ * https://www.postgresql.org/docs/current/sql-altertype.html
+ *
+ * Sort order of values may be negative or fractional.
+ * https://www.postgresql.org/docs/current/catalog-pg-enum.html
+ *
+ * Type ACL will be supported separately.
+ * https://www.postgresql.org/docs/current/ddl-priv.html
+ */
+const enumPropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    owner: z.string(),
+    labels: z.array(enumLabelSchema),
+    comment: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Enum extends BasePgModel {
+    schema;
+    name;
+    owner;
+    labels;
+    comment;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.owner = props.owner;
+        this.labels = props.labels;
+        this.comment = props.comment;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `type:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        const orderedLabels = [...this.labels]
+            .map((label) => ({ ...label }))
+            .sort((a, b) => a.sort_order - b.sort_order || a.label.localeCompare(b.label));
+        // Normalize sort_order to a deterministic 1..N sequence to avoid float gaps
+        // that occur when adding multiple enum values with AFTER clauses.
+        const labels = orderedLabels.map((label, idx) => ({
+            sort_order: idx + 1,
+            label: label.label,
+        }));
+        const privileges = [...this.privileges]
+            .map((priv) => ({
+            ...priv,
+            columns: priv.columns ? [...priv.columns].sort() : priv.columns,
+        }))
+            .sort((a, b) => {
+            const byGrantee = a.grantee.localeCompare(b.grantee);
+            if (byGrantee !== 0)
+                return byGrantee;
+            const byPriv = a.privilege.localeCompare(b.privilege);
+            if (byPriv !== 0)
+                return byPriv;
+            if (a.grantable !== b.grantable)
+                return a.grantable ? 1 : -1;
+            const colsA = (a.columns ?? []).join(",");
+            const colsB = (b.columns ?? []).join(",");
+            return colsA.localeCompare(colsB);
+        });
+        return {
+            owner: this.owner,
+            labels,
+            comment: this.comment,
+            privileges,
+        };
+    }
+}
+export async function extractEnums(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const enumRows = await sql `
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_type'::regclass
+)
+select
+  t.typnamespace::regnamespace::text as schema,
+  quote_ident(t.typname) as name,
+  e.enumsortorder as sort_order,
+  e.enumlabel as label,
+  t.typowner::regrole::text as owner,
+  obj_description(t.oid, 'pg_type') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+          'privilege', x.privilege_type,
+          'grantable', x.is_grantable
+        )
+        order by x.grantee, x.privilege_type
+      )
+      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges
+from
+  pg_catalog.pg_enum e
+  inner join pg_catalog.pg_type t on t.oid = e.enumtypid
+  left outer join extension_oids ext on t.oid = ext.objid
+  where not t.typnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and ext.objid is null
+order by
+  1, 2, 3;
+  `;
+        const grouped = {};
+        for (const e of enumRows) {
+            const key = `${e.schema}.${e.name}`;
+            if (!grouped[key]) {
+                grouped[key] = {
+                    schema: e.schema,
+                    name: e.name,
+                    owner: e.owner,
+                    labels: [],
+                    comment: e.comment,
+                    privileges: e.privileges,
+                };
+            }
+            grouped[key].labels.push({ sort_order: e.sort_order, label: e.label });
+        }
+        // Validate and parse each enum using the Zod schema
+        const validatedEnums = Object.values(grouped).map((e) => enumPropsSchema.parse(e));
+        return validatedEnums.map((e) => new Enum(e));
+    });
+}

package/dist/core/objects/type/range/changes/range.alter.d.ts

@@ -0,0 +1,33 @@
+import type { Range } from "../range.model.ts";
+import { AlterRangeChange } from "./range.base.ts";
+/**
+ * Alter a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altertype.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER TYPE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER TYPE name RENAME TO new_name
+ * ALTER TYPE name SET SCHEMA new_schema
+ * ```
+ */
+export type AlterRange = AlterRangeChangeOwner;
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export declare class AlterRangeChangeOwner extends AlterRangeChange {
+    readonly range: Range;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        range: Range;
+        owner: string;
+    });
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a range type by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TYPE change.
+ */