@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { View } from "../view.model.ts";
 import { DropViewChange } from "./view.base.ts";
 /**
@@ -13,5 +14,5 @@ export declare class DropView extends DropViewChange {
     });
     get drops(): (`column:${string}.${string}.${string}` | `view:${string}`)[];
     get requires(): (`column:${string}.${string}.${string}` | `view:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/view/changes/view.drop.js

@@ -24,7 +24,7 @@ export class DropView extends DropViewChange {
             ...this.view.columns.map((column) => stableId.column(this.view.schema, this.view.name, column.name)),
         ];
     }
-    serialize() {
+    serialize(_options) {
         return ["DROP VIEW", `${this.view.schema}.${this.view.name}`].join(" ");
     }
 }

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

@@ -1,3 +1,4 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
 import type { View } from "../view.model.ts";
 import { AlterViewChange } from "./view.base.ts";
 export type ViewPrivilege = GrantViewPrivileges | RevokeViewPrivileges | RevokeGrantOptionViewPrivileges;
@@ -38,7 +39,7 @@ export declare class GrantViewPrivileges extends AlterViewChange {
     });
     get creates(): `acl:${string}::grantee:${string}`[];
     get requires(): (`role:${string}` | `view:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke privileges on a view.
@@ -79,7 +80,7 @@ export declare class RevokeViewPrivileges extends AlterViewChange {
     });
     get drops(): `acl:${string}::grantee:${string}`[];
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `view:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }
 /**
  * Revoke grant option for privileges on a view.
@@ -103,5 +104,5 @@ export declare class RevokeGrantOptionViewPrivileges extends AlterViewChange {
         version?: number;
     });
     get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `view:${string}`)[];
-    serialize(): string;
+    serialize(_options?: SerializeOptions): string;
 }

package/dist/core/objects/view/changes/view.privilege.js

@@ -37,7 +37,7 @@ export class GrantViewPrivileges extends AlterViewChange {
     get requires() {
         return [this.view.stableId, stableId.role(this.grantee)];
     }
-    serialize() {
+    serialize(_options) {
         const hasGrantable = this.privileges.some((p) => p.grantable);
         const hasBase = this.privileges.some((p) => !p.grantable);
         if (hasGrantable && hasBase) {
@@ -98,7 +98,7 @@ export class RevokeViewPrivileges extends AlterViewChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("VIEW");
         const list = this.privileges.map((p) => p.privilege);
         const privSql = formatObjectPrivilegeList("VIEW", list, this.version);
@@ -138,7 +138,7 @@ export class RevokeGrantOptionViewPrivileges extends AlterViewChange {
             stableId.role(this.grantee),
         ];
     }
-    serialize() {
+    serialize(_options) {
         const kindPrefix = getObjectKindPrefix("VIEW");
         const privSql = formatObjectPrivilegeList("VIEW", this.privilegeNames, this.version);
         const viewName = `${this.view.schema}.${this.view.name}`;

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[];

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

@@ -1,5 +1,6 @@
 import { diffObjects } from "../base.diff.js";
-import { diffPrivileges, groupPrivilegesByColumns, } from "../base.privilege-diff.js";
+import { normalizeColumns } from "../base.model.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";
@@ -17,104 +18,37 @@ import { GrantViewPrivileges, RevokeGrantOptionViewPrivileges, RevokeViewPrivile
 export function diffViews(ctx, main, branch) {
     const { created, dropped, altered } = diffObjects(main, branch);
     const changes = [];
-    for (const viewId of created) {
-        const v = branch[viewId];
-        changes.push(new CreateView({ view: v }));
+    const appendCreateViewChanges = (view) => {
+        changes.push(new CreateView({ view }));
         // OWNER: If the view should be owned by someone other than the current user,
         // emit ALTER VIEW ... OWNER TO after creation
-        if (v.owner !== ctx.currentUser) {
-            changes.push(new AlterViewChangeOwner({ view: v, owner: v.owner }));
+        if (view.owner !== ctx.currentUser) {
+            changes.push(new AlterViewChangeOwner({ view, owner: view.owner }));
         }
-        if (v.comment !== null) {
-            changes.push(new CreateCommentOnView({ view: v }));
+        if (view.comment !== null) {
+            changes.push(new CreateCommentOnView({ view }));
         }
         // 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, "view", v.schema ?? "");
-        const desiredPrivileges = v.privileges;
+        const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(ctx.currentUser, "view", view.schema ?? "");
+        const creatorFilteredDefaults = view.owner !== ctx.currentUser
+            ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+            : effectiveDefaults;
+        const desiredPrivileges = view.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, view.owner);
+        changes.push(...emitColumnPrivilegeChanges(privilegeResults, view, view, "view", {
+            Grant: GrantViewPrivileges,
+            Revoke: RevokeViewPrivileges,
+            RevokeGrantOption: RevokeGrantOptionViewPrivileges,
+        }, effectiveDefaults, ctx.version));
+    };
+    for (const viewId of created) {
+        appendCreateViewChanges(branch[viewId]);
     }
     for (const viewId of dropped) {
         changes.push(new DropView({ view: main[viewId] }));
@@ -138,7 +72,15 @@ export function diffViews(ctx, main, branch) {
             "partition_bound",
         ];
         const nonAlterablePropsChanged = hasNonAlterableChanges(mainView, branchView, NON_ALTERABLE_FIELDS, { options: deepEqual });
-        if (nonAlterablePropsChanged) {
+        // Normalize columns (strip position, sort by name) to match stableSnapshot().
+        // Position-only differences are safe to ignore here because column order in a
+        // view is determined by its definition, which is already checked above via
+        // NON_ALTERABLE_FIELDS - a position change always implies a definition change.
+        if (!deepEqual(normalizeColumns(mainView.columns), normalizeColumns(branchView.columns))) {
+            changes.push(new DropView({ view: mainView }));
+            appendCreateViewChanges(branchView);
+        }
+        else if (nonAlterablePropsChanged) {
             // Replace the entire view using CREATE OR REPLACE to avoid drop when possible
             changes.push(new CreateView({ view: branchView, orReplace: true }));
         }
@@ -185,85 +127,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

@@ -14,10 +14,10 @@ declare const viewPropsSchema: z.ZodObject<{
     has_subclasses: z.ZodBoolean;
     is_populated: z.ZodBoolean;
     replica_identity: z.ZodEnum<{
-        f: "f";
         n: "n";
         i: "i";
         d: "d";
+        f: "f";
     }>;
     is_partition: z.ZodBoolean;
     options: z.ZodNullable<z.ZodArray<z.ZodString>>;
@@ -85,7 +85,7 @@ export declare class View extends BasePgModel implements TableLikeObject {
         has_triggers: boolean;
         has_subclasses: boolean;
         is_populated: boolean;
-        replica_identity: "f" | "n" | "i" | "d";
+        replica_identity: "n" | "i" | "d" | "f";
         is_partition: boolean;
         options: string[] | null;
         partition_bound: string | null;
@@ -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;
@@ -133,7 +147,7 @@ export declare class View extends BasePgModel implements TableLikeObject {
             has_triggers: boolean;
             has_subclasses: boolean;
             is_populated: boolean;
-            replica_identity: "f" | "n" | "i" | "d";
+            replica_identity: "n" | "i" | "d" | "f";
             is_partition: boolean;
             options: string[] | null;
             partition_bound: string | null;

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

@@ -1,6 +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({
@@ -95,21 +95,11 @@ 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),
             },
         };
     }
@@ -218,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

package/dist/core/plan/apply.js

@@ -1,12 +1,11 @@
 /**
  * Plan application - execute migration plans against target databases.
  */
