effect-cf 0.34.0 → 0.35.0

package/src/DurableObjectRpcWebSocket.ts

@@ -230,7 +230,6 @@ export const layer = (
       const disconnects = yield* Queue.make<number>();
       const connectionsBySocket = new Map<WebSocket, RpcConnection>();
       const connectionsById = new Map<number, RpcConnection>();
-      const clientIds = new Set<number>();
       const resetSockets = new WeakSet<WebSocket>();
       const declarationsById = new Map<string, AnyResumableStreamDeclaration>();
       const declarationsByTag = new Map<string, AnyResumableStreamDeclaration>();
@@ -268,21 +267,6 @@ export const layer = (
       }
 
       const reserveClientId = (socket: DurableWebSocket): AttachmentMetadata => {
-        const attachment = readAttachment(socket.raw, attachmentKey);
-
-        if (attachment._tag === "Invalid") {
-          throw new Error("Invalid Durable Object RPC websocket attachment metadata");
-        }
-
-        if (attachment._tag === "Valid") {
-          const metadata = attachment.metadata;
-
-          nextClientId = Math.max(nextClientId, metadata.clientId + 1);
-          writeAttachment(socket.raw, attachmentKey, metadata);
-
-          return metadata;
-        }
-
         const id = nextClientId++;
         const created: LegacyAttachmentMetadata = {
           version: legacyAttachmentVersion,
@@ -377,7 +361,6 @@ export const layer = (
 
         connectionsBySocket.set(socket.raw, connection);
         connectionsById.set(connection.id, connection);
-        clientIds.add(connection.id);
         nextClientId = Math.max(nextClientId, connection.id + 1);
 
         return connection;
@@ -434,7 +417,6 @@ export const layer = (
 
         connectionsBySocket.delete(socket.raw);
         connectionsById.delete(connection.id);
-        clientIds.delete(connection.id);
         activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
         connection.requestIds.clear();
         connection.nonResumableRequestIds.clear();
@@ -847,7 +829,7 @@ export const layer = (
 
               connection?.socket.raw.close();
             }),
-          clientIds: Effect.sync(() => clientIds),
+          clientIds: Effect.sync(() => new Set(connectionsById.keys())),
           initialMessage: Effect.succeedNone,
           supportsAck: true,
           supportsTransferables: false,
@@ -1141,17 +1123,10 @@ const writeAttachment = (socket: WebSocket, key: string, metadata: AttachmentMet
   }
 
   const attachment = Predicate.isObject(current) ? current : {};
-  const currentMetadata =
-    Predicate.hasProperty(attachment, key) && Predicate.isObject(attachment[key])
-      ? attachment[key]
-      : {};
 
   socket.serializeAttachment({
     ...attachment,
-    [key]: {
-      ...currentMetadata,
-      ...metadata,
-    },
+    [key]: metadata,
   });
 };
 

package/src/DurableObjectState.ts

@@ -3,6 +3,7 @@ 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 { runNativeCallback } from "./internal/NativeCallback";
 import { makeWaitUntilScheduler } from "./internal/WorkerContext";
 
 /**
@@ -87,24 +88,21 @@ export const fromDurableObjectState = (
     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,
-      ),
+      runNativeCallback<A, E, R, Exit.Exit<A, E>>((run) =>
+        state.blockConcurrencyWhile(() => runExitPreservingTypedFailures(run, effect)),
+      ).pipe(Effect.orDie, 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)),
-          ),
-        ),
-      ),
+      runNativeCallback<A, E, R, A>((run) =>
+        state.blockConcurrencyWhile(async () => {
+          const exit = await run(effect);
+
+          if (Exit.isFailure(exit)) {
+            throw Cause.squash(exit.cause);
+          }
+
+          return exit.value;
+        }),
+      ).pipe(Effect.orDie),
     acceptWebSocket: (ws: DurableWebSocket, tags?: Array<string>) =>
       Effect.sync(() => state.acceptWebSocket(ws.raw, tags)),
     getWebSockets: (tag?: string) =>
@@ -125,11 +123,11 @@ export const fromDurableObjectState = (
   };
 };
 
-const runPromiseExitPreservingTypedFailures = async <A, E, R>(
-  context: Context.Context<R>,
+const runExitPreservingTypedFailures = async <A, E, R>(
+  run: (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>>,
   effect: Effect.Effect<A, E, R>,
 ): Promise<Exit.Exit<A, E>> => {
-  const exit = await Effect.runPromiseExitWith(context)(effect);
+  const exit = await run(effect);
 
   if (Exit.isFailure(exit) && (Cause.hasDies(exit.cause) || Cause.hasInterrupts(exit.cause))) {
     throw Cause.squash(exit.cause);

package/src/DurableObjectStorage.ts

@@ -1,6 +1,19 @@
-import { Clock, Data, Duration, Effect, Exit, Option, Predicate, Schema as S } from "effect";
+import {
+  Cause,
+  Clock,
+  Data,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  Option,
+  Predicate,
+  Result,
+  Schema as S,
+} from "effect";
 
 import * as ErrorMessage from "./internal/ErrorMessage";
+import { runNativeCallback } from "./internal/NativeCallback";
 
 export type SqlStorageValue = globalThis.SqlStorageValue;
 
@@ -331,6 +344,7 @@ export const fromDurableObjectStorage = (
           // failed Exit is thrown to abort it. Keep a typed reference to that
           // Exit rather than recovering its type from the untyped catch binding.
           let aborted: Exit.Exit<A, E> | undefined;
+          let escapedFiber: Fiber.Fiber<unknown, unknown> | undefined;
 
           try {
             return Effect.succeed(
@@ -340,55 +354,59 @@ export const fromDurableObjectStorage = (
                 if (Exit.isSuccess(exit)) {
                   return exit.value;
                 }
+                const defect = Cause.findDefect(exit.cause);
+
+                if (Result.isSuccess(defect) && Cause.isAsyncFiberError(defect.success)) {
+                  escapedFiber = defect.success.fiber;
+                  escapedFiber.interruptUnsafe();
+                }
                 aborted = exit;
 
                 throw exit;
               }),
             );
           } catch (cause) {
-            if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-              return Effect.failCause(aborted.cause);
+            const failure: Effect.Effect<never, E | StorageOperationError> =
+              aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+                ? Effect.failCause(aborted.cause)
+                : Effect.fail(storageError("transactionSync", cause));
+            const fiber = escapedFiber;
+
+            if (fiber !== undefined) {
+              return Fiber.interrupt(fiber).pipe(Effect.andThen(failure));
             }
 
-            return Effect.fail(storageError("transactionSync", cause));
+            return failure;
           }
         }),
       ),
     ),
   transaction: <A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>) =>
-    Effect.context<R>().pipe(
-      Effect.flatMap((context) =>
-        Effect.callback<A, E | StorageOperationError>((resume) => {
-          // See `transactionSync`: the thrown Exit aborts Cloudflare's
-          // transaction, and holding it here keeps its error type.
-          let aborted: Exit.Exit<A, E> | undefined;
+    Effect.suspend(() => {
+      // See `transactionSync`: the thrown Exit aborts Cloudflare's
+      // transaction, and holding it here keeps its error type.
+      let aborted: Exit.Exit<A, E> | undefined;
 
-          void storage
-            .transaction(async (txn) => {
-              const exit = await Effect.runPromiseExitWith(context)(
-                closure(fromDurableObjectTransaction(txn)),
-              );
-
-              if (Exit.isSuccess(exit)) {
-                return exit.value;
-              }
-              aborted = exit;
-
-              throw exit;
-            })
-            .then(
-              (value) => resume(Effect.succeed(value)),
-              (cause) => {
-                if (aborted !== undefined && cause === aborted && Exit.isFailure(aborted)) {
-                  resume(Effect.failCause(aborted.cause));
-                } else {
-                  resume(Effect.fail(storageError("transaction", cause)));
-                }
-              },
-            );
+      return runNativeCallback<A, E, R, A>((run) =>
+        storage.transaction(async (txn) => {
+          const exit = await run(Effect.suspend(() => closure(fromDurableObjectTransaction(txn))));
+
+          if (Exit.isSuccess(exit)) {
+            return exit.value;
+          }
+          aborted = exit;
+
+          throw exit;
         }),
-      ),
-    ),
+      ).pipe(
+        Effect.catch(
+          (cause): Effect.Effect<never, E | StorageOperationError> =>
+            aborted !== undefined && cause === aborted && Exit.isFailure(aborted)
+              ? Effect.failCause(aborted.cause)
+              : Effect.fail(storageError("transaction", cause)),
+        ),
+      );
+    }),
   sync: () => tryStoragePromise("sync", () => storage.sync()),
   getCurrentBookmark: () =>
     tryStoragePromise("getCurrentBookmark", () => storage.getCurrentBookmark()),

package/src/DurableObjectWebSocket.ts

@@ -38,53 +38,37 @@ export interface DurableWebSocket<Attachment = unknown> {
   send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
   close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
   /** Serializes hibernation attachment metadata onto the socket. */
-  serializeAttachment<A = Attachment>(
+  serializeAttachment<A extends Attachment = Attachment>(
     value: A,
   ): Effect.Effect<void, DurableWebSocketAttachmentError>;
   /** Deserializes hibernation attachment metadata from the socket. */
   readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
 }
 
-const wrappers = new WeakMap<WebSocket, DurableWebSocket<unknown>>();
-
 export const fromWebSocket = <Attachment = unknown>(
   raw: WebSocket,
-): DurableWebSocket<Attachment> => {
-  const existing = wrappers.get(raw);
-
-  if (existing !== undefined) {
-    // SAFETY: Attachment is phantom; a wrapper's runtime behavior is independent of that type.
-    return existing as DurableWebSocket<Attachment>;
-  }
-
-  const socket: DurableWebSocket<unknown> = {
-    raw,
-    send: (data) =>
-      Effect.try({
-        try: () => raw.send(data),
-        catch: (cause) => new DurableWebSocketSendError({ cause }),
-      }),
-    close: (code, reason) =>
-      Effect.try({
-        try: () => raw.close(code, reason),
-        catch: (cause) => new DurableWebSocketCloseError({ cause }),
-      }),
-    serializeAttachment: (value) =>
-      Effect.try({
-        try: () => raw.serializeAttachment(value),
-        catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
-      }),
-    deserializeAttachment: Effect.try({
-      try: () => raw.deserializeAttachment(),
-      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+): DurableWebSocket<Attachment> => ({
+  raw,
+  send: (data) =>
+    Effect.try({
+      try: () => raw.send(data),
+      catch: (cause) => new DurableWebSocketSendError({ cause }),
     }),
-  };
-
-  wrappers.set(raw, socket);
-
-  // SAFETY: Attachment is phantom; the newly created wrapper supports values through its generic serializer.
-  return socket as DurableWebSocket<Attachment>;
-};
+  close: (code, reason) =>
+    Effect.try({
+      try: () => raw.close(code, reason),
+      catch: (cause) => new DurableWebSocketCloseError({ cause }),
+    }),
+  serializeAttachment: <A extends Attachment = Attachment>(value: A) =>
+    Effect.try({
+      try: () => raw.serializeAttachment(value),
+      catch: (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
+    }),
+  deserializeAttachment: Effect.try({
+    try: () => raw.deserializeAttachment(),
+    catch: (cause) => new DurableWebSocketAttachmentError({ operation: "deserialize", cause }),
+  }),
+});
 
 export interface AcceptUpgradeOptions<Attachment = unknown> {
   readonly tags?: ReadonlyArray<string> | undefined;
@@ -165,15 +149,13 @@ export const attachment = <const AttachmentSchema extends S.Codec<any, any, neve
   S.Codec.Encoded<AttachmentSchema>
 > => {
   type Attachment = S.Schema.Type<AttachmentSchema>;
-  type Encoded = S.Codec.Encoded<AttachmentSchema>;
 
   const serialize = (socket: DurableWebSocket<unknown>, value: Attachment) =>
     S.encodeEffect(schema)(value).pipe(
       Effect.mapError(
         (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
       ),
-      // SAFETY: S.encodeEffect returns this codec's declared Encoded representation.
-      Effect.flatMap((encoded) => socket.serializeAttachment(encoded as Encoded)),
+      Effect.flatMap((encoded) => socket.serializeAttachment(encoded)),
     );
 
   const deserialize = (socket: DurableWebSocket<unknown>) =>

package/src/RpcDefinition.ts

@@ -124,7 +124,7 @@ export const decodeWireError = (cause: WireValue): WireValue => {
   }
 };
 
-export const reservedMethodNames = new Set([
+const reservedMethodNameValues = [
   "constructor",
   "fetch",
   "connect",
@@ -137,21 +137,11 @@ export const reservedMethodNames = new Set([
   "dispose",
   "serialize",
   "deserialize",
-]);
+] as const;
+
+export const reservedMethodNames = new Set<string>(reservedMethodNameValues);
 
-export type ReservedMethodName =
-  | "constructor"
-  | "fetch"
-  | "connect"
-  | "alarm"
-  | "webSocketMessage"
-  | "webSocketClose"
-  | "webSocketError"
-  | "then"
-  | "dup"
-  | "dispose"
-  | "serialize"
-  | "deserialize";
+export type ReservedMethodName = (typeof reservedMethodNameValues)[number];
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
 

package/src/ServiceBinding.ts

@@ -145,7 +145,11 @@ export type ServiceBindingEffectClient<
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(
     method: Method,
     ...args: ServiceMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  ) => Effect.Effect<
+    Awaited<ServiceMethodSuccess<Api, Method>>,
+    ServiceBindingRpcError,
+    Scope.Scope
+  >;
 };
 
 export type ServiceBindingStaticClient<
@@ -168,7 +172,11 @@ export type ServiceBindingStaticClient<
   readonly scopedCall: <Method extends ServiceMethodKey<Api>>(
     method: Method,
     ...args: ServiceMethodArgs<Api, Method>
-  ) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
+  ) => Effect.Effect<
+    Awaited<ServiceMethodSuccess<Api, Method>>,
+    ServiceBindingRpcError,
+    Scope.Scope | R
+  >;
 };
 
 type ServiceBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
@@ -195,7 +203,22 @@ export const makeClient = <
       init?: RequestInit,
     ) {
       return yield* Effect.tryPromise({
-        try: () => service.fetch(input, init),
+        try: (signal) => {
+          const callerSignal =
+            init?.signal !== undefined
+              ? init.signal
+              : input instanceof Request
+                ? input.signal
+                : undefined;
+
+          return service.fetch(input, {
+            ...init,
+            signal:
+              callerSignal === null || callerSignal === undefined
+                ? signal
+                : AbortSignal.any([callerSignal, signal]),
+          });
+        },
         catch: (cause) => new ServiceBindingFetchError({ binding: definition.binding, cause }),
       });
     });
@@ -298,10 +321,19 @@ export const makeClient = <
       function* <Method extends ServiceMethodKey<Api>>(
         method: Method,
         ...args: ServiceMethodArgs<Api, Method>
-      ): Effect.fn.Return<ServiceMethodSuccess<Api, Method>, unknown, Scope.Scope> {
+      ): Effect.fn.Return<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, Scope.Scope> {
         const methodName = String(method);
         const result = yield* rpc(method, ...args);
-        const value = yield* CloudflareRpc.scoped(result);
+        const value = yield* CloudflareRpc.scoped(result).pipe(
+          Effect.mapError(
+            (cause) =>
+              new ServiceBindingRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          ),
+        );
 
         return yield* decodeSuccess<Method>(methodName, value);
       },

package/src/Vitest.ts

@@ -33,6 +33,7 @@ import {
 } from "./DurableObjectState";
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
 import type { WorkflowInstanceStatusName } from "./WorkflowBinding";
+import { runNativeCallback } from "./internal/NativeCallback";
 
 const currentEnv: WorkerEnv = env;
 
@@ -207,15 +208,20 @@ export const runInDurableObject = Effect.fn("effect-cf/vitest/runInDurableObject
   stub: globalThis.DurableObjectStub<Object>,
   use: (instance: Object, state: DurableObjectStateService) => Effect.Effect<A, E, R>,
 ): Effect.fn.Return<A, E, Exclude<R, DurableObjectState>> {
-  const context = yield* Effect.context<Exclude<R, DurableObjectState>>();
-  const exit = yield* Effect.promise(() =>
-    runInDurableObjectPromise(stub, (instance, nativeState) => {
-      const state = fromDurableObjectState(nativeState);
-      const effect = Effect.provideService(use(instance, state), DurableObjectState, state);
-
-      return Effect.runPromiseExitWith(context)(effect);
-    }),
-  );
+  const exit = yield* runNativeCallback<A, E, Exclude<R, DurableObjectState>, Exit.Exit<A, E>>(
+    (run) =>
+      runInDurableObjectPromise(stub, (instance, nativeState) => {
+        const state = fromDurableObjectState(nativeState);
+
+        return run(
+          Effect.provideService(
+            Effect.suspend(() => use(instance, state)),
+            DurableObjectState,
+            state,
+          ),
+        );
+      }),
+  ).pipe(Effect.orDie);
 
   return yield* exit;
 });
@@ -394,15 +400,12 @@ const runWorkflowModifier = Effect.fnUntraced(function* <A, E, R>(
   register: (use: (modifier: NativeWorkflowInstanceModifier) => Promise<void>) => Promise<any>,
   use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>,
 ): Effect.fn.Return<A, E, R> {
-  const context = yield* Effect.context<R>();
-  const exit = yield* Effect.promise(async () => {
+  const exit = yield* runNativeCallback<A, E, R, Exit.Exit<A, E>>(async (run) => {
     let callbackExit: Exit.Exit<A, E> | undefined;
 
     try {
       await register(async (modifier) => {
-        callbackExit = await Effect.runPromiseExitWith(context)(
-          use(wrapWorkflowModifier(modifier)),
-        );
+        callbackExit = await run(Effect.suspend(() => use(wrapWorkflowModifier(modifier))));
 
         if (Exit.isFailure(callbackExit)) {
           throw callbackExit;
@@ -421,7 +424,7 @@ const runWorkflowModifier = Effect.fnUntraced(function* <A, E, R>(
     }
 
     return callbackExit;
-  });
+  }).pipe(Effect.orDie);
 
   return yield* exit;
 });