sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Planetscale/ Postgres/ PostgresRole.test.ts

import * as Planetscale from "@alchemy.run/planetscale";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as ps from "@distilled.cloud/planetscale";
import * as Provider from "alchemy/Provider";
import * as RemovalPolicy from "alchemy/RemovalPolicy";
import { Redacted } from "effect";
import * as Cause from "effect/Cause";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import { MinimumLogLevel } from "effect/References";
import * as Schedule from "effect/Schedule";

const { test } = Test.make({ providers: Planetscale.providers() });

const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");

describe
  .skipIf(!process.env.PLANETSCALE_TEST)
  .concurrent(
    "PostgresRole",
    { tags: ["provider:planetscale", "provider:planetscale:postgres", "live"] },
    () => {
      // Read-only: PARENT FAN-OUT enumeration (org -> databases -> branches ->
      // default role) against the live org, without provisioning anything.
      test.provider("list enumerates default roles (read-only)", () =>
        Effect.gen(function* () {
          const provider = yield* Provider.findProvider(Planetscale.PostgresDefaultRole);
          const all = yield* provider.list();

          expect(Array.isArray(all)).toBe(true);
          for (const r of all) {
            expect(r).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              organization: expect.any(String),
              database: expect.any(String),
              branch: expect.any(String),
              privateHost: expect.any(String),
              privateConnectionServiceName: expect.any(String),
            });
          }
        }).pipe(logLevel),
      );

      // Deploy-and-find coverage, opt-in only (slow provisioning).
      test.provider.skipIf(!process.env.PLANETSCALE_DEPLOY_TEST)(
        "list finds a freshly deployed default role",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, role } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("ListDb", {
                  name: "alchemy-pg-default-list",
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role = yield* Planetscale.PostgresDefaultRole("ListRole", {
                  database,
                  forceReset: true,
                });
                return { database, role };
              }),
            );

            const provider = yield* Provider.findProvider(Planetscale.PostgresDefaultRole);
            const all = yield* provider.list();

            expect(
              all.some(
                (r) =>
                  r.organization === database.organization &&
                  r.database === database.name &&
                  r.branch === role.branch,
              ),
            ).toBe(true);

            yield* stack.destroy();
            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      // Read-only: PARENT FAN-OUT enumeration (org -> databases -> branches ->
      // roles, excluding the default role) against the live org, without
      // provisioning anything.
      test.provider("list enumerates roles (read-only)", () =>
        Effect.gen(function* () {
          const provider = yield* Provider.findProvider(Planetscale.PostgresRole);
          const all = yield* provider.list();

          expect(Array.isArray(all)).toBe(true);
          for (const r of all) {
            expect(r).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              organization: expect.any(String),
              database: expect.any(String),
              branch: expect.any(String),
              privateHost: expect.any(String),
              privateConnectionServiceName: expect.any(String),
            });
          }
        }).pipe(logLevel),
      );

      // Deploy-and-find coverage, opt-in only (slow provisioning).
      test.provider.skipIf(!process.env.PLANETSCALE_DEPLOY_TEST)(
        "list finds a freshly deployed role",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, role } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("ListDb", {
                  name: "alchemy-pg-role-list",
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role = yield* Planetscale.PostgresRole("ListRole", {
                  database,
                  inheritedRoles: ["pg_read_all_data"],
                });
                return { database, role };
              }),
            );

            const provider = yield* Provider.findProvider(Planetscale.PostgresRole);
            const all = yield* provider.list();

            expect(
              all.some(
                (r) =>
                  r.organization === database.organization &&
                  r.database === database.name &&
                  r.id === role.id,
              ),
            ).toBe(true);

            yield* stack.destroy();
            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "default role - create, duplicate fails, forceReset returns new id",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            // First: create default role, expect success
            const { database, role1 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role1 = yield* Planetscale.PostgresDefaultRole("Role1", { database });

                return { role1, database };
              }),
            );

            expect(role1).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              host: expect.any(String),
              username: expect.any(String),
              password: expect.any(Object),
              databaseName: "postgres",
              branch: "main",
              organization: database.organization,
              privateHost: expect.any(String),
              privateConnectionServiceName: expect.any(String),
            });

            const defaultRoleFromApi = yield* ps.getDefaultRole({
              organization: database.organization,
              database: database.name,
              branch: "main",
            });
            expect(role1.privateConnectionServiceName).toEqual(
              defaultRoleFromApi.private_connection_service_name,
            );
            expect(role1.privateHost).toEqual(defaultRoleFromApi.private_access_host_url);

            // Second: create again without forceReset — should fail (default already exists)
            const exit = yield* stack
              .deploy(
                Effect.gen(function* () {
                  const database = yield* Planetscale.PostgresDatabase("Database", {
                    clusterSize: "PS_10",
                    arch: "arm",
                  });
                  const role2 = yield* Planetscale.PostgresDefaultRole("Role2", { database });

                  return { role2 };
                }),
              )
              .pipe(Effect.exit);

            expect(Exit.isFailure(exit)).toBe(true);

            if (Exit.isFailure(exit)) {
              expect(Cause.pretty(exit.cause)).toMatch(
                /Default role already exists.*Use forceReset/,
              );
            }

            // Third: create with forceReset — should succeed and return a different role id
            const { role3 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role3 = yield* Planetscale.PostgresDefaultRole("Role3", {
                  database,
                  forceReset: true,
                });

                return { role3, database };
              }),
            );

            expect(role3).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              host: expect.any(String),
              username: expect.any(String),
              password: expect.any(Object),
              databaseName: "postgres",
              branch: "main",
              organization: database.organization,
            });

            // the default role ID is the same, but the password is different
            expect(Redacted.value(role3.password)).not.toEqual(Redacted.value(role1.password));

            yield* stack.destroy();
            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "create and delete role",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            // Create a role
            const { database, role } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role = yield* Planetscale.PostgresRole("Role", {
                  database,
                  // Empty array means no permissions, which is fine for testing.
                  inheritedRoles: [],
                });

                return { database, role };
              }),
            );

            expect(role).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              host: expect.any(String),
              username: expect.any(String),
              password: expect.any(Object),
              privateHost: expect.any(String),
              privateConnectionServiceName: expect.any(String),
            });

            const roleFromApi = yield* ps.getRole({
              id: role.id,
              database: database.name,
              organization: database.organization,
              branch: "main",
            });
            expect(role.privateConnectionServiceName).toEqual(
              roleFromApi.private_connection_service_name,
            );
            expect(role.privateHost).toEqual(roleFromApi.private_access_host_url);

            // Update role with different ttl (should trigger replacement)
            const { updatedRole } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const updatedRole = yield* Planetscale.PostgresRole("Role", {
                  database,
                  ttl: 3600,
                  inheritedRoles: [],
                });

                return { database, updatedRole };
              }),
            );

            expect(role.id).not.toEqual(updatedRole.id);
            expect(updatedRole.ttl).toEqual(3600);

            const found = yield* ps
              .getRole({
                id: role.id,
                database: database.name,
                organization: database.organization,
                branch: "main",
              })
              .pipe(
                Effect.map(() => true),
                Effect.catchTag("NotFound", () => Effect.succeed(false)),
              );

            expect(found).toBe(false);

            const updatedRoleFromApi = yield* ps.getRole({
              id: updatedRole.id,
              database: database.name,
              organization: database.organization,
              branch: "main",
            });

            expect(updatedRoleFromApi.ttl).toEqual(3600);

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      // Regression (#1832): `--force` upgrades the unchanged database's noop
      // to an update. Its conditional `name` stable must survive, or the
      // role sees `database.name === undefined`, plans a replacement and
      // rotates its credentials on every forced deploy.
      test.provider(
        "forced redeploy keeps the role (no replacement, credentials unchanged)",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const program = Effect.gen(function* () {
              const database = yield* Planetscale.PostgresDatabase("Database", {
                clusterSize: "PS_10",
                arch: "arm",
              });
              const role = yield* Planetscale.PostgresRole("RoleForce", {
                database,
                inheritedRoles: ["pg_read_all_data"],
              });
              return { database, role };
            });

            const { database, role } = yield* stack.deploy(program);
            const { role: forced } = yield* stack.deploy(program, { force: true });

            expect(forced.id).toEqual(role.id);
            expect(forced.name).toEqual(role.name);
            expect(forced.username).toEqual(role.username);
            expect(Redacted.value(forced.password)).toEqual(Redacted.value(role.password));

            // Out-of-band: the original role still exists and is the only
            // non-default role on the branch (no replacement was created).
            const live = yield* ps.getRole({
              id: role.id,
              database: database.name,
              organization: database.organization,
              branch: "main",
            });
            expect(live.id).toEqual(role.id);
            const roles = yield* ps.listRoles({
              database: database.name,
              organization: database.organization,
              branch: "main",
            });
            expect(roles.data.filter((r) => !r.default).map((r) => r.id)).toEqual([role.id]);

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "role with replication is created with the attribute and replaced when it changes",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, role1 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role1 = yield* Planetscale.PostgresRole("RoleReplication", {
                  database,
                  inheritedRoles: ["postgres"],
                  withReplication: true,
                });

                return { database, role1 };
              }),
            );

            expect(role1).toMatchObject({
              id: expect.any(String),
              inheritedRoles: ["postgres"],
              withReplication: true,
            });

            const { role2 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role2 = yield* Planetscale.PostgresRole("RoleReplication", {
                  database,
                  inheritedRoles: ["postgres"],
                });

                return { role2 };
              }),
            );

            expect(role2).toMatchObject({ withReplication: false });
            expect(role2.id).not.toEqual(role1.id);

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "role gets replaced when properties change",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, role1 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role1 = yield* Planetscale.PostgresRole("RoleReplace", {
                  database: database,
                  inheritedRoles: ["pg_read_all_data"],
                  ttl: 3600,
                });

                return { database, role1 };
              }),
            );

            expect(role1).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              inheritedRoles: ["pg_read_all_data"],
            });

            const originalId = role1.id;
            const originalName = role1.name;

            const { role2 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role2 = yield* Planetscale.PostgresRole("RoleReplace", {
                  database: database,
                  inheritedRoles: ["postgres"],
                  ttl: 7200,
                });

                return { role2 };
              }),
            );

            expect(role2).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              inheritedRoles: ["postgres"],
            });

            expect(role2.id).not.toEqual(originalId);
            expect(role2.name).not.toEqual(originalName);

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "role with RemovalPolicy.retain(true) should not be deleted via API",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { organization } = yield* yield* Planetscale.Credentials;

            const { database, role } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                }).pipe(RemovalPolicy.retain(true));
                const role = yield* Planetscale.PostgresRole("RoleRetainRemoval", {
                  database,
                  inheritedRoles: ["postgres"],
                }).pipe(RemovalPolicy.retain(true));

                return { database, role };
              }),
            );

            expect(role).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              database: database.name,
              inheritedRoles: ["postgres"],
            });

            yield* stack.destroy();

            const liveRole = yield* ps
              .getRole({ organization, database: database.name, branch: "main", id: role.id })
              .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));

            expect(liveRole).toBeDefined();
            expect(liveRole?.id).toEqual(role.id);

            // deleting the db takes care of deleting the role
            yield* ps
              .deleteDatabase({ organization, database: database.name })
              .pipe(Effect.catchTag("NotFound", () => Effect.void));

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "role update: successor is updatable without replacement",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, role1 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role1 = yield* Planetscale.PostgresRole("RoleSuccessor", {
                  database,
                  inheritedRoles: ["postgres"],
                  successor: "postgres",
                });

                return { database, role1 };
              }),
            );

            expect(role1).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              successor: "postgres",
            });

            const originalId = role1.id;

            const { role2 } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });
                const role2 = yield* Planetscale.PostgresRole("RoleSuccessor", {
                  database,
                  inheritedRoles: ["postgres"],
                  successor: "pg_read_all_data",
                });

                return { role2 };
              }),
            );

            expect(role2).toMatchObject({ id: originalId, successor: "pg_read_all_data" });

            expect(role2.id).toEqual(originalId);

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );

      test.provider(
        "role with custom branch",
        (stack) =>
          Effect.gen(function* () {
            yield* stack.destroy();

            const { database, branch, role } = yield* stack.deploy(
              Effect.gen(function* () {
                const database = yield* Planetscale.PostgresDatabase("Database", {
                  clusterSize: "PS_10",
                  arch: "arm",
                });

                const branch = yield* Planetscale.PostgresBranch("CustomBranch", { database });

                const role = yield* Planetscale.PostgresRole("RoleCustomBranch", {
                  database,
                  branch,
                  inheritedRoles: ["postgres"],
                });

                return { database, branch, role };
              }),
            );

            expect(role).toMatchObject({
              id: expect.any(String),
              name: expect.any(String),
              database: database.name,
              branch: branch.name,
              inheritedRoles: ["postgres"],
            });

            yield* stack.destroy();

            yield* waitForDatabaseToBeDeleted(database.name, database.organization);
          }).pipe(logLevel),
        5_000_000,
      );
    },
  );
const waitForDatabaseToBeDeleted = Effect.fn(function* (database: string, organization: string) {
  yield* ps.getDatabase({ organization, database }).pipe(
    Effect.flatMap(() => Effect.fail(new DatabaseStillExists())),
    Effect.retry({
      while: (e): e is DatabaseStillExists => e instanceof DatabaseStillExists,
      schedule: Schedule.exponential(100),
    }),
    Effect.catchTag("NotFound", () => Effect.void),
  );
});

class DatabaseStillExists extends Data.TaggedError("DatabaseStillExists") {}