alchemy 2.0.0-beta.37 → 2.0.0-beta.39

package/src/Runtime.ts

@@ -0,0 +1,38 @@
+/**
+ * Runtime helpers consumed by generated bundle entrypoints (Cloudflare
+ * Workers, Cloudflare Containers, AWS Lambda, …).
+ *
+ * Anything exported here runs *inside* the deployed function — keep the
+ * surface tiny and dependency-light.
+ */
+
+import * as Layer from "effect/Layer";
+
+/**
+ * Resolve the user's default-export entrypoint into a `Layer` for the
+ * bundled runtime.
+ *
+ * `entrypoint` may be any of:
+ *   - a `Layer` factory (`{ build: (...) => ... }`) — used as-is
+ *   - an effect-class with `asEffect()` (Alchemy `Platform`/`Worker` shape)
+ *   - a plain `Effect`
+ *
+ * Centralized so the inline ternary doesn't have to be re-emitted into
+ * every bundle template (and accidentally rewritten to `x : x` by a bulk
+ * replace, which silently swaps the class in for the Effect and bricks
+ * every deployed worker/lambda).
+ */
+export const makeEntrypointLayer = (
+  tag: any,
+  entrypoint: any,
+): Layer.Layer<any> => {
+  if (typeof entrypoint?.build === "function") {
+    return entrypoint;
+  }
+  return Layer.effect(
+    tag,
+    typeof entrypoint?.asEffect === "function"
+      ? entrypoint.asEffect()
+      : entrypoint,
+  );
+};

package/src/Secret.ts

