alchemy 2.0.0-beta.40 → 2.0.0-beta.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.40",
+  "version": "2.0.0-beta.41",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",

package/src/Apply.ts

@@ -22,18 +22,17 @@ import type { Input } from "./Input.ts";
 import { generateInstanceId, InstanceId } from "./InstanceId.ts";
 import * as Output from "./Output.ts";
 import {
+  type ActionApply,
   type Apply,
   type Delete,
   type Plan,
-  type ActionApply,
-  type ActionDelete,
 } from "./Plan.ts";
 import { findProviderByType } from "./Provider.ts";
 import type { ResourceBinding } from "./Resource.ts";
 import { Stack } from "./Stack.ts";
 import { Stage } from "./Stage.ts";
-import { recordResourceOp, type ResourceOp } from "./Telemetry/Metrics.ts";
 import {
+  type ActionState,
   type CreatedResourceState,
   type CreatingResourceState,
   type DeletingResourceState,
@@ -43,12 +42,12 @@ import {
   type ReplacingResourceState,
   type ResourceState,
   type RunningActionState,
-  type ActionState,
   type UpdatedResourceState,
   type UpdatingReourceState,
   State,
   StateStoreError,
 } from "./State/index.ts";
+import { type ResourceOp, recordResourceOp } from "./Telemetry/Metrics.ts";
 import { hashInput } from "./Util/hash.ts";
 
 export type ApplyEffect<
@@ -405,12 +404,31 @@ const executeNode = (
       });
 
     const markTerminal = (status: "created" | "updated") =>
-      Effect.sync(() => {
+      Effect.gen(function* () {
         terminalStatuses.set(fqn, {
           id: logicalId,
           type: node.resource.Type,
           status,
         });
+        // Emit immediately so the CLI surfaces the terminal status as soon
+        // as the resource is actually done — instead of batching every
+        // resource's "created"/"updated" event to the end of apply(), which
+        // makes long-running siblings appear stuck in "creating" until the
+        // entire deploy finishes.
+        //
+        // Cycle members are exempt: their initial pass produces an
+        // intermediate result that Phase 3 (`converge`) will overwrite once
+        // the SCC reaches a fixed point. Emitting "created"/"updated" here
+        // would surface that intermediate state to the CLI before the real
+        // terminal status is known. Their final status is flushed from
+        // `terminalStatuses` after `converge` completes.
+        if (inCycle) return;
+        yield* session.emit({
+          kind: "status-change",
+          id: logicalId,
+          type: node.resource.Type,
+          status,
+        });
       });
 
     const signalReady = Deferred.succeed(ready[fqn], void 0);
@@ -576,11 +594,16 @@ const executeNode = (
           });
         }
 
-        yield* report("creating");
+        // While we're waiting on upstream outputs the resource isn't actually
+        // creating anything yet — surface that as "pending" so the CLI doesn't
+        // look stuck in "creating" for slow-upstream deploys.
+        yield* report("pending");
 
         // Create runs against fully resolved upstream outputs and bindings, not the
         // raw Output expressions stored in the plan.
         yield* waitForDeps(allUpstreamFqns());
+
+        yield* report("creating");
         const outputs = getOutputs();
 
         const news = (yield* Output.evaluate(node.props, outputs)) as Record<
@@ -662,6 +685,9 @@ const executeNode = (
           });
         }
 
+        // See create-flow note: while we're waiting on upstream outputs
+        // this resource isn't actually updating yet.
+        yield* report("pending");
         yield* waitForDeps(allUpstreamFqns());
         const outputs = getOutputs();
 
@@ -867,11 +893,15 @@ const executeNode = (
           });
         }
 
-        yield* report("creating replacement");
+        // See create-flow note: while we're waiting on upstream outputs
+        // the replacement isn't actually being created yet.
+        yield* report("pending");
 
         // Replacement create is evaluated exactly like create, but against the new
         // generation's instance id and with the previous generations preserved in `old`.
         yield* waitForDeps(allUpstreamFqns());
+
+        yield* report("creating replacement");
         const outputs = getOutputs();
 
         const news = (yield* Output.evaluate(node.props, outputs)) as Record<
@@ -1052,13 +1082,16 @@ const executeActionNode = (
         type: task.Type,
         status: "skipped",
       });
+      yield* report("skipped");
       return;
     }
 
     // ── run ──
