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

package/src/core/objects/foreign-data-wrapper/server/changes/server.alter.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Server, type ServerProps } from "../server.model.ts";
+import {
+  AlterServerChangeOwner,
+  AlterServerSetOptions,
+  AlterServerSetVersion,
+} from "./server.alter.ts";
+
+describe.concurrent("server", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "old_owner",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerChangeOwner({
+        server,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SERVER test_server OWNER TO new_owner",
+      );
+    });
+
+    test("set version", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetVersion({
+        server,
+        version: "2.0",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe("ALTER SERVER test_server VERSION '2.0'");
+    });
+
+    test("set version to null", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: "1.0",
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetVersion({
+        server,
+        version: null,
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe("ALTER SERVER test_server VERSION ''");
+    });
+
+    test("set options ADD", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetOptions({
+        server,
+        options: [
+          { action: "ADD", option: "host", value: "localhost" },
+          { action: "ADD", option: "port", value: "5432" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SERVER test_server OPTIONS (ADD host 'localhost', ADD port '5432')",
+      );
+    });
+
+    test("set options SET", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetOptions({
+        server,
+        options: [{ action: "SET", option: "host", value: "newhost" }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SERVER test_server OPTIONS (SET host 'newhost')",
+      );
+    });
+
+    test("set options DROP", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetOptions({
+        server,
+        options: [{ action: "DROP", option: "host" }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SERVER test_server OPTIONS (DROP host)",
+      );
+    });
+
+    test("set options mixed ADD/SET/DROP", async () => {
+      const props: ServerProps = {
+        name: "test_server",
+        owner: "test",
+        foreign_data_wrapper: "test_fdw",
+        type: null,
+        version: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const server = new Server(props);
+      const change = new AlterServerSetOptions({
+        server,
+        options: [
+          { action: "ADD", option: "new_option", value: "new_value" },
+          { action: "SET", option: "existing_option", value: "updated_value" },
+          { action: "DROP", option: "old_option" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SERVER test_server OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
+      );
+    });
+  });
+});

package/src/core/objects/foreign-data-wrapper/server/changes/server.alter.ts

@@ -0,0 +1,126 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { Server } from "../server.model.ts";
+import { AlterServerChange } from "./server.base.ts";
+
+/**
+ * Alter a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterserver.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SERVER name [ VERSION 'new_version' ]
+ *     [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
+ * ALTER SERVER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ```
+ */
+
+export type AlterServer =
+  | AlterServerChangeOwner
+  | AlterServerSetOptions
+  | AlterServerSetVersion;
+
+/**
+ * ALTER SERVER ... OWNER TO ...
+ */
+export class AlterServerChangeOwner extends AlterServerChange {
+  public readonly server: Server;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { server: Server; owner: string }) {
+    super();
+    this.server = props.server;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.server.stableId, stableId.role(this.owner)];
+  }
+
+  serialize(): string {
+    return ["ALTER SERVER", this.server.name, "OWNER TO", this.owner].join(" ");
+  }
+}
+
+/**
+ * ALTER SERVER ... VERSION ...
+ */
+export class AlterServerSetVersion extends AlterServerChange {
+  public readonly server: Server;
+  public readonly version: string | null;
+  public readonly scope = "object" as const;
+
+  constructor(props: { server: Server; version: string | null }) {
+    super();
+    this.server = props.server;
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [this.server.stableId];
+  }
+
+  serialize(): string {
+    if (this.version === null) {
+      // PostgreSQL doesn't support removing version, but we'll handle it
+      return ["ALTER SERVER", this.server.name, "VERSION", "''"].join(" ");
+    }
+    return [
+      "ALTER SERVER",
+      this.server.name,
+      "VERSION",
+      quoteLiteral(this.version),
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER SERVER ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterServerSetOptions extends AlterServerChange {
+  public readonly server: Server;
+  public readonly options: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }>;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    server: Server;
+    options: Array<{
+      action: "ADD" | "SET" | "DROP";
+      option: string;
+      value?: string;
+    }>;
+  }) {
+    super();
+    this.server = props.server;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.server.stableId];
+  }
+
+  serialize(): string {
+    const optionParts: string[] = [];
+    for (const opt of this.options) {
+      if (opt.action === "DROP") {
+        optionParts.push(`DROP ${opt.option}`);
+      } else {
+        const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+        optionParts.push(`${opt.action} ${opt.option} ${value}`);
+      }
+    }
+
+    return [
+      "ALTER SERVER",
+      this.server.name,
+      "OPTIONS",
+      `(${optionParts.join(", ")})`,
+    ].join(" ");
+  }
+}

package/src/core/objects/foreign-data-wrapper/server/changes/server.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { Server } from "../server.model.ts";
+
+abstract class BaseServerChange extends BaseChange {
+  abstract readonly server: Server;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "server" = "server";
+}
+
+export abstract class CreateServerChange extends BaseServerChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterServerChange extends BaseServerChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropServerChange extends BaseServerChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/foreign-data-wrapper/server/changes/server.comment.ts

@@ -0,0 +1,60 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { Server } from "../server.model.ts";
+import { CreateServerChange, DropServerChange } from "./server.base.ts";
+
+/**
+ * Create/drop comments on servers.
+ */
+
+export type CommentServer = CreateCommentOnServer | DropCommentOnServer;
+
+export class CreateCommentOnServer extends CreateServerChange {
+  public readonly server: Server;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { server: Server }) {
+    super();
+    this.server = props.server;
+  }
+
+  get creates() {
+    return [stableId.comment(this.server.stableId)];
+  }
+
+  get requires() {
+    return [this.server.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON SERVER",
+      this.server.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+      quoteLiteral(this.server.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnServer extends DropServerChange {
+  public readonly server: Server;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { server: Server }) {
+    super();
+    this.server = props.server;
+  }
+
+  get drops() {
+    return [stableId.comment(this.server.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.server.stableId), this.server.stableId];
+  }
+
+  serialize(): string {
+    return ["COMMENT ON SERVER", this.server.name, "IS NULL"].join(" ");
+  }
+}

package/src/core/objects/foreign-data-wrapper/server/changes/server.create.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Server } from "../server.model.ts";
+import { CreateServer } from "./server.create.ts";
+
+describe("server", () => {
+  test("create basic", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server FOREIGN DATA WRAPPER test_fdw",
+    );
+  });
+
+  test("create with type", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: "postgres_fdw",
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server TYPE 'postgres_fdw' FOREIGN DATA WRAPPER test_fdw",
+    );
+  });
+
+  test("create with version", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: null,
+      version: "1.0",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server VERSION '1.0' FOREIGN DATA WRAPPER test_fdw",
+    );
+  });
+
+  test("create with type and version", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: "postgres_fdw",
+      version: "1.0",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server TYPE 'postgres_fdw' VERSION '1.0' FOREIGN DATA WRAPPER test_fdw",
+    );
+  });
+
+  test("create with options", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: null,
+      version: null,
+      options: ["host", "localhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server FOREIGN DATA WRAPPER test_fdw OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+
+  test("create with all properties", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: "postgres_fdw",
+      version: "1.0",
+      options: ["host", "localhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SERVER test_server TYPE 'postgres_fdw' VERSION '1.0' FOREIGN DATA WRAPPER test_fdw OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+});

package/src/core/objects/foreign-data-wrapper/server/changes/server.create.ts

@@ -0,0 +1,81 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { Server } from "../server.model.ts";
+import { CreateServerChange } from "./server.base.ts";
+
+/**
+ * Create a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createserver.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE SERVER [ IF NOT EXISTS ] server_name [ TYPE 'server_type' ] [ VERSION 'server_version' ]
+ *     FOREIGN DATA WRAPPER fdw_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateServer extends CreateServerChange {
+  public readonly server: Server;
+  public readonly scope = "object" as const;
+
+  constructor(props: { server: Server }) {
+    super();
+    this.server = props.server;
+  }
+
+  get creates() {
+    return [this.server.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Foreign Data Wrapper dependency
+    dependencies.add(
+      stableId.foreignDataWrapper(this.server.foreign_data_wrapper),
+    );
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.server.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE SERVER"];
+
+    // Add server name
+    parts.push(this.server.name);
+
+    // Add TYPE clause
+    if (this.server.type) {
+      parts.push("TYPE", quoteLiteral(this.server.type));
+    }
+
+    // Add VERSION clause
+    if (this.server.version) {
+      parts.push("VERSION", quoteLiteral(this.server.version));
+    }
+
+    // Add FOREIGN DATA WRAPPER clause
+    parts.push("FOREIGN DATA WRAPPER", this.server.foreign_data_wrapper);
+
+    // Add OPTIONS clause
+    if (this.server.options && this.server.options.length > 0) {
+      const optionPairs: string[] = [];
+      for (let i = 0; i < this.server.options.length; i += 2) {
+        if (i + 1 < this.server.options.length) {
+          optionPairs.push(
+            `${this.server.options[i]} ${quoteLiteral(this.server.options[i + 1])}`,
+          );
+        }
+      }
+      if (optionPairs.length > 0) {
+        parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+      }
+    }
+
+    return parts.join(" ");
+  }
+}

package/src/core/objects/foreign-data-wrapper/server/changes/server.drop.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { Server } from "../server.model.ts";
+import { DropServer } from "./server.drop.ts";
+
+describe("server", () => {
+  test("drop", async () => {
+    const server = new Server({
+      name: "test_server",
+      owner: "test",
+      foreign_data_wrapper: "test_fdw",
+      type: null,
+      version: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropServer({
+      server,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP SERVER test_server");
+  });
+});

package/src/core/objects/foreign-data-wrapper/server/changes/server.drop.ts

@@ -0,0 +1,34 @@
+import type { Server } from "../server.model.ts";
+import { DropServerChange } from "./server.base.ts";
+
+/**
+ * Drop a server.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropserver.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP SERVER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropServer extends DropServerChange {
+  public readonly server: Server;
+  public readonly scope = "object" as const;
+
+  constructor(props: { server: Server }) {
+    super();
+    this.server = props.server;
+  }
+
+  get drops() {
+    return [this.server.stableId];
+  }
+
+  get requires() {
+    return [this.server.stableId];
+  }
+
+  serialize(): string {
+    return ["DROP SERVER", this.server.name].join(" ");
+  }
+}