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

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

@@ -1,5 +1,5 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { diffPrivileges, emitColumnPrivilegeChanges, } from "../base.privilege-diff.js";
 import { deepEqual, hasNonAlterableChanges } from "../utils.js";
 import { AlterViewChangeOwner, AlterViewResetOptions, AlterViewSetOptions, } from "./changes/view.alter.js";
 import { CreateCommentOnView, DropCommentOnView, } from "./changes/view.comment.js";
@@ -34,87 +34,18 @@ export function diffViews(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, "view", v.schema ?? "");
+        const creatorFilteredDefaults = v.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
         const desiredPrivileges = v.privileges;
         // Filter out owner privileges - owner always has ALL privileges implicitly
         // and shouldn't be compared. Use the view owner as the reference.
-        const privilegeResults = diffPrivileges(effectiveDefaults, desiredPrivileges, v.owner, ctx.mainRoles);
-        // Generate grant changes
-        for (const [grantee, result] of privilegeResults) {
-            if (result.grants.length > 0) {
-                const grantGroups = groupPrivilegesByColumns(result.grants);
-                for (const [, group] of grantGroups) {
-                    for (const [grantable, privSet] of group.byGrant) {
-                        const privileges = Array.from(privSet).map((priv) => ({
-                            privilege: priv,
-                            grantable,
-                        }));
-                        changes.push(new GrantViewPrivileges({
-                            view: v,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
-            // Generate revoke changes
-            if (result.revokes.length > 0) {
-                const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                for (const [, group] of revokeGroups) {
-                    const allPrivileges = new Set();
-                    for (const [, privSet] of group.byGrant) {
-                        for (const priv of privSet) {
-                            allPrivileges.add(priv);
-                        }
-                    }
-                    const privileges = Array.from(allPrivileges).map((priv) => ({
-                        privilege: priv,
-                        grantable: false,
-                    }));
-                    changes.push(new RevokeViewPrivileges({
-                        view: v,
-                        grantee,
-                        privileges,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-            // Generate revoke grant option changes
-            if (result.revokeGrantOption.length > 0) {
-                const revokeGrantGroups = new Map();
-                for (const r of result.revokeGrantOption) {
-                    // For revoke grant option, we need to find the columns from the effective defaults
-                    const originalPriv = effectiveDefaults.find((p) => p.grantee === grantee && p.privilege === r);
-                    const key = originalPriv?.columns
-                        ? originalPriv.columns.sort().join(",")
-                        : "";
-                    if (!revokeGrantGroups.has(key)) {
-                        revokeGrantGroups.set(key, {
-                            columns: originalPriv?.columns
-                                ? [...originalPriv.columns]
-                                : undefined,
-                            privileges: new Set(),
-                        });
-                    }
-                    const group = revokeGrantGroups.get(key);
-                    if (!group)
-                        continue;
-                    group.privileges.add(r);
-                }
-                for (const [, group] of revokeGrantGroups) {
-                    const privilegeNames = Array.from(group.privileges);
-                    changes.push(new RevokeGrantOptionViewPrivileges({
-                        view: v,
-                        grantee,
-                        privilegeNames,
-                        columns: group.columns,
-                        version: ctx.version,
-                    }));
-                }
-            }
-        }
+        const privilegeResults = diffPrivileges(creatorFilteredDefaults, desiredPrivileges, v.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, v, v, "view", {
+            Grant: GrantViewPrivileges,
+            Revoke: RevokeViewPrivileges,
+            RevokeGrantOption: RevokeGrantOptionViewPrivileges,
+        }, effectiveDefaults, ctx.version));
     }
     for (const viewId of dropped) {
         changes.push(new DropView({ view: main[viewId] }));
@@ -185,85 +116,12 @@ export function diffViews(ctx, main, branch) {
             // PRIVILEGES (unified object and column privileges)
             // Filter out owner privileges - owner always has ALL privileges implicitly
             // and shouldn't be compared. Use branch owner as the reference.
-            const privilegeResults = diffPrivileges(mainView.privileges, branchView.privileges, branchView.owner, ctx.mainRoles);
-            for (const [grantee, result] of privilegeResults) {
-                // Generate grant changes
-                if (result.grants.length > 0) {
-                    const grantGroups = groupPrivilegesByColumns(result.grants);
-                    for (const [, group] of grantGroups) {
-                        for (const [grantable, privSet] of group.byGrant) {
-                            const privileges = Array.from(privSet).map((priv) => ({
-                                privilege: priv,
-                                grantable,
-                            }));
-                            changes.push(new GrantViewPrivileges({
-                                view: branchView,
-                                grantee,
-                                privileges,
-                                columns: group.columns,
-                                version: ctx.version,
-                            }));
-                        }
-                    }
-                }
-                // Generate revoke changes
-                if (result.revokes.length > 0) {
-                    const revokeGroups = groupPrivilegesByColumns(result.revokes);
-                    for (const [, group] of revokeGroups) {
-                        // Collapse all grantable groups into a single revoke (grantable: false)
-                        const allPrivileges = new Set();
-                        for (const [, privSet] of group.byGrant) {
-                            for (const priv of privSet) {
-                                allPrivileges.add(priv);
-                            }
-                        }
-                        const privileges = Array.from(allPrivileges).map((priv) => ({
-                            privilege: priv,
-                            grantable: false,
-                        }));
-                        changes.push(new RevokeViewPrivileges({
-                            view: mainView,
-                            grantee,
-                            privileges,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-                // Generate revoke grant option changes
-                if (result.revokeGrantOption.length > 0) {
-                    const revokeGrantGroups = new Map();
-                    for (const r of result.revokeGrantOption) {
-                        // For revoke grant option, we need to find the columns from the original privilege
-                        const originalPriv = mainView.privileges.find((p) => p.grantee === grantee && p.privilege === r);
-                        const key = originalPriv?.columns
-                            ? originalPriv.columns.sort().join(",")
-                            : "";
-                        if (!revokeGrantGroups.has(key)) {
-                            revokeGrantGroups.set(key, {
-                                columns: originalPriv?.columns
-                                    ? [...originalPriv.columns]
-                                    : undefined,
-                                privileges: new Set(),
-                            });
-                        }
-                        const group = revokeGrantGroups.get(key);
-                        if (!group)
-                            continue;
-                        group.privileges.add(r);
-                    }
-                    for (const [, group] of revokeGrantGroups) {
-                        const privilegeNames = Array.from(group.privileges);
-                        changes.push(new RevokeGrantOptionViewPrivileges({
-                            view: mainView,
-                            grantee,
-                            privilegeNames,
-                            columns: group.columns,
-                            version: ctx.version,
-                        }));
-                    }
-                }
-            }
+            const privilegeResults = diffPrivileges(mainView.privileges, branchView.privileges, branchView.owner);
+            changes.push(...emitColumnPrivilegeChanges(privilegeResults, branchView, mainView, "view", {
+                Grant: GrantViewPrivileges,
+                Revoke: RevokeViewPrivileges,
+                RevokeGrantOption: RevokeGrantOptionViewPrivileges,
+            }, mainView.privileges, ctx.version));
         }
     }
     return changes;

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

@@ -1,4 +1,4 @@
-import type { Sql } from "postgres";
+import type { Pool } from "pg";
 import z from "zod";
 import { BasePgModel, type TableLikeObject } from "../base.model.ts";
 import { type PrivilegeProps } from "../base.privilege-diff.ts";
@@ -123,7 +123,21 @@ export declare class View extends BasePgModel implements TableLikeObject {
         };
         data: {
             columns: {
-                [x: string]: unknown;
+                name: string;
+                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;
             }[];
             definition: string;
             row_security: boolean;
@@ -148,5 +162,5 @@ export declare class View extends BasePgModel implements TableLikeObject {
         };
     };
 }
-export declare function extractViews(sql: Sql): Promise<View[]>;
+export declare function extractViews(pool: Pool): Promise<View[]>;
 export {};

package/dist/core/objects/view/view.model.js

@@ -1,5 +1,6 @@
+import { sql } from "@ts-safeql/sql-tag";
 import z from "zod";
-import { BasePgModel, columnPropsSchema, } from "../base.model.js";
+import { BasePgModel, columnPropsSchema, normalizeColumns, } from "../base.model.js";
 import { privilegePropsSchema, } from "../base.privilege-diff.js";
 import { ReplicaIdentitySchema } from "../table/table.model.js";
 const viewPropsSchema = z.object({
@@ -94,29 +95,17 @@ export class View extends BasePgModel {
         };
     }
     stableSnapshot() {
-        const normalizeColumns = () => [...this.columns]
-            .map((col) => {
-            const { position: _pos, ...rest } = col;
-            return rest;
-        })
-            .sort((a, b) => {
-            const nameA = a.name ?? "";
-            const nameB = b.name ?? "";
-            return nameA.localeCompare(nameB);
-        });
         return {
             identity: this.identityFields,
             data: {
                 ...this.dataFields,
-                columns: normalizeColumns(),
+                columns: normalizeColumns(this.columns),
             },
         };
     }
 }
-export async function extractViews(sql) {
-    return sql.begin(async (sql) => {
-        await sql `set search_path = ''`;
-        const viewRows = await sql `
+export async function extractViews(pool) {
+    const { rows: viewRows } = await pool.query(sql `
 with extension_oids as (
   select
     objid
@@ -219,7 +208,7 @@ select
       from (
         -- one row for object ACL + one row per column ACL
         select null::name as attname, v.oid as relacl_oid, (
-          select c_rel.relacl from pg_class c_rel where c_rel.oid = v.oid
+          select COALESCE(c_rel.relacl, acldefault('r', c_rel.relowner)) from pg_class c_rel where c_rel.oid = v.oid
         ) as acl
         union all
         select a2.attname, v.oid as relacl_oid, a2.attacl
@@ -241,10 +230,9 @@ from
 group by
   v.oid, v.schema, v.name, v.definition, v.row_security, v.force_row_security, v.has_indexes, v.has_rules, v.has_triggers, v.has_subclasses, v.is_populated, v.replica_identity, v.is_partition, v.options, v.partition_bound, v.owner, v.comment
 order by
-  v.schema, v.name;
-    `;
-        // Validate and parse each row using the Zod schema
-        const validatedRows = viewRows.map((row) => viewPropsSchema.parse(row));
-        return validatedRows.map((row) => new View(row));
-    });
+  v.schema, v.name
+  `);
+    // Validate and parse each row using the Zod schema
+    const validatedRows = viewRows.map((row) => viewPropsSchema.parse(row));
+    return validatedRows.map((row) => new View(row));
 }

package/dist/core/plan/apply.d.ts

@@ -1,7 +1,7 @@
 /**
  * Plan application - execute migration plans against target databases.
  */
-import { type Sql } from "postgres";
+import type { Pool } from "pg";
 import type { Plan } from "./types.ts";
 type ApplyPlanResult = {
     status: "invalid_plan";
@@ -24,7 +24,7 @@ type ApplyPlanResult = {
 interface ApplyPlanOptions {
     verifyPostApply?: boolean;
 }
-type ConnectionInput = string | Sql;
+type ConnectionInput = string | Pool;
 /**
  * Apply a plan's SQL statements to a target database with integrity checks.
  * Validates fingerprints before and after application to ensure plan integrity.

package/dist/core/plan/apply.js

@@ -1,12 +1,11 @@
 /**
  * Plan application - execute migration plans against target databases.
  */
-import postgres, {} from "postgres";
 import { diffCatalogs } from "../catalog.diff.js";
 import { extractCatalog } from "../catalog.model.js";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.js";
 import { compileFilterDSL } from "../integrations/filter/dsl.js";
-import { postgresConfig } from "../postgres-config.js";
+import { createManagedPool, endPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 /**
  * Check if a statement is a session configuration statement (standalone SET statements).
@@ -26,19 +25,37 @@ export async function applyPlan(plan, source, target, options = {}) {
             message: "Plan contains no SQL statements to execute.",
         };
     }
-    const currentSql = typeof source === "string"
-        ? postgres(source, postgresConfig)
-        : source;
-    const desiredSql = typeof target === "string"
-        ? postgres(target, postgresConfig)
-        : target;
-    const shouldCloseCurrent = typeof source === "string";
-    const shouldCloseDesired = typeof target === "string";
+    let currentPool;
+    let desiredPool;
+    let shouldCloseCurrent = false;
+    let shouldCloseDesired = false;
+    if (typeof source === "string") {
+        const managed = await createManagedPool(source, {
+            role: plan.role,
+            label: "source",
+        });
+        currentPool = managed.pool;
+        shouldCloseCurrent = true;
+    }
+    else {
+        currentPool = source;
+    }
+    if (typeof target === "string") {
+        const managed = await createManagedPool(target, {
+            role: plan.role,
+            label: "target",
+        });
+        desiredPool = managed.pool;
+        shouldCloseDesired = true;
+    }
+    else {
+        desiredPool = target;
+    }
     try {
         // Recompute stableIds and fingerprints from current and desired catalogs
         const [currentCatalog, desiredCatalog] = await Promise.all([
-            extractCatalog(currentSql),
-            extractCatalog(desiredSql),
+            extractCatalog(currentPool),
+            extractCatalog(desiredPool),
         ]);
         const changes = diffCatalogs(currentCatalog, desiredCatalog);
         const ctx = {
@@ -73,7 +90,7 @@ export async function applyPlan(plan, source, target, options = {}) {
             return joined.endsWith(";") ? joined : `${joined};`;
         })();
         try {
-            await currentSql.unsafe(script);
+            await currentPool.query(script);
         }
         catch (error) {
             return { status: "failed", error, script };
@@ -81,7 +98,7 @@ export async function applyPlan(plan, source, target, options = {}) {
         const warnings = [];
         if (options.verifyPostApply !== false) {
             try {
-                const updatedCatalog = await extractCatalog(currentSql);
+                const updatedCatalog = await extractCatalog(currentPool);
                 const updatedFingerprint = hashStableIds(updatedCatalog, stableIds);
                 if (updatedFingerprint !== plan.target.fingerprint) {
                     warnings.push("Post-apply fingerprint does not match the plan target fingerprint.");
@@ -102,9 +119,9 @@ export async function applyPlan(plan, source, target, options = {}) {
     finally {
         const closers = [];
         if (shouldCloseCurrent)
-            closers.push(currentSql.end());
+            closers.push(endPool(currentPool));
         if (shouldCloseDesired)
-            closers.push(desiredSql.end());
+            closers.push(endPool(desiredPool));
         if (closers.length) {
             await Promise.all(closers);
         }

package/dist/core/plan/create.d.ts

@@ -1,22 +1,35 @@
 /**
  * Plan creation - the main entry point for creating migration plans.
  */
+import type { Pool } from "pg";
+import type { Catalog } from "../catalog.model.ts";
 import type { Change } from "../change.types.ts";
 import type { DiffContext } from "../context.ts";
 import type { CreatePlanOptions, Plan } from "./types.ts";
 /**
- * Create a migration plan by comparing two databases.
+ * Input for source/target: a postgres connection URL, an existing Pool, or
+ * an already-resolved Catalog (e.g. deserialized from a snapshot file).
+ */
+export type CatalogInput = string | Pool | Catalog;
+/**
+ * Create a migration plan by comparing two catalog states.
+ *
+ * Each input can be:
+ * - A postgres connection URL (string) -- a pool is created and catalog extracted
+ * - An existing pg Pool -- catalog is extracted directly
+ * - A Catalog instance -- used as-is (e.g. from a deserialized snapshot)
+ *
+ * When `source` is `null`, a minimal empty catalog (`createEmptyCatalog`) is
+ * used as the baseline. For a more accurate baseline, pass a Catalog
+ * deserialized from a snapshot of `template1` or another reference database.
  *
- * @param fromUrl - Source database connection URL (current state)
- * @param toUrl - Target database connection URL (desired state)
+ * @param source - Source catalog input (current state), or null for empty baseline
+ * @param target - Target catalog input (desired state)
  * @param options - Optional configuration
  * @returns A Plan if there are changes, null if databases are identical
  */
-import type { Sql } from "postgres";
-type ConnectionInput = string | Sql;
-export declare function createPlan(source: ConnectionInput, target: ConnectionInput, options?: CreatePlanOptions): Promise<{
+export declare function createPlan(source: CatalogInput | null, target: CatalogInput, options?: CreatePlanOptions): Promise<{
     plan: Plan;
     sortedChanges: Change[];
     ctx: DiffContext;
 } | null>;
-export {};