@nlabs/reaktor 0.3.0 → 0.4.1

package/lib/actions/reactions.js

@@ -0,0 +1,340 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  addReaction: () => addReaction,
+  deleteReaction: () => deleteReaction,
+  deleteReactionByItem: () => deleteReactionByItem,
+  getGroupUsersByReaction: () => getGroupUsersByReaction,
+  getItemsByReaction: () => getItemsByReaction,
+  getReactionCount: () => getReactionCount,
+  getReactionCountByUser: () => getReactionCountByUser,
+  getReactionsByItem: () => getReactionsByItem,
+  hasReaction: () => hasReaction,
+  parseReactionOptions: () => parseReactionOptions,
+  updateReaction: () => updateReaction
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_utils2 = __toModule(require("../utils"));
+const eventCategory = "reactions";
+const parseReactionOptions = (options = {}) => {
+  const {
+    from = 0,
+    to = 30
+  } = options;
+  return {
+    limit: (0, import_utils2.getLimit)(from, to)
+  };
+};
+const addReaction = (context, itemId, reaction = {}, allowDuplicate = false) => {
+  const action = "addReaction";
+  const { database, session: { userId: sessionId } } = context;
+  if (!sessionId) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context).then(() => null);
+  }
+  const {
+    name: itemName = "like",
+    value: itemValue
+  } = reaction;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(itemName, 32);
+  const formatValue = (0, import_utils.parseString)(itemValue, 32);
+  const edgeCollection = database.collection("hasReactions");
+  const sessionDocId = `users/${sessionId}`;
+  const edgeId = (0, import_utils.createHash)(`reaction-${formatItemId}-${sessionId}`);
+  const edge = {
+    _from: sessionDocId,
+    _key: edgeId,
+    _to: formatItemId,
+    added: Date.now(),
+    name: formatReactionName,
+    value: itemValue !== void 0 ? formatValue : void 0
+  };
+  if (!allowDuplicate) {
+    const aqlQry = import_arangojs.aql`FOR r IN hasReactions
+      FILTER r._from == ${sessionDocId} && r._to == ${formatItemId} && r.name == ${formatReactionName}
+      LIMIT 1
+      RETURN r`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).then((reaction2) => {
+      if (!!reaction2) {
+        return reaction2;
+      }
+      return edgeCollection.save(edge, { returnNew: true }).then(() => edge);
+    }).catch((error) => {
+      console.log("addReaction::error", error);
+      return (0, import_utils2.logError)({
+        action,
+        category: eventCategory,
+        label: "db_error"
+      }, error, context).then(() => null);
+    });
+  }
+  return edgeCollection.save(edge, { returnNew: true }).then(() => edge);
+};
+const deleteReaction = (context, reactionId) => {
+  const action = "deleteReaction";
+  const { database, session: { userId: sessionId } } = context;
+  if (!sessionId) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context).then(() => null);
+  }
+  const formatSessionId = `users/${(0, import_utils.parseId)(sessionId)}`;
+  const formatReactionId = `hasReactions/${(0, import_utils.parseId)(reactionId)}`;
+  const aqlQry = import_arangojs.aql`LET r = DOCUMENT(${formatReactionId})
+    FILTER r._from == ${formatSessionId}
+    LIMIT 1
+    REMOVE r IN hasReactions
+    RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const deleteReactionByItem = (context, itemId, reactionName) => {
+  const action = "deleteReactionByItem";
+  const { database, session: { userId: sessionId } } = context;
+  if (!sessionId) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context).then(() => null);
+  }
+  const formatSessionId = `users/${(0, import_utils.parseId)(sessionId)}`;
+  const formatItemDocId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(reactionName);
+  const aqlQry = import_arangojs.aql`FOR r in hasReactions
+    FILTER r._from == ${formatSessionId} && r._to == ${formatItemDocId} && r.name == ${formatReactionName}
+    LIMIT 1
+    REMOVE r IN hasReactions
+    RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const updateReaction = (context, reaction = {}) => {
+  const action = "updateReaction";
+  const { database, session: { userId: sessionId } } = context;
+  if (!sessionId) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context).then(() => null);
+  }
+  const {
+    id: itemId,
+    name: itemName,
+    value: itemValue
+  } = reaction;
+  const formatId = (0, import_utils.parseArangoId)(itemId);
+  const formatName = (0, import_utils.parseChar)(itemName, 32);
+  const formatValue = (0, import_utils.parseString)(itemValue, 32);
+  const edgeId = (0, import_utils.createHash)(`reaction-${formatId}-${sessionId}`);
+  const update = {
+    name: formatName,
+    value: formatValue
+  };
+  const insert = __spreadProps(__spreadValues({}, update), {
+    _key: edgeId,
+    added: Date.now()
+  });
+  const aqlQry = import_arangojs.aql`UPSERT ${{ _id: formatId }}
+    INSERT ${insert}
+    UPDATE ${update}
+    LIMIT 1
+    RETURN NEW`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => null));
+};
+const getReactionCount = (context, itemId, reactionName) => {
+  const action = "getReactionCount";
+  const { database } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(reactionName, 32);
+  const aqlQry = import_arangojs.aql`FOR i, r IN INBOUND ${formatItemId} hasReactions
+    FILTER r.name == ${formatReactionName}
+    COLLECT WITH COUNT INTO count
+    RETURN count`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => void 0));
+};
+const getReactionCountByUser = (context, itemId, itemType, reactionName) => {
+  const action = "getReactionCountByUser";
+  const { database, session: { userId: sessionId } } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(reactionName, 32);
+  const sessionDocId = `users/${sessionId}`;
+  const aqlQry = import_arangojs.aql`FOR i, r IN INBOUND ${formatItemId} hasReactions
+      FILTER r.name == ${formatReactionName} && r._from == ${sessionDocId}
+      COLLECT reactionValue = r.value INTO reactionItems
+      RETURN MERGE(r, {count: LENGTH(reactionItems[*].r.value)})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const getGroupUsersByReaction = (context, params = {}) => {
+  const action = "getGroupUsersByReaction";
+  const { database, session: { userId: sessionId } } = context;
+  if (!sessionId) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "unauthorized",
+      value: "invalid_session"
+    }, context).then(() => null);
+  }
+  const { filters = [], id: groupId, value } = params;
+  const reaction = (0, import_utils.parseChar)(value, 32);
+  const groupDocId = (0, import_utils.parseArangoId)(groupId);
+  const filterStr = filters.map((filter) => {
+    const { conditional, name, value: queryValue } = filter;
+    let filterCond = conditional;
+    if (conditional !== ">=" && conditional !== "<=" && conditional !== ">" && conditional !== "<") {
+      filterCond = "==";
+    }
+    switch (name) {
+      case "added":
+        return `r.added ${filterCond} ${(0, import_utils.parseNum)(queryValue)}`;
+      default:
+        return "";
+    }
+  }).concat([
+    `r.value == "${reaction}"`,
+    "u._id == r._from"
+  ]).join(" && ");
+  const aqlQry = `FOR g, r IN INBOUND "${groupDocId}" hasReactions
+      FOR u IN users
+      FILTER ${filterStr}
+      RETURN u`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const getReactionsByItem = (context, itemId, reactionName, options) => {
+  const action = "getReactionsByItem";
+  const { database } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(reactionName, 32);
+  const { limit } = parseReactionOptions(options);
+  const aqlQry = `FOR i, r IN INBOUND "${formatItemId}" hasReactions
+    FILTER r.name == "${formatReactionName}"
+    ${limit.aql}
+    RETURN MERGE(i, {reaction: r})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const getItemsByReaction = (context, itemId, reactionName, options) => {
+  const action = "getItemsByReaction";
+  const { database } = context;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatReactionName = (0, import_utils.parseChar)(reactionName, 32);
+  const { limit } = parseReactionOptions(options);
+  const aqlQry = `FOR u, r IN OUTBOUND "${formatItemId}" hasReactions
+    FILTER r.name == ${formatReactionName}
+    ${limit.aql}
+    RETURN MERGE(u, {reaction: r})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const hasReaction = (context, itemId, reactionName, direction = "OUTBOUND") => {
+  const action = "hasReaction";
+  const { database, session: { userId: sessionId } } = context;
+  const sessionDocId = `users/${sessionId}`;
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const formatDirection = direction === "OUTBOUND" ? "OUTBOUND" : "INBOUND";
+  const itemDirection = direction === "OUTBOUND" ? "r._to" : "r._from";
+  const aqlQry = `FOR i, r IN ${formatDirection} "${sessionDocId}" hasReactions
+    FILTER r.name == "${reactionName}" && ${itemDirection} == "${formatItemId}"
+    LIMIT 1
+    RETURN r`;
+  console.log({ aqlQry });
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((reactions) => reactions ? reactions.value === "true" : false).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => false));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addReaction,
+  deleteReaction,
+  deleteReactionByItem,
+  getGroupUsersByReaction,
+  getItemsByReaction,
+  getReactionCount,
+  getReactionCountByUser,
+  getReactionsByItem,
+  hasReaction,
+  parseReactionOptions,
+  updateReaction
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/reactions.ts"],
  "sourcesContent": ["import {createHash, parseArangoId, 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 {ApiContext, AppCollectionTypes, QueryFilter, User, UserReactionQuery} from '../types';\nimport {getLimit, logError, logException} from '../utils';\n\nconst eventCategory: string = 'reactions';\n\nexport type ReactionDirection = 'INBOUND' | 'OUTBOUND';\n\nexport interface Reaction {\n  readonly _from?: string;\n  readonly _key?: string;\n  readonly _to?: string;\n  readonly added?: number;\n  readonly count?: number;\n  readonly id?: string;\n  readonly name?: string;\n  readonly type?: AppCollectionTypes;\n  readonly value?: string;\n}\n\nexport interface ReactionOptions {\n  readonly from?: number;\n  readonly to?: number;\n}\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  reaction: Reaction = {},\n  allowDuplicate: boolean = false\n): Promise<Reaction> => {\n  const action: string = 'addReaction';\n  const {database, session: {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 = parseArangoId(itemId);\n  const formatReactionName: string = parseChar(itemName, 32);\n  const formatValue: string = parseString(itemValue, 32);\n  const edgeCollection: EdgeCollection = database.collection('hasReactions');\n  const sessionDocId: string = `users/${sessionId}`;\n  const edgeId: string = createHash(`reaction-${formatItemId}-${sessionId}`);\n  const edge: Reaction = {\n    _from: sessionDocId,\n    _key: edgeId,\n    _to: formatItemId,\n    added: Date.now(),\n    name: formatReactionName,\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 == ${formatItemId} && r.name == ${formatReactionName}\n      LIMIT 1\n      RETURN r`;\n\n    return 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(() => edge);\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 deleteReaction = (context: ApiContext, reactionId: string): Promise<Reaction> => {\n  const action: string = 'deleteReaction';\n  const {database, session: {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 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 deleteReactionByItem = (\n  context: ApiContext,\n  itemId: string,\n  reactionName: string\n): Promise<Reaction> => {\n  const action: string = 'deleteReactionByItem';\n  const {database, session: {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 formatItemDocId: string = parseArangoId(itemId);\n  const formatReactionName: string = parseChar(reactionName);\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR r in hasReactions\n    FILTER r._from == ${formatSessionId} && r._to == ${formatItemDocId} && r.name == ${formatReactionName}\n    LIMIT 1\n    REMOVE r IN hasReactions\n    RETURN OLD`;\n\n  return 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: Reaction = {}): Promise<Reaction> => {\n  const action: string = 'updateReaction';\n  const {database, session: {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    value: itemValue\n  } = reaction;\n  const formatId: string = parseArangoId(itemId);\n  const formatName: string = parseChar(itemName, 32);\n  const formatValue: string = parseString(itemValue, 32);\n  const edgeId: string = createHash(`reaction-${formatId}-${sessionId}`);\n  const update: Reaction = {\n    name: formatName,\n    value: formatValue\n  };\n  const insert: Reaction = {\n    ...update,\n    _key: edgeId,\n    added: Date.now()\n  };\n\n  // Query\n  const aqlQry: AqlQuery = aql`UPSERT ${{_id: formatId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    LIMIT 1\n    RETURN NEW`;\n\n  return 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  reactionName: string\n): Promise<Reaction> => {\n  const action: string = 'getReactionCount';\n  const {database} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const formatReactionName: any = parseChar(reactionName, 32);\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR i, r IN INBOUND ${formatItemId} hasReactions\n    FILTER r.name == ${formatReactionName}\n    COLLECT WITH COUNT INTO count\n    RETURN count`;\n\n  return 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<Reaction[]> => {\n  const action: string = 'getReactionCountByUser';\n  const {database, session: {userId: sessionId}} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const formatReactionName: any = parseChar(reactionName, 32);\n  const sessionDocId: string = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR i, r IN INBOUND ${formatItemId} 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 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<User[]> => {\n  const action: string = 'getGroupUsersByReaction';\n  const {database, session: {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 = parseArangoId(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 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  reactionName: string,\n  options: ReactionOptions\n): Promise<User[]> => {\n  const action: string = 'getReactionsByItem';\n  const {database} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const formatReactionName: string = parseChar(reactionName, 32);\n  const {limit} = parseReactionOptions(options);\n  const aqlQry: string = `FOR i, r IN INBOUND \"${formatItemId}\" hasReactions\n    FILTER r.name == \"${formatReactionName}\"\n    ${limit.aql}\n    RETURN MERGE(i, {reaction: r})`;\n\n  return 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  reactionName: string,\n  options: ReactionOptions\n): Promise<Reaction[]> => {\n  const action: string = 'getItemsByReaction';\n  const {database} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const formatReactionName: string = parseChar(reactionName, 32);\n  const {limit} = parseReactionOptions(options);\n\n  // Query\n  const aqlQry: string = `FOR u, r IN OUTBOUND \"${formatItemId}\" hasReactions\n    FILTER r.name == ${formatReactionName}\n    ${limit.aql}\n    RETURN MERGE(u, {reaction: r})`;\n\n  return 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  reactionName: string,\n  direction: ReactionDirection = 'OUTBOUND'\n): Promise<boolean> => {\n  const action: string = 'hasReaction';\n  const {database, session: {userId: sessionId}} = context;\n  const sessionDocId: string = `users/${sessionId}`;\n  const formatItemId: string = parseArangoId(itemId);\n  const formatDirection = direction === 'OUTBOUND' ? 'OUTBOUND' : 'INBOUND';\n  const itemDirection: string = direction === 'OUTBOUND' ? 'r._to' : 'r._from';\n\n  // Query\n  const aqlQry: string = `FOR i, r IN ${formatDirection} \"${sessionDocId}\" hasReactions\n    FILTER r.name == \"${reactionName}\" && ${itemDirection} == \"${formatItemId}\"\n    LIMIT 1\n    RETURN r`;\n\n  console.log({aqlQry});\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((reactions) => (reactions ? reactions.value === 'true' : false))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => false));\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/{data → actions}/s3.d.ts

@@ -4,4 +4,4 @@ export declare const s3Head: (params: HeadObjectRequest) => Promise<HeadObjectOu
 export declare const s3Put: (params: PutObjectRequest) => Promise<PutObjectOutput>;
 export declare const s3Delete: (params: DeleteObjectRequest) => Promise<DeleteObjectOutput>;
 export declare const s3DeleteList: (params: DeleteObjectsRequest) => Promise<DeleteObjectsOutput>;
-export declare const s3GetSignedUrl: (params: any) => string;
+export declare const s3GetSignedUrl: (params?: any) => string;

package/lib/actions/s3.js

@@ -0,0 +1,122 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  s3Delete: () => s3Delete,
+  s3DeleteList: () => s3DeleteList,
+  s3Get: () => s3Get,
+  s3GetSignedUrl: () => s3GetSignedUrl,
+  s3Head: () => s3Head,
+  s3Put: () => s3Put
+});
+var import_aws_sdk = __toModule(require("aws-sdk"));
+var import_config = __toModule(require("../config"));
+const s3Get = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.S3();
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  s3.getObject(params, (error, output) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(output);
+  });
+});
+const s3Head = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.S3();
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  s3.headObject(params, (error, output) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(output);
+  });
+});
+const s3Put = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.default.S3();
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  if (!params.StorageClass) {
+    params.StorageClass = "REDUCED_REDUNDANCY";
+  }
+  s3.putObject(params, (error, output) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(output);
+  });
+});
+const s3Delete = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.S3();
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  s3.deleteObject(params, (error, output) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(output);
+  });
+});
+const s3DeleteList = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.S3();
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  s3.deleteObjects(params, (error, output) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(output);
+  });
+});
+const s3GetSignedUrl = (params = {}) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const s3 = new import_aws_sdk.S3();
+  if (!params.Expires) {
+    params.Expires = 12 * 60 * 60;
+  }
+  if (!params.Bucket) {
+    params.Bucket = import_config.Config.get("aws.Bucket");
+  }
+  return s3.getSignedUrl("getObject", params);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  s3Delete,
+  s3DeleteList,
+  s3Get,
+  s3GetSignedUrl,
+  s3Head,
+  s3Put
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FjdGlvbnMvczMudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE5LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5pbXBvcnQgYXdzLCB7UzN9IGZyb20gJ2F3cy1zZGsnO1xuaW1wb3J0IHtcbiAgRGVsZXRlT2JqZWN0T3V0cHV0LFxuICBEZWxldGVPYmplY3RSZXF1ZXN0LFxuICBEZWxldGVPYmplY3RzT3V0cHV0LFxuICBEZWxldGVPYmplY3RzUmVxdWVzdCxcbiAgR2V0T2JqZWN0T3V0cHV0LFxuICBHZXRPYmplY3RSZXF1ZXN0LFxuICBIZWFkT2JqZWN0T3V0cHV0LFxuICBIZWFkT2JqZWN0UmVxdWVzdCxcbiAgUHV0T2JqZWN0T3V0cHV0LFxuICBQdXRPYmplY3RSZXF1ZXN0XG59IGZyb20gJ2F3cy1zZGsvY2xpZW50cy9zMyc7XG5cbmltcG9ydCB7Q29uZmlnfSBmcm9tICcuLi9jb25maWcnO1xuXG4vLyBBV1MgUzNcbi8vIGNvbnN0IGV2ZW50Q2F0ZWdvcnk6IHN0cmluZyA9ICdzMyc7XG5cbmV4cG9ydCBjb25zdCBzM0dldCA9IChwYXJhbXM6IEdldE9iamVjdFJlcXVlc3QpOiBQcm9taXNlPEdldE9iamVjdE91dHB1dD4gPT5cbiAgbmV3IFByb21pc2UoKHJlc29sdmUsIHJlamVjdCkgPT4ge1xuICAgIGF3cy5jb25maWcudXBkYXRlKENvbmZpZy5nZXQoJ2F3cycpKTtcbiAgICBjb25zdCBzMzogUzMgPSBuZXcgUzMoKTtcblxuICAgIGlmKCFwYXJhbXMuQnVja2V0KSB7XG4gICAgICBwYXJhbXMuQnVja2V0ID0gQ29uZmlnLmdldCgnYXdzLkJ1Y2tldCcpO1xuICAgIH1cblxuICAgIHMzLmdldE9iamVjdChwYXJhbXMsIChlcnJvcjogRXJyb3IsIG91dHB1dDogR2V0T2JqZWN0T3V0cHV0KSA9PiB7XG4gICAgICBpZihlcnJvcikge1xuICAgICAgICByZXR1cm4gcmVqZWN0KGVycm9yKTtcbiAgICAgIH1cblxuICAgICAgcmV0dXJuIHJlc29sdmUob3V0cHV0KTtcbiAgICB9KTtcbiAgfSk7XG5cbmV4cG9ydCBjb25zdCBzM0hlYWQgPSAocGFyYW1zOiBIZWFkT2JqZWN0UmVxdWVzdCk6IFByb21pc2U8SGVhZE9iamVjdE91dHB1dD4gPT5cbiAgbmV3IFByb21pc2UoKHJlc29sdmUsIHJlamVjdCkgPT4ge1xuICAgIGF3cy5jb25maWcudXBkYXRlKENvbmZpZy5nZXQoJ2F3cycpKTtcbiAgICBjb25zdCBzMzogUzMgPSBuZXcgUzMoKTtcblxuICAgIGlmKCFwYXJhbXMuQnVja2V0KSB7XG4gICAgICBwYXJhbXMuQnVja2V0ID0gQ29uZmlnLmdldCgnYXdzLkJ1Y2tldCcpO1xuICAgIH1cblxuICAgIHMzLmhlYWRPYmplY3QocGFyYW1zLCAoZXJyb3I6IEVycm9yLCBvdXRwdXQ6IEhlYWRPYmplY3RPdXRwdXQpID0+IHtcbiAgICAgIGlmKGVycm9yKSB7XG4gICAgICAgIHJldHVybiByZWplY3QoZXJyb3IpO1xuICAgICAgfVxuICAgICAgcmV0dXJuIHJlc29sdmUob3V0cHV0KTtcbiAgICB9KTtcbiAgfSk7XG5cblxuZXhwb3J0IGNvbnN0IHMzUHV0ID0gKHBhcmFtczogUHV0T2JqZWN0UmVxdWVzdCk6IFByb21pc2U8UHV0T2JqZWN0T3V0cHV0PiA9PlxuICBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgYXdzLmNvbmZpZy51cGRhdGUoQ29uZmlnLmdldCgnYXdzJykpO1xuICAgIGNvbnN0IHMzID0gbmV3IGF3cy5TMygpO1xuXG4gICAgaWYoIXBhcmFtcy5CdWNrZXQpIHtcbiAgICAgIHBhcmFtcy5CdWNrZXQgPSBDb25maWcuZ2V0KCdhd3MuQnVja2V0Jyk7XG4gICAgfVxuXG4gICAgaWYoIXBhcmFtcy5TdG9yYWdlQ2xhc3MpIHtcbiAgICAgIHBhcmFtcy5TdG9yYWdlQ2xhc3MgPSAnUkVEVUNFRF9SRURVTkRBTkNZJztcbiAgICB9XG5cbiAgICBzMy5wdXRPYmplY3QocGFyYW1zLCAoZXJyb3I6IEVycm9yLCBvdXRwdXQ6IFB1dE9iamVjdE91dHB1dCkgPT4ge1xuICAgICAgaWYoZXJyb3IpIHtcbiAgICAgICAgcmV0dXJuIHJlamVjdChlcnJvcik7XG4gICAgICB9XG4gICAgICByZXR1cm4gcmVzb2x2ZShvdXRwdXQpO1xuICAgIH0pO1xuICB9KTtcblxuZXhwb3J0IGNvbnN0IHMzRGVsZXRlID0gKHBhcmFtczogRGVsZXRlT2JqZWN0UmVxdWVzdCk6IFByb21pc2U8RGVsZXRlT2JqZWN0T3V0cHV0PiA9PlxuICBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgYXdzLmNvbmZpZy51cGRhdGUoQ29uZmlnLmdldCgnYXdzJykpO1xuICAgIGNvbnN0IHMzOiBTMyA9IG5ldyBTMygpO1xuXG4gICAgaWYoIXBhcmFtcy5CdWNrZXQpIHtcbiAgICAgIHBhcmFtcy5CdWNrZXQgPSBDb25maWcuZ2V0KCdhd3MuQnVja2V0Jyk7XG4gICAgfVxuXG4gICAgczMuZGVsZXRlT2JqZWN0KHBhcmFtcywgKGVycm9yLCBvdXRwdXQ6IERlbGV0ZU9iamVjdE91dHB1dCkgPT4ge1xuICAgICAgaWYoZXJyb3IpIHtcbiAgICAgICAgcmV0dXJuIHJlamVjdChlcnJvcik7XG4gICAgICB9XG4gICAgICByZXR1cm4gcmVzb2x2ZShvdXRwdXQpO1xuICAgIH0pO1xuICB9KTtcblxuZXhwb3J0IGNvbnN0IHMzRGVsZXRlTGlzdCA9IChwYXJhbXM6IERlbGV0ZU9iamVjdHNSZXF1ZXN0KTogUHJvbWlzZTxEZWxldGVPYmplY3RzT3V0cHV0PiA9PlxuICBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgYXdzLmNvbmZpZy51cGRhdGUoQ29uZmlnLmdldCgnYXdzJykpO1xuICAgIGNvbnN0IHMzOiBTMyA9IG5ldyBTMygpO1xuXG4gICAgaWYoIXBhcmFtcy5CdWNrZXQpIHtcbiAgICAgIHBhcmFtcy5CdWNrZXQgPSBDb25maWcuZ2V0KCdhd3MuQnVja2V0Jyk7XG4gICAgfVxuXG4gICAgczMuZGVsZXRlT2JqZWN0cyhwYXJhbXMsIChlcnJvcjogRXJyb3IsIG91dHB1dDogRGVsZXRlT2JqZWN0c091dHB1dCkgPT4ge1xuICAgICAgaWYoZXJyb3IpIHtcbiAgICAgICAgcmV0dXJuIHJlamVjdChlcnJvcik7XG4gICAgICB9XG4gICAgICByZXR1cm4gcmVzb2x2ZShvdXRwdXQpO1xuICAgIH0pO1xuICB9KTtcblxuZXhwb3J0IGNvbnN0IHMzR2V0U2lnbmVkVXJsID0gKHBhcmFtczogYW55ID0ge30pOiBzdHJpbmcgPT4ge1xuICBhd3MuY29uZmlnLnVwZGF0ZShDb25maWcuZ2V0KCdhd3MnKSk7XG4gIGNvbnN0IHMzOiBTMyA9IG5ldyBTMygpO1xuXG4gIGlmKCFwYXJhbXMuRXhwaXJlcykge1xuICAgIHBhcmFtcy5FeHBpcmVzID0gMTIgKiA2MCAqIDYwO1xuICB9XG5cbiAgaWYoIXBhcmFtcy5CdWNrZXQpIHtcbiAgICBwYXJhbXMuQnVja2V0ID0gQ29uZmlnLmdldCgnYXdzLkJ1Y2tldCcpO1xuICB9XG5cbiAgcmV0dXJuIHMzLmdldFNpZ25lZFVybCgnZ2V0T2JqZWN0JywgcGFyYW1zKTtcbn07XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFJQSxxQkFBc0I7QUFjdEIsb0JBQXFCO0FBS2QsTUFBTSxRQUFRLENBQUMsV0FDcEIsSUFBSSxRQUFRLENBQUMsU0FBUyxXQUFXO0FBQy9CLHlCQUFJLE9BQU8sT0FBTyxxQkFBTyxJQUFJO0FBQzdCLFFBQU0sS0FBUyxJQUFJO0FBRW5CLE1BQUcsQ0FBQyxPQUFPLFFBQVE7QUFDakIsV0FBTyxTQUFTLHFCQUFPLElBQUk7QUFBQTtBQUc3QixLQUFHLFVBQVUsUUFBUSxDQUFDLE9BQWMsV0FBNEI7QUFDOUQsUUFBRyxPQUFPO0FBQ1IsYUFBTyxPQUFPO0FBQUE7QUFHaEIsV0FBTyxRQUFRO0FBQUE7QUFBQTtBQUlkLE1BQU0sU0FBUyxDQUFDLFdBQ3JCLElBQUksUUFBUSxDQUFDLFNBQVMsV0FBVztBQUMvQix5QkFBSSxPQUFPLE9BQU8scUJBQU8sSUFBSTtBQUM3QixRQUFNLEtBQVMsSUFBSTtBQUVuQixNQUFHLENBQUMsT0FBTyxRQUFRO0FBQ2pCLFdBQU8sU0FBUyxxQkFBTyxJQUFJO0FBQUE7QUFHN0IsS0FBRyxXQUFXLFFBQVEsQ0FBQyxPQUFjLFdBQTZCO0FBQ2hFLFFBQUcsT0FBTztBQUNSLGFBQU8sT0FBTztBQUFBO0FBRWhCLFdBQU8sUUFBUTtBQUFBO0FBQUE7QUFLZCxNQUFNLFFBQVEsQ0FBQyxXQUNwQixJQUFJLFFBQVEsQ0FBQyxTQUFTLFdBQVc7QUFDL0IseUJBQUksT0FBTyxPQUFPLHFCQUFPLElBQUk7QUFDN0IsUUFBTSxLQUFLLElBQUksdUJBQUk7QUFFbkIsTUFBRyxDQUFDLE9BQU8sUUFBUTtBQUNqQixXQUFPLFNBQVMscUJBQU8sSUFBSTtBQUFBO0FBRzdCLE1BQUcsQ0FBQyxPQUFPLGNBQWM7QUFDdkIsV0FBTyxlQUFlO0FBQUE7QUFHeEIsS0FBRyxVQUFVLFFBQVEsQ0FBQyxPQUFjLFdBQTRCO0FBQzlELFFBQUcsT0FBTztBQUNSLGFBQU8sT0FBTztBQUFBO0FBRWhCLFdBQU8sUUFBUTtBQUFBO0FBQUE7QUFJZCxNQUFNLFdBQVcsQ0FBQyxXQUN2QixJQUFJLFFBQVEsQ0FBQyxTQUFTLFdBQVc7QUFDL0IseUJBQUksT0FBTyxPQUFPLHFCQUFPLElBQUk7QUFDN0IsUUFBTSxLQUFTLElBQUk7QUFFbkIsTUFBRyxDQUFDLE9BQU8sUUFBUTtBQUNqQixXQUFPLFNBQVMscUJBQU8sSUFBSTtBQUFBO0FBRzdCLEtBQUcsYUFBYSxRQUFRLENBQUMsT0FBTyxXQUErQjtBQUM3RCxRQUFHLE9BQU87QUFDUixhQUFPLE9BQU87QUFBQTtBQUVoQixXQUFPLFFBQVE7QUFBQTtBQUFBO0FBSWQsTUFBTSxlQUFlLENBQUMsV0FDM0IsSUFBSSxRQUFRLENBQUMsU0FBUyxXQUFXO0FBQy9CLHlCQUFJLE9BQU8sT0FBTyxxQkFBTyxJQUFJO0FBQzdCLFFBQU0sS0FBUyxJQUFJO0FBRW5CLE1BQUcsQ0FBQyxPQUFPLFFBQVE7QUFDakIsV0FBTyxTQUFTLHFCQUFPLElBQUk7QUFBQTtBQUc3QixLQUFHLGNBQWMsUUFBUSxDQUFDLE9BQWMsV0FBZ0M7QUFDdEUsUUFBRyxPQUFPO0FBQ1IsYUFBTyxPQUFPO0FBQUE7QUFFaEIsV0FBTyxRQUFRO0FBQUE7QUFBQTtBQUlkLE1BQU0saUJBQWlCLENBQUMsU0FBYyxPQUFlO0FBQzFELHlCQUFJLE9BQU8sT0FBTyxxQkFBTyxJQUFJO0FBQzdCLFFBQU0sS0FBUyxJQUFJO0FBRW5CLE1BQUcsQ0FBQyxPQUFPLFNBQVM7QUFDbEIsV0FBTyxVQUFVLEtBQUssS0FBSztBQUFBO0FBRzdCLE1BQUcsQ0FBQyxPQUFPLFFBQVE7QUFDakIsV0FBTyxTQUFTLHFCQUFPLElBQUk7QUFBQTtBQUc3QixTQUFPLEdBQUcsYUFBYSxhQUFhO0FBQUE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/lib/{data → actions}/search.d.ts

