HTTP Batcher

HTTP Request Batcher for SPA

It's for existing project not using GraphQL (maybe Apollo is better)

Install

npm i http-batcher

Usage

Define type of arguments of request. any form, even any is allowed.

// for example
interface Request {
  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
  url: 'string';
  parameter?: string;
}

Create Batcher instance with previously defined type, and options

const batcher = new Batcher<Request>(options);

and queue to the batcher instead of firing HTTP request

batcher.queue({
  method: 'GET',
  url: './notice/top/1',
});

Example

const API_ENDPOINT = './api';
const API_ENDPOINT_BATCH = './api-batch';

/*
 * API Call may includes HTTP method, URL, parameters, ...
 */
type APICall = [key: string, param: any];

function request([key, data]: APICall): Promise<any> {
  return XHR(`${API_ENDPOINT}/${key}`, data);
}

/*
 * To use this library, Batch API needed on the backend
 */
function batchRequest(data: APICall[]): Promise<any[]> {
  return XHR(API_ENDPOINT_BATCH, data);
}

/*
 * Create Batcher instance
 * See Options for details
 */
const defaultBatcher = new Batcher<APICall>({
  defaultDelay: 1,
  minDelay: 3,
  maxDelay: 100,
  process: batchRequest,
  preferSingle: request,
});

/*
 * Existing code (maybe) has a common function to call API
 * Change it to use the Batcher!
 * It batches nearly concurrent API calls into one HTTP request
 */
export default function API<Key extends keyof API_DEFINITION>(
  key: Key,
  param: API_DEFINITION[Key]['request'],
  batcher = defaultBatcher,
): Promise<API_DEFINITION[Key]['response']> {
  // Queuing to the batcher instead of firing actual HTTP request
  return batcher.queue<API_DEFINITION[Key]['response']>([key, param]);
}

Options

• defaultDelay - Time to wait for others to be queued, by millisecond. default 1
• minDelay - Minimum time to wait from the first queued time in the batch. default 0
• maxDelay - Maximum time to wait from the first queued time. required
• maxCount - Maximum batch size. default Infinity, UNSTABLE
• process - Actual executor for queued tasks. required
  • Function accepts array of the type of arguments of request and returns Promise for array contains each result
  • Some pre/post processing (e.g. remove redundant request by idempotency) can also be performed here
• preferSingle - If specified, used instead of process if count of requests of the batch is 1. optional
  • Function accepts the type of arguments of request and returns Promise for the result
  • Not required~~, but slight reduction in server side load can be expected?~~

Requirements

Typescript

License

Code licensed under the MIT License.