alchemy 2.0.0-beta.13 → 2.0.0-beta.14

package/src/Stack.ts

@@ -1,20 +1,29 @@
+import { ConfigProvider } from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { FileSystem } from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
 import { Path } from "effect/Path";
 import type { Scope } from "effect/Scope";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import type { AuthProviders } from "./Auth/AuthProvider.ts";
-import { DotAlchemy } from "./Config.ts";
+import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
+import { provideFreshArtifactStore } from "./Artifacts.ts";
+import { AuthProviders } from "./Auth/AuthProvider.ts";
+import { inkCLIAutoApprove } from "./Cli/InkCLI.tsx";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import { ref } from "./Ref.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
+import type { State } from "./State/State.ts";
+import { loadConfigProvider } from "./Util/ConfigProvider.ts";
 import { taggedFunction } from "./Util/effect.ts";
+import { fileLogger } from "./Util/FileLogger.ts";
+import { PlatformServices } from "./Util/PlatformServices.ts";
 
 export type StackServices =
   | Stack
@@ -22,16 +31,33 @@ export type StackServices =
   | Scope
   | FileSystem
   | Path
-  | DotAlchemy
+  | AlchemyContext
   | HttpClient
   | ChildProcessSpawner
   | AuthProviders;
 
+export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
+  A,
+  Err,
+  | PlatformServices
+  | HttpClient
+  | Scope
+  | AuthProviders
+  | AlchemyContext
+  | State
+  | Req
+>;
+
 export type Stack = Context.ServiceClass.Shape<
   "Stack",
   Omit<StackSpec, "output">
 >;
 
+export interface StackProps<Req> {
+  providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
+  state: Layer.Layer<State, never, StackServices>;
+}
+
 export const Stack: Context.ServiceClass<
   Stack,
   "Stack",
@@ -50,9 +76,7 @@ export const Stack: Context.ServiceClass<
   <Self>(): {
     <A, Req>(
       stackName: string,
-      options: {
-        providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
-      },
+      options: StackProps<NoInfer<Req>>,
       eff: Effect.Effect<A, never, Req>,
     ): Effect.Effect<Self> & {
       new (_: never): A extends object ? A : {};
@@ -75,9 +99,7 @@ export const Stack: Context.ServiceClass<
   };
   <A, Req>(
     stackName: string,
-    options: {
-      providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
-    },
+    options: StackProps<NoInfer<Req>>,
     eff: Effect.Effect<A, never, Req | StackServices>,
   ): Effect.Effect<CompiledStack<A>>;
 } = Object.assign(
@@ -87,23 +109,29 @@ export const Stack: Context.ServiceClass<
       stackName: string,
       options: {
         providers: Layer.Layer<NoInfer<Req>, never, StackServices>;
+        state: Layer.Layer<State, never, StackServices>;
       },
       eff: Effect.Effect<A, never, Req>,
     ) =>
