@ricsam/isolate-daemon 0.1.20 → 0.1.22

package/dist/cjs/connection.cjs

@@ -47,6 +47,26 @@ var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_callback_fs_handler = require("./callback-fs-handler.cjs");
 var import_isolate_runtime = require("@ricsam/isolate-runtime");
 var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
+var NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+var DEFAULT_CALLBACK_TIMEOUT_MS = 120000;
+var FETCH_CALLBACK_TIMEOUT_MS = 35000;
+function createAbortError(reason = "The operation was aborted") {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(reason, "AbortError");
+  }
+  const error = new Error(reason);
+  error.name = "AbortError";
+  return error;
+}
+function sendCallbackAbortMessage(connection, targetRequestId, reason) {
+  const abortMessage = {
+    type: import_isolate_protocol.MessageType.CALLBACK_ABORT,
+    requestId: connection.nextRequestId++,
+    targetRequestId,
+    reason
+  };
+  sendMessage(connection.socket, abortMessage);
+}
 function getErrorText(error) {
   if (error instanceof Error) {
     const cause = error.cause;
@@ -121,6 +141,7 @@ function handleConnection(socket, state) {
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
+      pending.cleanup?.();
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -454,14 +475,14 @@ async function waitForConnection(callbackContext) {
   }
   throw new Error("No connection available and no reconnection pending");
 }
-async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback) {
+async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback, options) {
   const conn = await waitForConnection(callbackContext);
   const cbId = getCallbackId();
   if (cbId === undefined) {
     throw new Error(`${label} callback not available`);
   }
   try {
-    return await invokeClientCallback(conn, cbId, args);
+    return await invokeClientCallback(conn, cbId, args, options);
   } catch (err) {
     if (callbackContext.reconnectionPromise && !callbackContext.connection) {
       const newConn = await callbackContext.reconnectionPromise.promise;
@@ -469,7 +490,7 @@ async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args,
       if (newCbId === undefined) {
         throw new Error(`${label} callback not available after reconnection`);
       }
-      return invokeClientCallback(newConn, newCbId, args);
+      return invokeClientCallback(newConn, newCbId, args, options);
     }
     throw err;
   }
@@ -792,6 +813,9 @@ async function handleCreateRuntime(message, connection, state) {
         }
       },
       fetch: async (url, init) => {
+        if (init.signal.aborted) {
+          throw createAbortError();
+        }
         const serialized = {
           url,
           method: init.method,
@@ -799,7 +823,16 @@ async function handleCreateRuntime(message, connection, state) {
           body: init.rawBody,
           signalAborted: init.signal.aborted
         };
-        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback);
+        const callbackAbortController = new AbortController;
+        const onInitAbort = () => callbackAbortController.abort();
+        init.signal.addEventListener("abort", onInitAbort, { once: true });
+        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback, {
+          signal: callbackAbortController.signal,
+          timeoutMs: FETCH_CALLBACK_TIMEOUT_MS,
+          timeoutLabel: "fetch callback"
+        }).finally(() => {
+          init.signal.removeEventListener("abort", onInitAbort);
+        });
         if (result && typeof result === "object" && result.__streamingResponse) {
           const response = result.response;
           response.__isCallbackStream = true;
@@ -1330,6 +1363,7 @@ function handleCallbackResponse(message, connection) {
     return;
   }
   connection.pendingCallbacks.delete(message.requestId);
+  pending.cleanup?.();
   if (message.error) {
     const error = new Error(message.error.message);
     error.name = message.error.name;
@@ -1341,12 +1375,68 @@ function handleCallbackResponse(message, connection) {
     pending.resolve(message.result);
   }
 }
-async function invokeClientCallback(connection, callbackId, args) {
+async function invokeClientCallback(connection, callbackId, args, options) {
   const requestId = connection.nextCallbackId++;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_CALLBACK_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId;
+    let onAbort;
+    let callbackInvokeSent = false;
+    const settle = (handler, value) => {
+      if (settled)
+        return;
+      settled = true;
+      connection.pendingCallbacks.delete(requestId);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+      if (options?.signal && onAbort) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+      handler(value);
+    };
+    onAbort = () => {
+      if (settled)
+        return;
+      if (callbackInvokeSent) {
+        sendCallbackAbortMessage(connection, requestId, options?.timeoutLabel ? `${options.timeoutLabel} aborted` : "Callback aborted");
+      }
+      settle(reject, createAbortError());
+    };
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        if (settled)
+          return;
+        const label = options?.timeoutLabel ?? "callback";
+        const timeoutError = new Error(`${label} timed out after ${timeoutMs}ms`);
+        if (callbackInvokeSent) {
+          sendCallbackAbortMessage(connection, requestId, timeoutError.message);
+        }
+        settle(reject, timeoutError);
+      }, timeoutMs);
+    }
     const pending = {
-      resolve,
-      reject
+      callbackId,
+      cleanup: () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = undefined;
+        }
+        if (options?.signal && onAbort) {
+          options.signal.removeEventListener("abort", onAbort);
+        }
+      },
+      resolve: (result) => settle(resolve, result),
+      reject: (error) => settle(reject, error)
     };
     connection.pendingCallbacks.set(requestId, pending);
     const invoke = {
@@ -1356,6 +1446,7 @@ async function invokeClientCallback(connection, callbackId, args) {
       args
     };
     sendMessage(connection.socket, invoke);
+    callbackInvokeSent = true;
   });
 }
 function handleStreamPush(message, connection) {
@@ -1480,16 +1571,36 @@ function handleCallbackStreamStart(message, connection) {
       return Promise.resolve();
     }
   });
+  const cancelStream = () => {
+    connection.callbackStreamReceivers.delete(message.streamId);
+    sendMessage(connection.socket, {
+      type: import_isolate_protocol.MessageType.CALLBACK_STREAM_CANCEL,
+      streamId: message.streamId
+    });
+  };
   connection.callbackStreamReceivers.set(message.streamId, receiver);
   const pending = connection.pendingCallbacks.get(message.requestId);
-  if (pending) {
-    connection.pendingCallbacks.delete(message.requestId);
-    const response = new Response(readableStream, {
+  if (!pending) {
+    cancelStream();
+    return;
+  }
+  try {
+    const body = NULL_BODY_STATUSES.has(message.metadata.status) ? null : readableStream;
+    const response = new Response(body, {
       status: message.metadata.status,
       statusText: message.metadata.statusText,
       headers: message.metadata.headers
     });
+    connection.pendingCallbacks.delete(message.requestId);
     pending.resolve({ __streamingResponse: true, response });
+    if (body === null) {
+      cancelStream();
+    }
+  } catch (err) {
+    connection.pendingCallbacks.delete(message.requestId);
+    cancelStream();
+    const error = err instanceof Error ? err : new Error(String(err));
+    pending.reject(error);
   }
 }
 function handleCallbackStreamChunk(message, connection) {
@@ -1752,4 +1863,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=3783342607D7276564756E2164756E21
+//# debugId=8F51D70F9171DF6C64756E2164756E21