Experimental pipeline for preflight

pipeline

// 1. want an object of promises kicked off by each task
// 2. each task declares its dependencies
// 3. if no dependencies it runs immediately
// 4. if dependencies, waits for them
// 5. unified pattern

const tasks = {};
// str, arr, (req, headers, deps) => headers
const taskRunner = {
	register: ({name, dependencies, catchable, task}) => {
		if (!dependencies) {
			tasks[name] = (req, headers, promises) => Promise.resolve(task(req, headers))
				.then(headers => {
					promises[name].resolve(headers);
					return headers;
				})
				.catch(err => promises[name].reject(err))
		} else {
			tasks[name] = (req, headers, promises) => Promise.all(
					dependencies.map(d => promises[d])
				)
				.then(deps => task(req, headers, deps))
				.then(headers => {
					promises[name].resolve(headers);
					return headers;
				})
				.catch(err => promises[name].reject(err))
		}

		return tasks[name];
	},
	run: (req, headers) => {
		const promises = Object.keys(tasks).reduce((obj, name) => {
			let resolver
			obj[name] = new Promise((resolve, reject) => {
				resolver = resolve;
				rejecter = reject;
			})
			obj[name].resolve = resolver;
			obj[name].reject = rejecter;
			return obj;
		}, {})

		return Promise.all(
			Object.keys(tasks)
				.map(name => tasks[name](req, headers, promises))
		)
			.then(() => headers)
	}
}
const barrier = taskRunner.register({name: 'barrier', dependencies: ['vanity', 'session', 'access'], task: () => {
	console.log('barrier');
}})


const session = taskRunner.register({name: 'session', task: () => {
	console.log('session');
}})

const access = taskRunner.register({name: 'access', dependencies: ['vanity', 'session'], task: () => {
	console.log('access');
}})

const ammit = taskRunner.register({name: 'ammit', dependencies: ['vanity', 'session'], task: () => {
	console.log('ammit');
}})

const vanity = taskRunner.register({name: 'vanity', task: () => {
	console.log('vanity')
}})


function pipeline (req) {
	const headers = {};
	return taskRunner.run(req, headers)
		.catch(console.log)
}

pipeline({})