@nlabs/reaktor 0.3.0 → 0.4.0

package/lib/data/tags.js

@@ -0,0 +1,397 @@
+"use strict";
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+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.iterator");
+
+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/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/es.string.iterator");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractTags = exports.linkTags = exports.createTagEdge = exports.createTag = exports.deleteTag = exports.updateTag = exports.tagPost = exports.addTag = exports.getTag = exports.getTagList = void 0;
+
+var _utils = require("@nlabs/utils");
+
+var _arangojs = require("arangojs");
+
+var _words = _interopRequireDefault(require("lodash/words"));
+
+var _utils2 = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _templateObject5() {
+  var data = _taggedTemplateLiteral(["REMOVE {_key:", "} IN isTagged"]);
+
+  _templateObject5 = function _templateObject5() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject4() {
+  var data = _taggedTemplateLiteral(["UPSERT {_key: ", "}\n    INSERT ", "\n    UPDATE {}\n    IN tags RETURN NEW"]);
+
+  _templateObject4 = function _templateObject4() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["FOR t IN tags\n    FILTER t._key == ", "\n    REMOVE t IN tags\n    RETURN OLD"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["UPSERT {_key: ", "}\n      INSERT ", "\n      UPDATE ", "\n      IN tags RETURN NEW"]);
+
+  _templateObject2 = function _templateObject2() {
+    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 _templateObject() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN tags RETURN NEW"]);
+
+  _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 = 'tags';
+
+var getTagList = function getTagList(context) {
+  var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 30;
+  var action = 'getList';
+  var database = context.database,
+      sessionId = context.userId;
+  var limit = (0, _utils2.getLimit)(from, to);
+  var aqlQry = "FOR t IN tagList\n      FILTER t.userId == \"".concat(sessionId, "\"\n      ").concat(limit.aql, "\n      SORT t.added\n      RETURN t");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.all();
+  }).then(function () {
+    var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    return list;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.getTagList = getTagList;
+
+var getTag = function getTag(context, tagId) {
+  var action = 'getItem';
+  var database = context.database;
+  var formatId = JSON.stringify((0, _utils.parseId)(tagId));
+  var aqlQry = "FOR t IN tags\n      FILTER t._key == ".concat(formatId, "\n      LIMIT 1\n      RETURN t");
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var tag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return tag;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.getTag = getTag;
+
+var addTag = function addTag(context, tag) {
+  var action = 'add';
+  var database = context.database,
+      sessionId = context.userId;
+  var now = Date.now();
+  var formatId = (0, _utils.createHash)("tag-".concat(sessionId));
+  var description = tag.description,
+      name = tag.name;
+  var insert = {
+    _key: formatId,
+    added: now,
+    description: (0, _utils.parseVarChar)(description, 64),
+    modified: now,
+    name: (0, _utils.parseVarChar)(name, 32)
+  };
+  var aqlQry = (0, _arangojs.aql)(_templateObject(), insert);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var tag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return tag;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.addTag = addTag;
+
+var tagPost = function tagPost(context, tagId, postId) {
+  var action = 'tagPost';
+  var database = context.database,
+      sessionId = context.userId;
+  var added = Date.now();
+  var edgeId = (0, _utils.createHash)("tagPost-".concat(sessionId));
+  var edgeCollection = (0, _utils2.useDb)(database).collection('isTagged');
+  var edge = {
+    _from: "tags/".concat(tagId),
+    _key: edgeId,
+    _to: "posts/".concat(postId),
+    added: added
+  };
+  return edgeCollection.save(edge, {
+    returnNew: true
+  }).then(function () {
+    var post = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return post;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.tagPost = tagPost;
+
+var updateTag = function updateTag(context) {
+  var item = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var action = 'update';
+  var database = context.database;
+  var now = Date.now();
+  var description = item.description,
+      id = item.id,
+      name = item.name;
+  var formatName = (0, _utils.parseVarChar)(name, 32);
+  var update = {
+    description: (0, _utils.parseVarChar)(description, 64),
+    modified: now,
+    name: formatName
+  };
+  var formatId = (0, _utils.parseId)(id);
+  var tagId = !formatId ? (0, _utils.createHash)("tag-".concat(formatName.toLowerCase()), null) : formatId;
+
+  var insert = _objectSpread(_objectSpread({}, update), {}, {
+    _key: tagId,
+    added: now
+  });
+
+  var aqlQry = (0, _arangojs.aql)(_templateObject2(), tagId, insert, update);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var tag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return tag;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.updateTag = updateTag;
+
+var deleteTag = function deleteTag(context, tagId) {
+  var action = 'delete';
+  var database = context.database;
+  var formatTagId = (0, _utils.parseId)(tagId);
+  var aqlQry = (0, _arangojs.aql)(_templateObject3(), formatTagId);
+  return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var tag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return tag;
+  })["catch"](function (error) {
+    return (0, _utils2.logError)({
+      action: action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {}).then(function () {
+      return null;
+    })["catch"](function (error) {
+      return Promise.reject(error);
+    });
+  });
+};
+
+exports.deleteTag = deleteTag;
+
+var createTag = function createTag(db, tagName) {
+  var tagId = (0, _utils.createHash)("tag-".concat(tagName));
+  var insert = {
+    _key: tagId,
+    added: Date.now(),
+    name: tagName
+  };
+  var aqlQry = (0, _arangojs.aql)(_templateObject4(), tagId, insert);
+  return db.query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var tag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return tag;
+  })["catch"](function (error) {
+    throw error;
+  });
+};
+
+exports.createTag = createTag;
+
+var createTagEdge = function createTagEdge(db, tag, itemType, itemId) {
+  var edgeCollection = db.collection('isTagged');
+  var tagId = tag._id,
+      tagKey = tag._key;
+  var edgeId = (0, _utils.createHash)("tag-".concat(itemType, "-").concat(tagKey, "-").concat(itemId));
+  var edge = {
+    _from: tagId,
+    _key: edgeId,
+    _to: "".concat(itemType, "/").concat(itemId),
+    added: Date.now(),
+    type: itemType
+  };
+  return edgeCollection.save(edge, {
+    returnNew: true
+  }).then(function () {
+    return tag;
+  });
+};
+
+exports.createTagEdge = createTagEdge;
+
+var linkTags = function linkTags(db, tagNames, itemType, itemId) {
+  return Promise.all(tagNames.map(function (tagId) {
+    return createTag(db, tagId).then(function (tag) {
+      return createTagEdge(db, tag, itemType, itemId);
+    });
+  }));
+};
+
+exports.linkTags = linkTags;
+
+var extractTags = function extractTags(db, itemType, itemId, content) {
+  var tags = (0, _words["default"])(content, /#[a-zA-Z\d-]+/g).map(function (tag) {
+    return (0, _utils.parseId)(tag);
+  });
+  var edgeCollection = db.collection('isTagged');
+  return edgeCollection.inEdges(itemId).then(function (edges) {
+    if (edges.length) {
+      // Remove linked edges
+      return Promise.all(edges.map(function (edge) {
+        var edgeKey = edge._key;
+        var aqlQry = (0, _arangojs.aql)(_templateObject5(), edgeKey);
+        return db.query(aqlQry)["catch"](function (error) {
+          throw error;
+        });
+      })).then(function () {
+        if (tags.length) {
+          // Create tags
+          return linkTags(db, tags, itemType, itemId);
+        }
+
+        return [];
+      });
+    } else if (tags.length) {
+      // Create tags
+      return linkTags(db, tags, itemType, itemId);
+    }
+
+    return [];
+  })["catch"](function (error) {
+    throw error;
+  });
+};
+
+exports.extractTags = extractTags;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/tags.ts"],"names":["eventCategory","getTagList","context","from","to","action","database","sessionId","userId","limit","aqlQry","aql","query","then","cursor","all","list","error","category","label","Promise","reject","getTag","tagId","formatId","JSON","stringify","next","tag","addTag","now","Date","description","name","insert","_key","added","modified","tagPost","postId","edgeId","edgeCollection","collection","edge","_from","_to","save","returnNew","post","updateTag","item","id","formatName","update","toLowerCase","deleteTag","formatTagId","createTag","db","tagName","createTagEdge","itemType","itemId","_id","tagKey","type","linkTags","tagNames","map","extractTags","content","tags","inEdges","edges","length","edgeKey"],"mappings":"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","sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseId, parseVarChar} from '@nlabs/utils';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport words from 'lodash/words';\n\nimport {ArangoDBLimit} from '../types/arangodb';\nimport {ApiContext} from '../types/auth';\nimport {PostType} from '../types/posts';\nimport {TagType} from '../types/tags';\nimport {getLimit, logError, useDb} from '../utils';\n\nconst eventCategory: string = 'tags';\n\nexport const getTagList = (context: ApiContext, from: number = 0, to: number = 30): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {database, userId: sessionId} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR t IN tagList\n      FILTER t.userId == \"${sessionId}\"\n      ${limit.aql}\n      SORT t.added\n      RETURN t`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((list = []) => list)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const getTag = (context: ApiContext, tagId: string): Promise<TagType> => {\n  const action: string = 'getItem';\n  const {database} = context;\n  const formatId: string = JSON.stringify(parseId(tagId));\n  const aqlQry: string = `FOR t IN tags\n      FILTER t._key == ${formatId}\n      LIMIT 1\n      RETURN t`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((tag = {}) => tag)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const addTag = (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'add';\n  const {database, userId: sessionId} = context;\n  const now: number = Date.now();\n  const formatId: string = createHash(`tag-${sessionId}`);\n  const {description, name} = tag;\n\n  const insert: any = {\n    _key: formatId,\n    added: now,\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: parseVarChar(name, 32)\n  };\n\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN tags RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((tag: TagType = {}) => tag)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const tagPost = (context: ApiContext, tagId, postId): Promise<PostType> => {\n  const action: string = 'tagPost';\n  const {database, userId: sessionId} = context;\n  const added: number = Date.now();\n  const edgeId: string = createHash(`tagPost-${sessionId}`);\n  const edgeCollection: EdgeCollection = useDb(database).collection('isTagged');\n  const edge: any = {_from: `tags/${tagId}`, _key: edgeId, _to: `posts/${postId}`, added};\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .then((post: PostType = {}) => post)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const updateTag = (context: ApiContext, item: TagType = {}): Promise<TagType> => {\n  const action: string = 'update';\n  const {database} = context;\n  const now: number = Date.now();\n  const {description, id, name} = item;\n  const formatName: string = parseVarChar(name, 32);\n\n  const update: TagType = {\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: formatName\n  };\n\n  const formatId: string = parseId(id);\n  const tagId: string = !formatId ? createHash(`tag-${formatName.toLowerCase()}`, null) : formatId;\n\n  const insert: TagType = {\n    ...update,\n    _key: tagId,\n    added: now\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${tagId}}\n      INSERT ${insert}\n      UPDATE ${update}\n      IN tags RETURN NEW`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((tag = {}) => tag)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const deleteTag = (context: ApiContext, tagId: string): Promise<TagType> => {\n  const action: string = 'delete';\n  const {database} = context;\n  const formatTagId: string = parseId(tagId);\n  const aqlQry: AqlQuery = aql`FOR t IN tags\n    FILTER t._key == ${formatTagId}\n    REMOVE t IN tags\n    RETURN OLD`;\n\n  return useDb(database).query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((tag: TagType = {}) => tag)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n};\n\nexport const createTag = (db: Database, tagName: string): Promise<TagType> => {\n  const tagId: string = createHash(`tag-${tagName}`);\n  const insert: TagType = {\n    _key: tagId,\n    added: Date.now(),\n    name: tagName\n  };\n\n  const aqlQry = aql`UPSERT {_key: ${tagId}}\n    INSERT ${insert}\n    UPDATE {}\n    IN tags RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((tag = {}) => tag)\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const createTagEdge = (db: Database, tag: TagType, itemType: string, itemId: string): Promise<TagType> => {\n  const edgeCollection = db.collection('isTagged');\n  const {_id: tagId, _key: tagKey} = tag;\n  const edgeId = createHash(`tag-${itemType}-${tagKey}-${itemId}`);\n  const edge: any = {\n    _from: tagId,\n    _key: edgeId,\n    _to: `${itemType}/${itemId}`,\n    added: Date.now(),\n    type: itemType\n  };\n\n  return edgeCollection.save(edge, {returnNew: true}).then(() => tag);\n};\n\nexport const linkTags = (db: Database, tagNames: string[], itemType: string, itemId: string): Promise<TagType[]> =>\n  Promise.all(\n    tagNames.map((tagId: string) => createTag(db, tagId)\n      .then((tag: TagType) => createTagEdge(db, tag, itemType, itemId)))\n  );\n\n\nexport const extractTags = (db: Database, itemType: string, itemId, content): Promise<TagType[]> => {\n  const tags: string[] = words(content, /#[a-zA-Z\\d-]+/g).map((tag: string) => parseId(tag));\n  const edgeCollection = db.collection('isTagged');\n\n  return edgeCollection.inEdges(itemId)\n    .then((edges: any) => {\n      if(edges.length) {\n        // Remove linked edges\n        return Promise.all(\n          edges.map((edge) => {\n            const {_key: edgeKey} = edge;\n            const aqlQry = aql`REMOVE {_key:${edgeKey}} IN isTagged`;\n            return db.query(aqlQry).catch((error: Error) => {\n              throw error;\n            });\n          }))\n          .then(() => {\n            if(tags.length) {\n              // Create tags\n              return linkTags(db, tags, itemType, itemId);\n            }\n            return [];\n          });\n      } else if(tags.length) {\n        // Create tags\n        return linkTags(db, tags, itemType, itemId);\n      }\n      return [];\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"]}

package/lib/data/users.d.ts

@@ -3,6 +3,9 @@ import { UserOptions, UserType } from '../types/users';
 export declare const getUserOptional: (fields: string[]) => any;
 export declare const parseUserOptions: (options?: UserOptions) => {
     limit: import("..").ArangoDBLimit;
+    from?: number;
+    to?: number;
+    username?: string;
 };
 export declare const addUser: (context: ApiContext, user: UserType) => Promise<UserType>;
 export declare const updateUser: (context: ApiContext, user: UserType) => Promise<UserType>;
@@ -10,8 +13,8 @@ export declare const deleteUser: (context: ApiContext, userId: string) => Promis
 export declare const deactivateUser: (context: ApiContext, userId: string) => Promise<UserType>;
 export declare const getSessionUser: (context: ApiContext) => Promise<UserType>;
 export declare const getUser: (context: ApiContext, userId: string) => Promise<UserType>;
-export declare const getUserList: (context: ApiContext, options?: UserOptions) => Promise<UserType>;
-export declare const getUsersByReaction: (context: ApiContext, reactionName: string, options?: UserOptions) => Promise<UserType>;
-export declare const getUsersByRecent: (context: ApiContext, options?: UserOptions) => Promise<UserType>;
-export declare const getUsersByUsername: (context: ApiContext, query: string, options?: UserOptions) => Promise<UserType>;
+export declare const getUserList: (context: ApiContext, options?: UserOptions) => Promise<UserType[]>;
+export declare const getUsersByReaction: (context: ApiContext, reactionName: string, options?: UserOptions) => Promise<UserType[]>;
+export declare const getUsersByRecent: (context: ApiContext, options?: UserOptions) => Promise<UserType[]>;
+export declare const getUsersByUsername: (context: ApiContext, query: string, options?: UserOptions) => Promise<UserType[]>;
 export declare const getDisplayName: (user?: UserType) => string;