sailfork / t3code-github / .repos/ alchemy-effect/ packages/ frontend-frameworks/ src/ vinext/ test/ aws.test.ts

import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as ChildProcess from "effect/process/ChildProcess";
import { ChildProcessSpawner } from "effect/process/ChildProcessSpawner";
import { describe, expect, it } from "vitest";
import {
  LAMBDA_ADAPTER_FILE_NAME,
  SERVE_ENTRY_NAME,
  makeAwsTarget,
  makeLambdaEntrySource,
  target,
} from "../aws.ts";
import { loadPrerenderPairs, seedStoreFromPrerender } from "../cache/seed.ts";

describe("makeAwsTarget", () => {
  it(
    "renders from an isolated Lambda directory without project dependencies",
    () =>
      Effect.runPromise(
        Effect.scoped(
          Effect.gen(function* () {
            const fs = yield* FileSystem.FileSystem;
            const path = yield* Path.Path;
            const root = yield* path.fromFileUrl(
              new URL("../../../../../examples/aws-website-vinext/", import.meta.url),
            );
            const configPath = path.join(root, "vite.config.ts");
            const configBefore = yield* fs.readFileString(configPath);
            expect(configBefore).not.toContain("@alchemy.run/frontend-frameworks");
            const built = yield* makeAwsTarget({ streaming: false }).build!({
              root,
              framework: "vinext",
            });
            expect(yield* fs.readFileString(configPath)).toBe(configBefore);
            expect(
              yield* fs.readFileString(path.join(built.distDirectory!, "server/index.js")),
            ).toContain("CACHE_BUCKET_NAME");
            const directory = yield* fs.makeTempDirectoryScoped({
              prefix: "vinext-lambda-",
            });
            yield* fs.copy(path.join(built.distDirectory!, "server"), directory);
            const prerender = yield* Effect.promise(() => loadPrerenderPairs(directory));
            expect(prerender.routeCount).toBeGreaterThan(0);
            expect(prerender.pairs.some((pair) => pair.key.includes("/isr"))).toBe(true);
            const values = new Map<string, string>();
            const store = {
              getText: (key: string) => Effect.runPromise(Effect.sync(() => values.get(key))),
              putText: (key: string, value: string) =>
                Effect.runPromise(
                  Effect.sync(() => {
                    values.set(key, value);
                  }),
                ),
              delete: (key: string) =>
                Effect.runPromise(
                  Effect.sync(() => {
                    values.delete(key);
                  }),
                ),
            };
            yield* Effect.promise(() => seedStoreFromPrerender(store, directory));
            const key = prerender.pairs[0]!.key;
            values.set(key, "refreshed at runtime");
            yield* Effect.promise(() => seedStoreFromPrerender(store, directory));
            expect(values.get(key)).toBe("refreshed at runtime");
            const spawner = yield* ChildProcessSpawner;
            const node = yield* Effect.sync(() => process.execPath);
            const child = yield* spawner.spawn(
              ChildProcess.make(
                node,
                [
                  "--input-type=module",
                  "--eval",
                  `
        import assert from "node:assert/strict";
        import { handler } from "./serve-aws-lambda.mjs";
        for (const route of ["/", "/isr", "/api/hello"]) {
          const response = await handler({ rawPath: route, rawQueryString: "name=Alchemy", requestContext: { domainName: "localhost", http: { method: "GET" } } });
          assert.equal(response.statusCode, 200);
          assert.ok(response.body.length > 0);
          if (route === "/") assert.match(response.body, /vinext on AWS/);
          if (route === "/api/hello") assert.equal(JSON.parse(response.body).greeting, "isolated Lambda");
        }
      `,
                ],
                {
                  cwd: directory,
                  env: { GREETING: "isolated Lambda" },
                  stdout: "inherit",
                  stderr: "inherit",
                },
              ),
            );
            expect(yield* child.exitCode).toBe(0);
          }),
        ).pipe(Effect.provide(NodeServices.layer)),
      ),
    120_000,
  );
  it("declares the aws platform and a wholesale vinext build (not OpenNext)", () => {
    const aws = makeAwsTarget();
    expect(aws.platform).toBe("aws");
    expect(aws.build).toBeTypeOf("function");
    expect(aws.bundle?.conditions).toContain("node");
    expect(aws.bundle?.external).toContain("@aws-sdk/");
    expect(aws.bundle?.external ?? []).not.toContain("cloudflare:");
  });

  it("wraps the App Router fetch handler as a streaming Lambda handler", () => {
    const source = makeLambdaEntrySource(true);
    expect(SERVE_ENTRY_NAME).toBe("server/serve-aws-lambda.mjs");
    expect(LAMBDA_ADAPTER_FILE_NAME).toBe("vinext-aws-lambda.mjs");
    expect(source).toContain('import rsc from "./index.js"');
    expect(source).toContain("toLambdaHandler");
    expect(source).toContain("export const handler");
    expect(source).toContain('hostRuntime: "node"');
    expect(source).not.toContain("toBufferedLambdaHandler");
    expect(source).not.toContain("opennext");
    expect(source).not.toContain("vinext/server/fetch-handler");
    expect(source).not.toContain("startProdServer");
  });

  it("can emit the buffered Lambda wrapper", () => {
    const source = makeLambdaEntrySource(false);
    expect(source).toContain("toBufferedLambdaHandler");
    expect(source).not.toContain("toLambdaHandler");
  });

  it("exposes the named `target` module export as the factory", () => {
    expect(target).toBe(makeAwsTarget);
  });
});