effect-cf 0.22.0 → 0.23.1

package/src/DurableObjectState.ts

@@ -2,6 +2,8 @@ import { Cause, Context, Effect, Exit } from "effect";
 
 import { fromDurableObjectStorage, type DurableObjectStorage } from "./DurableObjectStorage";
 import { fromWebSocket, type DurableWebSocket } from "./DurableObjectWebSocket";
+import type { WorkerContextWaitUntilOptions } from "./Worker";
+import { makeWaitUntilScheduler } from "./internal/WorkerContext";
 
 /**
  * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
@@ -15,6 +17,16 @@ export interface DurableObjectStateService {
   readonly storage: DurableObjectStorage;
   /** Registers background work with Cloudflare's lifecycle. */
   waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
+  /**
+   * Runs a background Effect via Cloudflare's `waitUntil` with the caller's
+   * Effect context, mirroring `WorkerContext.waitUntil` failure modes:
+   * `"observe"` (default) logs or routes failures to `onFailure`, while
+   * `"propagate"` also rejects the native `waitUntil` promise.
+   */
+  waitUntil<A, E, R, R2 = never>(
+    effect: Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ): Effect.Effect<void, never, R | R2>;
   /**
    * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
    *
@@ -72,45 +84,60 @@ export class DurableObjectState extends Context.Service<
  */
 export const fromDurableObjectState = (
   state: globalThis.DurableObjectState,
-): DurableObjectStateService => ({
-  raw: state,
-  id: state.id,
-  storage: fromDurableObjectStorage(state.storage),
-  waitUntil: (promise: Promise<unknown>) => Effect.sync(() => state.waitUntil(promise)),
-  blockConcurrencyWhile: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.promise(() =>
-          state.blockConcurrencyWhile(() => runPromiseExitPreservingTypedFailures(context, effect)),
+): DurableObjectStateService => {
+  const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) =>
+    state.waitUntil(promise),
+  );
+  const waitUntil = (<A, E, R, R2 = never>(
+    input: Promise<unknown> | Effect.Effect<A, E, R>,
+    options?: WorkerContextWaitUntilOptions<E, R2>,
+  ) =>
+    Effect.isEffect(input)
+      ? scheduleWaitUntil(input, options, options?.mode ?? "observe")
+      : Effect.sync(() => state.waitUntil(input))) as DurableObjectStateService["waitUntil"];
+
+  return {
+    raw: state,
+    id: state.id,
+    storage: fromDurableObjectStorage(state.storage),
+    waitUntil,
+    blockConcurrencyWhile: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      Effect.context<R>().pipe(
+        Effect.flatMap((context) =>
+          Effect.promise(() =>
+            state.blockConcurrencyWhile(() =>
+              runPromiseExitPreservingTypedFailures(context, effect),
+            ),
+          ),
         ),
+        Effect.flatten,
       ),
-      Effect.flatten,
-    ),
-  blockConcurrencyWhileOrReset: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.promise(() =>
-          state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect)),
+    blockConcurrencyWhileOrReset: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      Effect.context<R>().pipe(
+        Effect.flatMap((context) =>
+          Effect.promise(() =>
+            state.blockConcurrencyWhile(() => Effect.runPromiseWith(context)(effect)),
+          ),
         ),
       ),
+    acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
+      Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
+    getWebSockets: (tag?: string) =>
+      Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
+    setWebSocketAutoResponse: (pair?: WebSocketRequestResponsePair) =>
+      Effect.sync(() => state.setWebSocketAutoResponse(pair)),
+    getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
+    getWebSocketAutoResponseTimestamp: (ws: DurableWebSocket) =>
+      Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
+    setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
+      Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
+    getHibernatableWebSocketEventTimeout: Effect.sync(() =>
+      state.getHibernatableWebSocketEventTimeout(),
     ),
