sailfork / t3code-github / .repos/ alchemy-effect/ packages/ alchemy/ test/ Local/ RpcProvider.test.ts

import { describe, expect, it } from "@alchemy.run/test";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import { AlchemyContext } from "@/AlchemyContext.ts";
import * as Artifacts from "@/Artifacts.ts";
import * as RpcProvider from "@/Local/RpcProvider.ts";
import type { ProviderService } from "@/Provider.ts";
import { Resource } from "@/Resource.ts";
import { ResourceContext } from "@/ResourceContext.ts";
import { Stack, type StackSpec } from "@/Stack.ts";
import { Stage } from "@/Stage.ts";

interface TestResource extends Resource<
  "Local.RpcProvider.Test",
  {},
  { ok: boolean; artifact: string }
> {}
const TestResource = Resource<TestResource>("Local.RpcProvider.Test");

type StackShape = Omit<StackSpec, "output">;

interface Capture {
  stack?: StackShape;
  stage?: string;
  resource?: ResourceContext["Service"];
  artifact?: string;
}

const defaultStack: StackShape = {
  name: "default-stack",
  stage: "default-stage",
  resources: {},
  bindings: {},
  actions: {},
};

describe("Local.RpcProvider.effect", { tags: ["unit", "local"] }, () => {
  it.effect("provides default Stack, Stage, and ResourceContext to lifecycle effects", () =>
    Effect.gen(function* () {
      const [capture, result] = yield* useProvider((provider) =>
        provider.reconcile({
          id: "r",
          fqn: "r",
          instanceId: "inst-from-arg",
          news: {},
          olds: undefined,
          output: undefined,
          session: undefined as any,
          bindings: [],
        }),
      );
      expect(result).toMatchObject({ ok: true });
      expect(capture.stack).toBe(defaultStack);
      expect(capture.stage).toBe(defaultStack.stage);
      expect(capture.resource).toEqual({
        logicalId: "r",
        fqn: "r",
        instanceId: "inst-from-arg",
        type: "Local.RpcProvider.Test",
      });
    }),
  );

  it.effect("does not override Stack, Stage, or ResourceContext when already provided", () =>
    Effect.gen(function* () {
      const overrideStack: StackShape = {
        name: "override-stack",
        stage: "ignored-stage-on-stack",
        resources: {},
        bindings: {},
        actions: {},
      };
      const overrideResource: ResourceContext["Service"] = {
        logicalId: "override",
        fqn: "Override/override",
        instanceId: "override-instance-id",
        type: "Override.Type",
      };
      const [capture] = yield* useProvider((provider) =>
        provider
          .reconcile({
            id: "r",
            fqn: "r",
            instanceId: "inst-from-arg",
            news: {},
            olds: undefined,
            output: undefined,
            session: undefined as any,
            bindings: [],
          })
          .pipe(
            Effect.provide([
              Layer.succeed(Stack, overrideStack),
              Layer.succeed(Stage, "override-stage"),
              Layer.succeed(ResourceContext, overrideResource),
            ]),
          ),
      );
      expect(capture.stack).toBe(overrideStack);
      expect(capture.stage).toBe("override-stage");
      expect(capture.resource).toBe(overrideResource);
    }),
  );

  it.effect("provides defaults to Stream-returning lifecycle methods", () =>
    Effect.gen(function* () {
      const [capture, items] = yield* useProvider((provider) =>
        provider.tail!({
          id: "r",
          fqn: "r",
          instanceId: "inst-from-arg",
          props: {},
          output: { ok: true, artifact: "artifact" },
        }).pipe(Stream.runCollect),
      );
      expect(items.length).toBe(1);
      expect(capture.stack).toBe(defaultStack);
      expect(capture.stage).toBe(defaultStack.stage);
      expect(capture.resource).toEqual({
        logicalId: "r",
        fqn: "r",
        instanceId: "inst-from-arg",
        type: "Local.RpcProvider.Test",
      });
    }),
  );

  it.effect("omits ResourceContext fallback when input has no instanceId", () =>
    Effect.gen(function* () {
      const [capture, exit] = yield* useProvider((provider) =>
        provider
          .reconcile({
            id: "r",
            fqn: "r",
            news: {},
            olds: undefined,
            output: undefined,
            session: undefined!,
            instanceId: undefined!,
            bindings: [],
          })
          .pipe(Effect.exit),
      );
      expect(exit._tag).toBe("Failure");
      expect(capture.stack).toBe(defaultStack);
      expect(capture.stage).toBe(defaultStack.stage);
      expect(capture.resource).toBeUndefined();
    }),
  );

  it.effect("caches artifacts", () =>
    Effect.gen(function* () {
      const [capture, result] = yield* useProvider((provider) =>
        provider.diff!({
          id: "r",
          fqn: "r",
          news: {},
          olds: undefined,
          output: undefined,
          oldBindings: [],
          newBindings: [],
          instanceId: "inst-from-arg",
        }).pipe(
          Effect.andThen(
            Effect.all({
              sameInstanceId: provider.reconcile({
                id: "r",
                fqn: "r",
                instanceId: "inst-from-arg",
                news: {},
                olds: undefined,
                output: undefined,
                session: undefined as any,
                bindings: [],
              }),
              differentInstanceId: provider.reconcile({
                id: "r",
                fqn: "r",
                instanceId: "inst-from-arg-2",
                news: {},
                olds: undefined,
                output: undefined,
                session: undefined as any,
                bindings: [],
              }),
            }),
          ),
        ),
      );
      expect(capture.artifact).toBeDefined();
      expect(result.sameInstanceId.artifact).toBeDefined();
      expect(result.differentInstanceId.artifact).toBeDefined();
      expect(capture.artifact).toBe(result.sameInstanceId.artifact);
      expect(capture.artifact).not.toBe(result.differentInstanceId.artifact);
    }),
  );
});

const artifact = Effect.sync(() => crypto.randomUUID()).pipe(Artifacts.cached("artifact"));

const TestResourceProvider = (capture: Capture) =>
  RpcProvider.effect(
    TestResource,
    "ignored://entry",
    Effect.succeed({
      diff: Effect.fn(function* () {
        capture.artifact = yield* artifact;
      }),
      reconcile: Effect.fn(function* (_input: any) {
        capture.stack = yield* Stack;
        capture.stage = yield* Stage;
        capture.resource = yield* ResourceContext;
        return { ok: true, artifact: yield* artifact };
      }),
      tail: (_input: any) =>
        Stream.fromEffect(
          Effect.gen(function* () {
            capture.stack = yield* Stack;
            capture.stage = yield* Stage;
            capture.resource = yield* ResourceContext;
            return { timestamp: new Date(0), message: "ok" };
          }),
        ),
      delete: Effect.fn(function* () {}),
    }),
  );

const useProvider = <A, E, R>(
  callback: (provider: ProviderService<TestResource>) => Effect.Effect<A, E, R>,
) => {
  const capture: Capture = {};
  return TestResource.Provider.pipe(
    Effect.flatMap(callback),
    Effect.map((result) => [capture, result] as const),
    Effect.provide(
      Layer.provide(
        TestResourceProvider(capture),
        Layer.mergeAll(
          Layer.succeed(Stack, defaultStack),
          Layer.succeed(Stage, defaultStack.stage),
          Layer.sync(Artifacts.ArtifactStore, Artifacts.createArtifactStore),
          Layer.succeed(AlchemyContext, { dotAlchemy: "/tmp/.alchemy", dev: false, adopt: false }),
        ),
      ),
    ),
  );
};