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

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

@@ -0,0 +1,72 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import {
+  CreateForeignTableChange,
+  DropForeignTableChange,
+} from "./foreign-table.base.ts";
+
+/**
+ * Create/drop comments on foreign tables.
+ */
+
+export type CommentForeignTable =
+  | CreateCommentOnForeignTable
+  | DropCommentOnForeignTable;
+
+export class CreateCommentOnForeignTable extends CreateForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { foreignTable: ForeignTable }) {
+    super();
+    this.foreignTable = props.foreignTable;
+  }
+
+  get creates() {
+    return [stableId.comment(this.foreignTable.stableId)];
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+      quoteLiteral(this.foreignTable.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnForeignTable extends DropForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { foreignTable: ForeignTable }) {
+    super();
+    this.foreignTable = props.foreignTable;
+  }
+
+  get drops() {
+    return [stableId.comment(this.foreignTable.stableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(this.foreignTable.stableId),
+      this.foreignTable.stableId,
+    ];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,210 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { ForeignTable } from "../foreign-table.model.ts";
+import { CreateForeignTable } from "./foreign-table.create.ts";
+
+describe("foreign-table", () => {
+  test("create basic", async () => {
+    const foreignTable = new ForeignTable({
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: null,
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new CreateForeignTable({
+      foreignTable,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN TABLE public.test_table (id integer) SERVER test_server",
+    );
+  });
+
+  test("create with multiple columns", async () => {
+    const foreignTable = new ForeignTable({
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: null,
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+        {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new CreateForeignTable({
+      foreignTable,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN TABLE public.test_table (id integer, name text) SERVER test_server",
+    );
+  });
+
+  test("create with options", async () => {
+    const foreignTable = new ForeignTable({
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: ["schema_name", "remote_schema", "table_name", "remote_table"],
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new CreateForeignTable({
+      foreignTable,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN TABLE public.test_table (id integer) SERVER test_server OPTIONS (schema_name 'remote_schema', table_name 'remote_table')",
+    );
+  });
+
+  test("create with all properties", async () => {
+    const foreignTable = new ForeignTable({
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: ["schema_name", "remote_schema", "table_name", "remote_table"],
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+        {
+          name: "name",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new CreateForeignTable({
+      foreignTable,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE FOREIGN TABLE public.test_table (id integer, name text) SERVER test_server OPTIONS (schema_name 'remote_schema', table_name 'remote_table')",
+    );
+  });
+});

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

@@ -0,0 +1,81 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { CreateForeignTableChange } from "./foreign-table.base.ts";
+
+/**
+ * Create a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN TABLE [ IF NOT EXISTS ] table_name
+ *     ( [ { column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ] | table_constraint } [, ... ] ] )
+ *     SERVER server_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateForeignTable extends CreateForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable }) {
+    super();
+    this.foreignTable = props.foreignTable;
+  }
+
+  get creates() {
+    return [this.foreignTable.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.foreignTable.schema));
+
+    // Server dependency
+    dependencies.add(stableId.server(this.foreignTable.server));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.foreignTable.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE FOREIGN TABLE"];
+
+    // Add schema and name
+    parts.push(`${this.foreignTable.schema}.${this.foreignTable.name}`);
+
+    // Add columns
+    const columnDefs: string[] = [];
+    for (const col of this.foreignTable.columns) {
+      const colParts: string[] = [col.name, col.data_type_str];
+      columnDefs.push(colParts.join(" "));
+    }
+    parts.push(`(${columnDefs.join(", ")})`);
+
+    // Add SERVER clause
+    parts.push("SERVER", this.foreignTable.server);
+
+    // Add OPTIONS clause (table-level)
+    if (this.foreignTable.options && this.foreignTable.options.length > 0) {
+      const optionPairs: string[] = [];
+      for (let i = 0; i < this.foreignTable.options.length; i += 2) {
+        if (i + 1 < this.foreignTable.options.length) {
+          optionPairs.push(
+            `${this.foreignTable.options[i]} ${quoteLiteral(this.foreignTable.options[i + 1])}`,
+          );
+        }
+      }
+      if (optionPairs.length > 0) {
+        parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+      }
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import { ForeignTable } from "../foreign-table.model.ts";
+import { DropForeignTable } from "./foreign-table.drop.ts";
+
+describe("foreign-table", () => {
+  test("drop", async () => {
+    const foreignTable = new ForeignTable({
+      schema: "public",
+      name: "test_table",
+      owner: "test",
+      server: "test_server",
+      options: null,
+      comment: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new DropForeignTable({
+      foreignTable,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP FOREIGN TABLE public.test_table");
+  });
+});

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

@@ -0,0 +1,37 @@
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { DropForeignTableChange } from "./foreign-table.base.ts";
+
+/**
+ * Drop a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FOREIGN TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropForeignTable extends DropForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly scope = "object" as const;
+
+  constructor(props: { foreignTable: ForeignTable }) {
+    super();
+    this.foreignTable = props.foreignTable;
+  }
+
+  get drops() {
+    return [this.foreignTable.stableId];
+  }
+
+  get requires() {
+    return [this.foreignTable.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "DROP FOREIGN TABLE",
+      `${this.foreignTable.schema}.${this.foreignTable.name}`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,181 @@
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../../base.privilege.ts";
+import { stableId } from "../../../utils.ts";
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { AlterForeignTableChange } from "./foreign-table.base.ts";
+
+export type ForeignTablePrivilege =
+  | GrantForeignTablePrivileges
+  | RevokeForeignTablePrivileges
+  | RevokeGrantOptionForeignTablePrivileges;
+
+/**
+ * Grant privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantForeignTablePrivileges extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.foreignTable.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.foreignTable.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(
+        "GrantForeignTablePrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN TABLE",
+      list,
+      this.version,
+    );
+    const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+    return `GRANT ${privSql} ${kindPrefix} ${tableName} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeForeignTablePrivileges extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get drops() {
+    return [stableId.acl(this.foreignTable.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.foreignTable.stableId, this.grantee),
+      this.foreignTable.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN TABLE",
+      list,
+      this.version,
+    );
+    const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+    return `REVOKE ${privSql} ${kindPrefix} ${tableName} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a foreign table.
+ *
+ * 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 RevokeGrantOptionForeignTablePrivileges extends AlterForeignTableChange {
+  public readonly foreignTable: ForeignTable;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    foreignTable: ForeignTable;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.foreignTable = props.foreignTable;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.foreignTable.stableId, this.grantee),
+      this.foreignTable.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+    const privSql = formatObjectPrivilegeList(
+      "FOREIGN TABLE",
+      this.privilegeNames,
+      this.version,
+    );
+    const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${tableName} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { AlterForeignTable } from "./foreign-table.alter.ts";
+import type { CommentForeignTable } from "./foreign-table.comment.ts";
+import type { CreateForeignTable } from "./foreign-table.create.ts";
+import type { DropForeignTable } from "./foreign-table.drop.ts";
+import type { ForeignTablePrivilege } from "./foreign-table.privilege.ts";
+
+/** Union of all foreign-table-related change variants (`objectType: "foreign_table"`). @category Change Types */
+export type ForeignTableChange =
+  | AlterForeignTable
+  | CommentForeignTable
+  | CreateForeignTable
+  | DropForeignTable
+  | ForeignTablePrivilege;