effect-cf 0.40.3 → 0.41.1

package/src/DurableObjectNamespace.ts

@@ -11,6 +11,7 @@ import * as RpcDefinition from "./RpcDefinition";
 import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
 import * as RpcTracing from "./RpcTracing";
+import * as RpcTargets from "./RpcTargets";
 
 const expectedDurableObjectNamespace =
   "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
@@ -348,12 +349,18 @@ export const makeClient = <
     const get = (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.sync(() => namespace.get(id, options));
+    ) =>
+      RpcTargets.get(namespace, JSON.stringify(["id", id.toString(), options]), () =>
+        namespace.get(id, options),
+      ).pipe(Effect.orDie);
 
     const getByName = (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.sync(() => namespace.getByName(name, options));
+    ) =>
+      RpcTargets.get(namespace, JSON.stringify(["name", name, options]), () =>
+        namespace.getByName(name, options),
+      ).pipe(Effect.orDie);
 
     const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
       Effect.sync(() => namespace.jurisdiction(value));
@@ -377,7 +384,7 @@ export const makeClient = <
           });
         },
         catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
-      });
+      }).pipe(Effect.tapCause(() => RpcTargets.invalidate(stub)));
 
     const rpc = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
       stub: StubClient,
@@ -419,7 +426,7 @@ export const makeClient = <
             method: methodName,
             cause,
           }),
-      );
+      ).pipe(Effect.tapCause(() => RpcTargets.invalidate(stub)));
     });
 
     const decodeSuccess = Effect.fnUntraced(function* <Method extends StubMethodKey<Api>>(
@@ -459,6 +466,7 @@ export const makeClient = <
       ): Effect.fn.Return<StubMethodSuccess<Api, Method>, DurableObjectRpcError> {
         const methodName = String(method);
         const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+          Effect.tapCause(() => RpcTargets.invalidate(stub)),
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({
@@ -484,6 +492,7 @@ export const makeClient = <
         const methodName = String(method);
         const result = yield* rpc(stub, method, ...args);
         const value = yield* CloudflareRpc.scoped(result).pipe(
+          Effect.tapCause(() => RpcTargets.invalidate(stub)),
           Effect.mapError(
             (cause) =>
               new DurableObjectRpcError({

package/src/RpcTargets.ts

@@ -0,0 +1,94 @@
+import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
+import type * as Scope from "effect/Scope";
+import * as Option from "effect/Option";
+
+import { CurrentTargets, type Targets } from "./internal/RpcTargets";
+
+/** A native RPC target could not be constructed. */
+export class RpcTargetError extends Data.TaggedError("RpcTargetError")<{
+  readonly cause: unknown;
+}> {}
+
+/**
+ * Reuse a native RPC target within the current invocation. Native Durable Object
+ * stubs capture the calling request's channel when created. Recreating a stub
+ * after a callback can extend that callback's call chain until Cloudflare's
+ * subrequest depth limit is reached, even when an alarm owns the work.
+ *
+ * The owner and address must identify one target and its construction options.
+ * Outside an effect-cf invocation (or withScope), each lookup constructs a target.
+ */
+export const get = <A extends object, Owner extends object>(
+  owner: Owner,
+  address: string,
+  create: () => A,
+) =>
+  Effect.flatMap(Effect.serviceOption(CurrentTargets), (targets) =>
+    Effect.try({
+      try: () => (Option.isSome(targets) ? targets.value.get(owner, address, create) : create()),
+      catch: (cause) => new RpcTargetError({ cause }),
+    }),
+  );
+
+/** Discard a failed native target so a subsequent call can acquire a fresh channel. */
+export const invalidate = <Target extends object>(target: Target): Effect.Effect<void> =>
+  Effect.map(Effect.serviceOption(CurrentTargets), (targets) => {
+    if (Option.isSome(targets)) targets.value.invalidate(target);
+  });
+
+/**
+ * Own RPC targets in the current Scope, including a transferred response stream,
+ * never across incoming requests or durable retries. effect-cf entrypoints install this boundary automatically.
+ */
+export const withScope = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R | Scope.Scope> =>
+  Effect.gen(function* () {
+    let active = true;
+    let owners = new WeakMap<object, Map<string, object>>();
+    let addresses = new WeakMap<object, { entries: Map<string, object>; address: string }>();
+    const targets: Targets = {
+      get: <T extends object, Owner extends object>(
+        owner: Owner,
+        address: string,
+        create: () => T,
+      ): T => {
+        if (!active) return create();
+        let entries = owners.get(owner);
+
+        if (entries === undefined) {
+          entries = new Map();
+          owners.set(owner, entries);
+        }
+        const existing = entries.get(address);
+
+        if (existing !== undefined) {
+          // SAFETY: the caller's owner/address identifies the same native target type.
+          return existing as T;
+        }
+        const target = create();
+
+        entries.set(address, target);
+        addresses.set(target, { entries, address });
+
+        return target;
+      },
+      invalidate: (target) => {
+        const entry = addresses.get(target);
+
+        if (entry?.entries.get(entry.address) === target) entry.entries.delete(entry.address);
+        addresses.delete(target);
+      },
+    };
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        active = false;
+        owners = new WeakMap();
+        addresses = new WeakMap();
+      }),
+    );
+
+    return yield* effect.pipe(Effect.provideService(CurrentTargets, targets));
+  });