rest-methods/lib/server/manifest.js

Declaratively publish functions for remote invocation.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var _lodash = require("lodash");

var _lodash2 = _interopRequireDefault(_lodash);

var _const = require("../const");

var mergeParameterDocs = function mergeParameterDocs(paramsArray, methodDocs) {
  paramsArray = _lodash2["default"].clone(paramsArray, true);
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = paramsArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var item = _step.value;

      var details = methodDocs.params[item.name];
      if (details) {
        item.description = details.description;
        item.type = details.type;
      }
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator["return"]) {
        _iterator["return"]();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return paramsArray;
};

/**
  * Generates the manifest of currently registered methods
  * for delivery over the wire to clients.
  * @return {object}.
  */
var getMethods = function getMethods(server) {
  var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  if (!server) {
    throw new Error("getMethods: [server] not sepcified.");
  }
  var result = {};
  var methods = server[_const.METHODS];

  var formatMethod = function formatMethod(key, method) {
    if (_lodash2["default"].isEmpty(method)) {
      return;
    }
    var methodDefinition = {
      url: undefined,
      name: key.replace(/\//g, ".")
    };
    result[key] = methodDefinition;
    ["get", "put", "post", "delete"].map(function (verb) {
      var methodVerb = method[verb];
      if (methodVerb) {
        var verbDefiniton = methodDefinition[verb] = {};
        if (options.docs && methodVerb.docs && methodVerb.docs.description) {
          methodDefinition.description = methodVerb.docs.description;
        }
        if (methodVerb.route.path) {
          methodDefinition.url = methodVerb.route.path;
        }

        // Params.
        var params = _lodash2["default"].clone(methodVerb.params);
        if (verb === "get" || verb === "delete") {
          // Prune of parameters that are not on the URL for GET|DELETE verbs.
          params = _lodash2["default"].filter(params, function (param) {
            return _lodash2["default"].any(methodVerb.route.keys, function (routeKey) {
              return param.name === routeKey.name;
            });
          });
        }
        if (!_lodash2["default"].isEmpty(params)) {
          verbDefiniton.params = params;
          if (options.docs && methodVerb.docs) {
            verbDefiniton.params = mergeParameterDocs(verbDefiniton.params, methodVerb.docs);
          }
        }
      }
    });
  };

  Object.keys(methods).forEach(function (key) {
    formatMethod(key, methods[key]);
  });
  return result;
};

exports.getMethods = getMethods;

exports["default"] = function (server) {
  var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

  return {
    name: server.name,
    version: server.version || "0.0.0",
    basePath: server.basePath,
    methods: getMethods(server, options)
  };
};