alchemy 2.0.0-beta.14 → 2.0.0-beta.16

package/src/Plan.ts

@@ -1,6 +1,7 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
 import { asEffect } from ".//Util/types.ts";
 import {
   Artifacts,
@@ -271,6 +272,8 @@ export const make = <A>(
           return input;
         } else if (Output.isExpr(input)) {
           return yield* resolveOutput(input);
+        } else if (Redacted.isRedacted(input)) {
+          return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {
             concurrency: "unbounded",

package/src/Stack.ts

@@ -13,7 +13,7 @@ import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSp
 import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
 import { provideFreshArtifactStore } from "./Artifacts.ts";
 import { AuthProviders } from "./Auth/AuthProvider.ts";
-import { inkCLIAutoApprove } from "./Cli/InkCLI.tsx";
+import { Cli } from "./Cli/Cli.ts";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import { ref } from "./Ref.ts";
@@ -34,7 +34,8 @@ export type StackServices =
   | AlchemyContext
   | HttpClient
   | ChildProcessSpawner
-  | AuthProviders;
+  | AuthProviders
+  | Cli;
 
 export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   A,
@@ -44,6 +45,7 @@ export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   | Scope
   | AuthProviders
   | AlchemyContext
+  | Cli
   | State
   | Req
 >;
@@ -172,8 +174,33 @@ export const make =
     effect: Effect.Effect<A, Err, Req>,
   ) =>
     Effect.scope.pipe(
-      Effect.flatMap((scope) =>
-        options.providers.pipe(
+      Effect.flatMap((scope) => {
+        if (options.state == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a state store. ` +
+                `Add a \`state\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(),\n` +
+                `    state: Cloudflare.state(), // <-- required\n` +
+                `  }, ...)\n` +
+                `See https://alchemy.run/concepts/state-store for available state stores.`,
+            ),
+          );
+        }
+        if (options.providers == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a providers layer. ` +
+                `Add a \`providers\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(), // <-- required\n` +
+                `    state: Cloudflare.state(),\n` +
+                `  }, ...)`,
+            ),
+          );
+        }
+        return options.providers.pipe(
           Layer.provideMerge(options.state),
           Layer.provideMerge(
             Layer.effect(
@@ -192,8 +219,8 @@ export const make =
             ),
           ),
           Layer.buildWithScope(scope),
-        ),
-      ),
+        );
+      }),
       Effect.flatMap((context) =>
         Effect.all([
           effect,
@@ -257,7 +284,6 @@ export const evalStack = <A, B, Err, Req>(
       ),
     ),
     Effect.provide(Layer.succeed(Stage, options.stage)),
-    Effect.provide(inkCLIAutoApprove()),
     Effect.provide(Layer.provideMerge(alchemy, platform)),
     Effect.scoped,
   );

package/src/State/HttpStateStore.ts

@@ -143,6 +143,7 @@ const retryTransient = <A, Err, Req>(eff: Effect.Effect<A, Err, Req>) =>
 /** Collapse any client failure into a {@link StateStoreError}. */
 const mapStateStoreError = <A, E, R>(eff: Effect.Effect<A, E, R>) =>
   eff.pipe(
+    Effect.tapError(Effect.log),
     retryTransient,
     Effect.catch((e: E) =>
       Effect.fail(

package/src/Test/Bun.ts

@@ -9,6 +9,7 @@ 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 {
@@ -28,8 +29,7 @@ const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
 
 // override alchemy state store, CLI/reporting, state, and dotAlchemy
 const alchemy = Layer.mergeAll(
-  // CLI.inkCLI(),
-  // optional
+  inkCLI(),
   Logger.layer([Logger.consolePretty()]),
   AlchemyContextLive,
 );

package/src/Test/Vitest.ts

@@ -359,13 +359,17 @@ export namespace test {
   ): Effect.Effect<Input.Resolve<A>, Err, Req | Stack.Stack> =>
     Stack.Stack.use((stack) =>
       effect.pipe(
-        // Effect.tap(Effect.logInfo),
-        // @ts-expect-error
-        Stack.make(stack.name, Layer.effectContext(Effect.context<never>()), {
-          ...stack,
-          resources: {},
-          bindings: {},
-          output: {},
+        // @ts-expect-error - test harness reuses ambient runtime context
+        Stack.make({
+          name: stack.name,
+          providers: Layer.effectContext(Effect.context<never>()),
+          state: State.localState(),
+          stack: {
+            ...stack,
+            resources: {},
+            bindings: {},
+            output: {},
+          },
         }),
         Effect.flatMap(Plan.make),
         Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),