@nlabs/reaktor 0.4.0 → 0.4.1

package/lib/actions/tags.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, {
+  addTag: () => addTag,
+  addTagToItem: () => addTagToItem,
+  createTag: () => createTag,
+  createTagEdge: () => createTagEdge,
+  deleteTag: () => deleteTag,
+  deleteTagFromItem: () => deleteTagFromItem,
+  extractTags: () => extractTags,
+  getTag: () => getTag,
+  getTags: () => getTags,
+  getTagsByItem: () => getTagsByItem,
+  getTagsByOwner: () => getTagsByOwner,
+  linkTags: () => linkTags,
+  updateTag: () => updateTag
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_words = __toModule(require("lodash/words"));
+var import_utils2 = __toModule(require("../utils"));
+const eventCategory = "tags";
+const getTags = (context, args) => {
+  const action = "getList";
+  const { database } = context;
+  const { search = "", from = 0, to = 30 } = args;
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const filter = search.length ? `FILTER LIKE(t.name, "%${search}%")` : "";
+  const aqlQry = `FOR t IN tags
+    ${filter}
+    ${limit.aql}
+    SORT t.name
+    RETURN t`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((list = []) => list).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const getTagsByItem = (context, itemId, args) => {
+  const action = "getList";
+  const { from = 0, to = 30 } = args;
+  const { database } = context;
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const tagQuery = `FOR t, it IN INBOUND "${formatItemId}" isTagged
+    ${limit.aql}
+    SORT it.added
+    RETURN t`;
+  return database.query(tagQuery).then((cursor) => cursor.all() || []).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const getTagsByOwner = (context, args) => {
+  const action = "getList";
+  const { from = 0, id, to = 30 } = args;
+  const { database } = context;
+  const limit = (0, import_utils2.getLimit)(from, to);
+  const aqlQry = `FOR t IN tags
+    FILTER t.userId == "${id}"
+    ${limit.aql}
+    SORT t.added
+    RETURN t`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((list = []) => list).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const getTag = (context, tagId) => {
+  const action = "getItem";
+  const { database } = context;
+  const formatId = JSON.stringify((0, import_utils.parseId)(tagId));
+  const aqlQry = `FOR t IN tags
+    FILTER t._key == ${formatId}
+    LIMIT 1
+    RETURN t`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((tag = {}) => tag).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const addTag = (context, { tag }) => {
+  const action = "addTag";
+  const { database, session } = context;
+  const { userAccess } = session;
+  if (userAccess < 3) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "db_error"
+    }, session);
+  }
+  const now = Date.now();
+  const { description, name } = tag;
+  const formatId = (0, import_utils.createHash)(`tag-${name.toLowercase()}`, null);
+  const insert = {
+    _key: formatId,
+    added: now,
+    description: (0, import_utils.parseVarChar)(description, 64),
+    modified: now,
+    name: (0, import_utils.parseVarChar)(name, 32)
+  };
+  const aqlQry = import_arangojs.aql`INSERT ${insert} IN tags RETURN NEW`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((tag2 = {}) => tag2).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const addTagToItem = async (context, { itemId, tagId }) => {
+  const action = "addTagToItem";
+  const { database } = context;
+  const added = Date.now();
+  const formatTagId = (0, import_utils.parseArangoId)(tagId);
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const edgeId = (0, import_utils.createHash)(`isTagged-${formatTagId}-${formatItemId}`, null);
+  const edgeCollection = database.collection("isTagged");
+  const edge = { _from: formatTagId, _key: edgeId, _to: formatItemId, added };
+  console.log({ edge });
+  await edgeCollection.save(edge, { overwriteMode: "ignore", silent: true }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error",
+    params: {
+      edge
+    }
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+  const tagQuery = import_arangojs.aql`LET t = DOCUMENT(${formatTagId}) RETURN t`;
+  return database.query(tagQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error",
+    params: {
+      edge
+    }
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const updateTag = (context, item = {}) => {
+  const action = "update";
+  const { database, session } = context;
+  const { userAccess } = session;
+  if (userAccess < 3) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "db_error"
+    }, session);
+  }
+  const now = Date.now();
+  const { description, id, name } = item;
+  const formatName = (0, import_utils.parseVarChar)(name, 32);
+  const update = {
+    description: (0, import_utils.parseVarChar)(description, 64),
+    modified: now,
+    name: formatName
+  };
+  const formatId = (0, import_utils.parseId)(id);
+  const tagId = !formatId ? (0, import_utils.createHash)(`tag-${formatName.toLowerCase()}`, null) : formatId;
+  const insert = __spreadProps(__spreadValues({}, update), {
+    _key: tagId,
+    added: now
+  });
+  const aqlQry = import_arangojs.aql`UPSERT {_key: ${tagId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN tags RETURN NEW`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((tag = {}) => tag).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const deleteTag = (context, { tagId }) => {
+  const action = "deleteTag";
+  const { database, session } = context;
+  const { userAccess } = session;
+  if (userAccess < 3) {
+    return (0, import_utils2.logException)({
+      action,
+      category: eventCategory,
+      label: "db_error"
+    }, session);
+  }
+  const formatTagId = (0, import_utils.parseId)(tagId);
+  const aqlQry = import_arangojs.aql`FOR t IN tags
+    FILTER t._key == ${formatTagId}
+    REMOVE t IN tags
+    RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).then((tag = {}) => tag).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const deleteTagFromItem = async (context, { itemId, tagId }) => {
+  const action = "deleteTagFromItem";
+  const { database } = context;
+  const formatTagId = (0, import_utils.parseArangoId)(tagId);
+  const formatItemId = (0, import_utils.parseArangoId)(itemId);
+  const edgeId = (0, import_utils.createHash)(`isTagged-${formatTagId}-${formatItemId}`, null);
+  const edgeCollection = database.collection("isTagged");
+  const edge = { _key: edgeId };
+  await edgeCollection.remove(edge, { silent: true }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+  const tagQuery = import_arangojs.aql`LET t = DOCUMENT(${tagId}) RETURN t`;
+  return database.query(tagQuery).then((cursor) => cursor.next()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, {}).then(() => null).catch((error2) => Promise.reject(error2)));
+};
+const createTag = (db, tagName) => {
+  const tagId = (0, import_utils.createHash)(`tag-${tagName.toLowerCase()}`, null);
+  const insert = {
+    _key: tagId,
+    added: Date.now(),
+    name: tagName
+  };
+  const aqlQry = import_arangojs.aql`UPSERT {_key: ${tagId}}
+    INSERT ${insert}
+    UPDATE {}
+    IN tags RETURN NEW`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((tag = {}) => tag).catch((error) => {
+    throw error;
+  });
+};
+const createTagEdge = (db, tag, itemId) => {
+  const edgeCollection = db.collection("isTagged");
+  const { _id: tagId } = tag;
+  const edgeId = (0, import_utils.createHash)(`isTagged-${tagId}-${itemId}`);
+  const type = itemId.split("/")[0];
+  const edge = {
+    _from: tagId,
+    _key: edgeId,
+    _to: itemId,
+    added: Date.now(),
+    type
+  };
+  return edgeCollection.save(edge, { returnNew: true }).then(() => tag);
+};
+const linkTags = async (db, tagNames, itemId) => {
+  const edgeCollection = db.collection("isTagged");
+  const edges = await edgeCollection.inEdges(itemId);
+  console.log({ edges });
+  if (edges.length) {
+    await Promise.all(edges.map((edge) => {
+      const { _key: edgeKey } = edge;
+      const aqlQry = import_arangojs.aql`REMOVE {_key:${edgeKey}} IN isTagged`;
+      return db.query(aqlQry);
+    }));
+  }
+  return Promise.all(tagNames.map((tagName) => createTag(db, tagName).then((tag) => createTagEdge(db, tag, itemId))));
+};
+const extractTags = (db, itemId, content) => {
+  const tags = (0, import_words.default)(content, /#[a-zA-Z\d-]+/g).map((tag) => (0, import_utils.parseId)(tag));
+  const edgeCollection = db.collection("isTagged");
+  return edgeCollection.inEdges(itemId).then((edges) => {
+    if (edges.length) {
+      return Promise.all(edges.map((edge) => {
+        const { _key: edgeKey } = edge;
+        const aqlQry = import_arangojs.aql`REMOVE {_key:${edgeKey}} IN isTagged`;
+        return db.query(aqlQry).catch((error) => {
+          throw error;
+        });
+      })).then(() => {
+        if (tags.length) {
+          return linkTags(db, tags, itemId);
+        }
+        return [];
+      });
+    } else if (tags.length) {
+      return linkTags(db, tags, itemId);
+    }
+    return [];
+  }).catch((error) => {
+    throw error;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTag,
+  addTagToItem,
+  createTag,
+  createTagEdge,
+  deleteTag,
+  deleteTagFromItem,
+  extractTags,
+  getTag,
+  getTags,
+  getTagsByItem,
+  getTagsByOwner,
+  linkTags,
+  updateTag
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/tags.ts"],
  "sourcesContent": ["import {createHash, parseArangoId, 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 {TagType} from '../types/tags';\nimport {getLimit, logError, logException} from '../utils';\n\n/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nconst eventCategory: string = 'tags';\n\nexport const getTags = (\n  context: ApiContext,\n  args\n): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {database} = context;\n  const {search = '', from = 0, to = 30} = args;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const filter: string = search.length ? `FILTER LIKE(t.name, \"%${search}%\")` : '';\n  const aqlQry: string = `FOR t IN tags\n    ${filter}\n    ${limit.aql}\n    SORT t.name\n    RETURN t`;\n\n  return 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 getTagsByItem = (context: ApiContext, itemId: string,  args): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {from = 0, to = 30} = args;\n  const {database} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const formatItemId: string = parseArangoId(itemId);\n\n  const tagQuery: string = `FOR t, it IN INBOUND \"${formatItemId}\" isTagged\n    ${limit.aql}\n    SORT it.added\n    RETURN t`;\n\n  return database.query(tagQuery)\n    .then((cursor: ArrayCursor) => cursor.all() || [])\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 getTagsByOwner = (context: ApiContext, args): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {from = 0, id, to = 30} = args;\n  const {database} = context;\n  const limit: ArangoDBLimit = getLimit(from, to);\n  const aqlQry: string = `FOR t IN tags\n    FILTER t.userId == \"${id}\"\n    ${limit.aql}\n    SORT t.added\n    RETURN t`;\n\n  return 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 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}): Promise<TagType> => {\n  const action: string = 'addTag';\n  const {database, session} = context;\n  const {userAccess} = session;\n\n  if(userAccess < 3) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, session);\n  }\n\n  const now: number = Date.now();\n  const {description, name} = tag;\n  const formatId: string = createHash(`tag-${name.toLowercase()}`, null);\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 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 addTagToItem = async (context: ApiContext, {itemId, tagId}): Promise<TagType> => {\n  const action: string = 'addTagToItem';\n  const {database} = context;\n  const added: number = Date.now();\n  const formatTagId: string = parseArangoId(tagId);\n  const formatItemId: string = parseArangoId(itemId);\n  const edgeId: string = createHash(`isTagged-${formatTagId}-${formatItemId}`, null);\n  const edgeCollection: EdgeCollection = database.collection('isTagged');\n  const edge: any = {_from: formatTagId, _key: edgeId, _to: formatItemId, added};\n  console.log({edge});\n  await edgeCollection.save(edge, {overwriteMode: 'ignore', silent: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error',\n      params: {\n        edge\n      }\n    }, error, {}).then(() => null).catch((error) => Promise.reject(error)));\n\n\n  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${formatTagId}) RETURN t`;\n\n  return database.query(tagQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error',\n      params: {\n        edge\n      }\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, session} = context;\n  const {userAccess} = session;\n\n  if(userAccess < 3) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, session);\n  }\n\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 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}): Promise<TagType> => {\n  const action: string = 'deleteTag';\n  const {database, session} = context;\n  const {userAccess} = session;\n\n  if(userAccess < 3) {\n    return logException({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, session);\n  }\n\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 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 deleteTagFromItem = async (context: ApiContext, {itemId, tagId}): Promise<TagType> => {\n  const action: string = 'deleteTagFromItem';\n  const {database} = context;\n  const formatTagId: string = parseArangoId(tagId);\n  const formatItemId: string = parseArangoId(itemId);\n  const edgeId: string = createHash(`isTagged-${formatTagId}-${formatItemId}`, null);\n  const edgeCollection: EdgeCollection = database.collection('isTagged');\n  const edge: any = {_key: edgeId};\n\n  await edgeCollection.remove(edge, {silent: true})\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  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${tagId}) RETURN t`;\n\n  return database.query(tagQuery)\n    .then((cursor: ArrayCursor) => cursor.next())\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.toLowerCase()}`, null);\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, itemId: string): Promise<TagType> => {\n  const edgeCollection = db.collection('isTagged');\n  const {_id: tagId} = tag;\n  const edgeId = createHash(`isTagged-${tagId}-${itemId}`);\n  const type: string = itemId.split('/')[0];\n  const edge: any = {\n    _from: tagId,\n    _key: edgeId,\n    _to: itemId,\n    added: Date.now(),\n    type\n  };\n\n  return edgeCollection.save(edge, {returnNew: true}).then(() => tag);\n};\n\nexport const linkTags = async (db: Database, tagNames: string[], itemId: string): Promise<TagType[]> => {\n  const edgeCollection = db.collection('isTagged');\n  const edges: any = await edgeCollection.inEdges(itemId);\n\n  console.log({edges});\n  if(edges.length) {\n    await 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);\n      })\n    );\n  }\n\n  return Promise.all(tagNames.map((tagName: string) => createTag(db, tagName)\n    .then((tag: TagType) => createTagEdge(db, tag, itemId)))\n  );\n};\n\nexport const extractTags = (db: Database, 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, itemId);\n            }\n            return [];\n          });\n      } else if(tags.length) {\n        // Create tags\n        return linkTags(db, tags, itemId);\n      }\n      return [];\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/actions/users.d.ts

@@ -0,0 +1,44 @@
+import { ApiContext } from '../types/auth';
+import { User } from '../types/users';
+import { SessionError, SessionToken } from '../utils/session';
+export interface UserOptions {
+    readonly from?: number;
+    readonly to?: number;
+    readonly username?: string;
+}
+export declare enum UserAccess {
+    DEACTIVATED = 0,
+    ACTIVE = 1,
+    PREMIUM = 2,
+    CONTENT_ADMIN = 3,
+    ADMIN = 4
+}
+export declare const createToken: (userId: string, username: string, userAccess: number, expires?: number) => SessionToken;
+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, args: any) => Promise<User>;
+export declare const updateUser: (context: ApiContext, user: User) => Promise<any>;
+export declare const confirmCode: (context: ApiContext, args: any) => Promise<boolean>;
+export declare const deleteUser: (context: ApiContext, args: any) => Promise<any>;
+export declare const deactivateUser: (context: ApiContext, userId: string) => Promise<User>;
+export declare const getDisplayName: (user?: User) => string;
+export declare const getSessionUser: (context: ApiContext) => Promise<User>;
+export declare const getUser: (context: ApiContext, args: any) => Promise<User>;
+export declare const getUsers: (context: ApiContext, options?: UserOptions) => Promise<User[]>;
+export declare const getUsersByReactions: (context: ApiContext, { reactions, username }: any, options?: UserOptions) => Promise<User[]>;
+export declare const getUsersByTags: (context: ApiContext, { tags, username }: any, options?: UserOptions) => Promise<User[]>;
+export declare const getUsersByLatest: (context: ApiContext, { username }: {
+    username: any;
+}, options?: UserOptions) => Promise<User[]>;
+export declare const refreshSession: (context: ApiContext, { expires, token }: {
+    expires: any;
+    token: any;
+}) => Promise<SessionToken | SessionError>;
+export declare const signIn: (context: ApiContext, args: any) => Promise<SessionToken>;
+export declare const signOut: (context: ApiContext, args: any) => Promise<boolean>;
+export declare const getActiveUserCount: (context: ApiContext) => Promise<any>;