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

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

@@ -0,0 +1,172 @@
+import { diffObjects } from "../../base.diff.js";
+import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { hasNonAlterableChanges } from "../../utils.js";
+import { AlterRangeChangeOwner } from "./changes/range.alter.js";
+import { CreateCommentOnRange, DropCommentOnRange, } from "./changes/range.comment.js";
+import { CreateRange } from "./changes/range.create.js";
+import { DropRange } from "./changes/range.drop.js";
+import { GrantRangePrivileges, RevokeGrantOptionRangePrivileges, RevokeRangePrivileges, } from "./changes/range.privilege.js";
+/**
+ * Diff two sets of range types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The ranges in the main catalog.
+ * @param branch - The ranges in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffRanges(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const id of created) {
+        const createdRange = branch[id];
+        changes.push(new CreateRange({ range: createdRange }));
+        // OWNER: If the range type should be owned by someone other than the current user,
+        // emit ALTER TYPE ... OWNER TO after creation
+        if (createdRange.owner !== ctx.currentUser) {
+            changes.push(new AlterRangeChangeOwner({
+                range: createdRange,
+                owner: createdRange.owner,
+            }));
+        }
+        if (createdRange.comment !== null) {
+            changes.push(new CreateCommentOnRange({ range: createdRange }));
+        }
+        // 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, "range", createdRange.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("range", createdRange.privileges);
+        // Filter out owner privileges - owner always has ALL privileges implicitly
+        // and shouldn't be compared. Use the range owner as the reference.
+        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, createdRange.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 GrantRangePrivileges({
+                        range: createdRange,
+                        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 RevokeRangePrivileges({
+                        range: createdRange,
+                        grantee,
+                        privileges: list,
+                        version: ctx.version,
+                    }));
+                }
+            }
+            // Generate revoke grant option changes
+            if (result.revokeGrantOption.length > 0) {
+                changes.push(new RevokeGrantOptionRangePrivileges({
+                    range: createdRange,
+                    grantee,
+                    privilegeNames: result.revokeGrantOption,
+                    version: ctx.version,
+                }));
+            }
+        }
+    }
+    for (const id of dropped) {
+        changes.push(new DropRange({ range: main[id] }));
+    }
+    for (const id of altered) {
+        const mainRange = main[id];
+        const branchRange = branch[id];
+        const NON_ALTERABLE_FIELDS = [
+            // Changes to these require DROP + CREATE
+            "subtype_schema",
+            "subtype_str",
+            "collation",
+            "canonical_function_schema",
+            "canonical_function_name",
+            "subtype_diff_schema",
+            "subtype_diff_name",
+            "subtype_opclass_schema",
+            "subtype_opclass_name",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainRange, branchRange, NON_ALTERABLE_FIELDS);
+        if (nonAlterablePropsChanged) {
+            changes.push(new DropRange({ range: mainRange }), new CreateRange({ range: branchRange }));
+        }
+        else {
+            if (mainRange.owner !== branchRange.owner) {
+                changes.push(new AlterRangeChangeOwner({
+                    range: mainRange,
+                    owner: branchRange.owner,
+                }));
+            }
+            // COMMENT
+            if (mainRange.comment !== branchRange.comment) {
+                if (branchRange.comment === null) {
+                    changes.push(new DropCommentOnRange({ range: mainRange }));
+                }
+                else {
+                    changes.push(new CreateCommentOnRange({ range: branchRange }));
+                }
+            }
+            // 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("range", mainRange.privileges);
+            // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+            const branchPrivilegesFiltered = filterPublicBuiltInDefaults("range", branchRange.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, branchRange.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 GrantRangePrivileges({
+                            range: branchRange,
+                            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 RevokeRangePrivileges({
+                            range: mainRange,
+                            grantee,
+                            privileges: list,
+                            version: ctx.version,
+                        }));
+                    }
+                }
+                // Generate revoke grant option changes
+                if (result.revokeGrantOption.length > 0) {
+                    changes.push(new RevokeGrantOptionRangePrivileges({
+                        range: mainRange,
+                        grantee,
+                        privilegeNames: result.revokeGrantOption,
+                        version: ctx.version,
+                    }));
+                }
+            }
+        }
+    }
+    return changes;
+}

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

@@ -0,0 +1,81 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+import { type PrivilegeProps } from "../../base.privilege-diff.ts";
+declare const rangePropsSchema: z.ZodObject<{
+    schema: z.ZodString;
+    name: z.ZodString;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    subtype_schema: z.ZodString;
+    subtype_str: z.ZodString;
+    collation: z.ZodNullable<z.ZodString>;
+    canonical_function_schema: z.ZodNullable<z.ZodString>;
+    canonical_function_name: z.ZodNullable<z.ZodString>;
+    subtype_diff_schema: z.ZodNullable<z.ZodString>;
+    subtype_diff_name: z.ZodNullable<z.ZodString>;
+    subtype_opclass_schema: z.ZodNullable<z.ZodString>;
+    subtype_opclass_name: 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 RangePrivilegeProps = PrivilegeProps;
+export type RangeProps = z.infer<typeof rangePropsSchema>;
+export declare class Range extends BasePgModel {
+    readonly schema: RangeProps["schema"];
+    readonly name: RangeProps["name"];
+    readonly owner: RangeProps["owner"];
+    readonly comment: RangeProps["comment"];
+    readonly subtype_schema: RangeProps["subtype_schema"];
+    readonly subtype_str: RangeProps["subtype_str"];
+    readonly collation: RangeProps["collation"];
+    readonly canonical_function_schema: RangeProps["canonical_function_schema"];
+    readonly canonical_function_name: RangeProps["canonical_function_name"];
+    readonly subtype_diff_schema: RangeProps["subtype_diff_schema"];
+    readonly subtype_diff_name: RangeProps["subtype_diff_name"];
+    readonly subtype_opclass_schema: RangeProps["subtype_opclass_schema"];
+    readonly subtype_opclass_name: RangeProps["subtype_opclass_name"];
+    readonly privileges: RangePrivilegeProps[];
+    constructor(props: RangeProps);
+    get stableId(): `type:${string}`;
+    get identityFields(): {
+        schema: string;
+        name: string;
+    };
+    get dataFields(): {
+        owner: string;
+        subtype_schema: string;
+        subtype_str: string;
+        collation: string | null;
+        canonical_function_schema: string | null;
+        canonical_function_name: string | null;
+        subtype_diff_schema: string | null;
+        subtype_diff_name: string | null;
+        subtype_opclass_schema: string | null;
+        subtype_opclass_name: string | null;
+        comment: string | null;
+        privileges: {
+            grantee: string;
+            privilege: string;
+            grantable: boolean;
+            columns?: string[] | null | undefined;
+        }[];
+    };
+}
+/**
+ * Extract all range types from the database.
+ *
+ * We intentionally capture only non-default options for CREATE TYPE AS RANGE:
+ *  - SUBTYPE is required and always present
+ *  - SUBTYPE_OPCLASS is included only when it differs from the default btree opclass
+ *  - COLLATION is included only when it differs from the subtype's typcollation
+ *  - CANONICAL and SUBTYPE_DIFF are included only when set
+ *  - MULTIRANGE_TYPE_NAME is not included (we currently do not attempt to infer
+ *    whether it differs from the default auto-generated name)
+ */
+export declare function extractRanges(sql: Sql): Promise<Range[]>;
+export {};

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

