Feature Request: Revise index.export() to return an Array of Promises

Currently

• The function index.export( function(key, data) {..} ), returns a single value - the boolean true.
• The registered callback function is invoked four times, once each for keys reg, cfg, map and ctx.

Requested Improvement

-Adjust index.export() to return an array of promises - i.e., one promise for each prospective callback invocation. [Alternately, return an iterable suitable for a Promise.All() construct.]

Benefits

• The proposed would facilitate tracking (e.g., blocking on) the resulting N callbacks.
• Going forward, Flexsearch could adjust the number of callback invocations with less (if any) client impact.
• Errors (rejections) could be handled within the Promise framework.

Example

Simulate an exception in the callback function.

myErrantCallback (k, v) {
  // Convert k to kx for https://github.com/nextapps-de/flexsearch/issues/273
  let kx = k;
  if (k.lastIndexOf('.') > 0) {
    kx = k.substring(k.lastIndexOf('.') + 1);
  }
  // Throw a random exception 15% of the time.
  if (Math.floor(Math.random() * 100) < 15) {
    throw new Error(`k: ${k}, kx: ${kx}, v: ${v}`);
  } else {
    console.log(`k: ${k}, kx: ${kx}, v: ${v}`);
  }
}

The current export() facility, requires clients to anticipate and track the number of callback invocations AND deal with any exceptions that arise. The proposed facility simplifies these tasks.

Promise.All(index.improvedExport( function(key, data) {..} )
  .then(...)     // Take an action after all N Promises are fulfilled.
  .catch(...)    // Centrally manage exceptions.

[peterbe]

If I had this, I could do something like:

const bits = await Promise.all(index.export)
await fs.writeFile(bits, JSON.stringify(bits))

[danielvy]

I don’t think that export() needs to return an array of promises. If you need an array of promises you can just create one and add the created promises in the callbacks, as seen in the example provided by @rpsirois . But you probably never need this.

What doesn’t make sense is that export() is an asynchronous function by nature that invokes a callback and yet it doesn’t provide any way to know when it’s done invoking callbacks for all keys. So users need to jump through hoops and compare the keys provided to callbacks with some list of possible keys.

What’s needed is that export() should return a single promise when it’s done, i.e. finished calling all callbacks, and, if needed, waiting for callbacks that return promises. Then resolve.

So you can simply write:

await index.export();

By the way, the Typescript definitions incorrectly (for the actual code) type export() as returning Promise<void>, which was very confusing.