@ricsam/isolate 0.1.4 → 0.1.6

package/dist/cjs/internal/client/connection.cjs

@@ -81,6 +81,7 @@ async function connect(options = {}) {
   const state = {
     socket,
     pendingRequests: new Map,
+    pendingCallbackCalls: new Map,
     callbacks: new Map,
     callbacksNeedingRequestId: new Set,
     nextRequestId: 1,
@@ -113,6 +114,10 @@ async function connect(options = {}) {
         pending.reject(new Error("Connection closed"));
       }
       state.pendingRequests.clear();
+      for (const [, pending] of state.pendingCallbackCalls) {
+        pending.reject(new Error("Connection closed"));
+      }
+      state.pendingCallbackCalls.clear();
       for (const [, receiver] of state.streamResponses) {
         receiver.state = "errored";
         receiver.error = new Error("Connection closed");
@@ -310,6 +315,24 @@ function handleMessage(message, state) {
       handleCallbackInvoke(invoke, state);
       break;
     }
+    case import_protocol.MessageType.CALLBACK_RESPONSE: {
+      const response = message;
+      const pending = state.pendingCallbackCalls.get(response.requestId);
+      if (pending) {
+        state.pendingCallbackCalls.delete(response.requestId);
+        if (response.error) {
+          const error = new Error(response.error.message);
+          error.name = response.error.name;
+          if (response.error.stack) {
+            error.stack = response.error.stack;
+          }
+          pending.reject(error);
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+      break;
+    }
     case import_protocol.MessageType.PONG:
       break;
     case import_protocol.MessageType.CALLBACK_STREAM_CANCEL: {
@@ -550,6 +573,27 @@ async function handleCallbackInvoke(invoke, state) {
     }
   }
 }
+function invokeDaemonCallback(state, callbackId, args) {
+  if (!state.connected) {
+    return Promise.reject(new Error("Not connected"));
+  }
+  const requestId = state.nextRequestId++;
+  const requestContext = import_request_context.getRequestContext();
+  const invoke = {
+    type: import_protocol.MessageType.CALLBACK_INVOKE,
+    requestId,
+    callbackId,
+    args,
+    context: requestContext ? {
+      requestId: requestContext.requestId,
+      metadata: requestContext.metadata
+    } : undefined
+  };
+  return new Promise((resolve, reject) => {
+    state.pendingCallbackCalls.set(requestId, { resolve, reject });
+    sendMessage(state.socket, invoke);
+  });
+}
 function sendMessage(socket, message) {
   const frame = import_protocol.buildFrame(message);
   socket.write(frame);
@@ -1416,13 +1460,141 @@ var returnedPromiseRegistry = new Map;
 var returnedIteratorRegistry = new Map;
 function registerCustomFunctions(state, customFunctions) {
   const registrations = {};
+  const addCallbackIdsToRefs = (value) => {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (import_protocol.isPromiseRef(value)) {
+      const resolveCallbackId = state.nextCallbackId++;
+      state.callbacks.set(resolveCallbackId, async (...args) => {
+        const promiseId = args[0];
+        const promise = returnedPromiseRegistry.get(promiseId);
+        if (!promise) {
+          throw new Error(`Promise ${promiseId} not found`);
+        }
+        const promiseResult = await promise;
+        returnedPromiseRegistry.delete(promiseId);
+        const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
+        return addCallbackIdsToRefs(marshalledResult);
+      });
+      return {
+        ...value,
+        __resolveCallbackId: resolveCallbackId
+      };
+    }
+    if (import_protocol.isAsyncIteratorRef(value)) {
+      const nextCallbackId = state.nextCallbackId++;
+      state.callbacks.set(nextCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const iterator = returnedIteratorRegistry.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        const iterResult = await iterator.next();
+        if (iterResult.done) {
+          returnedIteratorRegistry.delete(iteratorId);
+        }
+        const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+        return {
+          done: iterResult.done,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const returnCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const returnValue = args[1];
+        const iterator = returnedIteratorRegistry.get(iteratorId);
+        returnedIteratorRegistry.delete(iteratorId);
+        if (!iterator || !iterator.return) {
+          return { done: true, value: undefined };
+        }
+        const iterResult = await iterator.return(returnValue);
+        const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+        return {
+          done: true,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const throwCallbackId = state.nextCallbackId++;
+      state.callbacks.set(throwCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const errorValue = args[1];
+        const iterator = returnedIteratorRegistry.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        try {
+          if (!iterator.throw) {
+            throw Object.assign(new Error(errorValue?.message ?? "Iterator does not support throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+          }
+          const thrownError = Object.assign(new Error(errorValue?.message ?? "Iterator throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+          const iterResult = await iterator.throw(thrownError);
+          if (iterResult.done) {
+            returnedIteratorRegistry.delete(iteratorId);
+          }
+          const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+          return {
+            done: iterResult.done,
+            value: addCallbackIdsToRefs(marshalledValue)
+          };
+        } catch (error) {
+          returnedIteratorRegistry.delete(iteratorId);
+          throw error;
+        }
+      });
+      return {
+        ...value,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId,
+        __throwCallbackId: throwCallbackId
+      };
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => addCallbackIdsToRefs(item));
+    }
+    const objResult = {};
+    for (const key of Object.keys(value)) {
+      objResult[key] = addCallbackIdsToRefs(value[key]);
+    }
+    return objResult;
+  };
+  const marshalCtx = {
+    registerCallback: (fn) => {
+      const returnedCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnedCallbackId, async (...args) => {
+        const fnResult = await fn(...args);
+        const marshalledResult = await import_protocol.marshalValue(fnResult, marshalCtx);
+        return addCallbackIdsToRefs(marshalledResult);
+      });
+      return returnedCallbackId;
+    },
+    registerPromise: (promise) => {
+      const promiseId = state.nextCallbackId++;
+      returnedPromiseRegistry.set(promiseId, promise);
+      return promiseId;
+    },
+    registerIterator: (iterator) => {
+      const iteratorId = state.nextCallbackId++;
+      returnedIteratorRegistry.set(iteratorId, iterator);
+      return iteratorId;
+    }
+  };
+  const unmarshalCtx = {};
+  unmarshalCtx.getCallback = (callbackId) => {
+    return async (...args) => {
+      const marshalledArgs = await import_protocol.marshalValue(args, marshalCtx);
+      const result = await invokeDaemonCallback(state, callbackId, addCallbackIdsToRefs(marshalledArgs));
+      return import_protocol.unmarshalValue(result, unmarshalCtx);
+    };
+  };
   for (const [name, def] of Object.entries(customFunctions)) {
     if (def.type === "asyncIterator") {
       const startCallbackId = state.nextCallbackId++;
       state.callbacks.set(startCallbackId, async (...args) => {
         try {
           const fn = def.fn;
-          const iterator = fn(...args);
+          const iterator = fn(...import_protocol.unmarshalValue(args, unmarshalCtx));
           const iteratorId = nextClientIteratorId++;
           clientIteratorSessions.set(iteratorId, { iterator });
           return { iteratorId };
@@ -1491,127 +1663,7 @@ function registerCustomFunctions(state, customFunctions) {
     } else {
       const callbackId = state.nextCallbackId++;
       state.callbacks.set(callbackId, async (...args) => {
-        const result = await def.fn(...args);
-        const addCallbackIdsToRefs = (value) => {
-          if (value === null || typeof value !== "object") {
-            return value;
-          }
-          if (import_protocol.isPromiseRef(value)) {
-            const resolveCallbackId = state.nextCallbackId++;
-            state.callbacks.set(resolveCallbackId, async (...args2) => {
-              const promiseId = args2[0];
-              const promise = returnedPromiseRegistry.get(promiseId);
-              if (!promise) {
-                throw new Error(`Promise ${promiseId} not found`);
-              }
-              const promiseResult = await promise;
-              returnedPromiseRegistry.delete(promiseId);
-              const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
-              return addCallbackIdsToRefs(marshalledResult);
-            });
-            return {
-              ...value,
-              __resolveCallbackId: resolveCallbackId
-            };
-          }
-          if (import_protocol.isAsyncIteratorRef(value)) {
-            const nextCallbackId = state.nextCallbackId++;
-            state.callbacks.set(nextCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const iterator = returnedIteratorRegistry.get(iteratorId);
-              if (!iterator) {
-                throw new Error(`Iterator ${iteratorId} not found`);
-              }
-              const iterResult = await iterator.next();
-              if (iterResult.done) {
-                returnedIteratorRegistry.delete(iteratorId);
-              }
-              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-              return {
-                done: iterResult.done,
-                value: addCallbackIdsToRefs(marshalledValue)
-              };
-            });
-            const returnCallbackId = state.nextCallbackId++;
-            state.callbacks.set(returnCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const returnValue = args2[1];
-              const iterator = returnedIteratorRegistry.get(iteratorId);
-              returnedIteratorRegistry.delete(iteratorId);
-              if (!iterator || !iterator.return) {
-                return { done: true, value: undefined };
-              }
-              const iterResult = await iterator.return(returnValue);
-              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-              return {
-                done: true,
-                value: addCallbackIdsToRefs(marshalledValue)
-              };
-            });
-            const throwCallbackId = state.nextCallbackId++;
-            state.callbacks.set(throwCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const errorValue = args2[1];
-              const iterator = returnedIteratorRegistry.get(iteratorId);
-              if (!iterator) {
-                throw new Error(`Iterator ${iteratorId} not found`);
-              }
-              try {
-                if (!iterator.throw) {
-                  throw Object.assign(new Error(errorValue?.message ?? "Iterator does not support throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
-                }
-                const thrownError = Object.assign(new Error(errorValue?.message ?? "Iterator throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
-                const iterResult = await iterator.throw(thrownError);
-                if (iterResult.done) {
-                  returnedIteratorRegistry.delete(iteratorId);
-                }
-                const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-                return {
-                  done: iterResult.done,
-                  value: addCallbackIdsToRefs(marshalledValue)
-                };
-              } catch (error) {
-                returnedIteratorRegistry.delete(iteratorId);
-                throw error;
-              }
-            });
-            return {
-              ...value,
-              __nextCallbackId: nextCallbackId,
-              __returnCallbackId: returnCallbackId,
-              __throwCallbackId: throwCallbackId
-            };
-          }
-          if (Array.isArray(value)) {
-            return value.map((item) => addCallbackIdsToRefs(item));
-          }
-          const objResult = {};
-          for (const key of Object.keys(value)) {
-            objResult[key] = addCallbackIdsToRefs(value[key]);
-          }
-          return objResult;
-        };
-        const marshalCtx = {
-          registerCallback: (fn) => {
-            const returnedCallbackId = state.nextCallbackId++;
-            state.callbacks.set(returnedCallbackId, async (...args2) => {
-              const fnResult = await fn(...args2);
-              const marshalledResult = await import_protocol.marshalValue(fnResult, marshalCtx);
-              return addCallbackIdsToRefs(marshalledResult);
-            });
-            return returnedCallbackId;
-          },
-          registerPromise: (promise) => {
-            const promiseId = state.nextCallbackId++;
-            returnedPromiseRegistry.set(promiseId, promise);
-            return promiseId;
-          },
-          registerIterator: (iterator) => {
-            const iteratorId = state.nextCallbackId++;
-            returnedIteratorRegistry.set(iteratorId, iterator);
-            return iteratorId;
-          }
-        };
+        const result = await def.fn(...import_protocol.unmarshalValue(args, unmarshalCtx));
         const marshalled = await import_protocol.marshalValue(result, marshalCtx);
         const withCallbackIds = addCallbackIdsToRefs(marshalled);
         return withCallbackIds;
@@ -1916,4 +1968,4 @@ function handleClientWsClose(isolateId, payload, state) {
   }
 }
 
-//# debugId=7D1BE4A52F267ED264756E2164756E21
+//# debugId=6EEF0F611807A4E264756E2164756E21