@@ -1,3 +1,3 @@
 import { ApiContext } from '../types/auth';
-import { UserType } from '../types/users';
-export declare const getSearchList: (context: ApiContext, query: string, from: number, to: number) => Promise<UserType[]>;
+import { User } from '../types/users';
+export declare const getSearchList: (context: ApiContext, query: string, from: number, to: number) => Promise<User[]>;

package/lib/actions/search.js

@@ -0,0 +1,99 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  getSearchList: () => getSearchList
+});
+var import_arangojs = __toModule(require("arangojs"));
+var import_flatten = __toModule(require("lodash/flatten"));
+var import_uniqBy = __toModule(require("lodash/uniqBy"));
+var import_utils = __toModule(require("../utils"));
+var import_users2 = __toModule(require("./users"));
+const eventCategory = "search";
+const getSearchList = (context, query, from, to) => {
+  const action = "getList";
+  const { database } = context;
+  const isString = true;
+  if (isString) {
+    const fields = [
+      { collection: "users", field: "first" },
+      { collection: "users", field: "last" },
+      { collection: "users", field: "email" },
+      { collection: "users", field: "username" },
+      { collection: "users", field: "name" }
+    ];
+    return Promise.all(fields.map((obj) => {
+      const qry = `prefix:${query}`;
+      const userQry = import_arangojs.aql`FOR u IN FULLTEXT(${obj.collection}, ${obj.field}, ${qry}, 50) RETURN u`;
+      return database.query(userQry).then((cursor) => cursor.all());
+    })).then((results) => {
+      const list = (0, import_uniqBy.default)((0, import_flatten.default)(results), "_key");
+      return list.map((item) => {
+        const { _id: itemId, name: itemName } = item;
+        const collectionIdList = itemId.split("/");
+        const collection = collectionIdList[0];
+        const name = collection === "users" ? (0, import_users2.getDisplayName)(item) : itemName;
+        return __spreadProps(__spreadValues({}, item), { name });
+      });
+    });
+  }
+  const limit = (0, import_utils.getLimit)(from, to);
+  const aqlQry = `FOR u IN users
+        FILTER u.phone == "${query}"
+        ${limit.aql}
+        RETURN u`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((list = []) => list.map((item = {}) => {
+    const { _id: itemId, name: itemName } = item;
+    const collectionIdList = itemId.split("/");
+    const collection = collectionIdList[0];
+    const name = collection === "users" ? (0, import_users2.getDisplayName)(item) : itemName;
+    return __spreadProps(__spreadValues({}, item), { name });
+  })).catch((error) => (0, import_utils.logException)({
+    action,
+    category: eventCategory,
+    label: "db_error",
+    value: error.message
+  }, context).then(() => null));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSearchList
+});
+//# sourceMappingURL=data:application/json;base64,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