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

package/src/core/objects/publication/changes/publication.alter.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
+import type { PublicationTableProps } from "../publication.model.ts";
+import { Publication } from "../publication.model.ts";
+import {
+  AlterPublicationAddSchemas,
+  AlterPublicationAddTables,
+  AlterPublicationDropSchemas,
+  AlterPublicationDropTables,
+  AlterPublicationSetList,
+  AlterPublicationSetOptions,
+  AlterPublicationSetOwner,
+} from "./publication.alter.ts";
+
+type PublicationProps = ConstructorParameters<typeof Publication>[0];
+
+const base: PublicationProps = {
+  name: "pub_base",
+  owner: "owner1",
+  comment: null,
+  all_tables: true,
+  publish_insert: true,
+  publish_update: true,
+  publish_delete: true,
+  publish_truncate: true,
+  publish_via_partition_root: false,
+  tables: [],
+  schemas: [],
+};
+
+const cloneTables = (tables: PublicationProps["tables"]) =>
+  tables.map((table) => ({
+    ...table,
+    columns: table.columns ? [...table.columns] : null,
+  }));
+
+const makePublication = (override: Partial<PublicationProps> = {}) =>
+  new Publication({
+    ...base,
+    ...override,
+    tables: override.tables
+      ? cloneTables(override.tables)
+      : cloneTables(base.tables),
+    schemas: override.schemas ? [...override.schemas] : [...base.schemas],
+  });
+
+describe("publication.alter", () => {
+  test("set options serializes assignments and requires publication", async () => {
+    const publication = makePublication({
+      name: "pub_options",
+      publish_delete: false,
+      publish_truncate: false,
+      publish_via_partition_root: true,
+    });
+    const change = new AlterPublicationSetOptions({
+      publication,
+      setPublish: true,
+      setPublishViaPartitionRoot: true,
+    });
+
+    expect(change.requires).toEqual([publication.stableId]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_options SET (publish = 'insert, update', publish_via_partition_root = true)",
+    );
+  });
+
+  test("set list serializes object selection and tracks dependencies", async () => {
+    const publication = makePublication({
+      name: "pub_set_list",
+      all_tables: false,
+      tables: [
+        {
+          schema: "public",
+          name: "authors",
+          columns: ["name", "id"],
+          row_filter: null,
+        },
+        {
+          schema: "public",
+          name: "articles",
+          columns: null,
+          row_filter: " published = true ",
+        },
+      ],
+      schemas: ["analytics"],
+    });
+    const change = new AlterPublicationSetList({ publication });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "articles"),
+      stableId.table("public", "authors"),
+      stableId.column("public", "authors", "id"),
+      stableId.column("public", "authors", "name"),
+      stableId.schema("analytics"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_set_list SET TABLE public.articles WHERE (published = true), TABLE public.authors (id, name), TABLES IN SCHEMA analytics",
+    );
+  });
+
+  test("add tables serializes new tables and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_add_tables" });
+    const tables: PublicationTableProps[] = [
+      {
+        schema: "public",
+        name: "logs",
+        columns: null,
+        row_filter: null,
+      },
+      {
+        schema: "audit",
+        name: "events",
+        columns: ["created_at", "id"],
+        row_filter: null,
+      },
+    ];
+    const change = new AlterPublicationAddTables({ publication, tables });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+      stableId.column("audit", "events", "created_at"),
+      stableId.column("audit", "events", "id"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_add_tables ADD TABLE public.logs, TABLE audit.events (created_at, id)",
+    );
+  });
+
+  test("drop tables serializes target list and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_drop_tables" });
+    const tables: PublicationTableProps[] = [
+      {
+        schema: "public",
+        name: "logs",
+        columns: null,
+        row_filter: null,
+      },
+      {
+        schema: "audit",
+        name: "events",
+        columns: ["id"],
+        row_filter: null,
+      },
+    ];
+    const change = new AlterPublicationDropTables({ publication, tables });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+    ]);
+    expect(change.drops).toEqual([
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_drop_tables DROP TABLE public.logs, audit.events",
+    );
+  });
+
+  test("add schemas serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_add_schemas" });
+    const change = new AlterPublicationAddSchemas({
+      publication,
+      schemas: ["analytics", "sales"],
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.schema("analytics"),
+      stableId.schema("sales"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_add_schemas ADD TABLES IN SCHEMA analytics, TABLES IN SCHEMA sales",
+    );
+  });
+
+  test("drop schemas serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_drop_schemas" });
+    const change = new AlterPublicationDropSchemas({
+      publication,
+      schemas: ["analytics", "sales"],
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.schema("analytics"),
+      stableId.schema("sales"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_drop_schemas DROP TABLES IN SCHEMA analytics, TABLES IN SCHEMA sales",
+    );
+  });
+
+  test("set owner serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_owner" });
+    const change = new AlterPublicationSetOwner({
+      publication,
+      owner: "owner2",
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.role("owner2"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_owner OWNER TO owner2",
+    );
+  });
+});

