alchemy 2.0.0-beta.25 → 2.0.0-beta.26

package/src/Telemetry/Layer.ts

@@ -1,6 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
 import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
 import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
 import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
@@ -11,6 +12,7 @@ import { collectAttributes, isTelemetryDisabled } from "./Attributes.ts";
 
 const TRACES_URL = "https://otel.alchemy.run/v1/traces";
 const METRICS_URL = "https://otel.alchemy.run/v1/metrics";
+const LOGS_URL = "https://otel.alchemy.run/v1/logs";
 
 const SERVICE_NAME = "alchemy-cli";
 
@@ -35,8 +37,18 @@ const buildOtlpLayer = (
     resource,
     exportInterval: "1 second",
   });
+  // Replace (don't merge with) the default stdout logger here; downstream
+  // commands re-add their own `fileLogger`/`consolePretty` via
+  // `Logger.layer([...], { mergeWithExisting: true })`, which stacks on top
+  // of this OtlpLogger without resurrecting Effect's default stdout logger.
+  const logger = OtlpLogger.layer({
+    url: LOGS_URL,
+    resource,
+    exportInterval: "1 second",
+    mergeWithExisting: false,
+  });
 
-  return Layer.mergeAll(tracer, metrics).pipe(
+  return Layer.mergeAll(tracer, metrics, logger).pipe(
     Layer.provide(OtlpSerialization.layerJson),
     Layer.provide(FetchHttpClient.layer),
   );

package/src/Test/Bun.ts

@@ -1,163 +1,187 @@
 import bun from "bun:test";
-import { ConfigProvider } from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HookOptions } from "node:test";
-import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
-import { provideFreshArtifactStore } from "../Artifacts.ts";
-import { AuthProviders } from "../Auth/AuthProvider.ts";
-import { inkCLI } from "../Cli/InkCLI.tsx";
-import { deploy as _deploy } from "../Deploy.ts";
-import { destroy as _destroy } from "../Destroy.ts";
-import {
-  type CompiledStack,
-  type StackEffect,
-  type StackServices,
-} from "../Stack.ts";
-import * as State from "../State/index.ts";
-import { loadConfigProvider } from "../Util/ConfigProvider.ts";
-import { PlatformServices } from "../Util/PlatformServices.ts";
-
-export type ProvidedServices = StackServices;
-
-type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
-
-const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
-
-// override alchemy state store, CLI/reporting, state, and dotAlchemy
-const alchemy = Layer.mergeAll(
-  inkCLI(),
-  Logger.layer([Logger.consolePretty()]),
-  AlchemyContextLive,
-);
-
-const run = <A>(effect: TestEffect<A>) =>
-  Effect.gen(function* () {
-    const configProvider = yield* loadConfigProvider(Option.none());
-
-    return yield* effect.pipe(
-      provideFreshArtifactStore,
-      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
-    );
-  }).pipe(
-    Effect.provideService(AuthProviders, {}),
-    Effect.provide(State.localState()),
-    Effect.provide(Layer.provideMerge(alchemy, platform)),
-    Effect.scoped,
-    Effect.runPromise,
-  );
-
-export const it = test;
-
-export const expect = bun.expect;
-
-export function test(
-  name: string,
-  test: TestEffect<void>,
-  options?: bun.TestOptions,
-) {
-  bun.test(name, () => run(test), options);
+
+import type { AlchemyContext } from "../AlchemyContext.ts";
+import type { CompiledStack } from "../Stack.ts";
+import type { Stage } from "../Stage.ts";
+import * as Core from "./Core.ts";
+
+export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
+export type ScratchStack = Core.ScratchStack;
+export type TestEffect<A, R = never> = Core.TestEffect<A, R>;
+
+export interface TestApi {
+  test: TestFn;
+  beforeAll: BeforeAllFn;
+  beforeEach: BeforeEachFn;
+  afterAll: AfterAllFn;
+  afterEach: AfterEachFn;
+  deploy: <A>(
+    stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.deploy<A>>;
+  destroy: (
+    stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
+    options?: { stage?: string },
+  ) => ReturnType<typeof Core.destroy>;
 }
 
-export namespace test {
-  export function skipIf(condition: boolean) {
-    return (
-      name: string,
-      test: TestEffect<void>,
-      options?: bun.TestOptions,
-    ) => {
-      bun.test.skipIf(condition)(name, () => run(test), options);
-    };
-  }
-
-  export function skip(
+interface TestFn {
+  (name: string, eff: TestEffect<void>, options?: bun.TestOptions): void;
+  skip: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.skip(name, () => run(test), options);
-  }
-
-  export function only(
+  ) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
+  only: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.only(name, () => run(test), options);
-  }
-
-  export function todo(
+  ) => void;
+  todo: (
     name: string,
-    test: TestEffect<void>,
+    eff: TestEffect<void>,
     options?: bun.TestOptions,
-  ) {
-    bun.test.todo(name, () => run(test), options);
-  }
+  ) => void;
+  provider: ProviderFn;
 }
 
-export const describe = bun.describe;
-
-export function beforeAll<A>(eff: TestEffect<A>, options?: HookOptions) {
-  let a: A;
-  bun.beforeAll(
-    () => run(eff).then((v) => (a = v)),
-    options ?? {
-      timeout: 120_000,
-    },
-  );
-  return Effect.sync(() => a);
+interface ProviderFn {
+  (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ): void;
+  skip: (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ) => void;
+  skipIf: (
+    condition: boolean,
+  ) => (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+    options?: bun.TestOptions,
+  ) => void;
 }
 
-export function beforeEach(eff: TestEffect<void>, options?: HookOptions) {
-  bun.beforeEach(() => run(eff), options);
+interface BeforeAllFn {
+  <A>(eff: TestEffect<A>, options?: HookOptions): Effect.Effect<A>;
 }
 
-export function afterAll(eff: TestEffect<any>, options?: HookOptions) {
-  bun.afterAll(() => run(eff), options);
+interface BeforeEachFn {
+  (eff: TestEffect<void>, options?: HookOptions): void;
 }
 
-export namespace afterAll {
-  export const skipIf =
-    (predicate: boolean) => (test: TestEffect<void>, options?: HookOptions) => {
-      if (predicate) {
-      } else {
-        bun.afterAll(
-          () => run(test),
-          options ?? {
-            timeout: 120_000,
-          },
-        );
-      }
-    };
+interface AfterAllFn {
+  (eff: TestEffect<any>, options?: HookOptions): void;
+  skipIf: (
+    predicate: boolean,
+  ) => (eff: TestEffect<any>, options?: HookOptions) => void;
 }
 
-export function afterEach(eff: TestEffect<void>, options?: HookOptions) {
-  bun.afterEach(() => run(eff), options);
+interface AfterEachFn {
+  (eff: TestEffect<void>, options?: HookOptions): void;
 }
 
-export const deploy = <A>(
-  stack: TestEffect<CompiledStack<A>, AlchemyContext>,
-  options?: {
-    /** @default test */
-    stage?: string;
-  },
-) =>
-  _deploy({
-    stack: stack,
-    stage: options?.stage ?? "test",
-  });
-
-export const destroy = (
-  stack: TestEffect<CompiledStack, AlchemyContext>,
-  options?: {
-    /** @default test */
-    stage?: string;
-  },
-) =>
-  _destroy({
-    stack,
-    stage: options?.stage ?? "test",
-  });
+const DEFAULT_HOOK_TIMEOUT: HookOptions = { timeout: 120_000 };
+
+/**
+ * Build the per-file test API. Configure providers / state once at the top of
+ * the test file:
+ *
+ * ```ts
+ * import * as Test from "alchemy/Test/Bun";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ *
+ * const { test, deploy, destroy, beforeAll, afterAll } = Test.make({
+ *   providers: Cloudflare.providers(),
+ *   state: Cloudflare.state(),
+ * });
+ * ```
+ */
+export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
+  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options);
+
+  const test = ((name, eff, opts) => {
+    bun.test(name, () => runEff(eff), opts);
+  }) as TestFn;
+
+  test.skip = (name, eff, opts) => {
+    bun.test.skip(name, () => runEff(eff), opts);
+  };
+  test.skipIf = (condition) => (name, eff, opts) => {
+    bun.test.skipIf(condition)(name, () => runEff(eff), opts);
+  };
+  test.only = (name, eff, opts) => {
+    bun.test.only(name, () => runEff(eff), opts);
+  };
+  test.todo = (name, eff, opts) => {
+    bun.test.todo(name, () => runEff(eff), opts);
+  };
+
+  const runProvider = (
+    name: string,
+    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
+  ) => {
+    const scratch = Core.scratchStack(options, name);
+    return Core.run(Core.withProviders(fn(scratch), options, scratch.name), {
+      ...options,
+      state: scratch.state,
+    });
+  };
+
+  const provider = ((name, fn, opts) => {
+    bun.test(name, () => runProvider(name, fn), opts);
+  }) as ProviderFn;
+  provider.skip = (name, fn, opts) => {
+    bun.test.skip(name, () => runProvider(name, fn), opts);
+  };
+  provider.skipIf = (condition) => (name, fn, opts) => {
+    bun.test.skipIf(condition)(name, () => runProvider(name, fn), opts);
+  };
+  test.provider = provider;
+
+  const beforeAll: BeforeAllFn = <A>(
+    eff: TestEffect<A>,
+    hookOptions?: HookOptions,
+  ) => {
+    let result: A;
+    bun.beforeAll(
+      () => runEff(eff).then((v) => (result = v)),
+      hookOptions ?? DEFAULT_HOOK_TIMEOUT,
+    );
+    return Effect.sync(() => result);
+  };
+
+  const beforeEach: BeforeEachFn = (eff, hookOptions) => {
+    bun.beforeEach(() => runEff(eff), hookOptions);
+  };
+
+  const afterAll = ((eff, hookOptions) => {
+    bun.afterAll(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+  }) as AfterAllFn;
+  afterAll.skipIf = (predicate) => (eff, hookOptions) => {
+    if (predicate) return;
+    bun.afterAll(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+  };
+
+  const afterEach: AfterEachFn = (eff, hookOptions) => {
+    bun.afterEach(() => runEff(eff), hookOptions);
+  };
+
+  return {
+    test,
+    beforeAll,
+    beforeEach,
+    afterAll,
+    afterEach,
+    deploy: (stack, callOpts) => Core.deploy(options, stack, callOpts),
+    destroy: (stack, callOpts) => Core.destroy(options, stack, callOpts),
+  };
+};

package/src/Test/Core.ts

@@ -0,0 +1,225 @@
+import { ConfigProvider } from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+
+import type { AlchemyContext } from "../AlchemyContext.ts";
+import { AlchemyContextLive } from "../AlchemyContext.ts";
+import { apply } from "../Apply.ts";
+import { provideFreshArtifactStore } from "../Artifacts.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
+import { withProfileOverride } from "../Auth/Profile.ts";
+import { LoggingCli } from "../Cli/LoggingCli.ts";
+import { deploy as _deploy } from "../Deploy.ts";
+import { destroy as _destroy } from "../Destroy.ts";
+import type { Input } from "../Input.ts";
+import * as Plan from "../Plan.ts";
+import {
+  type CompiledStack,
+  make as makeStack,
+  Stack,
+  type StackEffect,
+  type StackServices,
+} from "../Stack.ts";
+import { Stage } from "../Stage.ts";
+import * as State from "../State/index.ts";
+import { TelemetryLive } from "../Telemetry/Layer.ts";
+import { loadConfigProvider } from "../Util/ConfigProvider.ts";
+import { PlatformServices } from "../Util/PlatformServices.ts";
+
+/**
+ * Configuration shared by every test in a file. Pass to `Test.make(...)`.
+ */
+export interface MakeOptions<ROut = any> {
+  /** Provider layer for the stack — e.g. `AWS.providers()`, `Cloudflare.providers()`. */
+  providers: Layer.Layer<ROut, never, StackServices>;
+  /** State store for top-level `deploy(Stack)` / `destroy(Stack)`; defaults to {@link State.localState}. */
+  state?: Layer.Layer<State.State, never, StackServices>;
+  /** Override `ALCHEMY_PROFILE`; otherwise resolved from env / .env. */
+  profile?: string;
+  /** Default stage for deploy/destroy (default `"test"`). */
+  stage?: string;
+}
+
+export type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
+
+const platformLayer = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
+
+const alchemyLayer = Layer.mergeAll(
+  LoggingCli,
+  Logger.layer([Logger.consolePretty()], { mergeWithExisting: true }),
+  AlchemyContextLive,
+);
+
+/**
+ * Build the per-test runtime and return a self-contained Effect.
+ *
+ * Mirrors {@link "../bin/alchemy.ts"} composition: ConfigProvider via
+ * `loadConfigProvider` + `withProfileOverride`, an empty `AuthProviders`
+ * registry that the user's `providers` layer populates, the platform layers,
+ * and the configured state store. Adapters wrap this into runner-specific
+ * thunks (`bun.test` -> `runPromise`, `it.live` -> as-is).
+ */
+export const toEffect = <A>(
+  effect: TestEffect<A>,
+  options: MakeOptions,
+): Effect.Effect<A, any, never> =>
+  Effect.gen(function* () {
+    const base = yield* loadConfigProvider(Option.none());
+    const configProvider = withProfileOverride(base, options.profile);
+    return yield* effect.pipe(
+      provideFreshArtifactStore,
+      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
+    );
+  }).pipe(
+    Effect.provideService(AuthProviders, {}),
+    Effect.provide(options.state ?? State.localState()),
+    Effect.provide(Layer.provideMerge(alchemyLayer, platformLayer)),
+    Effect.scoped,
+  ) as Effect.Effect<A, any, never>;
+
+/** Promise wrapper around {@link toEffect} for `bun.test`-style runners. */
+export const run = <A>(
+  effect: TestEffect<A>,
+  options: MakeOptions,
+): Promise<A> => Effect.runPromise(toEffect(effect, options));
+
+/**
+ * Wrap an effect so it runs with `options.providers` + a placeholder Stack +
+ * Stage in scope. Used by `test.provider` so user code can call provider SDK
+ * APIs (e.g. `DynamoDB.describeTable`) directly inside the test body.
+ */
+export const withProviders = <A, E, R, ROut>(
+  effect: Effect.Effect<A, E, R>,
+  options: MakeOptions<ROut>,
+  stackName: string,
+): Effect.Effect<A, E, Exclude<R, ROut | Stack | Stage>> =>
+  effect.pipe(
+    Effect.provide(options.providers as Layer.Layer<any, never, any>),
+    Effect.provide(
+      Layer.succeed(Stack, {
+        name: stackName,
+        stage: options.stage ?? "test",
+        resources: {},
+        bindings: {},
+      }),
+    ),
+    Effect.provide(Layer.succeed(Stage, options.stage ?? "test")),
+  ) as Effect.Effect<A, E, Exclude<R, ROut | Stack | Stage>>;
+
+/**
+ * Curried `deploy` for the test factory: bakes in the configured stage and
+ * adds the telemetry layer the CLI uses, so `beforeAll(deploy(Stack))` works
+ * the same way as `alchemy deploy`.
+ */
+export const deploy = <A>(
+  options: MakeOptions,
+  stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>,
+  callOptions?: { stage?: string },
+) =>
+  _deploy({
+    stack: stack as Effect.Effect<CompiledStack<A>, never, any>,
+    stage: callOptions?.stage ?? options.stage ?? "test",
+  }).pipe(Effect.provide(TelemetryLive));
+
+export const destroy = (
+  options: MakeOptions,
+  stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
+  callOptions?: { stage?: string },
+) =>
+  _destroy({
+    stack: stack as Effect.Effect<CompiledStack, never, any>,
+    stage: callOptions?.stage ?? options.stage ?? "test",
+  }).pipe(Effect.provide(TelemetryLive));
+
+/**
+ * In-test scratch stack handed to `test.provider(name, (stack) => ...)`.
+ *
+ * Each scratch stack owns a private in-memory state store that is shared
+ * between successive `deploy`/`destroy` calls AND visible to the user's test
+ * body (so `yield* State` / `state.get(...)` see the same store the deploys
+ * mutated). This makes create / update / replace / delete paths exercisable
+ * without polluting `.alchemy/` or other tests in the same file.
+ */
+export interface ScratchStack<ROut = any> {
+  readonly name: string;
+  /** The shared in-memory state Layer for this scratch. @internal */
+  readonly state: Layer.Layer<State.State, never, never>;
+  deploy<A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<Input.Resolve<A>, any, Exclude<R, ROut | StackServices>>;
+  destroy(): Effect.Effect<void, any, never>;
+}
+
+const sanitizeStackName = (name: string) =>
+  name.replaceAll(/[^a-zA-Z0-9_]/g, "-").replace(/-+/g, "-");
+
+/**
+ * Build a fresh `ScratchStack` for `test.provider`. Allocates a private
+ * in-memory state store so the test is isolated from `.alchemy/` and from
+ * other tests in the same file.
+ */
+export const scratchStack = <ROut>(
+  options: MakeOptions<ROut>,
+  name: string,
+): ScratchStack<ROut> => {
+  const stage = options.stage ?? "test";
+  const stackName = sanitizeStackName(name);
+  const inMemory: Record<
+    string,
+    Record<string, Record<string, State.ResourceState>>
+  > = {};
+  const stateLayer = Layer.succeed(
+    State.State,
+    State.InMemoryService(inMemory),
+  );
+
+  const buildAndApply = (effect: Effect.Effect<any, any, any>) =>
+    (effect as Effect.Effect<any, any, never>).pipe(
+      makeStack({
+        name: stackName,
+        providers: options.providers,
+        state: stateLayer,
+      } as any) as any,
+      Effect.flatMap((compiled: any) =>
+        Plan.make(compiled).pipe(
+          Effect.flatMap(apply),
+          Effect.provide(compiled.services),
+        ),
+      ),
+      Effect.provide(Layer.succeed(Stage, stage)),
+      provideFreshArtifactStore,
+    );
+
+  return {
+    name: stackName,
+    state: stateLayer,
+    deploy: ((effect: Effect.Effect<any, any, any>) =>
+      buildAndApply(effect)) as ScratchStack<ROut>["deploy"],
+    destroy: () =>
+      Plan.make({
+        name: stackName,
+        stage,
+        resources: {},
+        bindings: {},
+        output: {},
+      }).pipe(
+        Effect.flatMap(apply),
+        Effect.asVoid,
+        Effect.provide(stateLayer),
+        Effect.provide(options.providers as Layer.Layer<any, never, any>),
+        Effect.provide(
+          Layer.succeed(Stack, {
+            name: stackName,
+            stage,
+            resources: {},
+            bindings: {},
+          }),
+        ),
+        Effect.provide(Layer.succeed(Stage, stage)),
+        provideFreshArtifactStore,
+      ) as Effect.Effect<void, any, never>,
+  };
+};