@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.5

package/src/core/objects/publication/publication.diff.test.ts

@@ -0,0 +1,297 @@
+import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import {
+  AlterPublicationAddSchemas,
+  AlterPublicationAddTables,
+  AlterPublicationDropSchemas,
+  AlterPublicationDropTables,
+  AlterPublicationSetOptions,
+  AlterPublicationSetOwner,
+} from "./changes/publication.alter.ts";
+import {
+  CreateCommentOnPublication,
+  DropCommentOnPublication,
+} from "./changes/publication.comment.ts";
+import { CreatePublication } from "./changes/publication.create.ts";
+import { DropPublication } from "./changes/publication.drop.ts";
+import { diffPublications } from "./publication.diff.ts";
+import { Publication, type PublicationProps } from "./publication.model.ts";
+
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
+const base: PublicationProps = {
+  name: "mypub",
+  owner: "postgres",
+  comment: null,
+  all_tables: false,
+  publish_insert: true,
+  publish_update: true,
+  publish_delete: true,
+  publish_truncate: true,
+  publish_via_partition_root: false,
+  tables: [],
+  schemas: [],
+};
+
+describe.concurrent("publication.diff", () => {
+  test("create and drop publication", () => {
+    const publication = new Publication(base);
+    const created = diffPublications(
+      ctx,
+      {},
+      { [publication.stableId]: publication },
+    );
+    expect(created.some((change) => change instanceof CreatePublication)).toBe(
+      true,
+    );
+
+    const dropped = diffPublications(
+      ctx,
+      { [publication.stableId]: publication },
+      {},
+    );
+    expect(dropped.some((change) => change instanceof DropPublication)).toBe(
+      true,
+    );
+  });
+
+  test("create publication requires referenced objects", () => {
+    const publication = new Publication({
+      ...base,
+      tables: [
+        {
+          schema: "public",
+          name: "accounts",
+          columns: ["id", "amount"],
+          row_filter: null,
+        },
+      ],
+      schemas: ["analytics"],
+    });
+
+    const changes = diffPublications(
+      ctx,
+      {},
+      { [publication.stableId]: publication },
+    );
+
+    const createChange = changes.find(
+      (change) => change instanceof CreatePublication,
+    );
+    expect(createChange).toBeDefined();
+    expect(createChange?.requires).toEqual(
+      expect.arrayContaining([
+        "role:postgres",
+        "table:public.accounts",
+        "column:public.accounts.id",
+        "column:public.accounts.amount",
+        "schema:analytics",
+      ]),
+    );
+  });
+
+  test("detect publish option changes", () => {
+    const mainPublication = new Publication(base);
+    const branchPublication = new Publication({
+      ...base,
+      publish_delete: false,
+    });
+    const changes = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(
+      changes.some((change) => change instanceof AlterPublicationSetOptions),
+    ).toBe(true);
+  });
+
+  test("switch to FOR ALL TABLES", () => {
+    const mainPublication = new Publication(base);
+    const branchPublication = new Publication({
+      ...base,
+      all_tables: true,
+    });
+    const changes = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(changes.some((change) => change instanceof DropPublication)).toBe(
+      true,
+    );
+    expect(changes.some((change) => change instanceof CreatePublication)).toBe(
+      true,
+    );
+  });
+
+  test("switch from FOR ALL TABLES to explicit list", () => {
+    const mainPublication = new Publication({
+      ...base,
+      all_tables: true,
+    });
+    const branchPublication = new Publication({
+      ...base,
+      tables: [
+        {
+          schema: "public",
+          name: "mytable",
+          columns: null,
+          row_filter: null,
+        },
+      ],
+    });
+    const changes = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(changes.some((change) => change instanceof DropPublication)).toBe(
+      true,
+    );
+    expect(changes.some((change) => change instanceof CreatePublication)).toBe(
+      true,
+    );
+  });
+
+  test("add and drop tables", () => {
+    const mainPublication = new Publication(base);
+    const branchPublication = new Publication({
+      ...base,
+      tables: [
+        {
+          schema: "public",
+          name: "t",
+          columns: ["id"],
+          row_filter: null,
+        },
+      ],
+    });
+    const addChanges = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(
+      addChanges.some((change) => change instanceof AlterPublicationAddTables),
+    ).toBe(true);
+
+    const addTablesChange = addChanges.find(
+      (change) => change instanceof AlterPublicationAddTables,
+    );
+    expect(addTablesChange?.requires).toEqual(
+      expect.arrayContaining(["table:public.t", "column:public.t.id"]),
+    );
+
+    const dropChanges = diffPublications(
+      ctx,
+      { [branchPublication.stableId]: branchPublication },
+      { [mainPublication.stableId]: mainPublication },
+    );
+    expect(
+      dropChanges.some(
+        (change) => change instanceof AlterPublicationDropTables,
+      ),
+    ).toBe(true);
+  });
+
+  test("detect row filter change as drop and add", () => {
+    const mainPublication = new Publication({
+      ...base,
+      tables: [
+        {
+          schema: "public",
+          name: "t",
+          columns: null,
+          row_filter: null,
+        },
+      ],
+    });
+    const branchPublication = new Publication({
+      ...base,
+      tables: [
+        {
+          schema: "public",
+          name: "t",
+          columns: null,
+          row_filter: "(id > 0)",
+        },
+      ],
+    });
+    const changes = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(
+      changes.some((change) => change instanceof AlterPublicationDropTables),
+    ).toBe(true);
+    expect(
+      changes.some((change) => change instanceof AlterPublicationAddTables),
+    ).toBe(true);
+  });
+
+  test("add and drop schemas", () => {
+    const mainPublication = new Publication(base);
+    const branchPublication = new Publication({
+      ...base,
+      schemas: ["public"],
+    });
+    const addChanges = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(
+      addChanges.some((change) => change instanceof AlterPublicationAddSchemas),
+    ).toBe(true);
+
+    const dropChanges = diffPublications(
+      ctx,
+      { [branchPublication.stableId]: branchPublication },
+      { [mainPublication.stableId]: mainPublication },
+    );
+    expect(
+      dropChanges.some(
+        (change) => change instanceof AlterPublicationDropSchemas,
+      ),
+    ).toBe(true);
+  });
+
+  test("owner and comment changes", () => {
+    const mainPublication = new Publication(base);
+    const branchPublication = new Publication({
+      ...base,
+      owner: "other_user",
+      comment: "replication publication",
+    });
+    const changes = diffPublications(
+      ctx,
+      { [mainPublication.stableId]: mainPublication },
+      { [branchPublication.stableId]: branchPublication },
+    );
+    expect(
+      changes.some((change) => change instanceof AlterPublicationSetOwner),
+    ).toBe(true);
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnPublication),
+    ).toBe(true);
+
+    const removeCommentPublication = new Publication({
+      ...base,
+      comment: null,
+    });
+    const dropCommentChanges = diffPublications(
+      ctx,
+      { [branchPublication.stableId]: branchPublication },
+      { [removeCommentPublication.stableId]: removeCommentPublication },
+    );
+    expect(
+      dropCommentChanges.some(
+        (change) => change instanceof DropCommentOnPublication,
+      ),
+    ).toBe(true);
+  });
+});