-      eff.pipe(make(stackName, options.providers), (eff) =>
-        Object.assign(eff, {
-          stage: new Proxy(
-            {},
-            {
-              get: (_, stage: string) =>
-                ref({
-                  stack: stackName,
-                  stage,
-                  id: stackName,
-                }),
-            },
-          ),
+      eff.pipe(
+        make({
+          name: stackName,
+          ...options,
         }),
+        (eff) =>
+          Object.assign(eff, {
+            stage: new Proxy(
+              {},
+              {
+                get: (_, stage: string) =>
+                  ref({
+                    stack: stackName,
+                    stage,
+                    id: stackName,
+                  }),
+              },
+            ),
+          }),
       ),
   ),
 ) as any;
@@ -130,38 +158,42 @@ export interface CompiledStack<
 
 export const StackName = Stack.use((stack) => Effect.succeed(stack.name));
 
+export interface MakeStackProps<ROut = never> {
+  name: string;
+  providers: Layer.Layer<ROut, never, StackServices>;
+  state: Layer.Layer<State, never, StackServices>;
+  /** @internal */
+  stack?: StackSpec;
+}
+
 export const make =
-  <ROut = never>(
-    name: string,
-    providers: Layer.Layer<ROut, never, StackServices>,
-    /** @internal */
-    stack?: StackSpec,
-  ) =>
+  <ROut = never>(options: MakeStackProps<ROut>) =>
   <A, Err = never, Req extends ROut | StackServices = never>(
     effect: Effect.Effect<A, Err, Req>,
   ) =>
     Effect.scope.pipe(
-      Effect.flatMap((scope) => {
-        const stackLayer = Layer.effect(
-          Stack,
-          Stage.asEffect().pipe(
-            Effect.map(
-              (stage) =>
-                stack ?? {
-                  name,
-                  stage,
-                  resources: {},
-                  bindings: {},
-                },
+      Effect.flatMap((scope) =>
+        options.providers.pipe(
+          Layer.provideMerge(options.state),
+          Layer.provideMerge(
+            Layer.effect(
+              Stack,
+              Stage.asEffect().pipe(
+                Effect.map(
+                  (stage) =>
+                    options.stack ?? {
+                      name: options.name,
+                      stage,
+                      resources: {},
+                      bindings: {},
+                    },
+                ),
+              ),
             ),
-            Effect.tap(Effect.logInfo),
           ),
-        );
-        return providers.pipe(
-          Layer.provideMerge(stackLayer),
           Layer.buildWithScope(scope),
-        );
-      }),
+        ),
+      ),
       Effect.flatMap((context) =>
         Effect.all([
           effect,
@@ -175,7 +207,7 @@ export const make =
             > => ({
               ...stack,
               output,
-              services,
+              services: Context.merge(services, context),
             }),
           ),
           Effect.provideContext(context),
@@ -186,3 +218,46 @@ export const make =
 export const CurrentStack = Effect.serviceOption(Stack)
   .asEffect()
   .pipe(Effect.map(Option.getOrUndefined));
+
+const platform = Layer.mergeAll(
+  PlatformServices,
+  FetchHttpClient.layer,
+  Logger.layer([fileLogger("out")]),
+);
+// override alchemy state store, CLI/reporting, state, and Config
+const alchemy = Layer.mergeAll(
+  // CLI.inkCLI(),
+  // optional
+  AlchemyContextLive,
+);
+
+export const evalStack = <A, B, Err, Req>(
+  effect: StackEffect<CompiledStack<A>, Stage | AlchemyContext>,
+  fn: (stack: CompiledStack<A>) => Effect.Effect<B, Err, Req>,
+  options: {
+    stage: string;
+  },
+) =>
+  Effect.gen(function* () {
+    const stack = yield* effect;
+    const configProvider = yield* loadConfigProvider(Option.none());
+
+    return yield* fn(stack).pipe(
+      provideFreshArtifactStore,
+      Effect.provide(stack.services),
+      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
+    );
+  }).pipe(
+    Effect.provide(
+      Layer.effect(
+        AuthProviders,
+        Effect.serviceOption(AuthProviders).pipe(
+          Effect.map(Option.getOrElse(() => ({}))),
+        ),
+      ),
+    ),
+    Effect.provide(Layer.succeed(Stage, options.stage)),
+    Effect.provide(inkCLIAutoApprove()),
+    Effect.provide(Layer.provideMerge(alchemy, platform)),
+    Effect.scoped,
+  );

package/src/State/HttpStateApi.ts

@@ -0,0 +1,155 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiError from "effect/unstable/httpapi/HttpApiError";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiMiddleware from "effect/unstable/httpapi/HttpApiMiddleware";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as HttpApiSecurity from "effect/unstable/httpapi/HttpApiSecurity";
+
+export const ResourceStateSchema = Schema.Any;
+
+export class BearerTokenValidator extends Context.Service<
+  BearerTokenValidator,
+  {
+    readonly validate: (
+      token: string,
+    ) => Effect.Effect<void, HttpApiError.Unauthorized>;
+  }
+>()("alchemy/State/BearerTokenValidator") {}
+
+export class StateAuth extends HttpApiMiddleware.Service<
+  StateAuth,
+  { requires: BearerTokenValidator }
+>()("alchemy/State/StateAuth", {
+  security: {
+    bearer: HttpApiSecurity.bearer,
+  },
+  error: HttpApiError.UnauthorizedNoContent,
+}) {}
+
+export const StateAuthLive: Layer.Layer<
+  StateAuth,
+  never,
+  BearerTokenValidator
+> = Layer.effect(
+  StateAuth,
+  Effect.gen(function* () {
+    const validator = yield* BearerTokenValidator;
+    return {
+      bearer: (httpEffect, { credential }) =>
+        validator
+          .validate(Redacted.value(credential))
+          .pipe(Effect.flatMap(() => httpEffect)),
+    };
+  }),
+);
+
+/** `stack` path segment for nested REST resources. */
+const StackParams = Schema.Struct({
+  stack: Schema.String,
+});
+
+/** Optional stage selector for stack deletion. */
+const OptionalStageQuery = Schema.Struct({
+  stage: Schema.optional(Schema.String),
+});
+
+/** `(stack, stage)` path segments shared by stage-scoped endpoints. */
+const StackStage = Schema.Struct({
+  stack: Schema.String,
+  stage: Schema.String,
+});
+
+/** `(stack, stage, fqn)` path segments for a single resource. */
+const ResourceKey = Schema.Struct({
+  stack: Schema.String,
+  stage: Schema.String,
+  fqn: Schema.String,
+});
+
+export const ListStacks = HttpApiEndpoint.get("listStacks", "/state/stacks", {
+  success: Schema.Array(Schema.String),
+});
+
+export const ListStages = HttpApiEndpoint.get(
+  "listStages",
+  "/state/stacks/:stack/stages",
+  {
+    params: StackParams,
+    success: Schema.Array(Schema.String),
+  },
+);
+
+export const ListResources = HttpApiEndpoint.get(
+  "listResources",
+  "/state/stacks/:stack/stages/:stage/resources",
+  {
+    params: StackStage,
+    success: Schema.Array(Schema.String),
+  },
+);
+
+export const GetState = HttpApiEndpoint.get(
+  "getState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    success: Schema.UndefinedOr(ResourceStateSchema),
+  },
+);
+
+export const SetState = HttpApiEndpoint.put(
+  "setState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    payload: ResourceStateSchema,
+    success: ResourceStateSchema,
+  },
+);
+
+export const DeleteState = HttpApiEndpoint.delete(
+  "deleteState",
+  "/state/stacks/:stack/stages/:stage/resources/:fqn",
+  {
+    params: ResourceKey,
+    success: HttpApiSchema.NoContent,
+  },
+);
+
+export const DeleteStack = HttpApiEndpoint.delete(
+  "deleteStack",
+  "/state/stacks/:stack",
+  {
+    params: StackParams,
+    query: OptionalStageQuery,
+    success: HttpApiSchema.NoContent,
+  },
+);
+
+export const GetReplacedResources = HttpApiEndpoint.get(
+  "getReplacedResources",
+  "/state/stacks/:stack/stages/:stage/replaced-resources",
+  {
+    params: StackStage,
+    success: Schema.Array(ResourceStateSchema),
+  },
+);
+
+export class StateGroup extends HttpApiGroup.make("state")
+  .add(ListStacks)
+  .add(ListStages)
+  .add(ListResources)
+  .add(GetState)
+  .add(SetState)
+  .add(DeleteState)
+  .add(GetReplacedResources)
+  .add(DeleteStack)
+  .middleware(StateAuth) {}
+
+export class StateApi extends HttpApi.make("alchemy-state").add(StateGroup) {}

package/src/State/HttpStateStore.ts

@@ -0,0 +1,155 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import { StateApi } from "./HttpStateApi.ts";
+
+import type { ReplacedResourceState, ResourceState } from "./ResourceState.ts";
+import { StateStoreError, type StateService } from "./State.ts";
+import { encodeState, reviveStateRecursive } from "./StateEncoding.ts";
+
+export interface HttpStateStoreProps {
+  url: string;
+  /** Bearer token used to authenticate every request. */
+  authToken: string;
+}
+
+export const makeHttpStateStore = ({ url, authToken }: HttpStateStoreProps) =>
+  Effect.gen(function* () {
+    const apiClient = yield* HttpApiClient.make(StateApi, {
+      baseUrl: url,
+      transformClient: HttpClient.mapRequest(
+        HttpClientRequest.bearerToken(authToken),
+      ),
+    });
+    const state = apiClient.state;
+
+    const service: StateService = {
+      listStacks: () =>
+        state.listStacks().pipe(
+          Effect.map((stacks) => [...stacks]),
+          mapStateStoreError,
+        ),
+      listStages: (stack) =>
+        state.listStages({ params: { stack } }).pipe(mapStateStoreError),
+      list: (request) =>
+        state.listResources({ params: request }).pipe(mapStateStoreError),
+      get: (request) =>
+        state
+          .getState({
+            params: {
+              stack: request.stack,
+              stage: request.stage,
+              fqn: encodeURIComponent(request.fqn),
+            },
+          })
+          .pipe(
+            Effect.map((s) =>
+              s == null
+                ? undefined
+                : (reviveStateRecursive(s) as ResourceState),
+            ),
+            mapStateStoreError,
+          ),
+      getReplacedResources: (request) =>
+        state.getReplacedResources({ params: request }).pipe(
+          Effect.map((resources) =>
+            resources.map(
+              (s) => reviveStateRecursive(s) as ReplacedResourceState,
+            ),
+          ),
+          mapStateStoreError,
+        ),
+      set: <V extends ResourceState>(request: {
+        stack: string;
+        stage: string;
+        fqn: string;
+        value: V;
+      }) =>
+        state
+          .setState({
+            params: {
+              stack: request.stack,
+              stage: request.stage,
+              fqn: encodeURIComponent(request.fqn),
+            },
+            payload: encodeState(request.value),
+          })
+          .pipe(
+            // Server echoes the stored value, but the client already
+            // has the canonical object (including any Redacted<T>
+            // instances); returning the input avoids a lossy round-trip.
+            Effect.map(() => request.value),
+            mapStateStoreError,
+          ),
+      delete: (request) =>
+        state
+          .deleteState({
+            params: {
+              stack: request.stack,
+              stage: request.stage,
+              fqn: encodeURIComponent(request.fqn),
+            },
+          })
+          .pipe(Effect.asVoid, mapStateStoreError),
+      deleteStack: (request) =>
+        state
+          .deleteStack({
+            params: { stack: request.stack },
+            query: request.stage === undefined ? {} : { stage: request.stage },
+          })
+          .pipe(Effect.asVoid, mapStateStoreError),
+    };
+    return service;
+  });
+
+/**
+ * Predicate over an `HttpClientError`-shaped failure that returns `true`
+ * for failures we expect to clear up on their own.
+ *
+ * We retry:
+ * - all transport-level errors (no `response` — DNS, TCP reset, TLS,
+ *   abort, etc.)
+ * - 408 (request timeout) and 429 (rate limit)
+ * - 404, which is normal in the seconds after a worker is first
+ *   deployed and the route hasn't propagated yet
+ * - every 5xx
+ *
+ * Anything else (400/401/403/etc.) is a real client-side problem and
+ * shouldn't be hidden behind retries.
+ */
+const isTransient = (e: any): boolean => {
+  if (e?._tag !== "HttpClientError") return false;
+  const status: number | undefined = e.response?.status;
+  if (status == null) return true;
+  if (status === 404 || status === 408 || status === 429) return true;
+  return status >= 500 && status < 600;
+};
+
+const retryTransient = <A, Err, Req>(eff: Effect.Effect<A, Err, Req>) =>
+  Effect.retry(eff, {
+    while: isTransient,
+    // Exponential backoff capped at 2s, no attempt limit. The state
+    // store is on the deploy critical path; we'd rather block than
+    // surface a transient blip as a hard failure (which historically
+    // stranded `syncState` mid-flight, leaving the remote store
+    // partially populated).
+    schedule: Schedule.exponential(100).pipe(
+      Schedule.either(Schedule.spaced("2 seconds")),
+    ),
+  });
+
+/** Collapse any client failure into a {@link StateStoreError}. */
+const mapStateStoreError = <A, E, R>(eff: Effect.Effect<A, E, R>) =>
+  eff.pipe(
+    retryTransient,
+    Effect.catch((e: E) =>
+      Effect.fail(
+        new StateStoreError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e instanceof Error ? e : undefined,
+        }),
+      ),
+    ),
+  ) as Effect.Effect<A, StateStoreError, R>;

package/src/State/InMemoryState.ts

@@ -1,32 +1,23 @@
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { ResourceState } from "./ResourceState.ts";
-import { State, type StateService } from "./State.ts";
+import { State } from "./State.ts";
 
 type StackId = string;
 type StageId = string;
 type Fqn = string;
 
-export const InMemory = (
+export const inMemoryState = (
   initialState: Record<
     StackId,
     Record<StageId, Record<Fqn, ResourceState>>
   > = {},
-) =>
-  Layer.succeed(State, InMemoryService(initialState)) as Layer.Layer<
-    State,
-    never,
-    never
-  >;
+) => Layer.succeed(State, InMemoryService(initialState));
 
 export const InMemoryService = (
-  initialState: Record<
-    StackId,
-    Record<StageId, Record<Fqn, ResourceState>>
-  > = {},
-) => {
-  const state = initialState;
-  return {
+  state: Record<StackId, Record<StageId, Record<Fqn, ResourceState>>> = {},
+) =>
+  State.of({
     listStacks: () => Effect.succeed(Array.from(Object.keys(state))),
     listStages: (stack: string) =>
       Effect.succeed(
@@ -78,9 +69,16 @@ export const InMemoryService = (
       stage: string;
       fqn: string;
     }) => Effect.succeed(delete state[stack]?.[stage]?.[fqn]),
+    deleteStack: ({ stack, stage }: { stack: string; stage?: string }) =>
+      Effect.sync(() => {
+        if (stage === undefined) {
+          delete state[stack];
+        } else {
+          delete state[stack]?.[stage];
+        }
+      }),
     list: ({ stack, stage }: { stack: string; stage: string }) =>
       Effect.succeed(
         Array.from(Object.keys(state[stack]?.[stage] ?? {}) ?? []),
       ),
-  } satisfies StateService;
-};
+  });

package/src/State/LocalState.ts

@@ -3,53 +3,13 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import type { PlatformError } from "effect/PlatformError";
-import * as Redacted from "effect/Redacted";
 import { decodeFqn, encodeFqn } from "../FQN.ts";
-import { isResource } from "../Resource.ts";
 import { State, StateStoreError, type StateService } from "./State.ts";
+import { encodeState, reviveState } from "./StateEncoding.ts";
 
-const REDACTED_MARKER = "__redacted__";
+export const localState = () => Layer.effect(State, makeLocalState());
 
-const encodeState = (value: unknown): unknown => {
-  if (value === null || value === undefined) return value;
-  if (Redacted.isRedacted(value)) {
-    return {
-      [REDACTED_MARKER]: encodeState(Redacted.value(value)),
-    };
-  }
-  if (isResource(value)) {
-    return {
-      id: value.LogicalId,
-      type: value.Type,
-      props: encodeState(value.Props),
-      attr: encodeState(value.Attributes),
-    };
-  }
-  if (Array.isArray(value)) return value.map(encodeState);
-  if (typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = encodeState(v);
-    }
-    return result;
-  }
-  return value;
-};
-
-const reviveState = (_key: string, value: unknown): unknown => {
-  if (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    REDACTED_MARKER in value
-  ) {
-    return Redacted.make((value as Record<string, unknown>)[REDACTED_MARKER]);
-  }
-  return value;
-};
-
-export const LocalState = Layer.effect(
-  State,
+export const makeLocalState = () =>
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -132,6 +92,15 @@ export const LocalState = Layer.effect(
           Effect.map(() => request.value),
         ),
       delete: (request) => fs.remove(resource(request)).pipe(recover),
+      deleteStack: ({ stack, stage }) =>
+        fs
+          .remove(
+            stage === undefined
+              ? path.join(stateDir, stack)
+              : stageDir({ stack, stage }),
+            { recursive: true },
+          )
+          .pipe(recover),
       list: (request) =>
         fs.readDirectory(stageDir(request)).pipe(
           recover,
@@ -143,5 +112,4 @@ export const LocalState = Layer.effect(
         ),
     };
     return state;
-  }),
-);
+  });