alchemy-effect 0.5.0 → 0.6.2

package/src/Tags.ts

@@ -0,0 +1,104 @@
+import * as Effect from "effect/Effect";
+import { Stack } from "./Stack.ts";
+import { Stage } from "./Stage.ts";
+
+export type Tags =
+  | Record<string, string | undefined>
+  | [string, string][]
+  | { Key: string; Value: string }[];
+
+const normalizeTags = (tags: Tags) =>
+  Array.isArray(tags)
+    ? Object.fromEntries(
+        tags.map((tag) =>
+          Array.isArray(tag) ? [tag[0], tag[1]] : [tag.Key, tag.Value],
+        ),
+      )
+    : tags;
+
+export const hasTags = (expectedTags: Tags, tags: Tags | undefined) => {
+  const actualTags = normalizeTags(tags ?? []);
+  return Object.entries(normalizeTags(expectedTags)).every(
+    ([key, value]) => actualTags[key] === value,
+  );
+};
+
+export const createTagsList = (tags: Tags) =>
+  Object.entries(normalizeTags(tags))
+    .filter((t): t is [string, string] => t[1] !== undefined)
+    .map(([Key, Value]) => ({
+      Key,
+      Value,
+    }));
+
+export const createInternalTags = Effect.fn(function* (id: string) {
+  const stack = yield* Stack;
+  const stage = yield* Stage;
+  return {
+    "alchemy::stack": stack.name,
+    "alchemy::stage": stage,
+    "alchemy::id": id,
+  };
+});
+
+/**
+ * Creates AWS-compatible tag filters for finding resources by alchemy tags.
+ * Use with AWS describe APIs that accept Filter parameters.
+ */
+export const createAlchemyTagFilters = Effect.fn(function* (id: string) {
+  const stack = yield* Stack;
+  const stage = yield* Stage;
+  return [
+    { Name: "tag:alchemy::stack", Values: [stack.name] },
+    { Name: "tag:alchemy::stage", Values: [stage] },
+    { Name: "tag:alchemy::id", Values: [id] },
+  ];
+});
+
+/**
+ * Checks if a resource has the expected alchemy tags for this app/stage/id.
+ */
+export const hasAlchemyTags = Effect.fn(function* (
+  id: string,
+  tags: Tags | undefined,
+) {
+  const stack = yield* Stack;
+  const stage = yield* Stage;
+  const expectedTags = {
+    "alchemy::stack": stack.name,
+    "alchemy::stage": stage,
+    "alchemy::id": id,
+  };
+  return hasTags(expectedTags, tags);
+});
+
+export const diffTags = (
+  oldTags: Record<string, string>,
+  newTags: Record<string, string>,
+) => {
+  const removed: string[] = [];
+  const updated: { Key: string; Value: string }[] = [];
+  const added: { Key: string; Value: string }[] = [];
+  for (const key in oldTags) {
+    if (!(key in newTags)) {
+      removed.push(key);
+    } else if (oldTags[key] !== newTags[key]) {
+      updated.push({ Key: key, Value: newTags[key] });
+    }
+  }
+  for (const key in newTags) {
+    if (!(key in oldTags)) {
+      added.push({ Key: key, Value: newTags[key] });
+    } else if (oldTags[key] !== newTags[key]) {
+      updated.push({ Key: key, Value: newTags[key] });
+    }
+  }
+  return {
+    added,
+    removed,
+    updated,
+    upsert: [...added, ...updated].filter(
+      (tag, index, self) => self.findIndex((t) => t.Key === tag.Key) === index,
+    ),
+  };
+};

package/src/Test/TestCli.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Cli } from "../Cli/Cli.ts";
+
+export const TestCli = Layer.succeed(
+  Cli,
+  Cli.of({
+    approvePlan: () => Effect.succeed(true),
+    displayPlan: () => Effect.void,
+    startApplySession: () =>
+      Effect.succeed({
+        done: () => Effect.void,
+        emit: (event) =>
+          Effect.log(
+            event.kind === "status-change"
+              ? `${event.status} ${event.id}(${event.type})`
+              : `${event.id}: ${event.message}`,
+          ),
+      }),
+  }),
+);