@@ -0,0 +1,165 @@
+import z from "zod";
+import { BasePgModel } from "../../base.model.js";
+import { privilegePropsSchema, } from "../../base.privilege-diff.js";
+const rangePropsSchema = z.object({
+    schema: z.string(),
+    name: z.string(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    // Subtype information
+    subtype_schema: z.string(),
+    subtype_str: z.string(),
+    // Optional, only present when non-default relative to subtype
+    collation: z.string().nullable(),
+    // Canonical and diff functions when present (non-default)
+    canonical_function_schema: z.string().nullable(),
+    canonical_function_name: z.string().nullable(),
+    subtype_diff_schema: z.string().nullable(),
+    subtype_diff_name: z.string().nullable(),
+    // Optional: print only when non-default (see extractor logic)
+    subtype_opclass_schema: z.string().nullable(),
+    subtype_opclass_name: z.string().nullable(),
+    privileges: z.array(privilegePropsSchema),
+});
+export class Range extends BasePgModel {
+    schema;
+    name;
+    owner;
+    comment;
+    subtype_schema;
+    subtype_str;
+    collation;
+    canonical_function_schema;
+    canonical_function_name;
+    subtype_diff_schema;
+    subtype_diff_name;
+    subtype_opclass_schema;
+    subtype_opclass_name;
+    privileges;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.schema = props.schema;
+        this.name = props.name;
+        // Data fields
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.subtype_schema = props.subtype_schema;
+        this.subtype_str = props.subtype_str;
+        this.collation = props.collation;
+        this.canonical_function_schema = props.canonical_function_schema;
+        this.canonical_function_name = props.canonical_function_name;
+        this.subtype_diff_schema = props.subtype_diff_schema;
+        this.subtype_diff_name = props.subtype_diff_name;
+        this.subtype_opclass_schema = props.subtype_opclass_schema;
+        this.subtype_opclass_name = props.subtype_opclass_name;
+        this.privileges = props.privileges;
+    }
+    get stableId() {
+        return `type:${this.schema}.${this.name}`;
+    }
+    get identityFields() {
+        return {
+            schema: this.schema,
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            owner: this.owner,
+            subtype_schema: this.subtype_schema,
+            subtype_str: this.subtype_str,
+            collation: this.collation,
+            canonical_function_schema: this.canonical_function_schema,
+            canonical_function_name: this.canonical_function_name,
+            subtype_diff_schema: this.subtype_diff_schema,
+            subtype_diff_name: this.subtype_diff_name,
+            subtype_opclass_schema: this.subtype_opclass_schema,
+            subtype_opclass_name: this.subtype_opclass_name,
+            comment: this.comment,
+            privileges: this.privileges,
+        };
+    }
+}
+/**
+ * Extract all range types from the database.
+ *
+ * We intentionally capture only non-default options for CREATE TYPE AS RANGE:
+ *  - SUBTYPE is required and always present
+ *  - SUBTYPE_OPCLASS is included only when it differs from the default btree opclass
+ *  - COLLATION is included only when it differs from the subtype's typcollation
+ *  - CANONICAL and SUBTYPE_DIFF are included only when set
+ *  - MULTIRANGE_TYPE_NAME is not included (we currently do not attempt to infer
+ *    whether it differs from the default auto-generated name)
+ */
+export async function extractRanges(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const rows = await sql `
+with extension_oids as (
+  select objid from pg_depend d
+  where d.refclassid = 'pg_extension'::regclass and d.classid = 'pg_type'::regclass
+), default_btree_opclass as (
+  -- For each input type, find its default btree operator class
+  select oc2.opcintype as type_oid, oc2.oid as opclass_oid
+  from pg_opclass oc2
+  join pg_am am on am.oid = oc2.opcmethod and am.amname = 'btree'
+  where oc2.opcdefault
+)
+select
+  -- range type identity
+  t.typnamespace::regnamespace::text as schema,
+  quote_ident(t.typname) as name,
+  t.typowner::regrole::text as owner,
+  obj_description(t.oid, 'pg_type') as comment,
+
+  -- subtype info
+  subt.typnamespace::regnamespace::text as subtype_schema,
+  format_type(r.rngsubtype, 0) as subtype_str,
+
+  -- include collation only if not default
+  case when r.rngcollation is not null and r.rngcollation <> 0 and r.rngcollation <> subt.typcollation then quote_ident(c.collname) else null end as collation,
+
+  -- include canonical/subtype_diff when set
+  case when r.rngcanonical <> 0 then pn_subcanon.nspname::regnamespace::text else null end as canonical_function_schema,
+  case when r.rngcanonical <> 0 then quote_ident(p_subcanon.proname) else null end as canonical_function_name,
+  case when r.rngsubdiff <> 0 then pn_subdiff.nspname::regnamespace::text else null end as subtype_diff_schema,
+  case when r.rngsubdiff <> 0 then quote_ident(p_subdiff.proname) else null end as subtype_diff_name,
+
+  -- include opclass only when not default for btree
+  case when r.rngsubopc is not null and r.rngsubopc <> 0 and r.rngsubopc <> dbo.opclass_oid then opc.opcnamespace::regnamespace::text else null end as subtype_opclass_schema,
+  case when r.rngsubopc is not null and r.rngsubopc <> 0 and r.rngsubopc <> dbo.opclass_oid then quote_ident(opc.opcname) else null end as subtype_opclass_name,
+
+  -- privileges
+  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_range r
+join pg_catalog.pg_type t on t.oid = r.rngtypid
+join pg_catalog.pg_type subt on subt.oid = r.rngsubtype
+left join default_btree_opclass dbo on dbo.type_oid = r.rngsubtype
+left join pg_catalog.pg_opclass opc on opc.oid = r.rngsubopc
+left join pg_catalog.pg_collation c on c.oid = r.rngcollation
+left join pg_catalog.pg_proc p_subcanon on p_subcanon.oid = r.rngcanonical
+left join pg_catalog.pg_namespace pn_subcanon on pn_subcanon.oid = p_subcanon.pronamespace
+left join pg_catalog.pg_proc p_subdiff on p_subdiff.oid = r.rngsubdiff
+left join pg_catalog.pg_namespace pn_subdiff on pn_subdiff.oid = p_subdiff.pronamespace
+left outer join extension_oids e on t.oid = e.objid
+where not t.typnamespace::regnamespace::text like any(array['pg\_%', 'information\_schema'])
+  and e.objid is null
+order by 1, 2;
+    `;
+        const validated = rows.map((row) => rangePropsSchema.parse(row));
+        return validated.map((row) => new Range(row));
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { CompositeTypeChange } from "./composite-type/changes/composite-type.types.ts";
+import type { EnumChange } from "./enum/changes/enum.types.ts";
+import type { RangeChange } from "./range/changes/range.types.ts";
+export type TypeChange = CompositeTypeChange | EnumChange | RangeChange;

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

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

package/dist/core/objects/utils.d.ts

@@ -0,0 +1,57 @@
+type Comparator<T> = (a: T, b: T) => boolean;
+/**
+ * JSON.stringify replacement that safely serializes BigInt values by converting
+ * them to strings. This ensures stable serialization for deep equality checks
+ * without throwing on BigInt instances.
+ */
+export declare function stringifyWithBigInt(value: unknown, space?: number): string;
+export declare function hasNonAlterableChanges<T, K extends keyof T>(main: T, branch: T, keys: ReadonlyArray<K>, comparators?: Partial<Record<K, Comparator<unknown>>>): boolean;
+export declare const deepEqual: Comparator<unknown>;
+export declare const stableId: {
+    schema(schema: string): `schema:${string}`;
+    table(schema: string, table: string): `table:${string}.${string}`;
+    view(schema: string, view: string): `view:${string}.${string}`;
+    materializedView(schema: string, view: string): `materializedView:${string}.${string}`;
+    acl(objectStableId: string, grantee: string): `acl:${string}::grantee:${string}`;
+    /**
+     *
+     * 'defacl:' || grantor || ':' || objtype || ':' || coalesce('schema:' || in_schema, 'global') || ':grantee:' || grantee as dependent_stable_id,
+     */
+    defacl(grantor: string, objtype: string, schema: string | null, grantee: string): `defacl:${string}:${string}:${string}:grantee:${string}`;
+    column(schema: string, table: string, column: string): `column:${string}.${string}.${string}`;
+    constraint(schema: string, table: string, constraint: string): `constraint:${string}.${string}.${string}`;
+    comment(objectStableId: string): `comment:${string}`;
+    role(role: string): `role:${string}`;
+    type(schema: string, name: string): `type:${string}.${string}`;
+    collation(schema: string, name: string): `collation:${string}.${string}`;
+    procedure(schema: string, name: string, args?: string): `procedure:${string}.${string}(${string})`;
+    membership(role: string, member: string): `membership:${string}->${string}`;
+    foreignDataWrapper(name: string): `foreignDataWrapper:${string}`;
+    server(name: string): `server:${string}`;
+    userMapping(server: string, user: string): `userMapping:${string}:${string}`;
+    foreignTable(schema: string, name: string): `foreignTable:${string}.${string}`;
+};
+/**
+ * Check if a schema name represents a user-defined type (not pg_catalog or information_schema).
+ * Used to filter out system types when building dependency lists.
+ */
+export declare function isUserDefinedTypeSchema(schema: string | null | undefined): boolean;
+/**
+ * Parse a procedure reference string (from regprocedure::text) to extract schema and function name.
+ * Format: "schema.function_name(argtypes)" or "function_name(argtypes)"
+ * Returns null if parsing fails or if it's a system procedure.
+ */
+export declare function parseProcedureReference(procRef: string | null | undefined): {
+    schema: string;
+    name: string;
+} | null;
+/**
+ * Parse a type string (from format_type) to extract schema and type name if it's schema-qualified.
+ * Format: "type_name" or "schema.type_name" or "schema.type_name[]"
+ * Returns null if it's not schema-qualified or if it's a system type.
+ */
+export declare function parseTypeString(typeStr: string | null | undefined): {
+    schema: string;
+    name: string;
+} | null;
+export {};

package/dist/core/objects/utils.js

@@ -0,0 +1,137 @@
+/**
+ * JSON.stringify replacement that safely serializes BigInt values by converting
+ * them to strings. This ensures stable serialization for deep equality checks
+ * without throwing on BigInt instances.
+ */
+export function stringifyWithBigInt(value, space = 2) {
+    return JSON.stringify(value, (_key, v) => (typeof v === "bigint" ? v.toString() : v), space);
+}
+export function hasNonAlterableChanges(main, branch, keys, comparators) {
+    const mainIndexable = main;
+    const branchIndexable = branch;
+    for (const key of keys) {
+        // Prefer custom comparator when provided; fallback to strict equality
+        const equals = comparators?.[key] ??
+            ((a, b) => a === b);
+        if (!equals(mainIndexable[key], branchIndexable[key]))
+            return true;
+    }
+    return false;
+}
+export const deepEqual = (a, b) => stringifyWithBigInt(a) === stringifyWithBigInt(b);
+// Helpers for stableId that aren't encoded in a class, mostly for sub-entities or meta entities.
+export const stableId = {
+    schema(schema) {
+        return `schema:${schema}`;
+    },
+    table(schema, table) {
+        return `table:${schema}.${table}`;
+    },
+    view(schema, view) {
+        return `view:${schema}.${view}`;
+    },
+    materializedView(schema, view) {
+        return `materializedView:${schema}.${view}`;
+    },
+    acl(objectStableId, grantee) {
+        return `acl:${objectStableId}::grantee:${grantee}`;
+    },
+    /**
+     *
+     * 'defacl:' || grantor || ':' || objtype || ':' || coalesce('schema:' || in_schema, 'global') || ':grantee:' || grantee as dependent_stable_id,
+     */
+    defacl(grantor, objtype, schema, grantee) {
+        return `defacl:${grantor}:${objtype}:${schema ? `schema:${schema}` : "global"}:grantee:${grantee}`;
+    },
+    column(schema, table, column) {
+        return `column:${schema}.${table}.${column}`;
+    },
+    constraint(schema, table, constraint) {
+        return `constraint:${schema}.${table}.${constraint}`;
+    },
+    comment(objectStableId) {
+        return `comment:${objectStableId}`;
+    },
+    role(role) {
+        return `role:${role}`;
+    },
+    type(schema, name) {
+        return `type:${schema}.${name}`;
+    },
+    collation(schema, name) {
+        return `collation:${schema}.${name}`;
+    },
+    procedure(schema, name, args = "") {
+        return `procedure:${schema}.${name}(${args})`;
+    },
+    membership(role, member) {
+        return `membership:${role}->${member}`;
+    },
+    foreignDataWrapper(name) {
+        return `foreignDataWrapper:${name}`;
+    },
+    server(name) {
+        return `server:${name}`;
+    },
+    userMapping(server, user) {
+        return `userMapping:${server}:${user}`;
+    },
+    foreignTable(schema, name) {
+        return `foreignTable:${schema}.${name}`;
+    },
+};
+/**
+ * Check if a schema name represents a user-defined type (not pg_catalog or information_schema).
+ * Used to filter out system types when building dependency lists.
+ */
+export function isUserDefinedTypeSchema(schema) {
+    return (schema != null && schema !== "pg_catalog" && schema !== "information_schema");
+}
+/**
+ * Parse a procedure reference string (from regprocedure::text) to extract schema and function name.
+ * Format: "schema.function_name(argtypes)" or "function_name(argtypes)"
+ * Returns null if parsing fails or if it's a system procedure.
+ */
+export function parseProcedureReference(procRef) {
+    if (!procRef)
+        return null;
+    // Format is "schema.function_name(argtypes)" or "function_name(argtypes)"
+    // Extract everything before the opening parenthesis
+    const match = procRef.match(/^([^(]+)\(/);
+    if (!match)
+        return null;
+    const qualifiedName = match[1];
+    const parts = qualifiedName.split(".");
+    if (parts.length === 1) {
+        // No schema prefix - assume current schema (we can't determine it here)
+        // For now, skip these as we need schema info
+        return null;
+    }
+    if (parts.length === 2) {
+        const [schema, name] = parts;
+        if (isUserDefinedTypeSchema(schema)) {
+            return { schema, name };
+        }
+    }
+    return null;
+}
+/**
+ * Parse a type string (from format_type) to extract schema and type name if it's schema-qualified.
+ * Format: "type_name" or "schema.type_name" or "schema.type_name[]"
+ * Returns null if it's not schema-qualified or if it's a system type.
+ */
+export function parseTypeString(typeStr) {
+    if (!typeStr)
+        return null;
+    // Remove array brackets for parsing
+    const baseType = typeStr.replace(/\[\]+$/, "");
+    // Check if it's schema-qualified (contains a dot)
+    const parts = baseType.split(".");
+    if (parts.length === 2) {
+        const [schema, name] = parts;
+        if (isUserDefinedTypeSchema(schema)) {
+            return { schema, name };
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,62 @@
+import type { View } from "../view.model.ts";
+import { AlterViewChange } from "./view.base.ts";
+/**
+ * Alter a view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterview.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name SET DEFAULT expression
+ * ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name DROP DEFAULT
+ * ALTER VIEW [ IF EXISTS ] name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER VIEW [ IF EXISTS ] name RENAME [ COLUMN ] column_name TO new_column_name
+ * ALTER VIEW [ IF EXISTS ] name RENAME TO new_name
+ * ALTER VIEW [ IF EXISTS ] name SET SCHEMA new_schema
+ * ALTER VIEW [ IF EXISTS ] name SET ( view_option_name [= view_option_value] [, ... ] )
+ * ALTER VIEW [ IF EXISTS ] name RESET ( view_option_name [, ... ] )
+ * ```
+ */
+export type AlterView = AlterViewChangeOwner | AlterViewResetOptions | AlterViewSetOptions;
+/**
+ * ALTER VIEW ... OWNER TO ...
+ */
+export declare class AlterViewChangeOwner extends AlterViewChange {
+    readonly view: View;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        view: View;
+        owner: string;
+    });
+    get requires(): `view:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER VIEW ... SET ( ... )
+ */
+export declare class AlterViewSetOptions extends AlterViewChange {
+    readonly view: View;
+    readonly options: string[];
+    readonly scope: "object";
+    constructor(props: {
+        view: View;
+        options: string[];
+    });
+    get requires(): `view:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER VIEW ... RESET ( ... )
+ */
+export declare class AlterViewResetOptions extends AlterViewChange {
+    readonly view: View;
+    readonly params: string[];
+    readonly scope: "object";
+    constructor(props: {
+        view: View;
+        params: string[];
+    });
+    get requires(): `view:${string}`[];
+    serialize(): string;
+}