sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Neon/ Providers.test.ts

import * as Neon from "@alchemy.run/neon";
import { Credentials } from "@alchemy.run/neon/Credentials";
import { Project } from "@alchemy.run/neon/Project";
import { expect, it } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as SDK from "@distilled.cloud/neon";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { AlchemyContext } from "alchemy/AlchemyContext";
import { ArtifactStore, createArtifactStore } from "alchemy/Artifacts";
import { AuthProvidersLive } from "alchemy/Auth/AuthProvider";
import * as Interaction from "alchemy/Interaction";
import { Stack } from "alchemy/Stack";
import { Stage } from "alchemy/Stage";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";
import { v4 as uuidv4 } from "uuid";

// Fresh providers rebuild on every deploy, re-registering the Neon auth
// provider under that deploy's ConfigProvider.
const { test } = Test.make({ providers: Layer.fresh(Neon.providers()) });

it.live(
  "resolving Neon credentials rejects an unknown explicit profile",
  () =>
    Effect.gen(function* () {
      const result = yield* Effect.result(
        Effect.sandbox(
          Effect.gen(function* () {
            return yield* yield* Credentials;
          }).pipe(Effect.provide(Neon.providers())),
        ),
      );
      expect(Result.isFailure(result)).toBe(true);
      if (Result.isFailure(result)) {
        expect(String(result.failure)).toContain("does not exist");
        expect(String(result.failure)).toContain("alchemy profile create");
      }
    }).pipe(
      Effect.provide(
        Layer.mergeAll(
          AuthProvidersLive,
          Layer.succeed(Stage, "test"),
          Layer.succeed(Stack, {
            name: "test",
            stage: "test",
            resources: {},
            bindings: {},
            actions: {},
          }),
          Layer.succeed(AlchemyContext, { dev: false, adopt: false, dotAlchemy: ".alchemy" }),
          Layer.succeed(
            ConfigProvider.ConfigProvider,
            ConfigProvider.fromUnknown({ ALCHEMY_PROFILE: `non-existent-${uuidv4()}` }),
          ),
          Layer.sync(ArtifactStore, createArtifactStore),
          NodeServices.layer,
          FetchHttpClient.layer,
          Interaction.layerNonInteractive(),
        ),
      ),
    ),
  { tags: ["unit", "provider:neon", "local"] },
);

test.provider(
  "credentials resolve through their own ConfigProvider after a deploy under another",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      // The profile's key, re-exposed as the CI environment variable.
      const { apiKey } = yield* yield* Credentials;
      const profileOnly = yield* ConfigProvider.ConfigProvider;
      const withEnvironmentKey = ConfigProvider.orElse(
        ConfigProvider.fromUnknown({ NEON_API_KEY: Redacted.value(apiKey) }),
        profileOnly,
      );
      const { project } = yield* Effect.gen(function* () {
        // Built under `NEON_API_KEY`, resolved only after the deploy below
        // has rebuilt (and re-registered) the Neon providers without it.
        const credentials = yield* Credentials;
        const deployed = yield* stack
          .deploy(
            Effect.gen(function* () {
              const project = yield* Project("ConfigProviderProject", {
                region: "aws-us-east-2",
              });
              return { project };
            }),
          )
          .pipe(Effect.provideService(ConfigProvider.ConfigProvider, profileOnly));
        expect(Redacted.value((yield* credentials).apiKey)).toBe(Redacted.value(apiKey));
        const observed = yield* SDK.getProject({ project_id: deployed.project.projectId });
        expect(observed.project.id).toBe(deployed.project.projectId);
        return deployed;
      }).pipe(
        Effect.provide(Layer.fresh(Neon.providers())),
        Effect.provideService(ConfigProvider.ConfigProvider, withEnvironmentKey),
      );

      yield* stack.destroy();
      const gone = yield* SDK.getProject({ project_id: project.projectId }).pipe(
        Effect.as(false),
        Effect.catchTag("NotFound", () => Effect.succeed(true)),
      );
      expect(gone).toBe(true);
    }),
  { tags: ["provider:neon", "provider:neon:project", "live"], timeout: 120_000 },
);