@vovikilelik/task-queue-js

Task-queue-js

Library for organizing client API based on Set theory.

Installation

• Git git clone http://git.vovikilelik.com/Clu/task-queue-js.git
• Npm npm i @vovikilelik/task-queue-js

Using

import { join, all, put } './task-queue.js';

Base scenarios

• join(...f)(x) - like y = await f[0](x); z = await f[1](y); ... f[n];
• all(...f)(x) - like Promise.all([...f.map(fn => fn(x))])
• put(key, f)(x) - like f(x[key]).then(a => ({ [key]: a }))

Each scenario does not call requests immediately after creation, but only creates a script described in ...tasks. In order for the request has been executed, you need to call the ready-made scenario, like the function:

/* Create scenario */
const scenario = join(task1, task2, ..., taskn);

/* Execute scenario with various initial data */
scenario(initData).then(...).catch(...);

Each task is a function that takes the result of the previous task and returns a Promise.

const task = (data) => doPromise(data);
const scenario = join(task);

/* execute with data */
scenario(data);

The result of the task will merged to the result of the previous one. It can complement the previous object or overwrite some of the fields.

const task = (prev) => makeRequest(prev).then(items => ({ items }));

join(task)({ id: 1 }).then(console.log);

> { id: 1, items: [] }

Scenarios and tasks can be combined, and conditions can be specified directly when declaring arguments:

join(
  all(
    join(
      all(),
      ...
    ),
  ),
  isValid() && task
);

If there is no need for requests to the server, you can immediately transfer the finished data, both in scripts and in tasks, or return nothing:

const task1 = () => ({ one: 'Hello!' });
const task2 = () => false; // Will be ignored

const scenario = join(task1, task2, { two: 'Hi!' });
scenario().then(console.log);

> { one: 'Hello!', two: 'Hi!' }

Examples

/* An function for make request, do not mind... */
const myFetch = (url) => fetch(`https://${url}`).then(response => response.json());

import { join } './task-queue.js';

/* First task needs to id */
const loadUser = (response) => {
  const { id } = response;

  return myFetch(`user/${id}`)
    .then(json => ({ user: json }));
}

/* Second task needs to wait result of first task */
const loadItems = (response) => {
  const { id, user } = response;

  return myFetch(`metadata/${id}/${user.id}`)
    .then(json => ({ items: json }));
}

/* This tasks will call consistently
   and next task will be accept previous result. */
const scenario = join(loadUser, loadItems);

Using

/* It able to various requesting */
scenario({ id: 1 }).then(setData);
// { id: 1, user: {...}, items: [] }

scenario({ id: 2 }).then(setData);
// { id: 2, user: {...}, items: [] }
...