@supabase/pg-delta 1.0.0-alpha.4 → 1.0.0-alpha.6

package/src/core/catalog.model.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from "bun:test";
+import { createEmptyCatalog } from "./catalog.model.ts";
+
+describe("createEmptyCatalog", () => {
+  test("PG < 15 returns a minimal catalog with only a public schema", async () => {
+    const catalog = await createEmptyCatalog(140000, "myuser");
+
+    // version and currentUser forwarded
+    expect(catalog.version).toBe(140000);
+    expect(catalog.currentUser).toBe("myuser");
+
+    // public schema owned by the provided currentUser (pre-PG15 behavior)
+    const publicSchema = catalog.schemas["schema:public"];
+    expect(publicSchema).toBeDefined();
+    expect(publicSchema.owner).toBe("myuser");
+
+    // everything else is empty
+    expect(Object.keys(catalog.schemas)).toEqual(["schema:public"]);
+    const emptyRecords = [
+      catalog.aggregates,
+      catalog.collations,
+      catalog.compositeTypes,
+      catalog.domains,
+      catalog.enums,
+      catalog.extensions,
+      catalog.procedures,
+      catalog.indexes,
+      catalog.materializedViews,
+      catalog.subscriptions,
+      catalog.publications,
+      catalog.rlsPolicies,
+      catalog.roles,
+      catalog.sequences,
+      catalog.tables,
+      catalog.triggers,
+      catalog.eventTriggers,
+      catalog.rules,
+      catalog.ranges,
+      catalog.views,
+      catalog.foreignDataWrappers,
+      catalog.servers,
+      catalog.userMappings,
+      catalog.foreignTables,
+      catalog.indexableObjects,
+    ];
+    for (const record of emptyRecords) {
+      expect(record).toEqual({});
+    }
+    expect(catalog.depends).toEqual([]);
+  });
+
+  test("PG 15-16 returns a full baseline catalog from snapshot", async () => {
+    const catalog = await createEmptyCatalog(160004, "admin_user");
+
+    // version and currentUser forwarded (not hardcoded from JSON)
+    expect(catalog.version).toBe(160004);
+    expect(catalog.currentUser).toBe("admin_user");
+
+    // public schema with pg_database_owner (PG 15+ default) and ACLs
+    const publicSchema = catalog.schemas["schema:public"];
+    expect(publicSchema.owner).toBe("pg_database_owner");
+    expect(publicSchema.privileges.length).toBeGreaterThan(0);
+
+    // plpgsql extension pre-installed
+    expect(catalog.extensions["extension:plpgsql"]).toBeDefined();
+    expect(catalog.extensions["extension:plpgsql"].name).toBe("plpgsql");
+
+    // postgres superuser role with default privileges
+    const role = catalog.roles["role:postgres"];
+    expect(role.name).toBe("postgres");
+    expect(role.is_superuser).toBe(true);
+    expect(role.default_privileges.length).toBeGreaterThan(0);
+
+    // no MAINTAIN privilege (PG 17+ only)
+    const relPrivs = role.default_privileges.find(
+      (dp) => dp.objtype === "r" && dp.grantee === "postgres",
+    );
+    expect(relPrivs).toBeDefined();
+    expect(relPrivs?.privileges.map((p) => p.privilege)).not.toContain(
+      "MAINTAIN",
+    );
+
+    // dependency graph populated
+    expect(catalog.depends.length).toBeGreaterThan(0);
+  });
+
+  test("PG 17 baseline adds MAINTAIN privilege to default relation grants", async () => {
+    const catalog = await createEmptyCatalog(170009, "admin_user");
+
+    // version and currentUser forwarded
+    expect(catalog.version).toBe(170009);
+    expect(catalog.currentUser).toBe("admin_user");
+
+    // same baseline objects as PG 15-16
+    expect(catalog.extensions["extension:plpgsql"]).toBeDefined();
+    expect(catalog.roles["role:postgres"]).toBeDefined();
+    expect(catalog.depends.length).toBeGreaterThan(0);
+
+    // MAINTAIN privilege present and in alphabetical order
+    const relPrivs = catalog.roles["role:postgres"].default_privileges.find(
+      (dp) => dp.objtype === "r" && dp.grantee === "postgres",
+    );
+    expect(relPrivs).toBeDefined();
+    const privNames = relPrivs?.privileges.map((p) => p.privilege) ?? [];
+    expect(privNames).toContain("MAINTAIN");
+    expect(privNames).toEqual([...privNames].sort());
+  });
+
+  test("PG 17 patching does not mutate the cached PG 15-16 baseline", async () => {
+    // force PG 17 baseline to be built first
+    await createEmptyCatalog(170000, "postgres");
+
+    const pg16 = await createEmptyCatalog(160000, "postgres");
+    const relPrivs = pg16.roles["role:postgres"].default_privileges.find(
+      (dp) => dp.objtype === "r" && dp.grantee === "postgres",
+    );
+    expect(relPrivs).toBeDefined();
+    expect(relPrivs?.privileges.map((p) => p.privilege)).not.toContain(
+      "MAINTAIN",
+    );
+  });
+});

