🦅 A tiny (~315B) utility that executes a dependency graph of async functions as concurrently as possible.
APACHE-2.0 License
$ npm i grfn
import { setTimeout } from 'node:timers/promises'
import grfn from 'grfn'
const fn = grfn({
// `e` depends on `a`, `c`, and `d`. Call `e` with the results of the
// functions once their returned promises resolve.
e: [
async (a, c, d) => {
await setTimeout(10)
return a * c * d
},
[`a`, `c`, `d`],
],
// `d` depends on `b`.
d: [
async b => {
await setTimeout(1)
return b * 2
},
[`b`],
],
// `c` depends on `a` and `b`.
c: [
async (a, b) => {
await setTimeout(5)
return a + b
},
[`a`, `b`],
],
// `a` and `b` have no dependencies! But they must still be listed. They take
// the input given to `fn`.
a: async (n1, n2, n3) => {
await setTimeout(15)
return n1 + n2 + n3
},
b: async (n1, n2, n3) => {
await setTimeout(10)
return n1 * n2 * n3
},
})
const output = await fn(4, 2, 3)
// This will be the output of `e` because no function depends on it!
console.log(`final output: ${output}`)
Output:
final output: 14256
The graph will be automatically validated, including cycle detection, via TypeScript magic!
grfn(vertices) => (...args) => Promise
Returns a function that runs the dependency graph of functions described by
vertices
:
Promise
that resolves to the value returned from the graph'svertices
Type: { [key: string]: Function | [Function, string[]?] }
An object describing a dependency graph of functions.
Each value in vertices
must be either:
[fnA, ['keyB', 'keyC']]
)[fn, []]
)The following constraints, which are validated via TypeScript magic, must also be met:
vertices
must also appear as a non-dependency:
b
doesn't appear as a non-dependency):
grfn({
a: [fnA, [`b`]],
})
grfn({
a: [fnA, [`b`]],
b: fnB,
})
vertices
must describe ana -> b -> a
):
grfn({
a: [fnA, [`b`]],
b: [fnB, [`a`]],
})
grfn({
a: [fnA, [`b`]],
b: fnB,
})
vertices
must have exactly one output function, a function that is notb
and c
are not depended on by any function):
grfn({
b: [fnB, [`a`]],
c: [fnC, [`a`]],
a: fnA,
})
grfn({
d: [fnD, [`b`, `c`]],
b: [fnB, [`a`]],
c: [fnC, [`a`]],
a: fnA,
})
Stars are always welcome!
For bugs and feature requests, please create an issue.
For pull requests, please read the contributing guidelines.
This is not an official Google product.