effect-cf 0.40.3 → 0.41.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.41.1
+
+### Patch Changes
+
+- [#161](https://github.com/danieljvdm/effect-cf/pull/161) [`a627f80`](https://github.com/danieljvdm/effect-cf/commit/a627f80449bf40227bddf917640aae9574faa563) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Retain Sandbox and Container RPC channels for each invocation so repeated lookups after callbacks do not exhaust Cloudflare's subrequest depth. Sandbox configuration continues to apply on each lookup, and failed channels are replaced on subsequent acquisition.
+
+## 0.41.0
+
+### Minor Changes
+
+- [#159](https://github.com/danieljvdm/effect-cf/pull/159) [`8cbc534`](https://github.com/danieljvdm/effect-cf/commit/8cbc5344ffa2aa031b6d98a2845ca3b945cf7d5f) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Reuse Durable Object RPC targets within each invocation so callbacks cannot grow a new subrequest chain on every call. Incoming requests and durable retries retain separate target lifetimes. Expose RpcTargets for native RPC adapters sharing the same invocation boundary.
+
 ## 0.40.3
 
 ### Patch Changes

package/dist/ContainerNamespace.mjs

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { get, invalidate } from "./RpcTargets.mjs";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -37,7 +38,7 @@ var ContainerOperationError = class extends Data.TaggedError("ContainerOperation
 		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
 	}
 };
-const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+const tryContainerPromise = (definition, instance, operation, evaluate, target) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new ContainerOperationError({
 		binding: definition.binding,
@@ -45,43 +46,44 @@ const tryContainerPromise = (definition, instance, operation, evaluate) => Effec
 		operation,
 		cause
 	})
-});
+}).pipe(Effect.tapCause(() => invalidate(target)));
 const makeInstanceClient = (definition, instance, stub) => {
+	const attempt = (operation, evaluate) => tryContainerPromise(definition, instance, operation, evaluate, stub);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
 		operation
 	} });
 	const hostListOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hosts) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation]([...hosts]));
+		return yield* attempt(operation, () => stub[operation]([...hosts]));
 	});
 	const hostnameOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hostname) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation](hostname));
+		return yield* attempt(operation, () => stub[operation](hostname));
 	});
 	return {
 		rawUnsafe: Effect.succeed(stub),
-		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+		state: attempt("state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
 			binding: definition.binding,
 			instance,
 			operation: "state",
 			cause
 		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
 		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
-			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
+			return yield* attempt("fetch", () => stub.fetch(input, init));
 		}),
 		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
-			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
+			return yield* attempt("start", () => stub.start(options, waitOptions));
 		}),
 		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
+			return yield* attempt("startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
 		}),
 		waitForPort: Effect.fn("ContainerNamespace.waitForPort", spanOptions("waitForPort"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "waitForPort", () => stub.waitForPort(options));
+			return yield* attempt("waitForPort", () => stub.waitForPort(options));
 		}),
 		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
-			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+			return yield* attempt("stop", () => stub.stop(signal));
 		}),
