@nlabs/reaktor 0.9.0 → 0.10.0

package/dist/actions/tags.js

@@ -0,0 +1,292 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tags_exports = {};
+__export(tags_exports, {
+  addTag: () => addTag,
+  addTagToItem: () => addTagToItem,
+  deleteTag: () => deleteTag,
+  deleteTagFromEdge: () => deleteTagFromEdge,
+  deleteTagFromItem: () => deleteTagFromItem,
+  extractTags: () => extractTags,
+  getTag: () => getTag,
+  getTags: () => getTags,
+  getTagsByItem: () => getTagsByItem,
+  getTagsByName: () => getTagsByName,
+  updateTag: () => updateTag,
+  updateTagsInItem: () => updateTagsInItem
+});
+module.exports = __toCommonJS(tags_exports);
+var import_utils = require("@nlabs/utils");
+var import_arangojs = require("arangojs");
+var import_words = __toESM(require("lodash/words"), 1);
+var import_tagAdapter = require("../adapters/tagAdapter");
+var import_error = require("../types/error");
+var import_analyticsUtils = require("../utils/analyticsUtils");
+var import_arangodbUtils = require("../utils/arangodbUtils");
+const eventCategory = "tags";
+const getTags = (context, options = {}) => {
+  const action = "getList";
+  const { database } = context;
+  const { search = "", from = 0, to = 30, userId } = options;
+  const limit = (0, import_arangodbUtils.getLimit)(from, to);
+  const filters = [];
+  if (search) {
+    filters.push(`LIKE(t.name, "%${search}%")`);
+  }
+  if (userId) {
+    filters.push(`t.userId == "${userId}"`);
+  }
+  const aqlQry = `FOR t IN tags
+    FILTER ${filters.join(" || ")}
+    ${limit.aql}
+    SORT t.name
+    RETURN t`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, {});
+    return [];
+  });
+};
+const getTagsByItem = (context, itemDocId, options = {}) => {
+  const action = "getTagsByItem";
+  const { from = 0, to = 30 } = options;
+  const { database } = context;
+  const limit = (0, import_arangodbUtils.getLimit)(from, to);
+  const formatItemId = (0, import_utils.parseArangoId)(itemDocId);
+  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_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, {});
+    return [];
+  });
+};
+const getTag = (context, tagId) => {
+  const action = "getTag";
+  const { database } = context;
+  const formatId = (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()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const getTagsByName = (context, tagNames) => {
+  const action = "getTagsByName";
+  const { database } = context;
+  const formatTagNames = tagNames.map((tagName) => (0, import_utils.parseVarChar)(tagName, 32)).filter((tagName) => !!tagName);
+  if (!formatTagNames.length) {
+    return Promise.resolve([]);
+  }
+  const aqlQry = import_arangojs.aql`FOR t IN tags
+    FILTER POSITION(${JSON.stringify(formatTagNames)}, t.name)
+    RETURN t`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, {});
+    return [];
+  });
+};
+const addTag = (context, tag) => {
+  const action = "addTag";
+  const { database } = context;
+  const now = Date.now();
+  const { description, name } = (0, import_tagAdapter.parseTag)(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()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const addTagToItem = async (context, { itemDocId, tagBy, tagDocId }) => {
+  const action = "addTagToItem";
+  const { database, session: { userId: sessionId } } = context;
+  const added = Date.now();
+  const formatTagDocId = (0, import_utils.parseArangoId)(tagDocId);
+  const formatItemDocId = (0, import_utils.parseArangoId)(itemDocId);
+  const edgeId = (0, import_utils.createHash)(`isTagged-${formatTagDocId}-${formatItemDocId}`, null);
+  const edgeCollection = database.collection("isTagged");
+  const type = formatItemDocId.split("/")[0];
+  const formatTagBy = (0, import_utils.parseId)(tagBy) || sessionId;
+  const edge = { _from: formatTagDocId, _key: edgeId, _to: formatItemDocId, added, tagBy: formatTagBy, type };
+  await edgeCollection.save(edge, { overwriteMode: "ignore", returnNew: true, silent: true }).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: {
+      edge
+    },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+  const tagQuery = import_arangojs.aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;
+  return database.query(tagQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: {
+      edge
+    },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const updateTag = (context, tag) => {
+  const action = "updateTag";
+  const { database, session: { userId: sessionId } } = context;
+  const now = Date.now();
+  const { description, name, tagId } = (0, import_tagAdapter.parseTag)(tag);
+  const formatName = (0, import_utils.parseVarChar)(name, 32);
+  const update = {
+    description: (0, import_utils.parseVarChar)(description, 64),
+    modified: now,
+    name: formatName
+  };
+  const newTagKey = tagId || (0, import_utils.createHash)(`tag-${formatName.toLowerCase()}`, null);
+  const insert = {
+    ...update,
+    _id: `tags/${newTagKey}`,
+    _key: newTagKey,
+    added: now,
+    tagBy: sessionId
+  };
+  const aqlQry = import_arangojs.aql`UPSERT {name: ${formatName}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN tags RETURN NEW`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const deleteTag = async (context, tag) => {
+  const action = "deleteTag";
+  const { database } = context;
+  const formatItemId = (0, import_arangodbUtils.getDocId)("tags", tag);
+  const tagQuery = `FOR it FROM isTagged
+    FILTER it._from == "${formatItemId}" || it._to == "${formatItemId}"
+    REMOVE it IN isTagged
+    RETURN OLD`;
+  await database.query(tagQuery).then((cursor) => cursor.all()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+  const aqlQry = `LET t = DOCUMENT(${formatItemId})
+    REMOVE t IN tags
+    RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const deleteTagFromEdge = async (context, { tagDocId, edgeDocId }) => {
+  const action = "deleteTagFromEdge";
+  const { database } = context;
+  const formatTagDocId = (0, import_utils.parseArangoId)(tagDocId);
+  const formatEdgeDocId = (0, import_utils.parseArangoId)(edgeDocId);
+  const edgeCollection = database.collection("isTagged");
+  const edge = { _id: formatEdgeDocId };
+  await edgeCollection.remove(edge, { silent: true }).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+  const tagQuery = import_arangojs.aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;
+  return database.query(tagQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const deleteTagFromItem = async (context, { tagId, itemId, itemType }) => {
+  const action = "deleteTagFromItem";
+  const { database } = context;
+  const formatTagDocId = (0, import_utils.parseArangoId)(`tags/${tagId}`);
+  const formatItemDocId = (0, import_utils.parseArangoId)(`${itemType}/${itemId}`);
+  const aqlQuery = `FOR it FROM isTagged
+    FILTER it._from == "${formatTagDocId}" || it._to == "${formatItemDocId}"
+    REMOVE it IN isTagged`;
+  return database.query(aqlQuery).then(() => true).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+const extractTags = (content) => (0, import_words.default)(content, /#[a-zA-Z\d-]+/g).map((tag) => (0, import_utils.parseId)(tag));
+const updateTagsInItem = (context, { itemDocId, tags }) => {
+  const action = "updateTagsInItem";
+  const { database } = context;
+  const edgeCollection = database.collection("isTagged");
+  return edgeCollection.inEdges(itemDocId, {}).then((edges) => Promise.all([
+    ...edges.filter(({ name: existingTagName }) => !tags.find(({ name: tagName }) => existingTagName === tagName)).map(({ _id: edgeDocId, _from: tagDocId }) => deleteTagFromEdge(context, { edgeDocId, tagDocId })),
+    ...tags.filter(({ name: tagName }) => !edges.find(({ name: existingTagName }) => existingTagName === tagName)).map(({ _id: tagDocId, tagBy }) => addTagToItem(context, { itemDocId, tagBy, tagDocId }))
+  ]).then(() => tags)).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, {}));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTag,
+  addTagToItem,
+  deleteTag,
+  deleteTagFromEdge,
+  deleteTagFromItem,
+  extractTags,
+  getTag,
+  getTags,
+  getTagsByItem,
+  getTagsByName,
+  updateTag,
+  updateTagsInItem
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/tags.ts"],
  "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, parseArangoId, parseId, parseVarChar} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {Edge} from 'arangojs/documents';\nimport words from 'lodash/words';\n\nimport {parseTag} from '../adapters/tagAdapter';\nimport {ErrorTypes} from '../types/error';\nimport {logError} from '../utils/analyticsUtils';\nimport {getDocId, getLimit} from '../utils/arangodbUtils';\n\nimport type {ArangoDbLimit} from '../types/arangodb';\nimport type {ApiContext} from '../types/auth';\nimport type {IsTaggedType, TagType} from '../types/tags';\nimport type {EdgeCollection} from 'arangojs/collections';\n\nconst eventCategory: string = 'tags';\nexport interface TagOptions {\n  readonly from?: number;\n  readonly search?: string;\n  readonly to?: number;\n  readonly userId?: string;\n}\n\nexport const getTags = (\n  context: ApiContext,\n  options: TagOptions = {}\n): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {database} = context;\n  const {search = '', from = 0, to = 30, userId} = options;\n  const limit: ArangoDbLimit = getLimit(from, to);\n\n  const filters: string[] = [];\n\n  if(search) {\n    filters.push(`LIKE(t.name, \"%${search}%\")`);\n  }\n\n  if(userId) {\n    filters.push(`t.userId == \"${userId}\"`);\n  }\n\n  const aqlQry: string = `FOR t IN tags\n    FILTER ${filters.join(' || ')}\n    ${limit.aql}\n    SORT t.name\n    RETURN t`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const getTagsByItem = (\n  context: ApiContext,\n  itemDocId: string,\n  options: TagOptions = {}\n): Promise<TagType[]> => {\n  const action: string = 'getTagsByItem';\n  const {from = 0, to = 30} = options;\n  const {database} = context;\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const formatItemId: string = parseArangoId(itemDocId);\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) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const getTag = (context: ApiContext, tagId: string): Promise<TagType> => {\n  const action: string = 'getTag';\n  const {database} = context;\n  const formatId: string = 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) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const getTagsByName = (context: ApiContext, tagNames: string[]): Promise<TagType[]> => {\n  const action: string = 'getTagsByName';\n  const {database} = context;\n  const formatTagNames = tagNames\n    .map((tagName) => parseVarChar(tagName, 32))\n    .filter((tagName) => !!tagName);\n\n  if(!formatTagNames.length) {\n    return Promise.resolve([]);\n  }\n\n  const aqlQry: AqlQuery = aql`FOR t IN tags\n    FILTER POSITION(${JSON.stringify(formatTagNames)}, t.name)\n    RETURN t`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const addTag = (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'addTag';\n  const {database} = context;\n  const now: number = Date.now();\n  const {description, name} = parseTag(tag);\n  const formatId: string = createHash(`tag-${name.toLowerCase()}`, null);\n  const insert: TagType = {\n    _key: formatId,\n    added: now,\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: parseVarChar(name, 32)\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN tags RETURN NEW`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const addTagToItem = async (\n  context: ApiContext,\n  {itemDocId, tagBy, tagDocId}: {itemDocId: string, tagBy?: string, tagDocId: string}\n): Promise<TagType> => {\n  const action: string = 'addTagToItem';\n  const {database, session: {userId: sessionId}} = context;\n  const added: number = Date.now();\n  const formatTagDocId: string = parseArangoId(tagDocId);\n  const formatItemDocId: string = parseArangoId(itemDocId);\n  const edgeId: string = createHash(`isTagged-${formatTagDocId}-${formatItemDocId}`, null);\n  const edgeCollection: EdgeCollection = database.collection('isTagged');\n  const type: string = formatItemDocId.split('/')[0];\n  const formatTagBy: string = parseId(tagBy) || sessionId;\n  const edge: Edge = {_from: formatTagDocId, _key: edgeId, _to: formatItemDocId, added, tagBy: formatTagBy, type};\n\n  await edgeCollection.save(edge, {overwriteMode: 'ignore', returnNew: true, silent: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {\n        edge\n      },\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;\n\n  return database.query(tagQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {\n        edge\n      },\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const updateTag = (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'updateTag';\n  const {database, session: {userId: sessionId}} = context;\n  const now: number = Date.now();\n  const {description, name, tagId} = parseTag(tag);\n  const formatName: string = parseVarChar(name, 32);\n  const update: TagType = {\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: formatName\n  };\n  const newTagKey: string = tagId || createHash(`tag-${formatName.toLowerCase()}`, null);\n  const insert: TagType = {\n    ...update,\n    _id: `tags/${newTagKey}`,\n    _key: newTagKey,\n    added: now,\n    tagBy: sessionId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {name: ${formatName}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN tags RETURN NEW`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTag = async (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'deleteTag';\n  const {database} = context;\n  const formatItemId = getDocId('tags', tag);\n  const tagQuery: string = `FOR it FROM isTagged\n    FILTER it._from == \"${formatItemId}\" || it._to == \"${formatItemId}\"\n    REMOVE it IN isTagged\n    RETURN OLD`;\n\n  await database.query(tagQuery)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const aqlQry = `LET t = DOCUMENT(${formatItemId})\n    REMOVE t IN tags\n    RETURN OLD`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTagFromEdge = async (context: ApiContext, {tagDocId, edgeDocId}): Promise<TagType> => {\n  const action = 'deleteTagFromEdge';\n  const {database} = context;\n  const formatTagDocId = parseArangoId(tagDocId);\n  const formatEdgeDocId = parseArangoId(edgeDocId);\n  const edgeCollection: EdgeCollection = database.collection('isTagged');\n  const edge = {_id: formatEdgeDocId};\n\n  await edgeCollection.remove(edge, {silent: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;\n\n  return database.query(tagQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTagFromItem = async (context: ApiContext, {tagId, itemId, itemType}): Promise<TagType> => {\n  const action = 'deleteTagFromItem';\n  const {database} = context;\n  const formatTagDocId = parseArangoId(`tags/${tagId}`);\n  const formatItemDocId = parseArangoId(`${itemType}/${itemId}`);\n\n  const aqlQuery: string = `FOR it FROM isTagged\n    FILTER it._from == \"${formatTagDocId}\" || it._to == \"${formatItemDocId}\"\n    REMOVE it IN isTagged`;\n\n  return database.query(aqlQuery)\n    .then(() => true)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const extractTags = (content: string): string[] =>\n  words(content, /#[a-zA-Z\\d-]+/g).map((tag: string) => parseId(tag));\n\nexport const updateTagsInItem = (context: ApiContext, {itemDocId, tags}): Promise<TagType[]> => {\n  const action = 'updateTagsInItem';\n  const {database} = context;\n  const edgeCollection = database.collection('isTagged') as EdgeCollection<TagType>;\n\n  return edgeCollection.inEdges(itemDocId, {})\n    .then((edges) => Promise.all([\n      ...(edges as unknown as IsTaggedType[])\n        .filter(({name: existingTagName}) => !tags.find(({name: tagName}) => existingTagName === tagName))\n        .map(({_id: edgeDocId, _from: tagDocId}) => deleteTagFromEdge(context, {edgeDocId, tagDocId})),\n      ...(tags as unknown as TagType[])\n        .filter(({name: tagName}) => !(edges as unknown as IsTaggedType[])\n          .find(({name: existingTagName}) => existingTagName === tagName))\n        .map(({_id: tagDocId, tagBy}) => addTagToItem(context, {itemDocId, tagBy, tagDocId}))\n    ])\n      .then(() => tags))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAA+D;AAC/D,sBAAkB;AAGlB,mBAAkB;AAElB,wBAAuB;AACvB,mBAAyB;AACzB,4BAAuB;AACvB,2BAAiC;AAOjC,MAAM,gBAAwB;AAQvB,MAAM,UAAU,CACrB,SACA,UAAsB,CAAC,MACA;AACvB,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,SAAS,IAAI,OAAO,GAAG,KAAK,IAAI,OAAM,IAAI;AACjD,QAAM,YAAuB,+BAAS,MAAM,EAAE;AAE9C,QAAM,UAAoB,CAAC;AAE3B,MAAG,QAAQ;AACT,YAAQ,KAAK,kBAAkB,MAAM,KAAK;AAAA,EAC5C;AAEA,MAAG,QAAQ;AACT,YAAQ,KAAK,gBAAgB,MAAM,GAAG;AAAA,EACxC;AAEA,QAAM,SAAiB;AAAA,aACZ,QAAQ,KAAK,MAAM,CAAC;AAAA,MAC3B,MAAM,GAAG;AAAA;AAAA;AAIb,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,IAAI,CAAyB,EACrD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,CAAC,CAAC;AAEZ,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,gBAAgB,CAC3B,SACA,WACA,UAAsB,CAAC,MACA;AACvB,QAAM,SAAiB;AACvB,QAAM,EAAC,OAAO,GAAG,KAAK,GAAE,IAAI;AAC5B,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,YAAuB,+BAAS,MAAM,EAAE;AAC9C,QAAM,mBAAuB,4BAAc,SAAS;AACpD,QAAM,WAAmB,yBAAyB,YAAY;AAAA,MAC1D,MAAM,GAAG;AAAA;AAAA;AAIb,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAAyB,EACrD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,CAAC,CAAC;AAEZ,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,SAAS,CAAC,SAAqB,UAAoC;AAC9E,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,eAAmB,sBAAQ,KAAK;AACtC,QAAM,SAAiB;AAAA,wBACD,QAAQ;AAAA;AAAA;AAI9B,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,gBAAgB,CAAC,SAAqB,aAA2C;AAC5F,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,iBAAiB,SACpB,IAAI,CAAC,gBAAY,2BAAa,SAAS,EAAE,CAAC,EAC1C,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO;AAEhC,MAAG,CAAC,eAAe,QAAQ;AACzB,WAAO,QAAQ,QAAQ,CAAC,CAAC;AAAA,EAC3B;AAEA,QAAM,SAAmB;AAAA,sBACL,KAAK,UAAU,cAAc,CAAC;AAAA;AAGlD,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,IAAI,CAAyB,EACrD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,CAAC,CAAC;AAEZ,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,SAAS,CAAC,SAAqB,QAAmC;AAC7E,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,MAAc,KAAK,IAAI;AAC7B,QAAM,EAAC,aAAa,KAAI,QAAI,4BAAS,GAAG;AACxC,QAAM,eAAmB,yBAAW,OAAO,KAAK,YAAY,CAAC,IAAI,IAAI;AACrE,QAAM,SAAkB;AAAA,IACtB,MAAM;AAAA,IACN,OAAO;AAAA,IACP,iBAAa,2BAAa,aAAa,EAAE;AAAA,IACzC,UAAU;AAAA,IACV,UAAM,2BAAa,MAAM,EAAE;AAAA,EAC7B;AACA,QAAM,SAAmB,6BAAa,MAAM;AAE5C,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,eAAe,OAC1B,SACA,EAAC,WAAW,OAAO,SAAQ,MACN;AACrB,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,UAAS,EAAC,IAAI;AACjD,QAAM,QAAgB,KAAK,IAAI;AAC/B,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,sBAA0B,4BAAc,SAAS;AACvD,QAAM,aAAiB,yBAAW,YAAY,cAAc,IAAI,eAAe,IAAI,IAAI;AACvF,QAAM,iBAAiC,SAAS,WAAW,UAAU;AACrE,QAAM,OAAe,gBAAgB,MAAM,GAAG,EAAE,CAAC;AACjD,QAAM,kBAAsB,sBAAQ,KAAK,KAAK;AAC9C,QAAM,OAAa,EAAC,OAAO,gBAAgB,MAAM,QAAQ,KAAK,iBAAiB,OAAO,OAAO,aAAa,KAAI;AAE9G,QAAM,eAAe,KAAK,MAAM,EAAC,eAAe,UAAU,WAAW,MAAM,QAAQ,KAAI,CAAC,EACrF,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ;AAAA,MACN;AAAA,IACF;AAAA,IACA,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AAEf,QAAM,WAAqB,uCAAuB,cAAc;AAEhE,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ;AAAA,MACN;AAAA,IACF;AAAA,IACA,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,YAAY,CAAC,SAAqB,QAAmC;AAChF,QAAM,SAAiB;AACvB,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,UAAS,EAAC,IAAI;AACjD,QAAM,MAAc,KAAK,IAAI;AAC7B,QAAM,EAAC,aAAa,MAAM,MAAK,QAAI,4BAAS,GAAG;AAC/C,QAAM,iBAAqB,2BAAa,MAAM,EAAE;AAChD,QAAM,SAAkB;AAAA,IACtB,iBAAa,2BAAa,aAAa,EAAE;AAAA,IACzC,UAAU;AAAA,IACV,MAAM;AAAA,EACR;AACA,QAAM,YAAoB,aAAS,yBAAW,OAAO,WAAW,YAAY,CAAC,IAAI,IAAI;AACrF,QAAM,SAAkB;AAAA,IACtB,GAAG;AAAA,IACH,KAAK,QAAQ,SAAS;AAAA,IACtB,MAAM;AAAA,IACN,OAAO;AAAA,IACP,OAAO;AAAA,EACT;AACA,QAAM,SAAmB,oCAAoB,UAAU;AAAA,aAC5C,MAAM;AAAA,aACN,MAAM;AAAA;AAGjB,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,YAAY,OAAO,SAAqB,QAAmC;AACtF,QAAM,SAAiB;AACvB,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,mBAAe,+BAAS,QAAQ,GAAG;AACzC,QAAM,WAAmB;AAAA,0BACD,YAAY,mBAAmB,YAAY;AAAA;AAAA;AAInE,QAAM,SAAS,MAAM,QAAQ,EAC1B,KAAK,CAAC,WAAW,OAAO,IAAI,CAAC,EAC7B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AAEf,QAAM,SAAS,oBAAoB,YAAY;AAAA;AAAA;AAI/C,SAAO,SAAS,MAAM,MAAM,EACzB,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,oBAAoB,OAAO,SAAqB,EAAC,UAAU,UAAS,MAAwB;AACvG,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,qBAAiB,4BAAc,QAAQ;AAC7C,QAAM,sBAAkB,4BAAc,SAAS;AAC/C,QAAM,iBAAiC,SAAS,WAAW,UAAU;AACrE,QAAM,OAAO,EAAC,KAAK,gBAAe;AAElC,QAAM,eAAe,OAAO,MAAM,EAAC,QAAQ,KAAI,CAAC,EAC7C,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AAEf,QAAM,WAAqB,uCAAuB,cAAc;AAEhE,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,oBAAoB,OAAO,SAAqB,EAAC,OAAO,QAAQ,SAAQ,MAAwB;AAC3G,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,qBAAiB,4BAAc,QAAQ,KAAK,EAAE;AACpD,QAAM,sBAAkB,4BAAc,GAAG,QAAQ,IAAI,MAAM,EAAE;AAE7D,QAAM,WAAmB;AAAA,0BACD,cAAc,mBAAmB,eAAe;AAAA;AAGxE,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,MAAM,IAAI,EACf,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;AAEO,MAAM,cAAc,CAAC,gBAC1B,aAAAA,SAAM,SAAS,gBAAgB,EAAE,IAAI,CAAC,YAAgB,sBAAQ,GAAG,CAAC;AAE7D,MAAM,mBAAmB,CAAC,SAAqB,EAAC,WAAW,KAAI,MAA0B;AAC9F,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,iBAAiB,SAAS,WAAW,UAAU;AAErD,SAAO,eAAe,QAAQ,WAAW,CAAC,CAAC,EACxC,KAAK,CAAC,UAAU,QAAQ,IAAI;AAAA,IAC3B,GAAI,MACD,OAAO,CAAC,EAAC,MAAM,gBAAe,MAAM,CAAC,KAAK,KAAK,CAAC,EAAC,MAAM,QAAO,MAAM,oBAAoB,OAAO,CAAC,EAChG,IAAI,CAAC,EAAC,KAAK,WAAW,OAAO,SAAQ,MAAM,kBAAkB,SAAS,EAAC,WAAW,SAAQ,CAAC,CAAC;AAAA,IAC/F,GAAI,KACD,OAAO,CAAC,EAAC,MAAM,QAAO,MAAM,CAAE,MAC5B,KAAK,CAAC,EAAC,MAAM,gBAAe,MAAM,oBAAoB,OAAO,CAAC,EAChE,IAAI,CAAC,EAAC,KAAK,UAAU,MAAK,MAAM,aAAa,SAAS,EAAC,WAAW,OAAO,SAAQ,CAAC,CAAC;AAAA,EACxF,CAAC,EACE,KAAK,MAAM,IAAI,CAAC,EAClB,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,CAAC,CAAC,CAAC;AACjB;",
  "names": ["words"]
}
