@ricsam/isolate-daemon 0.1.21 → 0.1.23

package/dist/cjs/connection.cjs

@@ -48,6 +48,25 @@ 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;
@@ -122,6 +141,7 @@ function handleConnection(socket, state) {
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
+      pending.cleanup?.();
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -455,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;
@@ -470,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;
   }
@@ -793,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,
@@ -800,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;
@@ -1331,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;
@@ -1342,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 = {
@@ -1357,6 +1446,7 @@ async function invokeClientCallback(connection, callbackId, args) {
       args
     };
     sendMessage(connection.socket, invoke);
+    callbackInvokeSent = true;
   });
 }
 function handleStreamPush(message, connection) {
@@ -1773,4 +1863,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=CCDD5E4DA24900F364756E2164756E21
+//# debugId=8F51D70F9171DF6C64756E2164756E21