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

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

@@ -0,0 +1,133 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../../base.privilege-diff.ts";
+
+/**
+ * All properties exposed by CREATE SERVER statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createserver.html
+ *
+ * ALTER SERVER statement can be generated for changes to the following properties:
+ *  - owner, type, version, options
+ * https://www.postgresql.org/docs/17/sql-alterserver.html
+ *
+ * Servers are not schema-qualified (no schema property).
+ */
+const serverPropsSchema = z.object({
+  name: z.string(),
+  owner: z.string(),
+  foreign_data_wrapper: z.string(),
+  type: z.string().nullable(),
+  version: z.string().nullable(),
+  options: z.array(z.string()).nullable(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type ServerPrivilegeProps = PrivilegeProps;
+export type ServerProps = z.infer<typeof serverPropsSchema>;
+
+export class Server extends BasePgModel {
+  public readonly name: ServerProps["name"];
+  public readonly owner: ServerProps["owner"];
+  public readonly foreign_data_wrapper: ServerProps["foreign_data_wrapper"];
+  public readonly type: ServerProps["type"];
+  public readonly version: ServerProps["version"];
+  public readonly options: ServerProps["options"];
+  public readonly comment: ServerProps["comment"];
+  public readonly privileges: ServerPrivilegeProps[];
+
+  constructor(props: ServerProps) {
+    super();
+
+    // Identity fields
+    this.name = props.name;
+
+    // Data fields
+    this.owner = props.owner;
+    this.foreign_data_wrapper = props.foreign_data_wrapper;
+    this.type = props.type;
+    this.version = props.version;
+    this.options = props.options;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `server:${string}` {
+    return `server:${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      owner: this.owner,
+      foreign_data_wrapper: this.foreign_data_wrapper,
+      type: this.type,
+      version: this.version,
+      options: this.options,
+      comment: this.comment,
+      privileges: this.privileges,
+    };
+  }
+}
+
+export async function extractServers(pool: Pool): Promise<Server[]> {
+  const { rows: serverRows } = await pool.query<ServerProps>(sql`
+      select
+        quote_ident(srv.srvname) as name,
+        srv.srvowner::regrole::text as owner,
+        quote_ident(fdw.fdwname) as foreign_data_wrapper,
+        srv.srvtype as type,
+        srv.srvversion as version,
+        coalesce(srv.srvoptions, array[]::text[]) as options,
+        obj_description(srv.oid, 'pg_foreign_server') as comment,
+        coalesce(
+          (
+            select json_agg(
+              json_build_object(
+                'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+                'privilege', x.privilege_type,
+                'grantable', x.is_grantable
+              )
+              order by x.grantee, x.privilege_type
+            )
+            from lateral aclexplode(srv.srvacl) as x(grantor, grantee, privilege_type, is_grantable)
+          ), '[]'
+        ) as privileges
+      from
+        pg_catalog.pg_foreign_server srv
+        inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+      where
+        not fdw.fdwname like any(array['pg\\_%'])
+      order by
+        srv.srvname
+  `);
+
+  // Validate and parse each row using the Zod schema
+  const validatedRows = serverRows.map((row: unknown) => {
+    const parsed = serverPropsSchema.parse(row);
+    // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+    if (parsed.options && parsed.options.length > 0) {
+      const parsedOptions: string[] = [];
+      for (const opt of parsed.options) {
+        const eqIndex = opt.indexOf("=");
+        if (eqIndex > 0) {
+          parsedOptions.push(opt.substring(0, eqIndex));
+          parsedOptions.push(opt.substring(eqIndex + 1));
+        }
+      }
+      parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+    }
+    return parsed;
+  });
+  return validatedRows.map((row: ServerProps) => new Server(row));
+}

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

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import { UserMapping, type UserMappingProps } from "../user-mapping.model.ts";
+import { AlterUserMappingSetOptions } from "./user-mapping.alter.ts";
+
+describe.concurrent("user-mapping", () => {
+  describe("alter", () => {
+    test("set options ADD", () => {
+      const props: UserMappingProps = {
+        user: "test_user",
+        server: "test_server",
+        options: null,
+      };
+      const userMapping = new UserMapping(props);
+      const change = new AlterUserMappingSetOptions({
+        userMapping,
+        options: [
+          { action: "ADD", option: "user", value: "remote_user" },
+          { action: "ADD", option: "password", value: "secret" },
+        ],
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (ADD user 'remote_user', ADD password 'secret')",
+      );
+    });
+
+    test("set options SET", () => {
+      const props: UserMappingProps = {
+        user: "test_user",
+        server: "test_server",
+        options: null,
+      };
+      const userMapping = new UserMapping(props);
+      const change = new AlterUserMappingSetOptions({
+        userMapping,
+        options: [{ action: "SET", option: "password", value: "new_secret" }],
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (SET password 'new_secret')",
+      );
+    });
+
+    test("set options DROP", () => {
+      const props: UserMappingProps = {
+        user: "test_user",
+        server: "test_server",
+        options: null,
+      };
+      const userMapping = new UserMapping(props);
+      const change = new AlterUserMappingSetOptions({
+        userMapping,
+        options: [{ action: "DROP", option: "password" }],
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER USER MAPPING FOR test_user SERVER test_server OPTIONS (DROP password)",
+      );
+    });
+
+    test("set options mixed ADD/SET/DROP", () => {
+      const props: UserMappingProps = {
+        user: "PUBLIC",
+        server: "test_server",
+        options: null,
+      };
+      const userMapping = new UserMapping(props);
+      const change = new AlterUserMappingSetOptions({
+        userMapping,
+        options: [
+          { action: "ADD", option: "new_option", value: "new_value" },
+          { action: "SET", option: "existing_option", value: "updated_value" },
+          { action: "DROP", option: "old_option" },
+        ],
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER USER MAPPING FOR PUBLIC SERVER test_server OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,69 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import type { UserMapping } from "../user-mapping.model.ts";
+import { AlterUserMappingChange } from "./user-mapping.base.ts";
+
+/**
+ * Alter a user mapping.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterusermapping.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER USER MAPPING FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC | SESSION_USER }
+ *     SERVER server_name
+ *     OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+ * ```
+ */
+
+export type AlterUserMapping = AlterUserMappingSetOptions;
+
+/**
+ * ALTER USER MAPPING ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterUserMappingSetOptions extends AlterUserMappingChange {
+  public readonly userMapping: UserMapping;
+  public readonly options: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }>;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    userMapping: UserMapping;
+    options: Array<{
+      action: "ADD" | "SET" | "DROP";
+      option: string;
+      value?: string;
+    }>;
+  }) {
+    super();
+    this.userMapping = props.userMapping;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.userMapping.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 USER MAPPING FOR",
+      this.userMapping.user,
+      "SERVER",
+      this.userMapping.server,
+      "OPTIONS",
+      `(${optionParts.join(", ")})`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { UserMapping } from "../user-mapping.model.ts";
+
+abstract class BaseUserMappingChange extends BaseChange {
+  abstract readonly userMapping: UserMapping;
+  abstract readonly scope: "object";
+  readonly objectType: "user_mapping" = "user_mapping";
+}
+
+export abstract class CreateUserMappingChange extends BaseUserMappingChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterUserMappingChange extends BaseUserMappingChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropUserMappingChange extends BaseUserMappingChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,85 @@
+import { describe, expect, test } from "bun:test";
+import { UserMapping } from "../user-mapping.model.ts";
+import { CreateUserMapping } from "./user-mapping.create.ts";
+
+describe("user-mapping", () => {
+  test("create basic", () => {
+    const userMapping = new UserMapping({
+      user: "test_user",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new CreateUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE USER MAPPING FOR test_user SERVER test_server",
+    );
+  });
+
+  test("create with PUBLIC user", () => {
+    const userMapping = new UserMapping({
+      user: "PUBLIC",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new CreateUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE USER MAPPING FOR PUBLIC SERVER test_server",
+    );
+  });
+
+  test("create with CURRENT_USER", () => {
+    const userMapping = new UserMapping({
+      user: "CURRENT_USER",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new CreateUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE USER MAPPING FOR CURRENT_USER SERVER test_server",
+    );
+  });
+
+  test("create with options", () => {
+    const userMapping = new UserMapping({
+      user: "test_user",
+      server: "test_server",
+      options: ["user", "remote_user", "password", "secret"],
+    });
+
+    const change = new CreateUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE USER MAPPING FOR test_user SERVER test_server OPTIONS (user 'remote_user', password 'secret')",
+    );
+  });
+
+  test("create with all properties", () => {
+    const userMapping = new UserMapping({
+      user: "PUBLIC",
+      server: "test_server",
+      options: ["user", "remote_user", "password", "secret"],
+    });
+
+    const change = new CreateUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE USER MAPPING FOR PUBLIC SERVER test_server OPTIONS (user 'remote_user', password 'secret')",
+    );
+  });
+});

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

@@ -0,0 +1,66 @@
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+import type { UserMapping } from "../user-mapping.model.ts";
+import { CreateUserMappingChange } from "./user-mapping.base.ts";
+
+/**
+ * Create a user mapping.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createusermapping.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE USER MAPPING [ IF NOT EXISTS ] FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC | SESSION_USER }
+ *     SERVER server_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateUserMapping extends CreateUserMappingChange {
+  public readonly userMapping: UserMapping;
+  public readonly scope = "object" as const;
+
+  constructor(props: { userMapping: UserMapping }) {
+    super();
+    this.userMapping = props.userMapping;
+  }
+
+  get creates() {
+    return [this.userMapping.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Server dependency
+    dependencies.add(stableId.server(this.userMapping.server));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE USER MAPPING FOR"];
+
+    // Add user (can be CURRENT_USER, PUBLIC, etc.)
+    parts.push(this.userMapping.user);
+
+    // Add SERVER clause
+    parts.push("SERVER", this.userMapping.server);
+
+    // Add OPTIONS clause
+    if (this.userMapping.options && this.userMapping.options.length > 0) {
+      const optionPairs: string[] = [];
+      for (let i = 0; i < this.userMapping.options.length; i += 2) {
+        if (i + 1 < this.userMapping.options.length) {
+          optionPairs.push(
+            `${this.userMapping.options[i]} ${quoteLiteral(this.userMapping.options[i + 1])}`,
+          );
+        }
+      }
+      if (optionPairs.length > 0) {
+        parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+      }
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { UserMapping } from "../user-mapping.model.ts";
+import { DropUserMapping } from "./user-mapping.drop.ts";
+
+describe("user-mapping", () => {
+  test("drop", () => {
+    const userMapping = new UserMapping({
+      user: "test_user",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new DropUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "DROP USER MAPPING FOR test_user SERVER test_server",
+    );
+  });
+
+  test("drop PUBLIC user mapping", () => {
+    const userMapping = new UserMapping({
+      user: "PUBLIC",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new DropUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "DROP USER MAPPING FOR PUBLIC SERVER test_server",
+    );
+  });
+
+  test("drop CURRENT_USER mapping", () => {
+    const userMapping = new UserMapping({
+      user: "CURRENT_USER",
+      server: "test_server",
+      options: null,
+    });
+
+    const change = new DropUserMapping({
+      userMapping,
+    });
+
+    expect(change.serialize()).toBe(
+      "DROP USER MAPPING FOR CURRENT_USER SERVER test_server",
+    );
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { UserMapping } from "../user-mapping.model.ts";
+import { DropUserMappingChange } from "./user-mapping.base.ts";
+
+/**
+ * Drop a user mapping.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropusermapping.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP USER MAPPING [ IF EXISTS ] FOR { user_name | USER | CURRENT_ROLE | CURRENT_USER | PUBLIC | SESSION_USER }
+ *     SERVER server_name
+ * ```
+ */
+export class DropUserMapping extends DropUserMappingChange {
+  public readonly userMapping: UserMapping;
+  public readonly scope = "object" as const;
+
+  constructor(props: { userMapping: UserMapping }) {
+    super();
+    this.userMapping = props.userMapping;
+  }
+
+  get drops() {
+    return [this.userMapping.stableId];
+  }
+
+  get requires() {
+    return [this.userMapping.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "DROP USER MAPPING FOR",
+      this.userMapping.user,
+      "SERVER",
+      this.userMapping.server,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { AlterUserMapping } from "./user-mapping.alter.ts";
+import type { CreateUserMapping } from "./user-mapping.create.ts";
+import type { DropUserMapping } from "./user-mapping.drop.ts";
+
+export type UserMappingChange =
+  | AlterUserMapping
+  | CreateUserMapping
+  | DropUserMapping;

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

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { AlterUserMappingSetOptions } from "./changes/user-mapping.alter.ts";
+import { CreateUserMapping } from "./changes/user-mapping.create.ts";
+import { DropUserMapping } from "./changes/user-mapping.drop.ts";
+import { diffUserMappings } from "./user-mapping.diff.ts";
+import { UserMapping, type UserMappingProps } from "./user-mapping.model.ts";
+
+describe.concurrent("user-mapping.diff", () => {
+  test("create and drop", () => {
+    const props: UserMappingProps = {
+      user: "u1",
+      server: "srv1",
+      options: null,
+    };
+    const mapping = new UserMapping(props);
+
+    const created = diffUserMappings({}, { [mapping.stableId]: mapping });
+    expect(created[0]).toBeInstanceOf(CreateUserMapping);
+
+    const dropped = diffUserMappings({ [mapping.stableId]: mapping }, {});
+    expect(dropped[0]).toBeInstanceOf(DropUserMapping);
+  });
+
+  test("alter: options changes", () => {
+    // With the simplified approach, SET actions are filtered out, but ADD actions are not.
+    // Adding a new option (password) should generate an ALTER statement.
+    const main = new UserMapping({
+      user: "u1",
+      server: "srv1",
+      options: ["user", "remote_user"],
+    });
+    const branch = new UserMapping({
+      user: "u1",
+      server: "srv1",
+      options: ["user", "remote_user", "password", "secret"],
+    });
+
+    const changes = diffUserMappings(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    // ADD actions are not filtered, so ALTER should be generated
+    const optionsChange = changes.find(
+      (c) => c instanceof AlterUserMappingSetOptions,
+    ) as AlterUserMappingSetOptions | undefined;
+    expect(optionsChange).toBeDefined();
+    expect(optionsChange?.options).toEqual([
+      { action: "ADD", option: "password", value: "secret" },
+    ]);
+  });
+
+  test("create with PUBLIC user", () => {
+    const mapping = new UserMapping({
+      user: "PUBLIC",
+      server: "srv1",
+      options: null,
+    });
+
+    const created = diffUserMappings({}, { [mapping.stableId]: mapping });
+    expect(created[0]).toBeInstanceOf(CreateUserMapping);
+    expect((created[0] as CreateUserMapping).userMapping.user).toBe("PUBLIC");
+  });
+
+  test("create with CURRENT_USER", () => {
+    const mapping = new UserMapping({
+      user: "CURRENT_USER",
+      server: "srv1",
+      options: null,
+    });
+
+    const created = diffUserMappings({}, { [mapping.stableId]: mapping });
+    expect(created[0]).toBeInstanceOf(CreateUserMapping);
+    expect((created[0] as CreateUserMapping).userMapping.user).toBe(
+      "CURRENT_USER",
+    );
+  });
+});