package/src/core/objects/publication/publication.diff.ts

@@ -0,0 +1,247 @@
+import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { deepEqual } from "../utils.ts";
+import {
+  AlterPublicationAddSchemas,
+  AlterPublicationAddTables,
+  AlterPublicationDropSchemas,
+  AlterPublicationDropTables,
+  AlterPublicationSetOptions,
+  AlterPublicationSetOwner,
+} from "./changes/publication.alter.ts";
+import {
+  CreateCommentOnPublication,
+  DropCommentOnPublication,
+} from "./changes/publication.comment.ts";
+import { CreatePublication } from "./changes/publication.create.ts";
+import { DropPublication } from "./changes/publication.drop.ts";
+import type { PublicationChange } from "./changes/publication.types.ts";
+import type {
+  Publication,
+  PublicationTableProps,
+} from "./publication.model.ts";
+
+export function diffPublications(
+  ctx: Pick<ObjectDiffContext, "currentUser">,
+  main: Record<string, Publication>,
+  branch: Record<string, Publication>,
+): PublicationChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+  const changes: PublicationChange[] = [];
+
+  for (const id of created) {
+    const publication = branch[id];
+    changes.push(new CreatePublication({ publication }));
+
+    // OWNER: If the publication should be owned by someone other than the current user,
+    // emit ALTER PUBLICATION ... OWNER TO after creation
+    if (publication.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterPublicationSetOwner({
+          publication,
+          owner: publication.owner,
+        }),
+      );
+    }
+
+    if (publication.comment !== null) {
+      changes.push(new CreateCommentOnPublication({ publication }));
+    }
+  }
+
+  for (const id of dropped) {
+    changes.push(new DropPublication({ publication: main[id] }));
+  }
+
+  for (const id of altered) {
+    const mainPublication = main[id];
+    const branchPublication = branch[id];
+
+    if (mainPublication.all_tables && !branchPublication.all_tables) {
+      changes.push(new DropPublication({ publication: mainPublication }));
+      changes.push(new CreatePublication({ publication: branchPublication }));
+      if (branchPublication.comment !== null) {
+        changes.push(
+          new CreateCommentOnPublication({ publication: branchPublication }),
+        );
+      }
+      continue;
+    }
+
+    const operationsChanged =
+      mainPublication.publish_insert !== branchPublication.publish_insert ||
+      mainPublication.publish_update !== branchPublication.publish_update ||
+      mainPublication.publish_delete !== branchPublication.publish_delete ||
+      mainPublication.publish_truncate !== branchPublication.publish_truncate;
+
+    const publishViaPartitionRootChanged =
+      mainPublication.publish_via_partition_root !==
+      branchPublication.publish_via_partition_root;
+
+    if (operationsChanged || publishViaPartitionRootChanged) {
+      changes.push(
+        new AlterPublicationSetOptions({
+          publication: branchPublication,
+          setPublish: operationsChanged,
+          setPublishViaPartitionRoot: publishViaPartitionRootChanged,
+        }),
+      );
+    }
+
+    let handledObjectLists = false;
+
+    if (mainPublication.all_tables !== branchPublication.all_tables) {
+      handledObjectLists = true;
+      // Changing the all_tables mode requires DROP + CREATE because
+      // ALTER PUBLICATION does not support SET ALL TABLES.
+      changes.push(new DropPublication({ publication: mainPublication }));
+      changes.push(new CreatePublication({ publication: branchPublication }));
+      if (branchPublication.comment !== null) {
+        changes.push(
+          new CreateCommentOnPublication({
+            publication: branchPublication,
+          }),
+        );
+      }
+      continue;
+    }
+
+    if (!handledObjectLists && !branchPublication.all_tables) {
+      const tableDiff = diffPublicationTables(
+        mainPublication.tables,
+        branchPublication.tables,
+      );
+      if (tableDiff.tablesToDrop.length > 0) {
+        changes.push(
+          new AlterPublicationDropTables({
+            publication: mainPublication,
+            tables: tableDiff.tablesToDrop,
+          }),
+        );
+      }
+      if (tableDiff.tablesToAdd.length > 0) {
+        changes.push(
+          new AlterPublicationAddTables({
+            publication: branchPublication,
+            tables: tableDiff.tablesToAdd,
+          }),
+        );
+      }
+
+      const schemaDiff = diffPublicationSchemas(
+        mainPublication.schemas,
+        branchPublication.schemas,
+      );
+      if (schemaDiff.schemasToDrop.length > 0) {
+        changes.push(
+          new AlterPublicationDropSchemas({
+            publication: mainPublication,
+            schemas: schemaDiff.schemasToDrop,
+          }),
+        );
+      }
+      if (schemaDiff.schemasToAdd.length > 0) {
+        changes.push(
+          new AlterPublicationAddSchemas({
+            publication: branchPublication,
+            schemas: schemaDiff.schemasToAdd,
+          }),
+        );
+      }
+    }
+
+    if (mainPublication.owner !== branchPublication.owner) {
+      changes.push(
+        new AlterPublicationSetOwner({
+          publication: branchPublication,
+          owner: branchPublication.owner,
+        }),
+      );
+    }
+
+    if (mainPublication.comment !== branchPublication.comment) {
+      if (branchPublication.comment === null) {
+        if (mainPublication.comment !== null) {
+          changes.push(
+            new DropCommentOnPublication({ publication: mainPublication }),
+          );
+        }
+      } else {
+        changes.push(
+          new CreateCommentOnPublication({ publication: branchPublication }),
+        );
+      }
+    }
+  }
+
+  return changes;
+}
+
+function diffPublicationTables(
+  mainTables: PublicationTableProps[],
+  branchTables: PublicationTableProps[],
+) {
+  const mainMap = new Map(
+    mainTables.map((table) => [`${table.schema}.${table.name}`, table]),
+  );
+  const branchMap = new Map(
+    branchTables.map((table) => [`${table.schema}.${table.name}`, table]),
+  );
+
+  const tablesToDropMap = new Map<string, PublicationTableProps>();
+  const tablesToAddMap = new Map<string, PublicationTableProps>();
+
+  for (const [key, mainTable] of mainMap) {
+    if (!branchMap.has(key)) {
+      tablesToDropMap.set(key, mainTable);
+    }
+  }
+
+  for (const [key, branchTable] of branchMap) {
+    const mainTable = mainMap.get(key);
+    if (!mainTable) {
+      tablesToAddMap.set(key, branchTable);
+      continue;
+    }
+
+    const mainComparable = {
+      columns: mainTable.columns,
+      row_filter: mainTable.row_filter,
+    };
+    const branchComparable = {
+      columns: branchTable.columns,
+      row_filter: branchTable.row_filter,
+    };
+
+    if (!deepEqual(mainComparable, branchComparable)) {
+      tablesToDropMap.set(key, mainTable);
+      tablesToAddMap.set(key, branchTable);
+    }
+  }
+
+  const tablesToDrop = Array.from(tablesToDropMap.values()).sort((a, b) => {
+    return a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name);
+  });
+  const tablesToAdd = Array.from(tablesToAddMap.values()).sort((a, b) => {
+    return a.schema.localeCompare(b.schema) || a.name.localeCompare(b.name);
+  });
+
+  return { tablesToDrop, tablesToAdd };
+}
+
+function diffPublicationSchemas(
+  mainSchemas: string[],
+  branchSchemas: string[],
+) {
+  const mainSet = new Set(mainSchemas);
+  const branchSet = new Set(branchSchemas);
+
+  const schemasToDrop = [...mainSet.difference(branchSet)].sort((a, b) =>
+    a.localeCompare(b),
+  );
+  const schemasToAdd = [...branchSet.difference(mainSet)].sort((a, b) =>
+    a.localeCompare(b),
+  );
+
+  return { schemasToDrop, schemasToAdd };
+}