-  acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
-    Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
-  getWebSockets: (tag?: string) =>
-    Effect.sync(() => state.getWebSockets(tag).map((socket) => fromWebSocket(socket))),
-  setWebSocketAutoResponse: (pair?: WebSocketRequestResponsePair) =>
-    Effect.sync(() => state.setWebSocketAutoResponse(pair)),
-  getWebSocketAutoResponse: Effect.sync(() => state.getWebSocketAutoResponse()),
-  getWebSocketAutoResponseTimestamp: (ws: DurableWebSocket) =>
-    Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws.raw)),
-  setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
-    Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-  getHibernatableWebSocketEventTimeout: Effect.sync(() =>
-    state.getHibernatableWebSocketEventTimeout(),
-  ),
-  getTags: (ws: DurableWebSocket) => Effect.sync(() => state.getTags(ws.raw)),
-  abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
-});
+    getTags: (ws: DurableWebSocket) => Effect.sync(() => state.getTags(ws.raw)),
+    abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
+  };
+};
 
 const runPromiseExitPreservingTypedFailures = async <A, E, R>(
   context: Context.Context<R>,

package/src/WorkflowBinding.ts

@@ -177,8 +177,12 @@ export const makeClient = <
       status: operation("status", () => raw.status()).pipe(
         Effect.flatMap((status) =>
           Effect.gen(function* () {
+            // Cloudflare reports `output: null` as a no-output sentinel while an
+            // instance is not complete; only a complete instance may carry a real
+            // null result (e.g. Schema.Null).
             const output =
-              status.output === undefined
+              status.output === undefined ||
+              (status.output === null && status.status !== "complete")
                 ? Option.none<ResultValue>()
                 : Option.some(
                     yield* decodeResult(status.output).pipe(

package/src/internal/WorkerContext.ts

@@ -13,16 +13,14 @@ const causeError = <E>(cause: Cause.Cause<E>) => {
 };
 
 const failureHandler = <E, R>(
+  label: string,
   cause: Cause.Cause<E>,
   options: WorkerContextWaitUntilOptions<E, R> | undefined,
 ) =>
-  (
-    options?.onFailure?.(cause) ??
-    Effect.logError("WorkerContext.waitUntil failed", Cause.pretty(cause))
-  ).pipe(
+  (options?.onFailure?.(cause) ?? Effect.logError(`${label} failed`, Cause.pretty(cause))).pipe(
     Effect.catchCause((handlerCause) =>
       Effect.logError(
-        "WorkerContext.waitUntil failure handler failed",
+        `${label} failure handler failed`,
         Cause.pretty(cause),
         Cause.pretty(handlerCause),
       ),
@@ -30,18 +28,19 @@ const failureHandler = <E, R>(
   );
 
 /**
- * Builds the `WorkerContext` service from a native `ExecutionContext`.
+ * Builds a `waitUntil` scheduler for any Cloudflare lifecycle that accepts
+ * background promises (`ExecutionContext`, `DurableObjectState`).
  *
  * Background effects capture the calling fiber's context via `Effect.context`
- * before being handed to `ctx.waitUntil`, so the default module-level
- * `Effect.runPromiseExit` runner is sufficient; entrypoints may still pass a
- * runtime-bound runner.
+ * before being registered, so the default module-level `Effect.runPromiseExit`
+ * runner is sufficient; entrypoints may still pass a runtime-bound runner.
  */
-export const fromExecutionContext = (
-  ctx: globalThis.ExecutionContext,
+export const makeWaitUntilScheduler = (
+  label: string,
+  register: (promise: Promise<unknown>) => void,
   runPromiseExit: RunWaitUntilEffect = (effect) => Effect.runPromiseExit(effect),
-): WorkerContextService => {
-  const schedule = <A, E, R, R2 = never>(
+) => {
+  return <A, E, R, R2 = never>(
     effect: Effect.Effect<A, E, R>,
     options: WorkerContextWaitUntilOptions<E, R2> | undefined,
     mode: "observe" | "propagate",
@@ -51,17 +50,14 @@ export const fromExecutionContext = (
         Effect.sync(() => {
           const runHandler = (cause: Cause.Cause<E>) =>
             runPromiseExit(
-              Effect.scoped(Effect.provideContext(failureHandler(cause, options), context)),
+              Effect.scoped(Effect.provideContext(failureHandler(label, cause, options), context)),
             ).then((exit) => {
               if (Exit.isFailure(exit)) {
-                console.error(
-                  "WorkerContext.waitUntil failure handler failed",
-                  Cause.pretty(exit.cause),
-                );
+                console.error(`${label} failure handler failed`, Cause.pretty(exit.cause));
               }
             });
 
-          ctx.waitUntil(
+          register(
             runPromiseExit(Effect.scoped(Effect.provideContext(effect, context))).then(
               async (exit) => {
                 if (Exit.isSuccess(exit)) {
@@ -79,6 +75,20 @@ export const fromExecutionContext = (
         }),
       ),
     );
+};
+
+/**
+ * Builds the `WorkerContext` service from a native `ExecutionContext`.
+ */
+export const fromExecutionContext = (
+  ctx: globalThis.ExecutionContext,
+  runPromiseExit: RunWaitUntilEffect = (effect) => Effect.runPromiseExit(effect),
+): WorkerContextService => {
+  const schedule = makeWaitUntilScheduler(
+    "WorkerContext.waitUntil",
+    (promise) => ctx.waitUntil(promise),
+    runPromiseExit,
+  );
 
   return {
     raw: ctx,