craft-ai/lib/client.js

'use strict';

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

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _request = require('./request');

var _request2 = _interopRequireDefault(_request);

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _interpreter = require('./interpreter');

var _defaults = require('./defaults');

var _defaults2 = _interopRequireDefault(_defaults);

var _jwtDecode2 = require('jwt-decode');

var _jwtDecode3 = _interopRequireDefault(_jwtDecode2);

var _time = require('./time');

var _time2 = _interopRequireDefault(_time);

var _constants = require('./constants');

var _errors = require('./errors');

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

var debug = (0, _debug2.default)('craft-ai:client');

function resolveAfterTimeout(timeout) {
  return new Promise(function (resolve) {
    return setTimeout(function () {
      return resolve();
    }, timeout);
  });
}

// A very simple regex, helps detect some issues.
var SIMPLE_HTTP_URL_REGEX = /^https?:\/\/.*$/;

function isUrl(url) {
  return SIMPLE_HTTP_URL_REGEX.test(url);
}

function createClient(tokenOrCfg) {
  var cfg = _lodash2.default.defaults({}, _lodash2.default.isString(tokenOrCfg) ? { token: tokenOrCfg } : tokenOrCfg, _defaults2.default);

  // Initialization check
  if (!_lodash2.default.has(cfg, 'token') || !_lodash2.default.isString(cfg.token)) {
    throw new _errors.CraftAiBadRequestError('Bad Request, unable to create a client with no or invalid token provided.');
  }
  try {
    var _jwtDecode = (0, _jwtDecode3.default)(cfg.token),
        owner = _jwtDecode.owner,
        platform = _jwtDecode.platform,
        project = _jwtDecode.project;

    // Keep the provided values


    cfg.owner = cfg.owner || owner;
    cfg.project = cfg.project || project;
    cfg.url = cfg.url || platform;
  } catch (e) {
    throw new _errors.CraftAiCredentialsError();
  }
  if (!_lodash2.default.has(cfg, 'url') || !isUrl(cfg.url)) {
    throw new _errors.CraftAiBadRequestError('Bad Request, unable to create a client with no or invalid url provided.');
  }
  if (!_lodash2.default.has(cfg, 'project') || !_lodash2.default.isString(cfg.project)) {
    throw new _errors.CraftAiBadRequestError('Bad Request, unable to create a client with no or invalid project provided.');
  } else {
    var splittedProject = cfg.project.split('/');
    if (splittedProject.length >= 2) {
      cfg.owner = splittedProject[0];
      cfg.project = splittedProject[1];
    }
  }
  if (!_lodash2.default.has(cfg, 'owner') || !_lodash2.default.isString(cfg.owner)) {
    throw new _errors.CraftAiBadRequestError('Bad Request, unable to create a client with no or invalid owner provided.');
  }
  if (cfg.proxy != null && !isUrl(cfg.proxy)) {
    throw new _errors.CraftAiBadRequestError('Bad Request, unable to create a client with an invalid proxy url provided.');
  }

  debug('Creating a client instance for project \'' + cfg.owner + '/' + cfg.project + '\' on \'' + cfg.url + '\'.');

  var request = (0, _request2.default)(cfg);

  // 'Public' attributes & methods
  var instance = {
    cfg: cfg,
    createAgent: function createAgent(configuration) {
      var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

      if (_lodash2.default.isUndefined(configuration) || !_lodash2.default.isObject(configuration)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to create an agent with no or invalid configuration provided.'));
      }

      if (!_lodash2.default.isUndefined(id) && !_constants.AGENT_ID_ALLOWED_REGEXP.test(id)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to create an agent with invalid agent id. It must only contain characters in "a-zA-Z0-9_-" and must be a string between 1 and ' + _constants.AGENT_ID_MAX_LENGTH + ' characters.'));
      }

      return request({
        method: 'POST',
        path: '/agents',
        body: {
          id: id,
          configuration: configuration
        }
      }).then(function (_ref) {
        var body = _ref.body;

        debug('Agent \'' + body.id + '\' created.');
        return body;
      });
    },
    getAgent: function getAgent(agentId) {
      if (!_constants.AGENT_ID_ALLOWED_REGEXP.test(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get an agent with invalid agent id. It must only contain characters in "a-zA-Z0-9_-" and cannot be the empty string.'));
      }

      return request({
        method: 'GET',
        path: '/agents/' + agentId
      }).then(function (_ref2) {
        var body = _ref2.body;
        return body;
      });
    },
    listAgents: function listAgents(agentId) {
      return request({
        method: 'GET',
        path: '/agents'
      }).then(function (_ref3) {
        var body = _ref3.body;
        return body.agentsList;
      });
    },
    deleteAgent: function deleteAgent(agentId) {
      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to delete an agent with no agentId provided.'));
      }

      return request({
        method: 'DELETE',
        path: '/agents/' + agentId
      }).then(function (_ref4) {
        var body = _ref4.body;

        debug('Agent \'' + agentId + '\' deleted');
        return body;
      });
    },
    destroyAgent: function destroyAgent(agentId) {
      (0, _constants.deprecation)('client.destroyAgent', 'client.deleteAgent');
      return this.deleteAgent(agentId);
    },
    getAgentContext: function getAgentContext(agentId) {
      var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get the agent context with no agentId provided.'));
      }
      var posixTimestamp = (0, _time2.default)(t).timestamp;
      if (_lodash2.default.isUndefined(posixTimestamp)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get the agent context with an invalid timestamp provided.'));
      }

      return request({
        method: 'GET',
        path: '/agents/' + agentId + '/context/state',
        query: {
          t: posixTimestamp
        }
      }).then(function (_ref5) {
        var body = _ref5.body;
        return body;
      });
    },
    addAgentContextOperations: function addAgentContextOperations(agentId, operations) {
      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to add agent context operations with no agentId provided.'));
      }
      if (!_lodash2.default.isArray(operations)) {
        // Only one given operation
        operations = [operations];
      }
      operations = _lodash2.default.compact(operations);

      if (!operations.length) {
        var message = 'No operation to add to the agent ' + cfg.owner + '/' + cfg.project + '/' + agentId + ' context.';

        debug(message);

        return Promise.resolve({ message: message });
      }

      return (0, _lodash2.default)(operations).map(function (_ref6) {
        var context = _ref6.context,
            timestamp = _ref6.timestamp;
        return {
          context: context,
          timestamp: (0, _time2.default)(timestamp).timestamp
        };
      }).orderBy('timestamp').chunk(cfg.operationsChunksSize).reduce(function (p, chunk) {
        return p.then(function () {
          return request({
            method: 'POST',
            path: '/agents/' + agentId + '/context',
            body: chunk
          });
        });
      }, Promise.resolve()).then(function () {
        var message = 'Successfully added ' + operations.length + ' operation(s) to the agent ' + cfg.owner + '/' + cfg.project + '/' + agentId + ' context.';
        debug(message);
        return { message: message };
      });
    },
    getAgentContextOperations: function getAgentContextOperations(agentId) {
      var _this = this;

      var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
      var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;

      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent context operations with no agentId provided.'));
      }
      var startTimestamp = void 0;
      if (start) {
        startTimestamp = (0, _time2.default)(start).timestamp;
        if (_lodash2.default.isUndefined(startTimestamp)) {
          return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent context operations with an invalid \'start\' timestamp provided.'));
        }
      }
      var endTimestamp = void 0;
      if (end) {
        endTimestamp = (0, _time2.default)(end).timestamp;
        if (_lodash2.default.isUndefined(endTimestamp)) {
          return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent context operations with an invalid \'end\' timestamp provided.'));
        }
      }

      var requestFollowingPages = function requestFollowingPages(_ref7) {
        var operations = _ref7.operations,
            nextPageUrl = _ref7.nextPageUrl;

        if (!nextPageUrl) {
          return Promise.resolve(operations);
        }
        return request({ url: nextPageUrl }, _this).then(function (_ref8) {
          var body = _ref8.body,
              nextPageUrl = _ref8.nextPageUrl;
          return requestFollowingPages({
            operations: operations.concat(body),
            nextPageUrl: nextPageUrl
          });
        });
      };

      return request({
        method: 'GET',
        path: '/agents/' + agentId + '/context',
        query: {
          start: startTimestamp,
          end: endTimestamp
        }
      }).then(function (_ref9) {
        var body = _ref9.body,
            nextPageUrl = _ref9.nextPageUrl;
        return requestFollowingPages({
          operations: body,
          nextPageUrl: nextPageUrl
        });
      });
    },
    getAgentStateHistory: function getAgentStateHistory(agentId) {
      var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
      var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;

      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent state history with no agentId provided.'));
      }
      var startTimestamp = void 0;
      if (start) {
        startTimestamp = (0, _time2.default)(start).timestamp;
        if (_lodash2.default.isUndefined(startTimestamp)) {
          return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent state history with an invalid \'start\' timestamp provided.'));
        }
      }
      var endTimestamp = void 0;
      if (end) {
        endTimestamp = (0, _time2.default)(end).timestamp;
        if (_lodash2.default.isUndefined(endTimestamp)) {
          return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to get agent state history with an invalid \'end\' timestamp provided.'));
        }
      }

      var requestFollowingPages = function requestFollowingPages(_ref10) {
        var stateHistory = _ref10.stateHistory,
            nextPageUrl = _ref10.nextPageUrl;

        if (!nextPageUrl) {
          return Promise.resolve(stateHistory);
        }
        return request({ url: nextPageUrl }).then(function (_ref11) {
          var body = _ref11.body,
              nextPageUrl = _ref11.nextPageUrl;
          return requestFollowingPages({
            stateHistory: stateHistory.concat(body),
            nextPageUrl: nextPageUrl
          });
        });
      };

      return request({
        method: 'GET',
        path: '/agents/' + agentId + '/context/state/history',
        query: {
          start: startTimestamp,
          end: endTimestamp
        }
      }).then(function (_ref12) {
        var body = _ref12.body,
            nextPageUrl = _ref12.nextPageUrl;
        return requestFollowingPages({
          stateHistory: body,
          nextPageUrl: nextPageUrl
        });
      });
    },
    getAgentInspectorUrl: function getAgentInspectorUrl(agentId) {
      var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

      (0, _constants.deprecation)('client.getAgentInspectorUrl', 'client.getSharedAgentInspectorUrl');
      return this.getSharedAgentInspectorUrl(agentId, t);
    },
    getSharedAgentInspectorUrl: function getSharedAgentInspectorUrl(agentId) {
      var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

      return request({
        method: 'GET',
        path: '/agents/' + agentId + '/shared'
      }).then(function (_ref13) {
        var body = _ref13.body;

        if (_lodash2.default.isUndefined(t)) {
          return body.shortUrl;
        } else {
          var posixTimestamp = (0, _time2.default)(t).timestamp;
          return body.shortUrl + '?t=' + posixTimestamp;
        }
      });
    },
    deleteSharedAgentInspectorUrl: function deleteSharedAgentInspectorUrl(agentId) {
      return request({
        method: 'DELETE',
        path: '/agents/' + agentId + '/shared'
      }).then(function () {
        debug('Delete shared inspector link for agent "' + agentId + '".');
      });
    },
    getAgentDecisionTree: function getAgentDecisionTree(agentId) {
      var t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
      var version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants.DEFAULT_DECISION_TREE_VERSION;

      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to retrieve an agent decision tree with no agentId provided.'));
      }
      var posixTimestamp = (0, _time2.default)(t).timestamp;
      if (_lodash2.default.isUndefined(posixTimestamp)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to retrieve an agent decision tree with an invalid timestamp provided.'));
      }

      var agentDecisionTreeRequest = function agentDecisionTreeRequest() {
        return request({
          method: 'GET',
          path: '/agents/' + agentId + '/decision/tree',
          query: {
            t: posixTimestamp
          },
          headers: {
            'x-craft-ai-tree-version': version
          }
        }).then(function (_ref14) {
          var body = _ref14.body;
          return body;
        });
      };

      if (!cfg.decisionTreeRetrievalTimeout) {
        // Don't retry
        return agentDecisionTreeRequest();
      } else {
        var start = Date.now();
        return Promise.race([agentDecisionTreeRequest().catch(function (error) {
          var requestDuration = Date.now() - start;
          var expectedRetryDuration = requestDuration + 2000; // Let's add some margin
          var timeoutBeforeRetrying = cfg.decisionTreeRetrievalTimeout - requestDuration - expectedRetryDuration;
          if (error instanceof _errors.CraftAiLongRequestTimeOutError && timeoutBeforeRetrying > 0) {
            // First timeout, let's retry once near the end of the set timeout
            return resolveAfterTimeout(timeoutBeforeRetrying).then(function () {
              return agentDecisionTreeRequest();
            });
          } else {
            return Promise.reject(error);
          }
        }), resolveAfterTimeout(cfg.decisionTreeRetrievalTimeout).then(function () {
          throw new _errors.CraftAiLongRequestTimeOutError();
        })]);
      }
    },
    computeAgentDecision: function computeAgentDecision(agentId, t) {
      for (var _len = arguments.length, contexts = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        contexts[_key - 2] = arguments[_key];
      }

      if (_lodash2.default.isUndefined(agentId)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to compute an agent decision with no agentId provided.'));
      }
      var posixTimestamp = (0, _time2.default)(t).timestamp;
      if (_lodash2.default.isUndefined(posixTimestamp)) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to compute an agent decision with no or invalid timestamp provided.'));
      }
      if (_lodash2.default.isUndefined(contexts) || _lodash2.default.size(contexts) === 0) {
        return Promise.reject(new _errors.CraftAiBadRequestError('Bad Request, unable to compute an agent decision with no context provided.'));
      }

      return request({
        method: 'GET',
        path: '/agents/' + agentId + '/decision/tree',
        query: {
          t: posixTimestamp
        }
      }).then(function (_ref15) {
        var body = _ref15.body;

        var decision = _interpreter.decide.apply(undefined, [body].concat(contexts));
        decision.timestamp = posixTimestamp;
        return decision;
      });
    }
  };

  return instance;
}