package/src/core/objects/publication/changes/publication.alter.ts

@@ -0,0 +1,232 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { stableId } from "../../utils.ts";
+import type {
+  Publication,
+  PublicationTableProps,
+} from "../publication.model.ts";
+import {
+  formatPublicationObjects,
+  formatPublicationTable,
+  getPublicationOperations,
+} from "../utils.ts";
+import { AlterPublicationChange } from "./publication.base.ts";
+
+export class AlterPublicationSetOptions extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly setPublish: boolean;
+  private readonly setPublishViaPartitionRoot: boolean;
+
+  constructor(props: {
+    publication: Publication;
+    setPublish: boolean;
+    setPublishViaPartitionRoot: boolean;
+  }) {
+    super();
+    this.publication = props.publication;
+    this.setPublish = props.setPublish;
+    this.setPublishViaPartitionRoot = props.setPublishViaPartitionRoot;
+  }
+
+  get requires() {
+    return [this.publication.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const assignments: string[] = [];
+
+    if (this.setPublish) {
+      const operations = getPublicationOperations(this.publication);
+      assignments.push(`publish = '${operations.join(", ")}'`);
+    }
+
+    if (this.setPublishViaPartitionRoot) {
+      assignments.push(
+        `publish_via_partition_root = ${this.publication.publish_via_partition_root ? "true" : "false"}`,
+      );
+    }
+
+    return `ALTER PUBLICATION ${this.publication.name} SET (${assignments.join(", ")})`;
+  }
+}
+
+export class AlterPublicationSetList extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+
+  constructor(props: { publication: Publication }) {
+    super();
+    this.publication = props.publication;
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    dependencies.add(this.publication.stableId);
+
+    for (const table of this.publication.tables) {
+      dependencies.add(stableId.table(table.schema, table.name));
+      if (table.columns) {
+        for (const column of table.columns) {
+          dependencies.add(stableId.column(table.schema, table.name, column));
+        }
+      }
+    }
+
+    for (const schema of this.publication.schemas) {
+      dependencies.add(stableId.schema(schema));
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const clauses = formatPublicationObjects(
+      this.publication.tables,
+      this.publication.schemas,
+    );
+    return `ALTER PUBLICATION ${this.publication.name} SET ${clauses.join(", ")}`;
+  }
+}
+
+export class AlterPublicationAddTables extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly tables: PublicationTableProps[];
+
+  constructor(props: {
+    publication: Publication;
+    tables: PublicationTableProps[];
+  }) {
+    super();
+    this.publication = props.publication;
+    this.tables = props.tables;
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    dependencies.add(this.publication.stableId);
+
+    for (const table of this.tables) {
+      dependencies.add(stableId.table(table.schema, table.name));
+      if (table.columns) {
+        for (const column of table.columns) {
+          dependencies.add(stableId.column(table.schema, table.name, column));
+        }
+      }
+    }
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const clauses = this.tables.map((table) => formatPublicationTable(table));
+    return `ALTER PUBLICATION ${this.publication.name} ADD ${clauses.join(", ")}`;
+  }
+}
+
+export class AlterPublicationDropTables extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly tables: PublicationTableProps[];
+
+  constructor(props: {
+    publication: Publication;
+    tables: PublicationTableProps[];
+  }) {
+    super();
+    this.publication = props.publication;
+    this.tables = props.tables;
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    dependencies.add(this.publication.stableId);
+
+    for (const table of this.tables) {
+      dependencies.add(stableId.table(table.schema, table.name));
+    }
+
+    return Array.from(dependencies);
+  }
+
+  get drops() {
+    // Treat ALTER PUBLICATION ... DROP TABLE as a destructive change so it runs
+    // in the drop phase before DROP TABLE removes the referenced relation.
+    return this.tables.map((table) => stableId.table(table.schema, table.name));
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const targets = this.tables.map((table) => `${table.schema}.${table.name}`);
+    return `ALTER PUBLICATION ${this.publication.name} DROP TABLE ${targets.join(", ")}`;
+  }
+}
+
+export class AlterPublicationAddSchemas extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly schemas: string[];
+
+  constructor(props: { publication: Publication; schemas: string[] }) {
+    super();
+    this.publication = props.publication;
+    this.schemas = props.schemas;
+  }
+
+  get requires() {
+    return [
+      this.publication.stableId,
+      ...this.schemas.map((schema) => stableId.schema(schema)),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const clauses = this.schemas.map((schema) => `TABLES IN SCHEMA ${schema}`);
+    return `ALTER PUBLICATION ${this.publication.name} ADD ${clauses.join(", ")}`;
+  }
+}
+
+export class AlterPublicationDropSchemas extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly schemas: string[];
+
+  constructor(props: { publication: Publication; schemas: string[] }) {
+    super();
+    this.publication = props.publication;
+    this.schemas = props.schemas;
+  }
+
+  get requires() {
+    return [
+      this.publication.stableId,
+      ...this.schemas.map((schema) => stableId.schema(schema)),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const clauses = this.schemas.map((schema) => `TABLES IN SCHEMA ${schema}`);
+    return `ALTER PUBLICATION ${this.publication.name} DROP ${clauses.join(", ")}`;
+  }
+}
+
+export class AlterPublicationSetOwner extends AlterPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+  private readonly owner: string;
+
+  constructor(props: { publication: Publication; owner: string }) {
+    super();
+    this.publication = props.publication;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.publication.stableId, stableId.role(this.owner)];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER PUBLICATION ${this.publication.name} OWNER TO ${this.owner}`;
+  }
+}

package/src/core/objects/publication/changes/publication.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Publication } from "../publication.model.ts";
+
+abstract class BasePublicationChange extends BaseChange {
+  abstract readonly publication: Publication;
+  abstract readonly scope: "object" | "comment";
+  readonly objectType = "publication" as const;
+}
+
+export abstract class CreatePublicationChange extends BasePublicationChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterPublicationChange extends BasePublicationChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropPublicationChange extends BasePublicationChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/publication/changes/publication.comment.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
+import { Publication } from "../publication.model.ts";
+import {
+  CreateCommentOnPublication,
+  DropCommentOnPublication,
+} from "./publication.comment.ts";
+
+type PublicationProps = ConstructorParameters<typeof Publication>[0];
+
+const base: PublicationProps = {
+  name: "pub_comment",
+  owner: "owner1",
+  comment: null,
+  all_tables: true,
+  publish_insert: true,
+  publish_update: true,
+  publish_delete: true,
+  publish_truncate: true,
+  publish_via_partition_root: false,
+  tables: [],
+  schemas: [],
+};
+
+const cloneTables = (tables: PublicationProps["tables"]) =>
+  tables.map((table) => ({
+    ...table,
+    columns: table.columns ? [...table.columns] : null,
+  }));
+
+const makePublication = (override: Partial<PublicationProps> = {}) =>
+  new Publication({
+    ...base,
+    ...override,
+    tables: override.tables
+      ? cloneTables(override.tables)
+      : cloneTables(base.tables),
+    schemas: override.schemas ? [...override.schemas] : [...base.schemas],
+  });
+
+describe("publication.comment", () => {
+  test("create comment serializes and tracks dependencies", async () => {
+    const publication = makePublication({
+      comment: "publication's overview",
+    });
+    const change = new CreateCommentOnPublication({ publication });
+
+    expect(change.creates).toEqual([stableId.comment(publication.stableId)]);
+    expect(change.requires).toEqual([publication.stableId]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "COMMENT ON PUBLICATION pub_comment IS 'publication''s overview'",
+    );
+  });
+
+  test("drop comment serializes and tracks dependencies", async () => {
+    const publication = makePublication({
+      comment: "some comment",
+    });
+    const change = new DropCommentOnPublication({ publication });
+
+    expect(change.drops).toEqual([stableId.comment(publication.stableId)]);
+    expect(change.requires).toEqual([
+      stableId.comment(publication.stableId),
+      publication.stableId,
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "COMMENT ON PUBLICATION pub_comment IS NULL",
+    );
+  });
+});

package/src/core/objects/publication/changes/publication.comment.ts

@@ -0,0 +1,65 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Publication } from "../publication.model.ts";
+import {
+  CreatePublicationChange,
+  DropPublicationChange,
+} from "./publication.base.ts";
+
+export type CommentPublication =
+  | CreateCommentOnPublication
+  | DropCommentOnPublication;
+
+export class CreateCommentOnPublication extends CreatePublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { publication: Publication }) {
+    super();
+    this.publication = props.publication;
+  }
+
+  get creates() {
+    return [stableId.comment(this.publication.stableId)];
+  }
+
+  get requires() {
+    return [this.publication.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON PUBLICATION",
+      this.publication.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: comment ensured non-null by caller
+      quoteLiteral(this.publication.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnPublication extends DropPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { publication: Publication }) {
+    super();
+    this.publication = props.publication;
+  }
+
+  get drops() {
+    return [stableId.comment(this.publication.stableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(this.publication.stableId),
+      this.publication.stableId,
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `COMMENT ON PUBLICATION ${this.publication.name} IS NULL`;
+  }
+}

package/src/core/objects/publication/changes/publication.create.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
+import { Publication } from "../publication.model.ts";
+import { CreatePublication } from "./publication.create.ts";
+
+type PublicationProps = ConstructorParameters<typeof Publication>[0];
+
+const base: PublicationProps = {
+  name: "pub_all_tables",
+  owner: "owner1",
+  comment: null,
+  all_tables: true,
+  publish_insert: true,
+  publish_update: true,
+  publish_delete: true,
+  publish_truncate: true,
+  publish_via_partition_root: false,
+  tables: [],
+  schemas: [],
+};
+
+const cloneTables = (tables: PublicationProps["tables"]) =>
+  tables.map((table) => ({
+    ...table,
+    columns: table.columns ? [...table.columns] : null,
+  }));
+
+const makePublication = (override: Partial<PublicationProps> = {}) =>
+  new Publication({
+    ...base,
+    ...override,
+    tables: override.tables
+      ? cloneTables(override.tables)
+      : cloneTables(base.tables),
+    schemas: override.schemas ? [...override.schemas] : [...base.schemas],
+  });
+
+describe("publication.create", () => {
+  test("serialize publication for all tables", async () => {
+    const publication = makePublication();
+    const change = new CreatePublication({ publication });
+
+    expect(change.creates).toEqual([publication.stableId]);
+    expect(change.requires).toEqual([stableId.role(publication.owner)]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE PUBLICATION pub_all_tables FOR ALL TABLES",
+    );
+  });
+
+  test("serialize publication with explicit objects and options", async () => {
+    const publication = makePublication({
+      name: "pub_custom",
+      all_tables: false,
+      publish_delete: false,
+      publish_truncate: false,
+      publish_via_partition_root: true,
+      tables: [
+        {
+          schema: "public",
+          name: "articles",
+          columns: null,
+          row_filter: "id > 1",
+        },
+        {
+          schema: "public",
+          name: "authors",
+          columns: ["name", "id"],
+          row_filter: null,
+        },
+      ],
+      schemas: ["analytics"],
+    });
+    const change = new CreatePublication({ publication });
+
+    expect(change.requires).toEqual([
+      stableId.role(publication.owner),
+      stableId.table("public", "articles"),
+      stableId.table("public", "authors"),
+      stableId.column("public", "authors", "id"),
+      stableId.column("public", "authors", "name"),
+      stableId.schema("analytics"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE PUBLICATION pub_custom FOR TABLE public.articles WHERE (id > 1), TABLE public.authors (id, name), TABLES IN SCHEMA analytics WITH (publish = 'insert, update', publish_via_partition_root = true)",
+    );
+  });
+});