@nlabs/reaktor 0.3.0 → 0.4.0

package/lib/data/reactions.js

@@ -0,0 +1,529 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.for-each");
+
+require("core-js/modules/es.array.join");
+
+require("core-js/modules/es.array.map");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.date.now");
+
+require("core-js/modules/es.date.to-string");
+
+require("core-js/modules/es.function.name");
+
+require("core-js/modules/es.object.define-properties");
+
+require("core-js/modules/es.object.define-property");
+
+require("core-js/modules/es.object.freeze");
+
+require("core-js/modules/es.object.get-own-property-descriptor");
+
+require("core-js/modules/es.object.get-own-property-descriptors");
+
+require("core-js/modules/es.object.keys");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasReaction = exports.getItemsByReaction = exports.getReactionsByItem = exports.getGroupUsersByReaction = exports.getReactionCountByUser = exports.getReactionCount = exports.updateReaction = exports.removeReactionByItem = exports.removeReaction = exports.addReaction = exports.parseReactionOptions = void 0;
+
+var _utils = require("@nlabs/utils");
+
+var _arangojs = require("arangojs");
+
+var _utils2 = require("../utils");
+
+function _templateObject6() {
+  var data = _taggedTemplateLiteral(["FOR i, r IN INBOUND ", " hasReactions\n      FILTER r.name == ", " && r._from == ", "\n      COLLECT reactionValue = r.value INTO reactionItems\n      RETURN MERGE(r, {count: LENGTH(reactionItems[*].r.value)})"]);
+
+  _templateObject6 = function _templateObject6() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject5() {
+  var data = _taggedTemplateLiteral(["FOR i, r IN INBOUND ", " hasReactions\n    FILTER r.name == ", " && r.type == ", "\n    COLLECT WITH COUNT INTO count\n    RETURN count"]);
+
+  _templateObject5 = function _templateObject5() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject4() {
+  var data = _taggedTemplateLiteral(["UPSERT ", "\n    INSERT ", "\n    UPDATE ", "\n    LIMIT 1\n    RETURN NEW"]);
+
+  _templateObject4 = function _templateObject4() {
+    return data;
+  };
+
+  return data;
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(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; }
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["FOR r IN hasReactions\n    FILTER r._from == ", "\n      && r._to == ", "\n      && r.type == ", "\n      && r.name == ", "\n    LIMIT 1\n    REMOVE r IN hasReactions\n    RETURN OLD"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["LET r = DOCUMENT(", ")\n    FILTER r._from == ", "\n    LIMIT 1\n    REMOVE r IN hasReactions\n    RETURN OLD"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["FOR r IN hasReactions\n      FILTER r._from == ", " && r._to == ", " && r.name == ", "\n      LIMIT 1\n      RETURN r"]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+var eventCategory = 'reactions';
+
+var parseReactionOptions = function parseReactionOptions() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$from = options.from,
+      from = _options$from === void 0 ? 0 : _options$from,
+      _options$to = options.to,
+      to = _options$to === void 0 ? 30 : _options$to;
+  return {
+    limit: (0, _utils2.getLimit)(from, to)
+  };
+};
+
+exports.parseReactionOptions = parseReactionOptions;
+
+var addReaction = function addReaction(context, itemId) {
+  var itemType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'users';
+  var reaction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var allowDuplicate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var action = 'addReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var _reaction$name = reaction.name,
+      itemName = _reaction$name === void 0 ? 'like' : _reaction$name,
+      itemValue = reaction.value;
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var formatReactionName = (0, _utils.parseChar)(itemName, 32);
+  var formatValue = (0, _utils.parseString)(itemValue, 32);
+  var edgeCollection = (0, _utils2.useDb)(database).collection('hasReactions');
+  var typeDocId = "".concat(formatItemType, "/").concat(formatItemId);
+  var sessionDocId = "users/".concat(sessionId);
+  var edgeId = (0, _utils.createHash)("reaction-".concat(formatItemId, "-").concat(sessionId));
+  var edge = {
+    _from: sessionDocId,
+    _key: edgeId,
+    _to: typeDocId,
+    added: Date.now(),
+    name: formatReactionName,
+    type: formatItemType,
+    value: itemValue !== undefined ? formatValue : undefined
+  }; // Check for duplicates if not allowed
+
+  if (!allowDuplicate) {
+    // Query
+    var aqlQry = (0, _arangojs.aql)(_templateObject(), sessionDocId, typeDocId, formatReactionName);
+    return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+      return cursor.next();
+    }).then(function (reaction) {
+      if (!!reaction) {
+        return reaction;
+      }
+
+      return edgeCollection.save(edge, {
+        returnNew: true
+      }).then(function () {
+        console.log('addReaction::edge', edge);
+        return edge;
+      });
+    })["catch"](function (error) {
+      console.log('addReaction::error', error);
+      return (0, _utils2.logError)({
+        action: action,
+        category: eventCategory,
+        label: 'db_error'
+      }, error, context).then(function () {
+        return null;
+      });
+    });
+  }
+
+  return edgeCollection.save(edge, {
+    returnNew: true
+  }).then(function () {
+    return edge;
+  });
+};
+
+exports.addReaction = addReaction;
+
+var removeReaction = function removeReaction(context, reactionId) {
+  var action = 'removeReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var formatSessionId = "users/".concat((0, _utils.parseId)(sessionId));
+  var formatReactionId = "hasReactions/".concat((0, _utils.parseId)(reactionId)); // Query
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject2(), formatReactionId, formatSessionId);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+
+exports.removeReaction = removeReaction;
+
+var removeReactionByItem = function removeReactionByItem(context, itemId, itemType, reactionName) {
+  var action = 'removeReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var formatSessionId = "users/".concat((0, _utils.parseId)(sessionId));
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var formatItemDocId = "".concat(formatItemType, "/").concat((0, _utils.parseId)(itemId));
+  var formatReactionName = (0, _utils.parseChar)(reactionName, 32); // Query
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject3(), formatSessionId, formatItemDocId, formatItemType, formatReactionName);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+
+exports.removeReactionByItem = removeReactionByItem;
+
+var updateReaction = function updateReaction(context) {
+  var reaction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'updateReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var itemId = reaction.id,
+      itemName = reaction.name,
+      itemType = reaction.type,
+      itemValue = reaction.value;
+  var formatId = (0, _utils.parseId)(itemId);
+  var formatName = (0, _utils.parseChar)(itemName, 32);
+  var formatType = (0, _utils.parseChar)(itemType, 32);
+  var formatValue = (0, _utils.parseString)(itemValue, 32);
+  var edgeId = (0, _utils.createHash)("reaction-".concat(formatId, "-").concat(sessionId));
+  var update = {
+    name: formatName,
+    type: formatType,
+    value: formatValue
+  };
+
+  var insert = _objectSpread(_objectSpread({}, update), {}, {
+    _key: edgeId,
+    added: Date.now()
+  }); // Query
+
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject4(), {
+    _key: formatId
+  }, insert, update);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return null;
+    });
+  });
+};
+
+exports.updateReaction = updateReaction;
+
+var getReactionCount = function getReactionCount(context, itemId, itemType, reactionName) {
+  var action = 'getReactionCount';
+  var database = context.database;
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatReactionName = (0, _utils.parseChar)(reactionName, 32);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var itemDocId = "".concat(formatItemType, "/").concat(formatItemId); // Query
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject5(), itemDocId, formatReactionName, formatItemType);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return undefined;
+    });
+  });
+};
+
+exports.getReactionCount = getReactionCount;
+
+var getReactionCountByUser = function getReactionCountByUser(context, itemId, itemType, reactionName) {
+  var action = 'getReactionsByUser';
+  var database = context.database,
+      sessionId = context.userId;
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatReactionName = (0, _utils.parseChar)(reactionName, 32);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var sessionDocId = "users/".concat(sessionId);
+  var itemDocId = "".concat(formatItemType, "/").concat(formatItemId); // Query
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject6(), itemDocId, formatReactionName, sessionDocId);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return [];
+    });
+  });
+};
+
+exports.getReactionCountByUser = getReactionCountByUser;
+
+var getGroupUsersByReaction = function getGroupUsersByReaction(context) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'getUsersByReaction';
+  var database = context.database,
+      sessionId = context.userId;
+
+  if (!sessionId) {
+    return (0, _utils2.logException)({
+      action: action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(function () {
+      return null;
+    });
+  }
+
+  var _params$filters = params.filters,
+      filters = _params$filters === void 0 ? [] : _params$filters,
+      groupId = params.id,
+      value = params.value;
+  var reaction = (0, _utils.parseChar)(value, 32);
+  var groupDocId = "groups/".concat((0, _utils.parseId)(groupId));
+  var filterStr = filters.map(function (filter) {
+    var conditional = filter.conditional,
+        name = filter.name,
+        queryValue = filter.value;
+    var filterCond = conditional;
+
+    if (conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {
+      filterCond = '==';
+    }
+
+    switch (name) {
+      case 'added':
+        return "r.added ".concat(filterCond, " ").concat((0, _utils.parseNum)(queryValue));
+
+      default:
+        return '';
+    }
+  }).concat(["r.value == \"".concat(reaction, "\""), 'u._id == r._from']).join(' && '); // Query
+
+  var aqlQry = "FOR g, r IN INBOUND \"".concat(groupDocId, "\" hasReactions\n      FOR u IN users\n      FILTER  ").concat(filterStr, "\n      RETURN u");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return [];
+    });
+  });
+};
+
+exports.getGroupUsersByReaction = getGroupUsersByReaction;
+
+var getReactionsByItem = function getReactionsByItem(context, itemId, itemType, reactionName, options) {
+  var action = 'getUsersByReactions';
+  var database = context.database;
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var formatReactionName = (0, _utils.parseChar)(reactionName, 32);
+  var itemDocId = "".concat(formatItemType, "/").concat(formatItemId);
+
+  var _parseReactionOptions = parseReactionOptions(options),
+      limit = _parseReactionOptions.limit;
+
+  var aqlQry = "FOR i, r IN INBOUND \"".concat(itemDocId, "\" hasReactions\n    FILTER r.name == \"").concat(formatReactionName, "\"\n    ").concat(limit.aql, "\n    RETURN MERGE(i, {reaction: r}");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return [];
+    });
+  });
+};
+
+exports.getReactionsByItem = getReactionsByItem;
+
+var getItemsByReaction = function getItemsByReaction(context, itemId, itemType, reactionName, options) {
+  var action = 'getUserReactionsByReaction';
+  var database = context.database;
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var formatReactionName = (0, _utils.parseChar)(reactionName, 32);
+  var itemDocId = "".concat(formatItemType, "/").concat(formatItemId);
+
+  var _parseReactionOptions2 = parseReactionOptions(options),
+      limit = _parseReactionOptions2.limit; // Query
+
+
+  var aqlQry = "FOR u, r IN OUTBOUND \"".concat(itemDocId, "\" hasReactions\n    FILTER r.name == ").concat(formatReactionName, "\n    ").concat(limit.aql, "\n    RETURN MERGE(u, {reaction: r})");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return [];
+    });
+  });
+};
+
+exports.getItemsByReaction = getItemsByReaction;
+
+var hasReaction = function hasReaction(context, itemId, itemType, reactionName) {
+  var direction = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'OUTBOUND';
+  var action = 'getReactionsByUser';
+  var database = context.database,
+      sessionId = context.userId;
+  var sessionDocId = "users/".concat(sessionId);
+  var formatItemId = (0, _utils.parseId)(itemId);
+  var formatItemType = (0, _utils.parseChar)(itemType, 32);
+  var formatDirection = direction === 'OUTBOUND' ? 'OUTBOUND' : 'INBOUND';
+  var itemDirection = direction === 'OUTBOUND' ? 'r._to' : 'r._from';
+  var itemDocId = "".concat(formatItemType, "/").concat(formatItemId); // Query
+
+  var aqlQry = "FOR i, r IN ".concat(formatDirection, " \"").concat(sessionDocId, "\" hasReactions\n    FILTER r.name == \"").concat(reactionName, "\" && ").concat(itemDirection, " == \"").concat(itemDocId, "\"\n    RETURN MERGE(i, {reaction: r})");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).then(function () {
+    var reactions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return !!reactions.length;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(function () {
+      return false;
+    });
+  });
+};
+
+exports.hasReaction = hasReaction;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/reactions.ts"],"names":["eventCategory","parseReactionOptions","options","from","to","limit","addReaction","context","itemId","itemType","reaction","allowDuplicate","action","database","sessionId","userId","category","label","value","then","name","itemName","itemValue","formatItemId","formatItemType","formatReactionName","formatValue","edgeCollection","collection","typeDocId","sessionDocId","edgeId","edge","_from","_key","_to","added","Date","now","type","undefined","aqlQry","aql","query","cursor","next","save","returnNew","console","log","error","removeReaction","reactionId","formatSessionId","formatReactionId","removeReactionByItem","reactionName","formatItemDocId","updateReaction","id","formatId","formatName","formatType","update","insert","getReactionCount","itemDocId","getReactionCountByUser","all","getGroupUsersByReaction","params","filters","groupId","groupDocId","filterStr","map","filter","conditional","queryValue","filterCond","concat","join","getReactionsByItem","getItemsByReaction","hasReaction","direction","formatDirection","itemDirection","reactions","length"],"mappings":"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","sourcesContent":["import {createHash, parseChar, parseId, parseNum, parseString} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\n\nimport {\n  ApiContext,\n  QueryFilter,\n  ReactionDirection,\n  ReactionOptions,\n  ReactionType,\n  UserReactionQuery,\n  UserType\n} from '../types';\nimport {getLimit, logError, logException, useDb} from '../utils';\n\nconst eventCategory: string = 'reactions';\n\nexport const parseReactionOptions = (options: ReactionOptions = {}) => {\n  const {\n    from = 0,\n    to = 30\n  } = options;\n\n  return {\n    limit: getLimit(from, to)\n  };\n};\n\nexport const addReaction = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string = 'users',\n  reaction: ReactionType = {},\n  allowDuplicate: boolean = false\n): Promise<ReactionType> => {\n  const action: string = 'addReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const {\n    name: itemName = 'like',\n    value: itemValue\n  } = reaction;\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: any = parseChar(itemType, 32);\n  const formatReactionName: string = parseChar(itemName, 32);\n  const formatValue: string = parseString(itemValue, 32);\n  const edgeCollection: EdgeCollection = useDb(database).collection('hasReactions');\n  const typeDocId: string = `${formatItemType}/${formatItemId}`;\n  const sessionDocId: string = `users/${sessionId}`;\n  const edgeId: string = createHash(`reaction-${formatItemId}-${sessionId}`);\n  const edge: ReactionType = {\n    _from: sessionDocId,\n    _key: edgeId,\n    _to: typeDocId,\n    added: Date.now(),\n    name: formatReactionName,\n    type: formatItemType,\n    value: itemValue !== undefined ? formatValue : undefined\n  };\n\n  // Check for duplicates if not allowed\n  if(!allowDuplicate) {\n    // Query\n    const aqlQry: AqlQuery = aql`FOR r IN hasReactions\n      FILTER r._from == ${sessionDocId} && r._to == ${typeDocId} && r.name == ${formatReactionName}\n      LIMIT 1\n      RETURN r`;\n\n    return useDb(database).query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next())\n      .then((reaction) => {\n        if(!!reaction) {\n          return reaction;\n        }\n\n        return edgeCollection.save(edge, {returnNew: true}).then(() => {\n          console.log('addReaction::edge', edge);\n          return edge;\n        });\n      })\n      .catch((error: Error) => {\n        console.log('addReaction::error', error);\n        return logError({\n          action,\n          category: eventCategory,\n          label: 'db_error'\n        }, error, context).then(() => null);\n      });\n  }\n\n  return edgeCollection.save(edge, {returnNew: true}).then(() => edge);\n};\n\nexport const removeReaction = (context: ApiContext, reactionId: string): Promise<ReactionType> => {\n  const action: string = 'removeReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const formatSessionId: string = `users/${parseId(sessionId)}`;\n  const formatReactionId: string = `hasReactions/${parseId(reactionId)}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`LET r = DOCUMENT(${formatReactionId})\n    FILTER r._from == ${formatSessionId}\n    LIMIT 1\n    REMOVE r IN hasReactions\n    RETURN OLD`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const removeReactionByItem = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string\n): Promise<ReactionType> => {\n  const action: string = 'removeReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const formatSessionId: string = `users/${parseId(sessionId)}`;\n  const formatItemType: string = parseChar(itemType, 32);\n  const formatItemDocId: string = `${formatItemType}/${parseId(itemId)}`;\n  const formatReactionName: string = parseChar(reactionName, 32);\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR r IN hasReactions\n    FILTER r._from == ${formatSessionId}\n      && r._to == ${formatItemDocId}\n      && r.type == ${formatItemType}\n      && r.name == ${formatReactionName}\n    LIMIT 1\n    REMOVE r IN hasReactions\n    RETURN OLD`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const updateReaction = (context: ApiContext, reaction: ReactionType = {}): Promise<ReactionType> => {\n  const action: string = 'updateReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const {\n    id: itemId,\n    name: itemName,\n    type: itemType,\n    value: itemValue\n  } = reaction;\n  const formatId: string = parseId(itemId);\n  const formatName: string = parseChar(itemName, 32);\n  const formatType: any = parseChar(itemType, 32);\n  const formatValue: string = parseString(itemValue, 32);\n  const edgeId: string = createHash(`reaction-${formatId}-${sessionId}`);\n  const update: ReactionType = {\n    name: formatName,\n    type: formatType,\n    value: formatValue\n  };\n  const insert: ReactionType = {\n    ...update,\n    _key: edgeId,\n    added: Date.now()\n  };\n\n  // Query\n  const aqlQry: AqlQuery = aql`UPSERT ${{_key: formatId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    LIMIT 1\n    RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => null));\n};\n\nexport const getReactionCount = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string\n): Promise<ReactionType> => {\n  const action: string = 'getReactionCount';\n  const {database} = context;\n  const formatItemId: string = parseId(itemId);\n  const formatReactionName: any = parseChar(reactionName, 32);\n  const formatItemType: any = parseChar(itemType, 32);\n  const itemDocId: string = `${formatItemType}/${formatItemId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR i, r IN INBOUND ${itemDocId} hasReactions\n    FILTER r.name == ${formatReactionName} && r.type == ${formatItemType}\n    COLLECT WITH COUNT INTO count\n    RETURN count`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => undefined));\n};\n\nexport const getReactionCountByUser = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string\n): Promise<ReactionType[]> => {\n  const action: string = 'getReactionsByUser';\n  const {database, userId: sessionId} = context;\n  const formatItemId: string = parseId(itemId);\n  const formatReactionName: any = parseChar(reactionName, 32);\n  const formatItemType: any = parseChar(itemType, 32);\n  const sessionDocId: string = `users/${sessionId}`;\n  const itemDocId: string = `${formatItemType}/${formatItemId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR i, r IN INBOUND ${itemDocId} hasReactions\n      FILTER r.name == ${formatReactionName} && r._from == ${sessionDocId}\n      COLLECT reactionValue = r.value INTO reactionItems\n      RETURN MERGE(r, {count: LENGTH(reactionItems[*].r.value)})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => []));\n};\n\nexport const getGroupUsersByReaction = (context: ApiContext, params: UserReactionQuery = {}): Promise<UserType[]> => {\n  const action: string = 'getUsersByReaction';\n  const {database, userId: sessionId} = context;\n\n  if(!sessionId) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'unauthorized',\n      value: 'invalid_session'\n    }, context).then(() => null);\n  }\n\n  const {filters = [], id: groupId, value}: UserReactionQuery = params;\n  const reaction = parseChar(value, 32);\n  const groupDocId = `groups/${parseId(groupId)}`;\n  const filterStr: string = filters\n    .map((filter: QueryFilter) => {\n      const {conditional, name, value: queryValue}: QueryFilter = filter;\n      let filterCond: string = conditional;\n\n      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {\n        filterCond = '==';\n      }\n\n      switch(name) {\n        case 'added':\n          return `r.added ${filterCond} ${parseNum(queryValue)}`;\n        default:\n          return '';\n      }\n    })\n    .concat([\n      `r.value == \"${reaction}\"`,\n      'u._id == r._from'\n    ])\n    .join(' && ');\n\n  // Query\n  const aqlQry: string = `FOR g, r IN INBOUND \"${groupDocId}\" hasReactions\n      FOR u IN users\n      FILTER  ${filterStr}\n      RETURN u`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => []));\n};\n\nexport const getReactionsByItem = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string,\n  options: ReactionOptions\n): Promise<UserType[]> => {\n  const action: string = 'getUsersByReactions';\n  const {database} = context;\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: string = parseChar(itemType, 32);\n  const formatReactionName: string = parseChar(reactionName, 32);\n  const itemDocId = `${formatItemType}/${formatItemId}`;\n  const {limit} = parseReactionOptions(options);\n  const aqlQry: string = `FOR i, r IN INBOUND \"${itemDocId}\" hasReactions\n    FILTER r.name == \"${formatReactionName}\"\n    ${limit.aql}\n    RETURN MERGE(i, {reaction: r}`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => []));\n};\n\nexport const getItemsByReaction = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string,\n  options: ReactionOptions\n): Promise<ReactionType[]> => {\n  const action: string = 'getUserReactionsByReaction';\n  const {database} = context;\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: string = parseChar(itemType, 32);\n  const formatReactionName: string = parseChar(reactionName, 32);\n  const itemDocId = `${formatItemType}/${formatItemId}`;\n  const {limit} = parseReactionOptions(options);\n\n  // Query\n  const aqlQry: string = `FOR u, r IN OUTBOUND \"${itemDocId}\" hasReactions\n    FILTER r.name == ${formatReactionName}\n    ${limit.aql}\n    RETURN MERGE(u, {reaction: r})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => []));\n};\n\nexport const hasReaction = (\n  context: ApiContext,\n  itemId: string,\n  itemType: string,\n  reactionName: string,\n  direction: ReactionDirection = 'OUTBOUND'\n): Promise<boolean> => {\n  const action: string = 'getReactionsByUser';\n  const {database, userId: sessionId} = context;\n  const sessionDocId: string = `users/${sessionId}`;\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: string = parseChar(itemType, 32);\n  const formatDirection = direction === 'OUTBOUND' ? 'OUTBOUND' : 'INBOUND';\n  const itemDirection: string = direction === 'OUTBOUND' ? 'r._to' : 'r._from';\n  const itemDocId: string = `${formatItemType}/${formatItemId}`;\n\n  // Query\n  const aqlQry: string = `FOR i, r IN ${formatDirection} \"${sessionDocId}\" hasReactions\n    FILTER r.name == \"${reactionName}\" && ${itemDirection} == \"${itemDocId}\"\n    RETURN MERGE(i, {reaction: r})`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((reactions = []) => !!reactions.length)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => false));\n};\n"]}