fusion-plugin-rpc/dist/index.es.js

import { createToken, createPlugin, memoize } from 'fusion-core';
import { UniversalEventsToken } from 'fusion-plugin-universal-events';
import bodyparser from 'koa-bodyparser';
import mapObject from 'just-map-object';
import isEqual from 'just-compare';

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */
const RPCToken = createToken('RPCToken');
const RPCHandlersToken = createToken('RPCHandlersToken');
const BodyParserOptionsToken = createToken('BodyParserOptionsToken');
const RPCHandlersConfigToken = createToken('RPCHandlersConfigToken');

const formatApiPath = apiPath => `/${apiPath}/`.replace(/\/{2,}/g, '/');

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

/* eslint-env browser */

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */
class MissingHandlerError extends Error {
  constructor(method) {
    super(`Missing RPC handler for ${method}`);
    this.code = 'ERR_MISSING_HANDLER';
    Error.captureStackTrace(this, MissingHandlerError);
  }

}

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */
class ResponseError extends Error {
  constructor(message) {
    super(message);
    this.code = null;
    this.meta = null;
    Error.captureStackTrace(this, ResponseError);
  }

}

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

/* eslint-env node */
const statKey$1 = 'rpc:method';
/* Helper function */

function hasHandler(handlers, method) {
  return handlers.hasOwnProperty(method);
}

class RPC$1 {
  constructor(emitter, handlers, ctx) {
    if (!ctx || !ctx.headers) {
      throw new Error('fusion-plugin-rpc requires `ctx`');
    }

    this.ctx = ctx;
    this.emitter = emitter;
    this.handlers = handlers;
    return this;
  }

  async request(method, args) {
    const startTime = ms();

    if (!this.ctx) {
      throw new Error('fusion-plugin-rpc requires `ctx`');
    }

    if (!this.emitter) {
      throw new Error('fusion-plugin-rpc requires `emitter`');
    }

    const scopedEmitter = this.emitter.from(this.ctx);

    if (!this.handlers) {
      throw new Error('fusion-plugin-rpc requires `handlers`');
    }

    if (!hasHandler(this.handlers, method)) {
      const e = new MissingHandlerError(method);

      if (scopedEmitter) {
        scopedEmitter.emit('rpc:error', {
          method,
          origin: 'server',
          error: e
        });
      }

      throw e;
    }

    try {
      const result = await this.handlers[method](args, this.ctx);

      if (scopedEmitter) {
        scopedEmitter.emit(statKey$1, {
          method,
          status: 'success',
          origin: 'server',
          timing: ms() - startTime
        });
      }

      return result;
    } catch (e) {
      if (scopedEmitter) {
        scopedEmitter.emit(statKey$1, {
          method,
          error: e,
          status: 'failure',
          origin: 'server',
          timing: ms() - startTime
        });
      }

      throw e;
    }
  }

}

const pluginFactory$1 = () => createPlugin({
  deps: {
    emitter: UniversalEventsToken,
    handlers: RPCHandlersToken,
    bodyParserOptions: BodyParserOptionsToken.optional,
    rpcConfig: RPCHandlersConfigToken.optional
  },
  provides: deps => {
    const {
      emitter,
      handlers
    } = deps;
    const service = {
      from: memoize(ctx => new RPC$1(emitter, handlers, ctx))
    };
    return service;
  },
  middleware: deps => {
    const {
      emitter,
      handlers,
      bodyParserOptions,
      rpcConfig
    } = deps;
    if (!handlers) throw new Error('Missing handlers registered to RPCHandlersToken');
    if (!emitter) throw new Error('Missing emitter registered to UniversalEventsToken');
    const parseBody = bodyparser(bodyParserOptions);
    const apiPath = formatApiPath(rpcConfig && rpcConfig.apiPath ? rpcConfig.apiPath : 'api');
    return async (ctx, next) => {
      await next();
      const scopedEmitter = emitter.from(ctx);

      if (ctx.method === 'POST' && ctx.path.startsWith(apiPath)) {
        const startTime = ms(); // eslint-disable-next-line no-useless-escape

        const pathMatch = new RegExp(`${apiPath}([^/]+)`, 'i');
        const [, method] = ctx.path.match(pathMatch) || [];

        if (hasHandler(handlers, method)) {
          await parseBody(ctx, () => Promise.resolve());

          try {
            const result = await handlers[method](ctx.request.body, ctx);
            ctx.body = {
              status: 'success',
              data: result
            };

            if (scopedEmitter) {
              scopedEmitter.emit(statKey$1, {
                method,
                status: 'success',
                origin: 'browser',
                timing: ms() - startTime
              });
            }
          } catch (e) {
            const error = e instanceof ResponseError ? e : new Error('UnknownError - Use ResponseError from fusion-plugin-rpc (or fusion-plugin-rpc-redux-react if you are using React) package for more detailed error messages');
            ctx.body = {
              status: 'failure',
              data: {
                message: error.message,
                // $FlowFixMe
                code: error.code,
                // $FlowFixMe
                meta: error.meta
              }
            };

            if (scopedEmitter) {
              scopedEmitter.emit(statKey$1, {
                method,
                error: e,
                status: 'failure',
                origin: 'browser',
                timing: ms() - startTime
              });
            }
          }
        } else {
          const e = new MissingHandlerError(method);
          ctx.body = {
            status: 'failure',
            data: {
              message: e.message,
              code: e.code
            }
          };
          ctx.status = 404;

          if (scopedEmitter) {
            scopedEmitter.emit('rpc:error', {
              origin: 'browser',
              method,
              error: e
            });
          }
        }
      }
    };
  }
});
/* Helper functions */


function ms() {
  const [seconds, ns] = process.hrtime();
  return Math.round(seconds * 1000 + ns / 1e6);
}

var serverDataFetching = true && pluginFactory$1();

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */
class RPC$2 {
  constructor(handlers) {
    this.handlers = handlers;
  }

  async request(method, args) {
    if (!this.handlers) {
      throw new Error('fusion-plugin-rpc requires `handlers`');
    }

    if (!this.handlers[method]) {
      throw new MissingHandlerError(method);
    }

    return this.handlers[method](args);
  }

}

const plugin = createPlugin({
  deps: {
    handlers: RPCHandlersToken,
    emitter: UniversalEventsToken
  },
  provides: ({
    handlers
  } = {}) => {
    return {
      from: () => new RPC$2(handlers)
    };
  }
});

function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty$1(target, key, source[key]); }); } return target; }

function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const getMockRpcHandlers = (fixtures, onMockRpc) => fixtures.reduce((rpcHandlers, fixture) => _objectSpread$1({}, rpcHandlers, mapObject(fixture, (rpcId, responseDetails) => async (...args) => {
  const response = Array.isArray(responseDetails) ? responseDetails.filter(item => isEqual(item.args, args))[0].response : responseDetails;
  onMockRpc && onMockRpc(rpcId, args, response);

  if (response instanceof Error) {
    throw response;
  }

  return response;
})), {});

/** Copyright (c) 2018 Uber Technologies, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */
var index = serverDataFetching;

export default index;
export { plugin as mock, ResponseError, BodyParserOptionsToken, RPCToken, RPCHandlersToken, RPCHandlersConfigToken, getMockRpcHandlers };