@@ -78,7 +78,7 @@ export const toOutput = <T, R = never>(
     return source;
   }
   if (Config.isConfig(source)) {
-    return Output.asOutput(source.asEffect() as any) as Output.Output<T, R>;
+    return Output.asOutput(source as any) as Output.Output<T, R>;
   }
   if (Effect.isEffect(source)) {
     return Output.asOutput(source as any) as Output.Output<T, R>;

package/src/Stack.ts

@@ -20,6 +20,7 @@ import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
+import type { ActionLike } from "./Action.ts";
 import type { State } from "./State/State.ts";
 import { loadConfigProvider } from "./Util/ConfigProvider.ts";
 import { effectClass, taggedFunction } from "./Util/effect.ts";
@@ -164,6 +165,10 @@ export interface StackSpec<Output = any> {
   bindings: {
     [logicalId: string]: ResourceBinding[];
   };
+  /** Tasks registered on the stack, keyed by FQN. */
+  actions: {
+    [logicalId: string]: ActionLike;
+  };
   output: Output;
 }
 
@@ -221,7 +226,7 @@ export const make =
           Layer.provideMerge(
             Layer.effect(
               Stack,
-              Stage.asEffect().pipe(
+              Stage.pipe(
                 Effect.map(
                   (stage) =>
                     options.stack ?? {
@@ -229,6 +234,7 @@ export const make =
                       stage,
                       resources: {},
                       bindings: {},
+                      actions: {},
                     },
                 ),
               ),
@@ -240,7 +246,7 @@ export const make =
       Effect.flatMap((context) =>
         Effect.all([
           effect,
-          Stack.asEffect(),
+          Stack,
           Effect.context<ROut | StackServices>(),
         ]).pipe(
           Effect.map(
@@ -259,7 +265,7 @@ export const make =
     );
 
 export const CurrentStack = Effect.serviceOption(Stack)
-  .asEffect()
+
   .pipe(Effect.map(Option.getOrUndefined));
 
 const platform = Layer.mergeAll(
@@ -278,9 +284,7 @@ const alchemy = (overrides?: { dev?: boolean }) =>
       ? Layer.provide(
           Layer.effect(
             AlchemyContext,
-            AlchemyContext.asEffect().pipe(
-              Effect.map((ctx) => ({ ...ctx, dev: overrides.dev! })),
-            ),
+            AlchemyContext.useSync((ctx) => ({ ...ctx, dev: overrides.dev! })),
           ),
           AlchemyContextLive,
         )

package/src/State/ActionState.ts

@@ -0,0 +1,51 @@
+import type { NamespaceNode } from "../Namespace.ts";
+
+/**
+ * Persisted state for an {@link Action}. Actions share the same FQN
+ * namespace as resources but are discriminated by `kind: "action"`. The
+ * engine keys action state in the {@link State} store under the same `fqn`
+ * field as resources.
+ */
+export type ActionState = RunningActionState | RanActionState;
+
+export type ActionStatus = ActionState["status"];
+
+interface BaseActionState {
+  readonly kind: "action";
+  /** Type of the Action (e.g. "NightlySync"). Mirrors `resourceType` for resources. */
+  actionType: string;
+  /** Namespace of the Action. */
+  namespace: NamespaceNode | undefined;
+  /** Fully qualified name (namespace + logical id). */
+  fqn: string;
+  /** Logical id of the Action (stable across runs). */
+  logicalId: string;
+  /** Current status. */
+  status: ActionStatus;
+  /** FQNs of nodes that depend on this Action's output. */
+  downstream: string[];
+  /** Hash of the resolved input, used to skip noop runs. */
+  inputHash: string;
+  /** Resolved input snapshot from the most recent attempt. */
+  input: unknown;
+}
+
+/**
+ * The Action body has started but persistence after success has not yet
+ * occurred. On resume the engine treats this as "should run" since the
+ * effect may have completed but the output wasn't durably recorded.
+ */
+export interface RunningActionState extends BaseActionState {
+  status: "running";
+}
+
+/**
+ * The Action body completed and its output is durably persisted. Future
+ * plans skip the body when `inputHash` matches the new resolved input
+ * (unless `--force` is set).
+ */
+export interface RanActionState extends BaseActionState {
+  status: "ran";
+  /** Materialized output value returned by the Action body. */
+  output: unknown;
+}

package/src/State/HttpStateStore.ts

@@ -7,7 +7,11 @@ 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 {
+  StateStoreError,
+  type StateService,
+  type PersistedState,
+} from "./State.ts";
 import { encodeState, reviveStateRecursive } from "./StateEncoding.ts";
 
 /**
@@ -90,7 +94,7 @@ export const makeHttpStateStore = ({
           ),
           mapStateStoreError,
         ),
-      set: <V extends ResourceState>(request: {
+      set: <V extends PersistedState>(request: {
         stack: string;
         stage: string;
         fqn: string;

package/src/State/InMemoryState.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { recordStateStoreInit } from "../Telemetry/Metrics.ts";
 import type { ResourceState } from "./ResourceState.ts";
-import { State } from "./State.ts";
+import { State, type PersistedState } from "./State.ts";
 
 type StackId = string;
 type StageId = string;
@@ -54,7 +54,7 @@ export const InMemoryService = (
           (s) => s.status === "replaced",
         ),
       ),
-    set: <V extends ResourceState>({
+    set: <V extends PersistedState>({
       stack,
       stage,
       fqn,
@@ -68,7 +68,7 @@ export const InMemoryService = (
       Effect.sync(() => {
         const stackState = (state[stack] ??= {});
         const stageState = (stackState[stage] ??= {});
-        stageState[fqn] = value;
+        stageState[fqn] = value as ResourceState;
         return value;
       }),
     delete: ({

package/src/State/ResourceState.ts

@@ -27,6 +27,11 @@ export type ReplacementOldResourceState =
   | ReplacementResourceState;
 
 interface BaseResourceState {
+  /**
+   * Discriminator vs {@link ActionState}. Optional for back-compat: legacy
+   * persisted rows have no `kind` field and are implicitly resources.
+   */
+  readonly kind?: "resource";
   /** Type of the Resource (e.g. AWS.Lambda.Function) */
   resourceType: string;
   /** Namespace of the Resource */

package/src/State/State.ts

@@ -2,6 +2,21 @@ import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import type { ReplacedResourceState, ResourceState } from "./ResourceState.ts";
+import type { ActionState } from "./ActionState.ts";
+
+/**
+ * Anything persistable under an FQN. Resources are discriminated by status
+ * strings ("creating", "created", …) and Tasks by `kind: "action"`.
+ */
+export type PersistedState = ResourceState | ActionState;
+
+export const isActionState = (
+  s: PersistedState | undefined,
+): s is ActionState => !!s && (s as any).kind === "action";
+
+export const isResourceState = (
+  s: PersistedState | undefined,
+): s is ResourceState => !!s && (s as any).kind !== "task";
 
 export class StateStoreError extends Data.TaggedError("StateStoreError")<{
   message: string;
@@ -41,7 +56,7 @@ export interface StateService {
     stack: string;
     stage: string;
     fqn: string;
-  }): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
+  }): Effect.Effect<PersistedState | undefined, StateStoreError, never>;
   /**
    * List top-level resources that are still in replacement cleanup.
    *
@@ -59,7 +74,7 @@ export interface StateService {
   /**
    * Set a resource by its FQN (namespace-qualified key).
    */
-  set<V extends ResourceState>(request: {
+  set<V extends PersistedState>(request: {
     stack: string;
     stage: string;
     fqn: string;

package/src/State/index.ts

@@ -4,5 +4,6 @@ export * from "./InMemoryState.ts";
 export * from "./LocalState.ts";
 export * from "./ResourceState.ts";
 export * from "./State.ts";
+export * from "./ActionState.ts";
 export * from "./StateEncoding.ts";
 export * from "./Sync.ts";

package/src/Test/Core.ts

@@ -67,9 +67,7 @@ export const resolveDev = (options: { dev?: boolean }): boolean => {
 const overrideAlchemyContext = (overrides: { dev: boolean }) =>
   Layer.effect(
     AlchemyContext,
-    AlchemyContext.asEffect().pipe(
-      Effect.map((ctx) => ({ ...ctx, ...overrides })),
-    ),
+    AlchemyContext.pipe(Effect.map((ctx) => ({ ...ctx, ...overrides }))),
   );
 
 export type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
@@ -153,6 +151,7 @@ export const withProviders = <A, E, R, ROut>(
         stage: options.stage ?? "test",
         resources: {},
         bindings: {},
+        actions: {},
       }),
     ),
     Effect.provide(Layer.succeed(Stage, options.stage ?? "test")),
@@ -262,6 +261,7 @@ export const scratchStack = <ROut>(
         stage,
         resources: {},
         bindings: {},
+        actions: {},
         output: {},
       }).pipe(
         Effect.flatMap(apply),
@@ -274,6 +274,7 @@ export const scratchStack = <ROut>(
             stage,
             resources: {},
             bindings: {},
+            actions: {},
           }),
         ),
         Effect.provide(Layer.succeed(Stage, stage)),

package/src/Util/effect.ts

@@ -27,10 +27,10 @@ export const effectClass: {
             return impl;
           }
           static [Symbol.iterator]() {
-            return new SingleShotGen(this);
+            return new SingleShotGen(this.asEffect());
           }
           static pipe(...fns: any) {
-            return pipeArguments(this.asEffect(), fns);
+            return pipeArguments(this, fns);
           }
         },
         impl,
@@ -44,9 +44,9 @@ export const taggedFunction = <
   fn: Fn,
 ): Tag & Fn => {
   const overrides = {
-    asEffect: () => tag.asEffect(),
+    asEffect: () => tag,
     [Symbol.iterator]: () => tag[Symbol.iterator](),
-    pipe: (...fns: any[]) => pipeArguments(tag.asEffect(), fns as any),
+    pipe: (...fns: any[]) => pipeArguments(tag, fns as any),
     toString: () => `${tag.toString()}.${fn.name}`,
   };
 

package/src/Util/hash.ts

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+import * as Effect from "effect/Effect";
+
+/**
+ * Stable hash of a resolved Task input. Wrapped in `Effect.sync` so the
+ * call participates in the Effect runtime (tracing/interruption) per the
+ * Effect-platform conventions.
+ */
+export const hashInput = (input: unknown): Effect.Effect<string> =>
+  Effect.sync(() =>
+    createHash("sha256")
+      .update(JSON.stringify(input ?? null))
+      .digest("hex"),
+  );