package/src/Test/TestState.ts

@@ -0,0 +1,37 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Stack } from "../Stack.ts";
+import { Stage } from "../Stage.ts";
+import * as State from "../State/index.ts";
+
+export const state = (resources: Record<string, State.ResourceState> = {}) =>
+  Layer.effect(
+    State.State,
+    Effect.gen(function* () {
+      return State.InMemoryService({
+        [(yield* Stack).name]: {
+          [yield* Stage]: resources,
+        },
+      });
+    }),
+  );
+
+export const defaultState = (
+  resources: Record<string, State.ResourceState> = {},
+  other?: {
+    [stack: string]: {
+      [stage: string]: {
+        [resourceId: string]: State.ResourceState;
+      };
+    };
+  },
+) =>
+  Layer.succeed(
+    State.State,
+    State.InMemoryService({
+      ["test-app"]: {
+        ["test-stage"]: resources,
+      },
+      ...other,
+    }),
+  );

package/src/Test/Vitest.ts

@@ -0,0 +1,503 @@
+import type * as aws from "@distilled.cloud/aws";
+import * as cf from "@distilled.cloud/cloudflare";
+import { NodeServices } from "@effect/platform-node";
+import { expect, it } from "@effect/vitest";
+import { Logger } from "effect";
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { MinimumLogLevel } from "effect/References";
+import * as Scope from "effect/Scope";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as NodePath from "node:path";
+import {
+  afterAll as vitestAfterAll,
+  beforeAll as vitestBeforeAll,
+} from "vitest";
+import * as AWS from "../AWS/index.ts";
+import * as Cloudflare from "../Cloudflare/index.ts";
+
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { apply } from "../Apply.ts";
+import * as Credentials from "../AWS/Credentials.ts";
+import * as Region from "../AWS/Region.ts";
+import type { Command } from "../Build/Command.ts";
+import type { Cli } from "../Cli/index.ts";
+import {
+  buildNamespaceTree,
+  flattenTree,
+  type DerivedAction,
+} from "../Cli/NamespaceTree.ts";
+import { DotAlchemy, dotAlchemy } from "../Config.ts";
+import { ExecutionContext } from "../ExecutionContext.ts";
+import type { Input } from "../Input.ts";
+import type { Output } from "../Output.ts";
+import * as Plan from "../Plan.ts";
+import type { Provider } from "../Provider.ts";
+import * as Server from "../Server/index.ts";
+import * as Serverless from "../Serverless/index.ts";
+import * as Stack from "../Stack.ts";
+import * as Stage from "../Stage.ts";
+import * as State from "../State/index.ts";
+import { TestCli } from "./TestCli.ts";
+
+export const expectEmptyObject = () =>
+  expect.toSatisfy(
+    (deletions) => Object.keys(deletions).length === 0,
+    "empty object",
+  );
+
+export const expectPropExpr = (identifier: string, src: any) =>
+  expect.objectContaining({
+    kind: "PropExpr",
+    identifier,
+    expr: expect.objectContaining({
+      kind: "ResourceExpr",
+      src,
+    }),
+  });
+
+type Provided =
+  | Scope.Scope
+  | Stack.Stack
+  | State.State
+  | Stage.Stage
+  | DotAlchemy
+  | HttpClient.HttpClient
+  | FileSystem.FileSystem
+  | Path.Path
+  | aws.Credentials.Credentials
+  | aws.Region.Region
+  | Cli
+  | ExecutionContext
+  | Server.ProcessContext
+  | Server.ServerHost
+  | Serverless.FunctionContext
+  | AWS.StageConfig
+  | Provider<Command>
+  | Layer.Success<ReturnType<typeof AWS.providers>>
+  | Layer.Success<ReturnType<typeof Cloudflare.providers>>
+  | ChildProcessSpawner;
+
+const quietLogger = Logger.make(() => {
+  // console.log(options.message);
+});
+
+const platform = Layer.mergeAll(
+  NodeServices.layer,
+  FetchHttpClient.layer,
+  Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
+);
+
+const awsStageConfig = Layer.effect(
+  AWS.StageConfig,
+  Effect.gen(function* () {
+    const AWS_PROFILE = yield* Config.string("AWS_PROFILE").pipe(
+      Config.withDefault("default"),
+    );
+
+    const LOCAL = yield* Config.boolean("LOCAL").pipe(
+      Config.withDefault(false),
+    );
+
+    const LOCALSTACK_ENDPOINT = yield* Config.string(
+      "LOCALSTACK_ENDPOINT",
+    ).pipe(Config.withDefault("http://localhost.localstack.cloud:4566"));
+
+    return AWS.StageConfig.of({
+      profile: LOCAL ? undefined : AWS_PROFILE,
+      region: LOCAL ? "us-east-1" : undefined,
+      credentials: LOCAL
+        ? {
+            accessKeyId: "test",
+            secretAccessKey: "test",
+            sessionToken: "test",
+          }
+        : undefined,
+      endpoint: LOCAL ? LOCALSTACK_ENDPOINT : undefined,
+    });
+  }),
+);
+
+const awsProviders = Layer.provideMerge(
+  AWS.providers(),
+  Layer.mergeAll(Credentials.fromStageConfig(), Region.fromStageConfig()),
+);
+
+const cfProviders = Layer.provideMerge(
+  Cloudflare.providers(),
+  Layer.mergeAll(cf.CredentialsFromEnv, FetchHttpClient.layer),
+);
+
+const deriveStackName = (testPath: string, suffix: string) => {
+  const testDir = testPath.includes("/test/")
+    ? (testPath.split("/test/").pop() ?? "")
+    : NodePath.basename(testPath);
+  const testPathWithoutExt = testDir.replace(/\.[^.]+$/, "");
+  return `${testPathWithoutExt}-${suffix}`
+    .replaceAll(/[^a-zA-Z0-9_]/g, "-")
+    .replace(/-+/g, "-");
+};
+
+const runWithContext = <A, Err>(
+  stackName: string,
+  effect: Effect.Effect<A, Err, Provided>,
+  options: { state?: Layer.Layer<State.State, never, Stack.Stack> } = {},
+): Effect.Effect<
+  A,
+  aws.Credentials.CredentialsError | Config.ConfigError | Err,
+  never
+> => {
+  const stack = Layer.effect(
+    Stack.Stack,
+    Effect.succeed({
+      name: stackName,
+      stage: "test",
+      resources: {},
+      bindings: {},
+    }),
+  );
+
+  const alchemy = Layer.provideMerge(
+    Layer.mergeAll(options.state ?? State.LocalState, TestCli),
+    Layer.mergeAll(awsStageConfig, stack, dotAlchemy),
+  );
+
+  const context = {
+    Type: "Test",
+    id: "Test",
+    env: {},
+    exports: {},
+    listen: () => Effect.void,
+    serve: () => Effect.void,
+    get: <T>(_key: string) => Effect.succeed<T>(undefined as T),
+    set: (_id: string, _output: Output) =>
+      Effect.sync(() => _id.replaceAll(/[^a-zA-Z0-9]/g, "_")),
+  };
+
+  // Test harness does not fully close `Req`; runtime provides enough for tests.
+  // @ts-expect-error Residual requirement channel on `effect` after ConfigProvider.
+  return Effect.gen(function* () {
+    const configProvider = ConfigProvider.orElse(
+      yield* ConfigProvider.fromDotEnv({ path: ".env" }),
+      ConfigProvider.fromEnv(),
+    );
+    return yield* effect.pipe(
+      Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
+    );
+  }).pipe(
+    Effect.provide(
+      Layer.provideMerge(
+        Layer.mergeAll(awsProviders, cfProviders),
+        Layer.provideMerge(alchemy, platform),
+      ),
+    ),
+    Effect.provideService(Stage.Stage, "test"),
+    Effect.provideService(ExecutionContext, context as any),
+    Effect.provideService(Server.ServerHost, {
+      run: (_effect) => Effect.void,
+    }),
+    Effect.provideService(
+      MinimumLogLevel,
+      process.env.DEBUG ? "Debug" : "Info",
+    ),
+    Effect.provide(NodeServices.layer),
+  );
+};
+
+export function test(
+  name: string,
+  options: {
+    timeout?: number;
+    state?: Layer.Layer<State.State, never, Stack.Stack>;
+  },
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function test(
+  name: string,
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function test(
+  name: string,
+  ...args:
+    | [
+        {
+          timeout?: number;
+          state?: Layer.Layer<State.State, never, Stack.Stack>;
+        },
+        Effect.Effect<void, any, Provided>,
+      ]
+    | [Effect.Effect<void, any, Provided>]
+) {
+  const [options = {}, testCase] =
+    args.length === 1 ? [undefined, args[0]] : args;
+
+  const testPath = expect.getState().testPath ?? "";
+  const stackName = deriveStackName(testPath, name);
+  const effect = runWithContext(stackName, testCase, options);
+
+  return it.live(name, () => effect, options.timeout);
+}
+
+export namespace test {
+  export function skip(
+    name: string,
+    options: {
+      timeout?: number;
+      state?: Layer.Layer<State.State, never, Stack.Stack>;
+    },
+    testCase: Effect.Effect<void, any, Provided>,
+  ): void;
+
+  export function skip(
+    name: string,
+    testCase: Effect.Effect<void, any, Provided>,
+  ): void;
+
+  export function skip(
+    name: string,
+    ...args:
+      | [
+          {
+            timeout?: number;
+            state?: Layer.Layer<State.State, never, Stack.Stack>;
+          },
+          Effect.Effect<void, any, Provided>,
+        ]
+      | [Effect.Effect<void, any, Provided>]
+  ) {
+    const [options = {}, _testCase] =
+      args.length === 1 ? [undefined, args[0]] : args;
+    it.skip(name, () => {}, options.timeout);
+  }
+
+  export function skipIf(condition: boolean) {
+    return function (
+      name: string,
+      ...args:
+        | [
+            {
+              timeout?: number;
+              state?: Layer.Layer<State.State, never, Stack.Stack>;
+            },
+            Effect.Effect<void, any, Provided>,
+          ]
+        | [Effect.Effect<void, any, Provided>]
+    ) {
+      if (condition) {
+        const [options = {}, _testCase] =
+          args.length === 1 ? [undefined, args[0]] : args;
+        it.skip(name, () => {}, options.timeout);
+      } else {
+        test(name, ...(args as [Effect.Effect<void, any, Provided>]));
+      }
+    };
+  }
+
+  export const state = (resources: Record<string, State.ResourceState> = {}) =>
+    Layer.effect(
+      State.State,
+      Effect.gen(function* () {
+        const stack = yield* Stack.Stack;
+        return State.InMemoryService({
+          [stack.name]: {
+            [stack.stage]: resources,
+          },
+        });
+      }),
+    );
+
+  export const defaultState = (
+    resources: Record<string, State.ResourceState> = {},
+    other?: {
+      [stack: string]: {
+        [stage: string]: {
+          [resourceId: string]: State.ResourceState;
+        };
+      };
+    },
+  ) =>
+    Layer.succeed(
+      State.State,
+      State.InMemoryService({
+        ["test-app"]: {
+          ["test-stage"]: resources,
+        },
+        ...other,
+      }),
+    );
+
+  export const deploy = <A, Err = never, Req = any>(
+    effect: Effect.Effect<A, Err, Req>,
+  ): Effect.Effect<Input.Resolve<A>, Err, Req | Stack.Stack> =>
+    Stack.Stack.use((stack) => {
+      return effect.pipe(
+        // Effect.tap(Effect.logInfo),
+        // @ts-expect-error
+        Stack.make(stack.name, Layer.effectServices(Effect.services<never>()), {
+          ...stack,
+          resources: {},
+          bindings: {},
+        }),
+        Effect.flatMap(Plan.make),
+        Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
+        Effect.flatMap(apply),
+      );
+    });
+}
+
+type AnyAction = Plan.CRUD["action"] | Plan.BindingAction | DerivedAction;
+
+const formatPlan = (plan: Plan.Plan) => {
+  const items = [
+    ...Object.values(plan.resources),
+    ...Object.values(plan.deletions),
+  ] as Plan.CRUD[];
+
+  if (items.length === 0) {
+    return "Plan: no changes planned";
+  }
+
+  const counts = items.reduce(
+    (acc, item) => {
+      acc[item.action] += 1;
+      return acc;
+    },
+    {
+      create: 0,
+      update: 0,
+      delete: 0,
+      noop: 0,
+      replace: 0,
+    },
+  );
+
+  const summary = (["create", "update", "delete", "replace"] as const)
+    .filter((action) => counts[action] > 0)
+    .map((action) => `${counts[action]} to ${action}`)
+    .join(" | ");
+
+  const flatItems = flattenTree(buildNamespaceTree(items));
+  const lines = [`Plan: ${summary}`];
+
+  for (const item of flatItems) {
+    const indent = "  ".repeat(item.depth);
+    const icon = getActionIcon(item.action);
+
+    if (item.type === "namespace") {
+      lines.push(`${indent}${icon} ${item.id}`);
+      continue;
+    }
+
+    if (item.type === "binding") {
+      lines.push(`${indent}${icon} ${item.bindingSid}`);
+      continue;
+    }
+
+    const bindingSuffix =
+      item.bindingCount && item.bindingCount > 0
+        ? ` (${item.bindingCount} bindings)`
+        : "";
+    lines.push(
+      `${indent}${icon} ${item.id} (${item.resourceType})${bindingSuffix}`,
+    );
+  }
+
+  return lines.join("\n");
+};
+
+const getActionIcon = (action: AnyAction): string =>
+  ({
+    create: "+",
+    update: "~",
+    delete: "-",
+    noop: "•",
+    replace: "!",
+    mixed: "*",
+  })[action] ?? "?";
+
+export function skip(
+  name: string,
+  options: {
+    timeout?: number;
+    state?: Layer.Layer<State.State, never, Stack.Stack>;
+  },
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function skip(
+  name: string,
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
+export function skip(
+  name: string,
+  ...args:
+    | [
+        {
+          timeout?: number;
+          state?: Layer.Layer<State.State, never, Stack.Stack>;
+        },
+        Effect.Effect<void, any, Provided>,
+      ]
+    | [Effect.Effect<void, any, Provided>]
+) {
+  const [options = {}, _testCase] =
+    args.length === 1 ? [undefined, args[0]] : args;
+  it.skip(name, () => {}, options.timeout);
+}
+
+export function skipIf(condition: boolean) {
+  return function (
+    name: string,
+    ...args:
+      | [
+          {
+            timeout?: number;
+            state?: Layer.Layer<State.State, never, Stack.Stack>;
+          },
+          Effect.Effect<void, any, Provided>,
+        ]
+      | [Effect.Effect<void, any, Provided>]
+  ) {
+    if (condition) {
+      const [options = {}, _testCase] =
+        args.length === 1 ? [undefined, args[0]] : args;
+      it.skip(name, () => {}, options.timeout);
+    } else {
+      test(name, ...(args as [Effect.Effect<void, any, Provided>]));
+    }
+  };
+}
+
+export function beforeAll<A, E = never, R extends Provided = never>(
+  effect: Effect.Effect<A, E, R>,
+  options?: { timeout?: number; stackName?: string },
+): void {
+  const testPath = expect.getState().testPath ?? "";
+  const stackName = options?.stackName ?? deriveStackName(testPath, "suite");
+
+  vitestBeforeAll(
+    () => Effect.runPromise(Effect.scoped(runWithContext(stackName, effect))),
+    options?.timeout,
+  );
+}
+
+export function afterAll<A, E, R extends Provided = never>(
+  effect: Effect.Effect<A, E, R>,
+  options?: { timeout?: number; stackName?: string },
+): void {
+  const testPath = expect.getState().testPath ?? "";
+  const stackName = options?.stackName ?? deriveStackName(testPath, "suite");
+
+  vitestAfterAll(
+    () => Effect.runPromise(Effect.scoped(runWithContext(stackName, effect))),
+    options?.timeout,
+  );
+}

package/src/Test/index.ts

@@ -0,0 +1,3 @@
+export * from "./TestCli.ts";
+export * from "./TestState.ts";
+export * from "./Vitest.ts";