如何将同步结果返回给异步函数调用

Question

In Node 13, an external 3rd party library calls my code:

const myInput = myCode.run(somVar); // it doesn't use await

As my code then has to perform nested synchronous calls, how could I provide an appropriate return value to the 3rd party library that is not a promise, but the result of my promises? Ideally something like this:

const run = (inputVar) =>{
   let result
   (async ()=>{  
      result = await doSyncCalls(inputVar);
   })(); // code should not proceed until after await
   return result;
} // will return undefined, but ideally should return doSyncCalls result

deasync would be a good solution, except it has an unresolved bug that causes nested promises to not resolve.

Answer 1

Well, there is no way to synchronously return (from the callback) a value that you obtain asynchronously within the callback. Javascript does not currently support that. So, these are your options:

1. Put the asynchronous code in a child_process. Then run that child process with something like child_process.execFileSync() . That allows you to run the asynchronous code in the child process, but have the parent process block and wait for the result. This is a hack because it blocks the parent while waiting for the result. But, it can be made to work.

2. Before calling the library function, prefetch whatever value it is you will need when the callback is called. This allows you to use regular asynchronous programming before you call the library and then once you have the desired value in some sort of cache, you can then call the 3rd party library and when it calls you back and wants the value, you will have it synchronously in a cache somewhere. Obviously, this only works if you can figure what value or range of possible values will be required in the callback so you can pre-fetch them.

3. Modify the code in the library to add support for an asycnhronous callback.

4. Redesign code to work a different way that doesn't require this library or that can use some other library that doesn't have this problem.

5. Write or find some native code add-on (like deasync ) that lets you block somehow during the asynchronous operation while still letting the event queue do what it needs to do to process the asynchronous completion. This would have to hook deep into the internals of the V8 engine. Or fix, deasync so it works for your case.

6. Write a blocking add-on in native code that could carry out your asynchronous operation in native code while blocking the V8 engine.

FYI, since everything but #2, #3 and #4 all block the main JS thread which is generally a bad thing to do in any server environment, and you've said that #2 was not practical, my preference would be #3 or #4. Since you don't share the actual code and actual detailed library and problem, we can't help you with any specifics.

Probably the most straightforward solution to implement is #1 (package the code up into a child process that you run synchronously), but it blocks the app while running which is a downside.