sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ Lambda/ Version.test.ts

import { fileURLToPath } from "node:url";
import * as AWS from "@alchemy.run/aws";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Lambda from "@distilled.cloud/aws/lambda";
import * as Provider from "alchemy/Provider";
import { destroy } from "alchemy/RemovalPolicy";
import { isResourceState, State, type ResourceState } from "alchemy/State";
import * as Effect from "effect/Effect";

const handlerV1Path = fileURLToPath(new URL("./fixtures/version-handler-v1.ts", import.meta.url));
const handlerV2Path = fileURLToPath(new URL("./fixtures/version-handler-v2.ts", import.meta.url));

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

test.provider(
  "publish, recover, promote, retain, list, and explicitly delete versions",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const program = ({
        handlerPath,
        envVersion,
        reservedConcurrentExecutions,
        includeVersion = true,
        includeAlias = true,
        destroyVersion = false,
      }: {
        handlerPath: string;
        envVersion: string;
        reservedConcurrentExecutions?: number;
        includeVersion?: boolean;
        includeAlias?: boolean;
        destroyVersion?: boolean;
      }) =>
        Effect.gen(function* () {
          const fn = yield* AWS.Lambda.Function("VersionedFn", {
            main: handlerPath,
            handler: "handler",
            isExternal: true,
            functionUrl: false,
            env: { VERSION: envVersion },
            reservedConcurrentExecutions,
          });

          const version = includeVersion
            ? yield* AWS.Lambda.Version("Release", {
                function: fn,
              }).pipe(destroy(destroyVersion))
            : undefined;

          const live =
            includeAlias && version
              ? yield* AWS.Lambda.Alias("Live", {
                  version,
                  aliasName: "live",
                })
              : undefined;

          return { fn, version, live };
        });

      // --- create ---
      const created = yield* stack.deploy(
        program({ handlerPath: handlerV1Path, envVersion: "one" }),
      );
      const v1 = created.version!;

      expect(v1.version).toMatch(/^[1-9]\d*$/);
      expect(v1.versionArn).toBe(`${v1.functionArn}:${v1.version}`);
      expect(v1.codeSha256).toBeTruthy();
      expect(v1.configSha256).toBeTruthy();
      expect(v1.sourceHash).toMatch(/^[a-f0-9]{64}$/);
      expect(created.live!.functionVersion).toBe(v1.version);

      const cloudV1 = yield* getVersionOrUndefined(v1.functionName, v1.version);
      expect(cloudV1?.FunctionArn).toBe(v1.versionArn);
      expect(cloudV1?.CodeSha256).toBe(v1.codeSha256);
      const countV1 = (yield* numberedVersions(v1.functionName)).length;

      // --- noop ---
      const unchanged = yield* stack.deploy(
        program({ handlerPath: handlerV1Path, envVersion: "one" }),
      );
      expect(unchanged.version!.version).toBe(v1.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countV1);

      // --- code change + alias promotion ---
      const codeChanged = yield* stack.deploy(
        program({ handlerPath: handlerV2Path, envVersion: "one" }),
      );
      const v2 = codeChanged.version!;
      expect(v2.version).not.toBe(v1.version);
      expect(v2.codeSha256).not.toBe(v1.codeSha256);
      expect(codeChanged.live!.aliasArn).toBe(created.live!.aliasArn);
      expect(codeChanged.live!.functionVersion).toBe(v2.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countV1 + 1);
      expect(yield* getVersionOrUndefined(v1.functionName, v1.version)).toBeDefined();

      // --- versioned configuration change ---
      const configChanged = yield* stack.deploy(
        program({ handlerPath: handlerV2Path, envVersion: "two" }),
      );
      const current = configChanged.version!;
      expect(current.version).not.toBe(v2.version);
      expect(current.codeSha256).toBe(v2.codeSha256);
      expect(current.configSha256).not.toBe(v2.configSha256);
      const countCurrent = (yield* numberedVersions(v1.functionName)).length;
      expect(countCurrent).toBe(countV1 + 2);

      // --- operational-only change ---
      const operational = yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 0,
        }),
      );
      expect(operational.version!.version).toBe(current.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countCurrent);

      // --- crash after PublishVersion, before state write ---
      // State resolves to an Effect that initializes and yields the concrete
      // state-store service.
      const state = yield* yield* State;
      const stage = stack.stage;
      const fqns = yield* state.list({ stack: stack.name, stage });
      const rows = yield* Effect.forEach(fqns, (fqn) =>
        state.get({ stack: stack.name, stage, fqn }).pipe(Effect.map((row) => ({ fqn, row }))),
      );
      const versionRow = rows.find(
        (row): row is { fqn: string; row: ResourceState } =>
          isResourceState(row.row) && row.row.resourceType === "AWS.Lambda.Version",
      );
      if (!versionRow?.row.props) {
        return yield* Effect.die(
          new Error("no persisted AWS.Lambda.Version props found after deploy"),
        );
      }
      yield* state.set({
        stack: stack.name,
        stage,
        fqn: versionRow.fqn,
        value: {
          ...versionRow.row,
          props: versionRow.row.props,
          status: "creating",
          attr: undefined,
        },
      });

      const recovered = yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 0,
        }),
      );
      expect(recovered.version!.version).toBe(current.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countCurrent);

      // --- crash before the Function reference resolved ---
      // An interrupted first create persists the Function reference as
      // missing (it was still an unresolved Output at checkpoint time). The
      // recovery read finds nothing to recover instead of crashing (#2002),
      // and the re-driven create reuses the published version.
      yield* state.set({
        stack: stack.name,
        stage,
        fqn: versionRow.fqn,
        value: {
          ...versionRow.row,
          props: { ...versionRow.row.props, function: undefined },
          status: "creating",
          attr: undefined,
        },
      });
      const strippedRecovery = yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 0,
        }),
      );
      expect(strippedRecovery.version!.version).toBe(current.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countCurrent);

      // --- retain on removal and recover on re-add ---
      yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 0,
          includeVersion: false,
          includeAlias: false,
        }),
      );
      expect(yield* getVersionOrUndefined(v1.functionName, current.version)).toBeDefined();

      const readded = yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 0,
        }),
      );
      expect(readded.version!.version).toBe(current.version);
      expect((yield* numberedVersions(v1.functionName)).length).toBe(countCurrent);

      // --- list + nuke posture ---
      const provider = yield* Provider.findProvider(AWS.Lambda.Version);
      expect(provider.nuke?.skip).toBe(true);
      const listed = yield* provider.list();
      expect(listed.some((version) => version.versionArn === current.versionArn)).toBe(true);
      expect(listed.every((version) => version.version !== "$LATEST")).toBe(true);

      // --- explicitly authorized, qualified-only deletion ---
      yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          // Force an operational-only Version update so the explicit removal
          // policy is persisted before the resource is removed.
          reservedConcurrentExecutions: 1,
          destroyVersion: true,
        }),
      );
      yield* stack.deploy(
        program({
          handlerPath: handlerV2Path,
          envVersion: "two",
          reservedConcurrentExecutions: 1,
          includeVersion: false,
          includeAlias: false,
        }),
      );

      expect(yield* getVersionOrUndefined(v1.functionName, current.version)).toBeUndefined();
      expect(
        yield* Lambda.getFunctionConfiguration({
          FunctionName: v1.functionName,
          Qualifier: "$LATEST",
        }),
      ).toBeDefined();
      expect(yield* getVersionOrUndefined(v1.functionName, v1.version)).toBeDefined();

      yield* stack.destroy();
    }).pipe(
      Effect.tap(() => stack.destroy()),
      Effect.onError(() => stack.destroy().pipe(Effect.ignore)),
    ),
  { tags: ["provider:aws", "provider:aws:lambda", "live"], timeout: 360_000 },
);

const numberedVersions = Effect.fn(function* (functionName: string) {
  const response = yield* Lambda.listVersionsByFunction({
    FunctionName: functionName,
  });
  return (response.Versions ?? []).filter((version) => version.Version !== "$LATEST");
});

const getVersionOrUndefined = Effect.fn(function* (functionName: string, version: string) {
  return yield* Lambda.getFunctionConfiguration({
    FunctionName: functionName,
    Qualifier: version,
  }).pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)));
});