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

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;
+  public 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" | "security_label";
+  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)",
+    );
+  });
+});

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

@@ -0,0 +1,83 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { stableId } from "../../utils.ts";
+import type { Publication } from "../publication.model.ts";
+import {
+  formatPublicationObjects,
+  getPublicationOperations,
+  isDefaultPublicationOperations,
+} from "../utils.ts";
+import { CreatePublicationChange } from "./publication.base.ts";
+
+/**
+ * Create a logical replication publication.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createpublication.html
+ */
+export class CreatePublication extends CreatePublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+
+  constructor(props: { publication: Publication }) {
+    super();
+    this.publication = props.publication;
+  }
+
+  get creates() {
+    return [this.publication.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    dependencies.add(stableId.role(this.publication.owner));
+
+    if (!this.publication.all_tables) {
+      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 parts: string[] = ["CREATE PUBLICATION", this.publication.name];
+
+    if (this.publication.all_tables) {
+      parts.push("FOR ALL TABLES");
+    } else {
+      const objectClauses = formatPublicationObjects(
+        this.publication.tables,
+        this.publication.schemas,
+      );
+      if (objectClauses.length > 0) {
+        parts.push("FOR", objectClauses.join(", "));
+      }
+    }
+
+    const options: string[] = [];
+    if (!isDefaultPublicationOperations(this.publication)) {
+      const operations = getPublicationOperations(this.publication);
+      options.push(`publish = '${operations.join(", ")}'`);
+    }
+
+    if (this.publication.publish_via_partition_root) {
+      options.push("publish_via_partition_root = true");
+    }
+
+    if (options.length > 0) {
+      parts.push("WITH", `(${options.join(", ")})`);
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Publication } from "../publication.model.ts";
+import { DropPublication } from "./publication.drop.ts";
+
+type PublicationProps = ConstructorParameters<typeof Publication>[0];
+
+const base: PublicationProps = {
+  name: "pub_drop_me",
+  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.drop", () => {
+  test("serialize drop statement and track dependencies", async () => {
+    const publication = makePublication();
+    const change = new DropPublication({ publication });
+
+    expect(change.drops).toEqual([publication.stableId]);
+    expect(change.requires).toEqual([publication.stableId]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("DROP PUBLICATION pub_drop_me");
+  });
+});

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

@@ -0,0 +1,30 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Publication } from "../publication.model.ts";
+import { DropPublicationChange } from "./publication.base.ts";
+
+/**
+ * Drop a logical replication publication.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droppublication.html
+ */
+export class DropPublication extends DropPublicationChange {
+  public readonly publication: Publication;
+  public readonly scope = "object" as const;
+
+  constructor(props: { publication: Publication }) {
+    super();
+    this.publication = props.publication;
+  }
+
+  get drops() {
+    return [this.publication.stableId];
+  }
+
+  get requires() {
+    return [this.publication.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `DROP PUBLICATION ${this.publication.name}`;
+  }
+}