@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

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

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { CreateForeignDataWrapper } from "./foreign-data-wrapper.create.ts";
+
+describe("foreign-data-wrapper", () => {
+  test("create basic", async () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR",
+    );
+  });
+
+  test("create with handler", async () => {
+    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,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func NO VALIDATOR",
+    );
+  });
+
+  test("create with validator", async () => {
+    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,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER VALIDATOR public.validator_func",
+    );
+  });
+
+  test("create with handler and validator", async () => {
+    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,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func VALIDATOR public.validator_func",
+    );
+  });
+
+  test("create with options", async () => {
+    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,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw NO HANDLER NO VALIDATOR OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+
+  test("create with all properties", async () => {
+    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,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER public.handler_func VALIDATOR public.validator_func OPTIONS (host 'localhost', port '5432')",
+    );
+  });
+
+  test("create with schema-qualified handler (no function args in output)", async () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: "extensions.iceberg_fdw_handler",
+      validator: "extensions.iceberg_fdw_validator",
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN DATA WRAPPER test_fdw HANDLER extensions.iceberg_fdw_handler VALIDATOR extensions.iceberg_fdw_validator",
+    );
+  });
+});

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,26 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { DropForeignDataWrapper } from "./foreign-data-wrapper.drop.ts";
+
+describe("foreign-data-wrapper", () => {
+  test("drop", async () => {
+    const fdw = new ForeignDataWrapper({
+      name: "test_fdw",
+      owner: "test",
+      handler: null,
+      validator: null,
+      options: null,
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropForeignDataWrapper({
+      foreignDataWrapper: fdw,
+    });
+
+    await assertValidSql(change.serialize());
+
+    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,13 @@
+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";
+
+/** Union of all FDW wrapper-level change variants (`objectType: "foreign_data_wrapper"`). @category Change Types */
+export type ForeignDataWrapperChange =
+  | AlterForeignDataWrapper
+  | CommentForeignDataWrapper
+  | CreateForeignDataWrapper
+  | DropForeignDataWrapper
+  | ForeignDataWrapperPrivilege;