effect-cf 0.50.0 → 0.52.0

package/src/DurableObjectContainer.ts

@@ -102,6 +102,10 @@ export interface ContainerTcpPort {
   readonly connect: (
     ...args: Parameters<globalThis.Fetcher["connect"]>
   ) => Effect.Effect<ReturnType<globalThis.Fetcher["connect"]>, ContainerError>;
+  /** Closes the socket when the scope ends, awaiting cleanup and preserving close failures as defects. */
+  readonly connectScoped: (
+    ...args: Parameters<globalThis.Fetcher["connect"]>
+  ) => Effect.Effect<ReturnType<globalThis.Fetcher["connect"]>, ContainerError, Scope.Scope>;
 }
 
 /** Direct container control inside a Durable Object; lifecycle policy belongs to the application. */
@@ -248,6 +252,9 @@ const fromTcpPort = (port: globalThis.Fetcher): ContainerTcpPort => {
       });
     });
 
+  const connect: ContainerTcpPort["connect"] = (...args) =>
+    attempt("getTcpPort.connect", () => port.connect(...args));
+
   return {
     raw: port,
     fetch,
@@ -259,7 +266,11 @@ const fromTcpPort = (port: globalThis.Fetcher): ContainerTcpPort => {
 
         return new Request(url, request);
       }).pipe(Effect.flatMap((forwarded) => fetch(forwarded))),
-    connect: (...args) => attempt("getTcpPort.connect", () => port.connect(...args)),
+    connect,
+    connectScoped: (...args) =>
+      Effect.acquireRelease(connect(...args), (socket) =>
+        attemptPromise("getTcpPort.close", () => socket.close()).pipe(Effect.orDie),
+      ),
   };
 };
 

package/src/DurableObjectRpcWebSocket.ts

