@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

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

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel, columnPropsSchema, } from "../../base.model.js";
 import { privilegePropsSchema, } from "../../base.privilege-diff.js";
@@ -109,10 +110,8 @@ export class CompositeType extends BasePgModel {
         };
     }
 }
-export async function extractCompositeTypes(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const compositeTypeRows = await sql `
+export async function extractCompositeTypes(pool) {
+    const { rows: compositeTypeRows } = await pool.query(sql `
       WITH extension_oids AS (
         SELECT objid
         FROM pg_depend d
@@ -137,6 +136,7 @@ export async function extractCompositeTypes(sql) {
           c.relowner::regrole::text           AS owner,
           obj_description(c.reltype, 'pg_type') AS comment,
           c.relacl                            AS relacl,    -- used by privileges LATERAL
+          c.relowner                          AS relowner,
           c.oid                                AS oid
         FROM pg_catalog.pg_class c
         LEFT JOIN extension_oids e ON c.reltype = e.objid
@@ -174,7 +174,7 @@ export async function extractCompositeTypes(sql) {
                 )
                 ORDER BY x.grantee, x.privilege_type
               ) AS privileges
-        FROM LATERAL aclexplode(ct.relacl) AS x(grantor, grantee, privilege_type, is_grantable)
+        FROM LATERAL aclexplode(COALESCE(ct.relacl, acldefault('T', ct.relowner))) AS x(grantor, grantee, privilege_type, is_grantable)
       ) priv ON TRUE
 
       -- columns as a per-row LATERAL subquery (so no GROUP BY needed)
@@ -214,10 +214,9 @@ export async function extractCompositeTypes(sql) {
           AND NOT a.attisdropped
       ) cols ON TRUE
 
-      ORDER BY ct.schema, ct.name;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = compositeTypeRows.map((row) => compositeTypePropsSchema.parse(row));
-        return validatedRows.map((row) => new CompositeType(row));
-    });
+      ORDER BY ct.schema, ct.name
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = compositeTypeRows.map((row) => compositeTypePropsSchema.parse(row));
+    return validatedRows.map((row) => new CompositeType(row));
 }

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

@@ -3,4 +3,5 @@ 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";
+/** Union of all enum-related change variants (`objectType: "enum"`). @category Change Types */
 export type EnumChange = AlterEnum | CommentEnum | CreateEnum | DropEnum | EnumPrivilege;

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

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
-import type { Role } from "../../role/role.model.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
 import type { EnumChange } from "./changes/enum.types.ts";
 import type { Enum } from "./enum.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Enum } from "./enum.model.ts";
  * @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[];
+export declare function diffEnums(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Enum>, branch: Record<string, Enum>): EnumChange[];

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } 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";
@@ -36,50 +36,21 @@ export function diffEnums(ctx, main, branch) {
         // 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 ?? "");
+        const creatorFilteredDefaults = createdEnum.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // 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,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("enum", creatorFilteredDefaults), desiredPrivileges, createdEnum.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdEnum, createdEnum, "enum", {
+            Grant: GrantEnumPrivileges,
+            Revoke: RevokeEnumPrivileges,
+            RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        }, ctx.version));
     }
     for (const enumId of dropped) {
         changes.push(new DropEnum({ enum: main[enumId] }));
@@ -105,42 +76,16 @@ export function diffEnums(ctx, main, branch) {
                 changes.push(new CreateCommentOnEnum({ enum: branchEnum }));
             }
             const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "enum", branchEnum.schema ?? "");
+            const creatorFilteredDefaults = branchEnum.owner !== ctx.currentUser
+                ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+                : effectiveDefaults;
             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,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("enum", creatorFilteredDefaults), desiredPrivileges, branchEnum.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchEnum, branchEnum, "enum", {
+                Grant: GrantEnumPrivileges,
+                Revoke: RevokeEnumPrivileges,
+                RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+            }, ctx.version));
             continue;
         }
         // OWNER
@@ -169,44 +114,12 @@ export function diffEnums(ctx, main, branch) {
         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,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchEnum.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchEnum, mainEnum, "enum", {
+            Grant: GrantEnumPrivileges,
+            Revoke: RevokeEnumPrivileges,
+            RevokeGrantOption: RevokeGrantOptionEnumPrivileges,
+        }, 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()

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

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../../base.model.ts";
 import { type PrivilegeProps } from "../../base.privilege-diff.ts";
@@ -62,5 +62,5 @@ export declare class Enum extends BasePgModel {
         }[];
     };
 }
-export declare function extractEnums(sql: Sql): Promise<Enum[]>;
+export declare function extractEnums(pool: Pool): Promise<Enum[]>;
 export {};

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

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../../base.model.js";
 import { privilegePropsSchema, } from "../../base.privilege-diff.js";
@@ -90,10 +91,8 @@ export class Enum extends BasePgModel {
         };
     }
 }
