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

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

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
+
+describe("foreign-data-wrapper", () => {
+  test("create basic", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR",
+    );
+  });
+
+  test("create with handler", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: "public.handler_func()",
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() NO VALIDATOR",
+    );
+  });
+
+  test("create with validator", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: "public.validator_func()",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER VALIDATOR public.validator_func()",
+    );
+  });
+
+  test("create with handler and validator", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: "public.handler_func()",
+      validator: "public.validator_func()",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() VALIDATOR public.validator_func()",
+    );
+  });
+
+  test("create with options", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: null,
+      options: ["host", "localhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+
+  test("create with all properties", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: "public.handler_func()",
+      validator: "public.validator_func()",
+      options: ["host", "localhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func() VALIDATOR public.validator_func() OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+});

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

@@ -0,0 +1,95 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { CreateForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+
+/**
+ * Create a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN DATA WRAPPER name
+ *     [ HANDLER handler_function | NO HANDLER ]
+ *     [ VALIDATOR validator_function | NO VALIDATOR ]
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateForeignDataWrapper extends CreateForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignDataWrapper: ForeignDataWrapper }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+  }
+
+  get creates() {
+    return [this.foreignDataWrapper.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.foreignDataWrapper.owner));
+
+    // Handler function dependency (if specified)
+    if (this.foreignDataWrapper.handler) {
+      // Handler is stored as "schema.function_name(args)"
+      // We need to parse it to get the procedure stableId
+      // For now, we'll skip this dependency as it's complex to parse
+      // TODO: Parse handler function reference to add procedure dependency
+    }
+
+    // Validator function dependency (if specified)
+    if (this.foreignDataWrapper.validator) {
+      // Similar to handler
+      // TODO: Parse validator function reference to add procedure dependency
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE FOREIGN DATA WRAPPER"];
+
+    // Add FDW name
+    parts.push(this.foreignDataWrapper.name);
+
+    // Add HANDLER clause
+    if (this.foreignDataWrapper.handler) {
+      parts.push("HANDLER", this.foreignDataWrapper.handler);
+    } else {
+      parts.push("NO HANDLER");
+    }
+
+    // Add VALIDATOR clause
+    if (this.foreignDataWrapper.validator) {
+      parts.push("VALIDATOR", this.foreignDataWrapper.validator);
+    } else {
+      parts.push("NO VALIDATOR");
+    }
+
+    // Add OPTIONS clause
+    if (
+      this.foreignDataWrapper.options &&
+      this.foreignDataWrapper.options.length > 0
+    ) {
+      const optionPairs: string[] = [];
+      for (let i = 0; i < this.foreignDataWrapper.options.length; i += 2) {
+        if (i + 1 < this.foreignDataWrapper.options.length) {
+          optionPairs.push(
+            `${this.foreignDataWrapper.options[i]} ${quoteLiteral(this.foreignDataWrapper.options[i + 1])}`,
+          );
+        }
+      }
+      if (optionPairs.length > 0) {
+        parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+      }
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
+
+describe("foreign-data-wrapper", () => {
+  test("drop", () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    expect(change.serialize()).toBe("DROP FOREIGN DATA WRAPPER test_fdw");
+  });
+});

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

@@ -0,0 +1,36 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { DropForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+
+/**
+ * Drop a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropForeignDataWrapper extends DropForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignDataWrapper: ForeignDataWrapper }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+  }
+
+  get drops() {
+    return [this.foreignDataWrapper.stableId];
+  }
+
+  get requires() {
+    return [this.foreignDataWrapper.stableId];
+  }
+
+  serialize(): string {
+    return ["DROP FOREIGN DATA WRAPPER", this.foreignDataWrapper.name].join(
+      " ",
+    );
+  }
+}

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

@@ -0,0 +1,172 @@
+import { formatObjectPrivilegeList } from "../../../base.privilege.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { AlterForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+
+export type ForeignDataWrapperPrivilege =
+  | GrantForeignDataWrapperPrivileges
+  | RevokeForeignDataWrapperPrivileges
+  | RevokeGrantOptionForeignDataWrapperPrivileges;
+
+/**
+ * Grant privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON FOREIGN DATA WRAPPER name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignDataWrapper: ForeignDataWrapper;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.foreignDataWrapper.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.foreignDataWrapper.stableId, stableId.role(this.grantee)];
+  }
+
+  serialize(): string {
+    const hasGrantable = this.privileges.some((p) => p.grantable);
+    const hasBase = this.privileges.some((p) => !p.grantable);
+    if (hasGrantable && hasBase) {
+      throw new Error(
+        "GrantForeignDataWrapperPrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN DATA WRAPPER",
+      list,
+      this.version,
+    );
+    return `GRANT ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN DATA WRAPPER name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignDataWrapper: ForeignDataWrapper;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get drops() {
+    return [stableId.acl(this.foreignDataWrapper.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.foreignDataWrapper.stableId, this.grantee),
+      this.foreignDataWrapper.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN DATA WRAPPER",
+      list,
+      this.version,
+    );
+    return `REVOKE ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a foreign data wrapper.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionForeignDataWrapperPrivileges extends AlterForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignDataWrapper: ForeignDataWrapper;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.foreignDataWrapper.stableId, this.grantee),
+      this.foreignDataWrapper.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN DATA WRAPPER",
+      this.privilegeNames,
+      this.version,
+    );
+    return `REVOKE GRANT OPTION FOR ${privSql} ON FOREIGN DATA WRAPPER ${this.foreignDataWrapper.name} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { AlterForeignDataWrapper } from "./foreign-data-wrapper.alter.ts";
+import type { CommentForeignDataWrapper } from "./foreign-data-wrapper.comment.ts";
+import type { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
+import type { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
+import type { ForeignDataWrapperPrivilege } from "./foreign-data-wrapper.privilege.ts";
+
+export type ForeignDataWrapperChange =
+  | AlterForeignDataWrapper
+  | CommentForeignDataWrapper
+  | CreateForeignDataWrapper
+  | DropForeignDataWrapper
+  | ForeignDataWrapperPrivilege;

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper/foreign-data-wrapper.diff.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, test } from "bun:test";
+import { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import {
+  AlterForeignDataWrapperChangeOwner,
+  AlterForeignDataWrapperSetOptions,
+} from "./changes/foreign-data-wrapper.alter.ts";
+import { CreateForeignDataWrapper } from "./changes/foreign-data-wrapper.create.ts";
+import { DropForeignDataWrapper } from "./changes/foreign-data-wrapper.drop.ts";
+import { diffForeignDataWrappers } from "./foreign-data-wrapper.diff.ts";
+import {
+  ForeignDataWrapper,
+  type ForeignDataWrapperProps,
+} from "./foreign-data-wrapper.model.ts";
+
+const testContext = {
+  version: 170000,
+  currentUser: "postgres",
+  defaultPrivilegeState: new DefaultPrivilegeState({}),
+  mainRoles: {},
+};
+
+describe.concurrent("foreign-data-wrapper.diff", () => {
+  test("create and drop", () => {
+    const props: ForeignDataWrapperProps = {
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    };
+    const fdw = new ForeignDataWrapper(props);
+
+    const created = diffForeignDataWrappers(
+      testContext,
+      {},
+      {
+        [fdw.stableId]: fdw,
+      },
+    );
+    expect(created[0]).toBeInstanceOf(CreateForeignDataWrapper);
+
+    const dropped = diffForeignDataWrappers(
+      testContext,
+      {
+        [fdw.stableId]: fdw,
+      },
+      {},
+    );
+    expect(dropped[0]).toBeInstanceOf(DropForeignDataWrapper);
+  });
+
+  test("alter: owner change", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o2",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((c) => c instanceof AlterForeignDataWrapperChangeOwner),
+    ).toBe(true);
+  });
+
+  test("alter: options changes", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: ["host", "localhost"],
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: null,
+      options: ["host", "newhost", "port", "5432"],
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    const optionsChange = changes.find(
+      (c) => c instanceof AlterForeignDataWrapperSetOptions,
+    ) as AlterForeignDataWrapperSetOptions | undefined;
+    expect(optionsChange).toBeDefined();
+    expect(optionsChange?.options.length).toBeGreaterThan(0);
+  });
+
+  test("handler change triggers drop and create", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: "public.old_handler()",
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: "public.new_handler()",
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    // Handler change should trigger drop + create
+    expect(changes.some((c) => c instanceof DropForeignDataWrapper)).toBe(true);
+    expect(changes.some((c) => c instanceof CreateForeignDataWrapper)).toBe(
+      true,
+    );
+  });
+
+  test("validator change triggers drop and create", () => {
+    const main = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: "public.old_validator()",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+    const branch = new ForeignDataWrapper({
+      name: "fdw1",
+      owner: "o1",
+      handler: null,
+      validator: "public.new_validator()",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const changes = diffForeignDataWrappers(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    // Validator change should trigger drop + create
+    expect(changes.some((c) => c instanceof DropForeignDataWrapper)).toBe(true);
+    expect(changes.some((c) => c instanceof CreateForeignDataWrapper)).toBe(
+      true,
+    );
+  });
+});