package/src/core/catalog.model.ts

@@ -55,7 +55,7 @@ import {
 } from "./objects/rls-policy/rls-policy.model.ts";
 import { extractRoles, type Role } from "./objects/role/role.model.ts";
 import { extractRules, type Rule } from "./objects/rule/rule.model.ts";
-import { extractSchemas, type Schema } from "./objects/schema/schema.model.ts";
+import { extractSchemas, Schema } from "./objects/schema/schema.model.ts";
 import {
   extractSequences,
   type Sequence,
@@ -176,6 +176,132 @@ export class Catalog {
   }
 }
 
+// Lazily cached deserialized baselines (shared across calls)
+let _pg1516Baseline: Catalog | null = null;
+let _pg17Baseline: Catalog | null = null;
+
+async function loadBaselineJson(): Promise<Record<string, unknown>> {
+  const mod = await import(
+    "./fixtures/empty-catalogs/postgres-15-16-baseline.json"
+  );
+  return mod.default as Record<string, unknown>;
+}
+
+async function getPg1516Baseline(): Promise<Catalog> {
+  if (!_pg1516Baseline) {
+    const { deserializeCatalog } = await import("./catalog.snapshot.ts");
+    const json = await loadBaselineJson();
+    _pg1516Baseline = deserializeCatalog(json);
+  }
+  return _pg1516Baseline;
+}
+
+async function getPg17Baseline(): Promise<Catalog> {
+  if (!_pg17Baseline) {
+    const { deserializeCatalog } = await import("./catalog.snapshot.ts");
+    // PG 17 is identical to PG 15-16 except for a single addition:
+    // the MAINTAIN privilege on default relation (objtype "r") privileges.
+    // We patch the 15-16 baseline to avoid shipping a second full JSON file.
+    const json = await loadBaselineJson();
+    const patched = structuredClone(json);
+    const roles = patched.roles as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+    const pgRole = roles?.["role:postgres"];
+    if (pgRole) {
+      const defaultPrivileges = pgRole.default_privileges as Array<{
+        objtype: string;
+        grantee: string;
+        privileges: Array<{ privilege: string; grantable: boolean }>;
+      }>;
+      const relPrivs = defaultPrivileges?.find(
+        (dp) => dp.objtype === "r" && dp.grantee === "postgres",
+      );
+      if (relPrivs) {
+        const insertIdx = relPrivs.privileges.findIndex(
+          (p) => p.privilege === "INSERT",
+        );
+        if (insertIdx === -1) {
+          throw new Error(
+            "PG17 baseline patch failed: INSERT privilege not found in default relation privileges",
+          );
+        }
+        relPrivs.privileges.splice(insertIdx + 1, 0, {
+          privilege: "MAINTAIN",
+          grantable: false,
+        });
+      }
+    }
+    _pg17Baseline = deserializeCatalog(patched);
+  }
+  return _pg17Baseline;
+}
+
+/**
+ * Create a baseline catalog representing a fresh PostgreSQL database.
+ *
+ * For PG 15+ this deserializes a pre-extracted snapshot of an empty `template1`
+ * database, including the `plpgsql` extension, `postgres` role with default
+ * privileges, and the `public` schema with its default ACLs and depends.
+ *
+ * For PG < 15, falls back to a minimal inline catalog with only the `public`
+ * schema. For exact fidelity on older versions, snapshot a real reference
+ * database using `serializeCatalog` and pass the deserialized result as source
+ * to `createPlan`.
+ */
+export async function createEmptyCatalog(
+  version: number,
+  currentUser: string,
+): Promise<Catalog> {
+  if (version >= 170000) {
+    const baseline = await getPg17Baseline();
+    return new Catalog({ ...baseline, version, currentUser });
+  }
+  if (version >= 150000) {
+    const baseline = await getPg1516Baseline();
+    return new Catalog({ ...baseline, version, currentUser });
+  }
+
+  const publicSchema = new Schema({
+    name: "public",
+    owner: currentUser,
+    comment: "standard public schema",
+    privileges: [],
+  });
+
+  return new Catalog({
+    aggregates: {},
+    collations: {},
+    compositeTypes: {},
+    domains: {},
+    enums: {},
+    extensions: {},
+    procedures: {},
+    indexes: {},
+    materializedViews: {},
+    subscriptions: {},
+    publications: {},
+    rlsPolicies: {},
+    roles: {},
+    schemas: { [publicSchema.stableId]: publicSchema },
+    sequences: {},
+    tables: {},
+    triggers: {},
+    eventTriggers: {},
+    rules: {},
+    ranges: {},
+    views: {},
+    foreignDataWrappers: {},
+    servers: {},
+    userMappings: {},
+    foreignTables: {},
+    depends: [],
+    indexableObjects: {},
+    version,
+    currentUser,
+  });
+}
+
 export async function extractCatalog(pool: Pool) {
   const [
     aggregates,