-		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
+		destroy: attempt("destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
 		setAllowedHosts: hostListOperation("setAllowedHosts"),
 		setDeniedHosts: hostListOperation("setDeniedHosts"),
 		allowHost: hostnameOperation("allowHost"),
@@ -92,15 +94,16 @@ const makeInstanceClient = (definition, instance, stub) => {
 };
 const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
 const makeClient = (definition) => (namespace) => {
-	const getByName = (name, options) => Effect.try({
-		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
-		catch: (cause) => new ContainerOperationError({
-			binding: definition.binding,
-			instance: name,
-			operation: "getByName",
-			cause
-		})
-	});
+	const getByName = (name, options) => get(namespace, JSON.stringify([
+		"container",
+		name,
+		options
+	]), () => namespace.getByName(name, options)).pipe(Effect.map((stub) => makeInstanceClient(definition, name, stub)), Effect.mapError((error) => new ContainerOperationError({
+		binding: definition.binding,
+		instance: name,
+		operation: "getByName",
+		cause: error.cause
+	})));
 	const byName = (name, options) => {
 		const instance = getByName(name, options);
 		return {

package/dist/DurableObjectNamespace.mjs

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { get, invalidate } from "./RpcTargets.mjs";
 import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
 import { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
 import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
@@ -41,8 +42,16 @@ const makeClient = (definition) => {
 		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
 		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
 		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
-		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
-		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
+		const get$1 = (id, options) => get(namespace, JSON.stringify([
+			"id",
+			id.toString(),
+			options
+		]), () => namespace.get(id, options)).pipe(Effect.orDie);
+		const getByName = (name, options) => get(namespace, JSON.stringify([
+			"name",
+			name,
+			options
+		]), () => namespace.getByName(name, options)).pipe(Effect.orDie);
 		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
 		const fetch = (stub, input, init) => Effect.tryPromise({
 			try: (signal) => {
@@ -56,7 +65,7 @@ const makeClient = (definition) => {
 				binding: definition.binding,
 				cause
 			})
-		});
+		}).pipe(Effect.tapCause(() => invalidate(stub)));
 		const rpc = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
@@ -69,7 +78,7 @@ const makeClient = (definition) => {
 				binding: definition.binding,
 				method: methodName,
 				cause
-			}));
+			})).pipe(Effect.tapCause(() => invalidate(stub)));
 		});
 		const decodeSuccess$1 = Effect.fnUntraced(function* (methodName, value) {
 			if (definition.definition === void 0) return value;
@@ -81,7 +90,7 @@ const makeClient = (definition) => {
 		});
 		const call = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.tapCause(() => invalidate(stub)), Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -91,7 +100,7 @@ const makeClient = (definition) => {
 		const scopedCall = Effect.fnUntraced(function* (stub, method, ...args) {
 			const methodName = String(method);
 			const result = yield* rpc(stub, method, ...args);
-			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
+			const value = yield* scoped(result).pipe(Effect.tapCause(() => invalidate(stub)), Effect.mapError((cause) => new DurableObjectRpcError({
 				binding: definition.binding,
 				method: methodName,
 				cause
@@ -101,14 +110,14 @@ const makeClient = (definition) => {
 		const directMethods = makeDirectMethods(definition.definition, {
 			call,
 			fetch,
-			get,
+			get: get$1,
 			getByName
 		});
 		return Object.assign(directMethods, {
 			newUniqueId,
 			idFromName,
 			idFromString,
-			get,
+			get: get$1,
 			getByName,
 			jurisdiction,
 			fetch,

package/dist/RpcTargets.d.mts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+declare namespace RpcTargets_d_exports {
+  export { RpcTargetError, get, invalidate, withScope };
+}
+declare const RpcTargetError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RpcTargetError";
+} & Readonly<A>;
+/** A native RPC target could not be constructed. */
+declare class RpcTargetError extends RpcTargetError_base<{
+  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.
+ */
+declare const get: <A extends object, Owner extends object>(owner: Owner, address: string, create: () => A) => Effect.Effect<A, RpcTargetError, never>;
+/** Discard a failed native target so a subsequent call can acquire a fresh channel. */
+declare const invalidate: <Target extends object>(target: Target) => Effect.Effect<void>;
+/**
+ * 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.
+ */
+declare const withScope: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Scope.Scope>;
+//#endregion
+export { RpcTargetError, RpcTargets_d_exports, get, invalidate, withScope };

package/dist/RpcTargets.mjs

@@ -0,0 +1,72 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { CurrentTargets } from "./internal/RpcTargets.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/RpcTargets.ts
+var RpcTargets_exports = /* @__PURE__ */ __exportAll({
+	RpcTargetError: () => RpcTargetError,
+	get: () => get,
+	invalidate: () => invalidate,
+	withScope: () => withScope
+});
+/** A native RPC target could not be constructed. */
+var RpcTargetError = class extends Data.TaggedError("RpcTargetError") {};
+/**
+* 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.
+*/
+const get = (owner, address, create) => 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. */
+const invalidate = (target) => 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.
+*/
+const withScope = (effect) => Effect.gen(function* () {
+	let active = true;
+	let owners = /* @__PURE__ */ new WeakMap();
+	let addresses = /* @__PURE__ */ new WeakMap();
+	const targets = {
+		get: (owner, address, create) => {
+			if (!active) return create();
+			let entries = owners.get(owner);
+			if (entries === void 0) {
+				entries = /* @__PURE__ */ new Map();
+				owners.set(owner, entries);
+			}
+			const existing = entries.get(address);
+			if (existing !== void 0) return existing;
+			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 = /* @__PURE__ */ new WeakMap();
+		addresses = /* @__PURE__ */ new WeakMap();
+	}));
+	return yield* effect.pipe(Effect.provideService(CurrentTargets, targets));
+});
+//#endregion
+export { RpcTargetError, RpcTargets_exports, get, invalidate, withScope };