Enables DataLoader for GraphQL subscriptions

yarn add dataloader-warehouse

A typical data loader is created at the beginning of a mutation and disposed of after it returns. This is a best practice to reduce security concerns and to avoid stale data. Unfortunately, it isn't possible with subscriptions since they are long-lived. The current workaround is to turn off the dataLoader cache, which is horribly inefficient. This package allows you to use the same dataLoader for your mutation and subscription payloads, when safe to do so.

• dataLoader: an instance created by the DataLoader class
• dataLoaderBase: an object where each key is a dataLoader
• dataLoaderWarehouse: an object where each key is a dataLoaderBase

import DataLoaderWarehouse from 'dataloader-warehouse';
const dataLoaderWarehouse = new DataLoaderWarehouse({onShare: '_share', ttl: 5000});

import DataLoader from 'dataloader';
import {graphql} from 'graphql';

const dataLoaderBase = {todos: new DataLoader(todoBatchFn)};
const warehouseWorker = dataLoaderWarehouse.add(dataLoaderBase);
const result = await graphql(schema, query, {}, {warehouseWorker}, variables);
warehouseWorker.dispose();

import {subscribe} from 'graphql';

// Important! Note {cache: false}. You should already have been doing this since subs are long-lived.
const dataLoaderBase = {todos: new DataLoader(todoBatchFn, {cache: false})};
const warehouseWorker = dataLoaderWarehouse.add(dataLoaderBase);
const asyncIterator = await subscribe(schema, document, {}, {warehouseWorker}, variables);
await forAwaitEach(asyncIterator, iterableCb);
warehouseWorker.dispose();

// UpdateTodo.js
resolve(source, args, {warehouseWorker}) {
  const updatedTodo = db.update({foo: 'bar'});
  const operationId = warehouseWorker.share();
  pubsub.publish('updatedTodo', {updatedTodo, operationId})
}

async subscribe(source, args, {warehouseWorker}) {
  const asyncIterator = pubsub.asyncIterator('updatedTodo');
  const getNextPromise = async () => {
    const nextRes = await asyncIterator.next();
    const {value, done} = nextRes;
    if (done) {
      return asyncIterator.return();
    }
    if (value.operationId) {
      warehouseWorker.useShared(value.operationId);
    }
    return nextRes;
  };
  return {
    next() {
      return getNextPromise();   
    },
    return() {
      warehouseWorker.dispose({force: true});
      return asyncIterator.return();
    }
  }
}

todo: {
  type: Todo,
  resolve: (source, args, {warehouseWorker}) {
    // before
    // return dataLoaderBase.todos.load(source.id) 
    
    // after
    return warehouseWorker.get('todos').load(source.id)
  }
}

The DataLoaderWarehouse takes the following args

• ttl: time to live (ms). Smaller number means less memory usage. 100-5000 is reasonable.
• onShare: The name of the method in your dataLoaderBase to call when you call share(). Use this to sanitize your dataLoaderBase of any sensitive info that might have been provided to it (such as an auth token) This is not required, but provides peace of mind if you're unsure about your schema authorization.

The dataLoaderWarehouse instance has a single public method:

• add(dataLoaderBase): Call this with an object containing all your loaders. It returns a WarehouseWorker.

The WarehouseWorker (the result of DataLoaderWarehouse#add) has the following methods:

• dispose(options): dispose of the data loader if it is not being shared. Options include:
  • force: boolean, defaults to false. If true, calling dispose will dispose of the dataLoaderBase even if it is being shared.
• share(ttl): Returns a unique ID to be fed to useShared. Also begins the TTL. Although strongly discouraged, you may provide a TTL here to override the one defined by the DataLoaderWarehouse. This is useful if you need to extend the time because you are making an external API call, or using setTimeout.
• useShared(operationId): Replaces the current dataLoaderBase with the dataLoaderBase belonging to the operationId. You'll want to pass in the operationId provided by the publishing mutation
• getID: returns the ID of the current dataLoaderBase. Useful for testing.
• isShared: returns true if the dataLoaderBase is currently being shared. Useful for testing.

MIT