@@ -87,8 +87,8 @@ export interface LayerOptions {
   readonly attachmentKey?: string | undefined;
   /**
    * Heartbeat behavior. `"auto-response"` (the default) installs Cloudflare's
-   * hibernation-safe text Ping/Pong response while an RPC socket exists and no
-   * non-resumable RPC operation is active, then removes it while one is pending.
+   * hibernation-safe text Ping/Pong response for the lifetime of RPC sockets,
+   * including pending operations. Keepalives never dispatch application code.
    * `"passthrough"` leaves the Durable Object's existing auto-response
    * configuration unchanged and makes the application responsible for waking a
    * lost pending operation.
@@ -248,7 +248,6 @@ export const layer = (
         readonly request: RpcMessage.RequestEncoded;
       }> = [];
       let nextClientId = 0;
-      let activeNonResumableRequestCount = 0;
       let writeRequest:
         | ((clientId: number, data: RpcMessage.FromClientEncoded) => Effect.Effect<void>)
         | undefined;
@@ -383,8 +382,7 @@ export const layer = (
         heartbeatPolicy,
       );
 
-      const syncHeartbeat = () =>
-        heartbeat.setEnabled(connectionsBySocket.size > 0 && activeNonResumableRequestCount === 0);
+      const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0);
 
       const persistConnection = Effect.fn("DurableObjectRpcWebSocket.persistConnection")(function* (
         connection: RpcConnection,
@@ -430,7 +428,6 @@ export const layer = (
 
         connectionsBySocket.delete(socket.raw);
         connectionsById.delete(connection.id);
-        activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
         connection.requestIds.clear();
         connection.nonResumableRequestIds.clear();
         connection.subscriptionsByRequestId.clear();
@@ -511,7 +508,6 @@ export const layer = (
         } else {
           connection.requestIds.add(request.id);
           connection.nonResumableRequestIds.add(request.id);
-          activeNonResumableRequestCount++;
         }
 
         if (!(yield* persistOrReset(connection))) {
@@ -529,9 +525,7 @@ export const layer = (
         preserveAckFilter = false,
       ) {
         if (connection.requestIds.delete(requestId)) {
-          if (connection.nonResumableRequestIds.delete(requestId)) {
-            activeNonResumableRequestCount--;
-          }
+          connection.nonResumableRequestIds.delete(requestId);
 
           const subscription = removeSubscription(connection, requestId);
 
@@ -557,10 +551,6 @@ export const layer = (
         function* (connection: RpcConnection) {
           const hadRequests = connection.requestIds.size > 0;
 
-          if (connection.requestIds.size > 0) {
-            activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
-          }
-
           connection.requestIds.clear();
           connection.nonResumableRequestIds.clear();
           connection.subscriptionsByRequestId.clear();

package/src/DurableObjectStorage.ts

@@ -1,7 +1,5 @@
 import * as Cause from "effect/Cause";
-import * as Clock from "effect/Clock";
 import * as Data from "effect/Data";
-import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
@@ -91,15 +89,6 @@ export interface DurableObjectTransaction {
   delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
   rollback(): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: globalThis.DurableObjectSetAlarmOptions,
-  ): StorageEffect<void>;
-  setAlarmAfter(
-    delay: Duration.Input,
-    options?: globalThis.DurableObjectSetAlarmOptions,
-  ): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
 }
 
 export interface DurableObjectStorage {
@@ -110,20 +99,11 @@ export interface DurableObjectStorage {
   put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
   /**
-   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
-   * documents that active alarms must be deleted separately with `deleteAlarm()`.
+   * Deletes all stored data, including logical schedules. Use the alarm scheduler
+   * to cancel individual alarms without deleting application data.
    */
   deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
   getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: globalThis.DurableObjectSetAlarmOptions,
-  ): StorageEffect<void>;
-  setAlarmAfter(
-    delay: Duration.Input,
-    options?: globalThis.DurableObjectSetAlarmOptions,
-  ): StorageEffect<void>;
-  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
   /**
    * SQLite-backed Durable Object storage only.
    *
@@ -165,21 +145,6 @@ const tryStoragePromise = <A>(operation: string, evaluate: () => Promise<A>): St
     catch: (cause) => storageError(operation, cause),
   });
 
-const setAlarmAfter = Effect.fn("DurableObjectStorage.setAlarmAfter")(function* (
-  operation: string,
-  setAlarm: (
-    scheduledTime: number,
-    options?: globalThis.DurableObjectSetAlarmOptions,
-  ) => Promise<void>,
-  delay: Duration.Input,
-  options?: globalThis.DurableObjectSetAlarmOptions,
-) {
-  const now = yield* Clock.currentTimeMillis;
-  const delayMillis = Math.ceil(Duration.toMillis(delay));
-
-  yield* tryStoragePromise(operation, () => setAlarm(now + delayMillis, options));
-});
-
 const fromSqlCursor = <T extends Record<string, SqlStorageValue>>(
   cursor: globalThis.SqlStorageCursor<T>,
 ): SqlCursor<T> => ({
@@ -297,17 +262,6 @@ const fromDurableObjectTransaction = (
     rollback: () => tryStorageSync("transaction.rollback", () => txn.rollback()),
     getAlarm: (options?: globalThis.DurableObjectGetAlarmOptions) =>
       tryStoragePromise("transaction.getAlarm", () => txn.getAlarm(options)),
-    setAlarm: (scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions) =>
-      tryStoragePromise("transaction.setAlarm", () => txn.setAlarm(scheduledTime, options)),
-    setAlarmAfter: (delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions) =>
-      setAlarmAfter(
-        "transaction.setAlarm",
-        (scheduledTime, options) => txn.setAlarm(scheduledTime, options),
-        delay,
-        options,
-      ),
-    deleteAlarm: (options?: globalThis.DurableObjectSetAlarmOptions) =>
-      tryStoragePromise("transaction.deleteAlarm", () => txn.deleteAlarm(options)),
   }) as DurableObjectTransaction;
 
 export const fromDurableObjectStorage = (
@@ -323,17 +277,6 @@ export const fromDurableObjectStorage = (
     tryStoragePromise("deleteAll", () => storage.deleteAll(options)),
   getAlarm: (options?: globalThis.DurableObjectGetAlarmOptions) =>
     tryStoragePromise("getAlarm", () => storage.getAlarm(options)),
-  setAlarm: (scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions) =>
-    tryStoragePromise("setAlarm", () => storage.setAlarm(scheduledTime, options)),
-  setAlarmAfter: (delay: Duration.Input, options?: globalThis.DurableObjectSetAlarmOptions) =>
-    setAlarmAfter(
-      "setAlarm",
-      (scheduledTime, options) => storage.setAlarm(scheduledTime, options),
-      delay,
-      options,
-    ),
-  deleteAlarm: (options?: globalThis.DurableObjectSetAlarmOptions) =>
-    tryStoragePromise("deleteAlarm", () => storage.deleteAlarm(options)),
   transactionSync: <A, E, R>(closure: () => Effect.Effect<A, E, R>) =>
     Effect.context<R>().pipe(
       Effect.flatMap((context) =>

package/src/DurableObjectWebSocket.ts

@@ -7,6 +7,30 @@ import * as S from "effect/Schema";
 import { DurableObjectState } from "./DurableObjectState";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export const DEFAULT_KEEPALIVE_REQUEST = "effect-cf:ping";
+export const DEFAULT_KEEPALIVE_RESPONSE = "effect-cf:pong";
+
+/**
+ * Registers exact text keepalives with Cloudflare so they never invoke the object.
+ * The pair applies to all hibernating sockets on this object; install in its constructor.
+ * Clients send the request text and consume the response outside their application protocol.
+ */
+export const installKeepalive = Effect.fn("DurableObjectWebSocket.installKeepalive")(function* (
+  request = DEFAULT_KEEPALIVE_REQUEST,
+  response = DEFAULT_KEEPALIVE_RESPONSE,
+) {
+  const state = yield* DurableObjectState;
+  const configured = yield* state.getWebSocketAutoResponse;
+
+  if (configured !== null && (configured.request !== request || configured.response !== response)) {
+    return yield* Effect.die(
+      new Error("Durable Object already has a different keepalive protocol"),
+    );
+  }
+
+  yield* state.setWebSocketAutoResponse(new WebSocketRequestResponsePair(request, response));
+});
+
 export type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
 
 export class DurableWebSocketSendError extends Data.TaggedError("DurableWebSocketSendError")<{