-export async function extractEnums(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const enumRows = await sql `
+export async function extractEnums(pool) {
+    const { rows: enumRows } = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -120,7 +119,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from
@@ -130,25 +129,24 @@ from
   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 });
+  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,
+            };
         }
-        // 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));
-    });
+        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.create.js

@@ -1,4 +1,4 @@
-import { isUserDefinedTypeSchema, parseProcedureReference, stableId, } from "../../../utils.js";
+import { isUserDefinedTypeSchema, parseProcedureReference, parseTypeString, stableId, } from "../../../utils.js";
 import { CreateRangeChange } from "./range.base.js";
 /**
  * Create a range type.
@@ -74,8 +74,11 @@ export class CreateRange extends CreateRangeChange {
         const name = `${this.range.schema}.${this.range.name}`;
         const prefix = ["CREATE TYPE", name, "AS RANGE"].join(" ");
         const opts = [];
-        // Required subtype
-        const subtypeQualified = this.range.subtype_schema && this.range.subtype_schema !== "pg_catalog"
+        // Required subtype (format_type may already return schema-qualified name)
+        const alreadyQualified = parseTypeString(this.range.subtype_str);
+        const subtypeQualified = !alreadyQualified &&
+            this.range.subtype_schema &&
+            this.range.subtype_schema !== "pg_catalog"
             ? `${this.range.subtype_schema}.${this.range.subtype_str}`
             : this.range.subtype_str;
         opts.push(`SUBTYPE = ${subtypeQualified}`);

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

@@ -3,4 +3,5 @@ import type { CommentRange } from "./range.comment.ts";
 import type { CreateRange } from "./range.create.ts";
 import type { DropRange } from "./range.drop.ts";
 import type { RangePrivilege } from "./range.privilege.ts";
+/** Union of all range-related change variants (`objectType: "range"`). @category Change Types */
 export type RangeChange = AlterRange | CommentRange | CreateRange | DropRange | RangePrivilege;

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

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
-import type { Role } from "../../role/role.model.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
 import type { RangeChange } from "./changes/range.types.ts";
 import type { Range } from "./range.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { Range } from "./range.model.ts";
  * @param branch - The ranges in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffRanges(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, Range>, branch: Record<string, Range>): RangeChange[];
+export declare function diffRanges(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, Range>, branch: Record<string, Range>): RangeChange[];

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../../base.diff.js";
-import { diffPrivileges, filterPublicBuiltInDefaults, groupPrivilegesByGrantable, } from "../../base.privilege-diff.js";
+import { diffPrivileges, emitObjectPrivilegeChanges, filterPublicBuiltInDefaults, } 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";
@@ -37,50 +37,21 @@ export function diffRanges(ctx, main, branch) {
         // 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 ?? "");
+        const creatorFilteredDefaults = createdRange.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         // 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,
-                }));
-            }
-        }
+        const privilegeResults = diffPrivileges(filterPublicBuiltInDefaults("range", creatorFilteredDefaults), desiredPrivileges, createdRange.owner);
+        changes.push(...emitObjectPrivilegeChanges(privilegeResults, createdRange, createdRange, "range", {
+            Grant: GrantRangePrivileges,
+            Revoke: RevokeRangePrivileges,
+            RevokeGrantOption: RevokeGrantOptionRangePrivileges,
+        }, ctx.version));
     }
     for (const id of dropped) {
         changes.push(new DropRange({ range: main[id] }));
@@ -128,44 +99,12 @@ export function diffRanges(ctx, main, branch) {
             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,
-                    }));
-                }
-            }
+            const privilegeResults = diffPrivileges(mainPrivilegesFiltered, branchPrivilegesFiltered, branchRange.owner);
+            changes.push(...emitObjectPrivilegeChanges(privilegeResults, branchRange, mainRange, "range", {
+                Grant: GrantRangePrivileges,
+                Revoke: RevokeRangePrivileges,
+                RevokeGrantOption: RevokeGrantOptionRangePrivileges,
+            }, ctx.version));
         }
     }
     return changes;

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

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel } from "../../base.model.ts";
 import { type PrivilegeProps } from "../../base.privilege-diff.ts";
@@ -77,5 +77,5 @@ export declare class Range extends BasePgModel {
  *  - 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 declare function extractRanges(pool: Pool): Promise<Range[]>;
 export {};

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

@@ -1,3 +1,4 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
 import { BasePgModel } from "../../base.model.js";
 import { privilegePropsSchema, } from "../../base.privilege-diff.js";
@@ -92,10 +93,8 @@ export class Range extends BasePgModel {
  *  - 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 `
+export async function extractRanges(pool) {
+    const { rows } = await pool.query(sql `
 with extension_oids as (
   select objid from pg_depend d
   where d.refclassid = 'pg_extension'::regclass and d.classid = 'pg_type'::regclass
@@ -141,7 +140,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges
 from pg_catalog.pg_range r
@@ -157,9 +156,8 @@ left join pg_catalog.pg_namespace pn_subdiff on pn_subdiff.oid = p_subdiff.prona
 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));
-    });
+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

@@ -1,4 +1,5 @@
 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";
+/** Union of all type-related change variants (`objectType: "composite_type" | "enum" | "range"`). @category Change Types */
 export type TypeChange = CompositeTypeChange | EnumChange | RangeChange;

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

@@ -3,4 +3,5 @@ import type { CommentView } from "./view.comment.ts";
 import type { CreateView } from "./view.create.ts";
 import type { DropView } from "./view.drop.ts";
 import type { ViewPrivilege } from "./view.privilege.ts";
+/** Union of all view-related change variants (`objectType: "view"`). @category Change Types */
 export type ViewChange = AlterView | CommentView | CreateView | DropView | ViewPrivilege;

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

@@ -1,5 +1,4 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import type { ViewChange } from "./changes/view.types.ts";
 import type { View } from "./view.model.ts";
 /**
@@ -10,9 +9,4 @@ import type { View } from "./view.model.ts";
  * @param branch - The views in the branch catalog.
  * @returns A list of changes to apply to main to make it match branch.
  */
-export declare function diffViews(ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-}, main: Record<string, View>, branch: Record<string, View>): ViewChange[];
+export declare function diffViews(ctx: Pick<ObjectDiffContext, "version" | "currentUser" | "defaultPrivilegeState">, main: Record<string, View>, branch: Record<string, View>): ViewChange[];