-import { escapeIdentifier } from "pg";
 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 { createPool } 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).
@@ -30,39 +29,23 @@ export async function applyPlan(plan, source, target, options = {}) {
     let desiredPool;
     let shouldCloseCurrent = false;
     let shouldCloseDesired = false;
-    // Suppress expected shutdown errors from idle pool connections (57P01 = admin_shutdown)
-    const onError = (err) => {
-        if (err.code !== "57P01") {
-            console.error("Pool error:", err);
-        }
-    };
     if (typeof source === "string") {
-        currentPool = createPool(source, {
-            onError,
-            onConnect: async (client) => {
-                // Force fully qualified names in catalog queries for fingerprint verification
-                await client.query("SET search_path = ''");
-                if (plan.role) {
-                    await client.query(`SET ROLE ${escapeIdentifier(plan.role)}`);
-                }
-            },
+        const managed = await createManagedPool(source, {
+            role: plan.role,
+            label: "source",
         });
+        currentPool = managed.pool;
         shouldCloseCurrent = true;
     }
     else {
         currentPool = source;
     }
     if (typeof target === "string") {
-        desiredPool = createPool(target, {
-            onError,
-            onConnect: async (client) => {
-                // Force fully qualified names in catalog queries for fingerprint verification
-                await client.query("SET search_path = ''");
-                if (plan.role) {
-                    await client.query(`SET ROLE ${escapeIdentifier(plan.role)}`);
-                }
-            },
+        const managed = await createManagedPool(target, {
+            role: plan.role,
+            label: "target",
         });
+        desiredPool = managed.pool;
         shouldCloseDesired = true;
     }
     else {
@@ -136,9 +119,9 @@ export async function applyPlan(plan, source, target, options = {}) {
     finally {
         const closers = [];
         if (shouldCloseCurrent)
-            closers.push(currentPool.end());
+            closers.push(endPool(currentPool));
         if (shouldCloseDesired)
-            closers.push(desiredPool.end());
+            closers.push(endPool(desiredPool));
         if (closers.length) {
             await Promise.all(closers);
         }

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

@@ -2,21 +2,34 @@
  * 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
  */
-type ConnectionInput = string | Pool;
-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 {};