-    // Wait for stable (post-reconcile) upstream attrs — not precreate stubs.
-    // This is `waitForStableDeps` at the call site, passed in as the
-    // `waitForDeps` parameter here.
+    // Tasks wait on `waitForStableDeps` (post-reconcile attrs) for their
+    // upstreams, which is often the slowest dep chain in the deploy.
+    // Surface that as "pending" instead of having the task show no status
+    // until its run actually starts.
+    yield* report("pending");
     yield* waitForDeps(
       Object.keys(Output.resolveUpstream(node.input)).filter(
         (f) => f in readyStable,
@@ -1108,6 +1141,7 @@ const executeActionNode = (
       type: task.Type,
       status: "ran",
     });
+    yield* report("ran");
   }).pipe(
     Effect.catchCause((cause) =>
       Effect.gen(function* () {

package/src/Cli/Event.ts

@@ -12,7 +12,7 @@ export type ApplyStatus =
   | "deleted"
   | "replacing"
   | "replaced"
-  // Task lifecycle (see {@link Task})
+  // Action lifecycle (see {@link Action})
   | "running"
   | "ran"
   | "skipped"

package/src/Cloudflare/Bridge.ts

@@ -1,2 +1,3 @@
 export * from "./Workers/InferEnv.ts";
 export * from "./Workers/Rpc.ts";
+export * from "./Workers/RpcAsync.ts";

package/src/Cloudflare/Container/ContainerBinding.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect";
-import { type Rpc } from "../../Platform.ts";
+import { type Rpc } from "../../Rpc.ts";
 import {
   fromCloudflareFetcher,
   toCloudflareFetcher,

package/src/Cloudflare/Fetcher.ts

@@ -6,7 +6,11 @@ import { pipe } from "effect/Function";
 import * as Latch from "effect/Latch";
 import * as Scope from "effect/Scope";
 import * as HttpBody from "effect/unstable/http/HttpBody";
-import { HttpClientError } from "effect/unstable/http/HttpClientError";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import {
+  HttpClientError,
+  TransportError,
+} from "effect/unstable/http/HttpClientError";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 import type { HttpServerError } from "effect/unstable/http/HttpServerError";
@@ -118,6 +122,39 @@ export const fromCloudflareFetcher = (fetcher: cf.Fetcher): Fetcher => {
   };
 };
 
+/**
+ * Adapt anything that exposes a server-shaped `fetch` (e.g. a Durable Object
+ * stub, a Worker service binding) into an Effect `HttpClient`. Lets HttpApi
+ * clients address bindings without a base URL via `transformClient`.
+ */
+export const toHttpClient = (fetcher: {
+  fetch: (
+    request: HttpServerRequest.HttpServerRequest,
+  ) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError>;
+}) =>
+  HttpClient.make((request) => {
+    console.log("toHttpClient: request", request.url);
+    return fetcher.fetch(HttpServerRequest.fromClientRequest(request)).pipe(
+      Effect.map((response) => {
+        console.log("toHttpClient: response", response);
+        return HttpClientResponse.fromWeb(
+          request,
+          HttpServerResponse.toWeb(response),
+        );
+      }),
+      Effect.mapError(
+        (cause) =>
+          new HttpClientError({
+            reason: new TransportError({
+              request,
+              cause,
+              description: "Fetcher-backed HttpClient request failed",
+            }),
+          }),
+      ),
+    );
+  });
+
 export const fromCloudflareSocket = (cfSocket: cf.Socket): Socket.Socket => {
   const latch = Latch.makeUnsafe(false);
   let currentFiberSet: FiberSet.FiberSet<any, any> | undefined;

package/src/Cloudflare/Local/SidecarHandlers.ts

@@ -44,13 +44,10 @@ import { Stack } from "../../Stack.ts";
 import { Stage } from "../../Stage.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { getCompatibility } from "../Workers/Compatibility.ts";
-import { getCronBindings } from "../Workers/index.ts";
 import * as Vite from "../Workers/Vite.ts";
-import type {
-  Worker,
-  WorkerAssetsConfig,
-  WorkerBinding,
-} from "../Workers/Worker.ts";
+import type { Worker, WorkerAssetsConfig } from "../Workers/Worker.ts";
+import { getCronBindings } from "../Workers/WorkerAsyncBindings.ts";
+import type { WorkerBinding } from "../Workers/WorkerBinding.ts";
 import {
   WorkerBundle,
   type WorkerBundleOptions,

package/src/Cloudflare/Website/StaticSite.ts

@@ -8,12 +8,16 @@ import {
   Worker,
   type WorkerAssetsConfig,
   type WorkerBindingProps,
+  type WorkerEnv,
   type WorkerProps,
 } from "../Workers/Worker.ts";
 
-export interface StaticSiteProps<Bindings extends WorkerBindingProps = {}>
+export interface StaticSiteProps<
+  Bindings extends WorkerBindingProps = {},
+  Env extends WorkerEnv = WorkerEnv,
+>
   extends
-    Omit<WorkerProps<Bindings, WorkerAssetsConfig>, "assets">,
+    Omit<WorkerProps<Bindings, Env, WorkerAssetsConfig>, "assets">,
     Omit<CommandProps, "env"> {
   /**
    * Optional configuration for static asset routing behavior.
@@ -116,12 +120,13 @@ export type StaticSite = ReturnType<typeof StaticSite>;
  */
 export const StaticSite = <
   const Bindings extends WorkerBindingProps = {},
+  const Env extends WorkerEnv = WorkerEnv,
   Req = never,
 >(
   id: string,
   propsEff:
-    | InputProps<StaticSiteProps<Bindings>>
-    | Effect.Effect<InputProps<StaticSiteProps<Bindings>>, never, Req>,
+    | InputProps<StaticSiteProps<Bindings, Env>>
+    | Effect.Effect<InputProps<StaticSiteProps<Bindings, Env>>, never, Req>,
 ) =>
   Effect.gen(function* () {
     const props = Effect.isEffect(propsEff)
@@ -149,7 +154,7 @@ export const StaticSite = <
       })),
     );
 
-    return yield* Worker<Bindings, WorkerAssetsConfig, Req>(
+    return yield* Worker<Bindings, Env, WorkerAssetsConfig, Req>(
       "Worker",
       Effect.map(props, (props) => ({
         ...props,

package/src/Cloudflare/Website/Vite.ts

@@ -5,12 +5,14 @@ import {
   Worker,
   type WorkerAssetsConfig,
   type WorkerBindingProps,
+  type WorkerEnv,
   type WorkerProps,
 } from "../Workers/Worker.ts";
 
 export interface ViteProps<
   Bindings extends WorkerBindingProps = {},
-> extends Omit<WorkerProps<Bindings>, "vite" | "main"> {
+  Env extends WorkerEnv = {},
+> extends Omit<WorkerProps<Bindings, Env>, "vite" | "main"> {
   /**
    * Root directory passed to Vite's `root` option.
    * Defaults to the current working directory (`process.cwd()`).
@@ -109,14 +111,15 @@ export interface ViteProps<
  */
 export const Vite = <
   const Bindings extends WorkerBindingProps = {},
+  const Env extends WorkerEnv = {},
   Req = never,
 >(
   id: string,
   propsEff?:
-    | InputProps<ViteProps<Bindings>>
-    | Effect.Effect<InputProps<ViteProps<Bindings>>, never, Req>,
+    | InputProps<ViteProps<Bindings, Env>>
+    | Effect.Effect<InputProps<ViteProps<Bindings, Env>>, never, Req>,
 ) =>
-  Worker<Bindings, WorkerAssetsConfig, Req>(
+  Worker<Bindings, Env, WorkerAssetsConfig, Req>(
     id,
     Effect.map(
       Effect.isEffect(propsEff) ? propsEff : Effect.succeed(propsEff),

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -0,0 +1,180 @@
+import type * as cf from "@cloudflare/workers-types";
+import type { DurableObject as DurableObjectClass } from "cloudflare:workers";
+
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+
+import { HttpServerResponse } from "effect/unstable/http";
+import type {
+  DurableObjectExport,
+  DurableObjectShape,
+} from "./DurableObjectNamespace.ts";
+import {
+  DurableObjectState,
+  fromDurableObjectState,
+} from "./DurableObjectState.ts";
+import { makeRequestEffect } from "./HttpServer.ts";
+import { fromWebSocket } from "./WebSocket.ts";
+import { getWorkerExport, handleRpcExit } from "./WorkerBridge.ts";
+
+/**
+ * Create a DurableObjectBridge class that proxies RPC method calls through
+ * the Effect runtime, encoding success/fail/stream results as RPC envelopes.
+ *
+ * Accepts the `DurableObject` base class and a `getExport` resolver so the
+ * implementation lives in real TypeScript instead of a generated string template.
+ */
+export const makeDurableObjectBridge =
+  (
+    DurableObject: typeof DurableObjectClass,
+    {
+      entrypoint,
+      stack,
+    }: {
+      entrypoint: Effect.Effect<Record<string, any>>;
+      stack: {
+        name: string;
+        stage: string;
+      };
+    },
+  ) =>
+  (className: string) =>
+    class DurableObjectBridge extends DurableObject {
+      #state;
+      #globalContext;
+      #exported;
+      #instance;
+      constructor(state: cf.DurableObjectState, env: any) {
+        super(state as any, env);
+        this.#state = state;
+
+        const { globalContext, exported } =
+          getWorkerExport<DurableObjectExport>({
+            entrypoint,
+            stack,
+            exportName: className,
+          });
+
+        this.#globalContext = globalContext;
+        this.#exported = exported;
+
+        this.#instance = state.blockConcurrencyWhile(() =>
+          this.#exported.pipe(
+            Effect.flatMap(({ constructor, services }) =>
+              constructor.pipe(
+                Effect.provide(
+                  Layer.succeed(
+                    DurableObjectState,
+                    fromDurableObjectState(this.#state),
+                  ).pipe(Layer.provideMerge(Layer.succeedContext(services))),
+                ),
+                Effect.map((instance) => ({ instance, services })),
+              ),
+            ),
+            Effect.provide(this.#globalContext),
+            Effect.runPromise,
+          ),
+        );
+
+        return new Proxy(this, {
+          get: (target, prop) => {
+            console.log(target, prop, prop in target);
+            const bind = (f: any) =>
+              typeof f === "function" ? f.bind(target) : f;
+            if (typeof prop !== "string") return bind((target as any)[prop]);
+            if (prop in target) return bind((target as any)[prop]);
+            return async (...args: any[]) =>
+              this.#execute((instance) => {
+                const method = instance[prop as keyof DurableObjectShape];
+                if (typeof method === "function") {
+                  return (method as any)(...args);
+                } else if (Effect.isEffect(method)) {
+                  return method;
+                } else {
+                  return Effect.succeed(method);
+                }
+              }, handleRpcExit);
+          },
+        });
+      }
+
+      async #execute(
+        fn: (instance: DurableObjectShape) => Effect.Effect<any, any, any>,
+        onExit?: (exit: Exit.Exit<any, any>) => Promise<any>,
+      ) {
+        const scope = Scope.makeUnsafe();
+
+        const { instance, services } = await this.#instance;
+
+        return fn(instance)
+          .pipe(
+            Effect.provide(
+              Layer.succeed(
+                DurableObjectState,
+                fromDurableObjectState(this.#state),
+              ).pipe(
+                Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
+                Layer.provideMerge(Layer.succeedContext(services)),
+                Layer.provideMerge(this.#globalContext),
+              ),
+            ),
+            Effect.runPromiseExit,
+          )
+          .then(
+            onExit ??
+              ((exit) =>
+                exit._tag === "Success"
+                  ? Promise.resolve(exit.value)
+                  : Promise.reject(Cause.squash(exit.cause))),
+          )
+          .finally(() =>
+            Scope.close(scope, Exit.void).pipe(Effect.runPromise, (promise) =>
+              this.#state.waitUntil(promise),
+            ),
+          );
+      }
+
+      async fetch(request: Request): Promise<any> {
+        return this.#execute((instance) =>
+          instance.fetch
+            ? makeRequestEffect(request as any, instance.fetch)
+            : Effect.succeed(
+                HttpServerResponse.text("Not implemented", {
+                  status: 404,
+                }),
+              ),
+        );
+      }
+
+      async alarm(alarmInfo?: cf.AlarmInvocationInfo) {
+        return this.#execute((instance) => instance.alarm!(alarmInfo));
+      }
+
+      async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
+        return this.#execute(
+          (instance) =>
+            instance.webSocketMessage?.(fromWebSocket(ws as any), message) ??
+            Effect.void,
+        );
+      }
+
+      async webSocketClose(
+        ws: WebSocket,
+        code: number,
+        reason: string,
+        wasClean: boolean,
+      ) {
+        return this.#execute(
+          (instance) =>
+            instance.webSocketClose?.(
+              fromWebSocket(ws as any),
+              code,
+              reason,
+              wasClean,
+            ) ?? Effect.void,
+        );
+      }
+    } as any;

package/src/Cloudflare/Workers/DurableObjectNamespace.ts

@@ -9,29 +9,25 @@ import type { HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
 import type { PlatformServices } from "../../Platform.ts";
 import { effectClass, taggedFunction } from "../../Util/effect.ts";
-import {
-  DurableObjectState,
-  fromDurableObjectState,
-} from "./DurableObjectState.ts";
+import { DurableObjectState } from "./DurableObjectState.ts";
 import { makeRpcStub } from "./Rpc.ts";
 import { type DurableWebSocket } from "./WebSocket.ts";
 import { Worker, WorkerEnvironment, type WorkerServices } from "./Worker.ts";
 
 export interface DurableObjectExport {
   readonly kind: "durableObject";
-  readonly make: (
-    state: cf.DurableObjectState,
-    env: any,
-  ) => Effect.Effect<Record<string, unknown>>;
+  readonly constructor: Effect.Effect<
+    DurableObjectShape,
+    never,
+    DurableObjectState
+  >;
+  readonly services: Context.Context<never>;
 }
 
 export const isDurableObjectExport = (
   value: unknown,
 ): value is DurableObjectExport =>
-  typeof value === "object" &&
-  value !== null &&
-  "kind" in value &&
-  (value as any).kind === "durableObject";
+  typeof value === "object" && (value as any)?.kind === "durableObject";
 
 export type DurableObjectId = cf.DurableObjectId;
 export type DurableObjectJurisdiction = cf.DurableObjectJurisdiction;
@@ -46,10 +42,7 @@ const TypeId = "Cloudflare.DurableObjectNamespace";
 export const isDurableObjectNamespaceLike = (
   value: unknown,
 ): value is DurableObjectNamespaceLike =>
-  typeof value === "object" &&
-  value !== null &&
-  "kind" in value &&
-  value.kind === TypeId;
+  typeof value === "object" && (value as any)?.kind === TypeId;
 
 export interface DurableObjectNamespaceLike<Shape = any> {
   kind: TypeId;
@@ -574,11 +567,7 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
               const [namespace, impl] = args as any as [
                 name: string,
                 impl: Effect.Effect<
-                  Effect.Effect<
-                    DurableObjectNamespace<any>,
-                    never,
-                    DurableObjectState
-                  >
+                  Effect.Effect<DurableObjectShape, never, DurableObjectState>
                 >,
               ];
               const worker = yield* Worker;
@@ -600,52 +589,6 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
                 ],
               });
 
-              const services =
-                yield* Effect.context<Effect.Services<typeof impl>>();
-
-              yield* worker.export(namespace, {
-                kind: "durableObject",
-                make: (state: cf.DurableObjectState, env: any) => {
-                  const doState = fromDurableObjectState(state);
-                  return constructor.pipe(
-                    Effect.provideContext(services),
-                    Effect.provideService(DurableObjectState, doState),
-                    Effect.provideService(WorkerEnvironment, env),
-                    Effect.map((methods: any) => {
-                      const wrapped: Record<string, unknown> = {};
-                      for (const key of Object.getOwnPropertyNames(methods)) {
-                        const value = methods[key];
-                        if (Effect.isEffect(value)) {
-                          wrapped[key] = (
-                            value as Effect.Effect<any, any, any>
-                          ).pipe(
-                            Effect.provideService(DurableObjectState, doState),
-                          );
-                        } else if (typeof value === "function") {
-                          wrapped[key] = (...args: unknown[]) => {
-                            const result = (value as Function)(...args);
-                            if (Effect.isEffect(result)) {
-                              return (
-                                result as Effect.Effect<any, any, any>
-                              ).pipe(
-                                Effect.provideService(
-                                  DurableObjectState,
-                                  doState,
-                                ),
-                              );
-                            }
-                            return result;
-                          };
-                        } else {
-                          wrapped[key] = value;
-                        }
-                      }
-                      return wrapped;
-                    }),
-                  );
-                },
-              } satisfies DurableObjectExport);
-
               const binding = yield* Effect.serviceOption(
                 WorkerEnvironment,
               ).pipe(
@@ -699,9 +642,18 @@ export const DurableObjectNamespace: DurableObjectNamespaceClass =
                 //   use((ns) => ns.jurisdiction(jurisdiction) as any),
               };
 
-              const constructor = yield* impl.pipe(
-                Effect.provideService(DurableObjectNamespaceScope, self as any),
-              );
+              yield* worker.export(namespace, {
+                kind: "durableObject",
+                // initialize the object's constructor (apply infra dependencies)
+                constructor: yield* impl.pipe(
+                  Effect.provideService(
+                    DurableObjectNamespaceScope,
+                    self as any,
+                  ),
+                ),
+                // grab the object's infra dependencies so we can apply them when calling the instance's methods
+                services: yield* Effect.context<Effect.Services<typeof impl>>(),
+              } satisfies DurableObjectExport);
 
               return self;
             }),