@nlabs/reaktor 0.4.0 → 0.4.2

package/lib/actions/posts.d.ts

@@ -0,0 +1,19 @@
+import { Database } from 'arangojs';
+import { ApiContext, FileType, PostInputType, PostOptions, PostType } from '../types';
+export declare const parsePostOptions: (options?: PostOptions) => {
+    latitude: number;
+    limit: import("../types").ArangoDBLimit;
+    longitude: number;
+    type: string;
+};
+export declare const getPostOptional: (fields: string[], sessionId: string) => any;
+export declare const getPost: (context: ApiContext, itemId: string, options: PostOptions) => Promise<Partial<PostType>>;
+export declare const getPostsByReactions: (context: ApiContext, reactions?: string[], options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostsByTags: (context: ApiContext, tags?: string[], options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostsByUser: (context: ApiContext, userId: string, options?: PostOptions) => Promise<PostType[]>;
+export declare const getPostComments: (context: ApiContext, itemId: string, options?: PostOptions) => Promise<PostType[]>;
+export declare const addPost: (context: ApiContext, post: PostInputType) => Promise<PostType>;
+export declare const updatePost: (context: ApiContext, post: PostInputType) => Promise<PostType>;
+export declare const deletePost: (context: ApiContext, postId: string) => Promise<PostType>;
+export declare const cleanPosts: (database: Database) => Promise<number>;
+export declare const createPostEdge: (db: Database, file: FileType, postId: string) => Promise<FileType>;

package/lib/actions/posts.js

@@ -0,0 +1,538 @@
+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, {
+  addPost: () => addPost,
+  cleanPosts: () => cleanPosts,
+  createPostEdge: () => createPostEdge,
+  deletePost: () => deletePost,
+  getPost: () => getPost,
+  getPostComments: () => getPostComments,
+  getPostOptional: () => getPostOptional,
+  getPostsByReactions: () => getPostsByReactions,
+  getPostsByTags: () => getPostsByTags,
+  getPostsByUser: () => getPostsByUser,
+  parsePostOptions: () => parsePostOptions,
+  updatePost: () => updatePost
+});
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_utils2 = __toModule(require("../utils"));
+var import_files = __toModule(require("./files"));
+var import_tags = __toModule(require("./tags"));
+const MAX_CONTENT_LENGTH = 1e5;
+const eventCategory = "posts";
+const parsePostOptions = (options = {}) => {
+  const {
+    from = 0,
+    latitude = 0,
+    longitude = 0,
+    to = 30,
+    type = "post"
+  } = options;
+  return {
+    latitude: (0, import_utils.parseNum)(latitude, 32),
+    limit: (0, import_utils2.getLimit)(from, to),
+    longitude: (0, import_utils.parseNum)(longitude, 32),
+    type: (0, import_utils.parseChar)(type, 32)
+  };
+};
+const getPostOptional = (fields, sessionId) => fields.reduce((selects, field) => {
+  switch (field) {
+    case "hasRsvp": {
+      selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(
+          FOR post, r IN INBOUND p._id hasReactions
+          FILTER r.name == "rsvp" && r.type == "posts" && r._from == "users/${sessionId}"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        ))`);
+      selects.objects.push("hasRsvp:hasRsvp");
+      return selects;
+    }
+    case "isSaved": {
+      selects.queries.push(`LET isSaved = TO_BOOL(FIRST(
+          FOR post, r IN INBOUND p._id hasReactions
+          FILTER r.name == "pin" && r.type == "posts" && r._from == "users/${sessionId}"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        ))`);
+      selects.objects.push("isSaved:isSaved");
+      return selects;
+    }
+    case "reactions": {
+      selects.queries.push(`LET reactions = (
+          FOR post, r IN INBOUND p._id hasReactions
+          COLLECT reactionName = r.value INTO reactionItems
+          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+        )`);
+      selects.objects.push("reactions:reactions");
+      return selects;
+    }
+    case "rsvpCount": {
+      selects.queries.push(`LET rsvpCount = FIRST(
+          FOR post, r IN INBOUND p._id hasReactions
+          FILTER r.name == "rsvp" && r.type == "posts"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        )`);
+      selects.objects.push("rsvpCount:rsvpCount");
+      return selects;
+    }
+    case "viewCount": {
+      selects.queries.push(`LET viewCount = FIRST(
+          FOR post, r IN INBOUND p._id hasReactions
+          FILTER r.name == "view" && r.type == "posts"
+          COLLECT WITH COUNT INTO count
+          RETURN count
+        )`);
+      selects.objects.push("viewCount:viewCount");
+      return selects;
+    }
+    default: {
+      return selects;
+    }
+  }
+}, { objects: [], queries: [] });
+const getPost = (context, itemId, options) => {
+  const action = "getPost";
+  const { database, fields, session: { userId: sessionId } } = context;
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  const { type } = parsePostOptions(options);
+  const db = database;
+  const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+  const aqlQry = import_arangojs.aql`FOR p IN posts
+    FILTER p._key == ${formatItemId} && p.type == ${type}
+    LIMIT 1
+    RETURN p`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((post = {}) => {
+    const {
+      _id: postDocId,
+      groupId,
+      privacy = "default"
+    } = post;
+    let privacyAqlQry;
+    if (groupId && privacy === "group") {
+      privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join("\n")}
+          FOR group IN groups
+          FILTER group._key == p.groupId
+          FOR u, e IN OUTBOUND group._id isGrouped
+          FILTER u._key == "${sessionId}"
+          LIMIT 1
+          RETURN MERGE(p, {${selectObjects.join(", ")}})`;
+    } else if (privacy === "public") {
+      privacyAqlQry = `LET p = DOCUMENT("${postDocId}")
+          ${selectQueries.join("\n")}
+          LIMIT 1
+          RETURN MERGE(p, {${selectObjects.join(", ")}})`;
+    }
+    if (privacyAqlQry) {
+      return db.query(privacyAqlQry).then((cursor) => cursor.next() || {}).catch((error) => (0, import_utils2.logError)({
+        action,
+        category: eventCategory,
+        label: "db_error"
+      }, error, context).then(() => ({})));
+    }
+    return {};
+  }).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => ({})));
+};
+const getPostsByReactions = (context, reactions = [], options) => {
+  const action = "getPostsByReactions";
+  const { database, fields, session: { userId: sessionId } } = context;
+  const { latitude, limit, longitude, type } = parsePostOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+  const formatSessionId = `users/${sessionId}`;
+  const formatReactions = JSON.stringify(reactions.map((reaction) => (0, import_utils.parseChar)(reaction, 32).toLowerCase()));
+  const sortBy = [];
+  const filters = [`p.type == "${type}"`, 'p.privacy == "public"'];
+  const formatLatitude = (0, import_utils.parseNum)(latitude);
+  const formatLongitude = (0, import_utils.parseNum)(longitude);
+  if (formatLatitude && formatLongitude) {
+    selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
+      NOT_NULL(p.latitude, 0),
+      NOT_NULL(p.longitude, 0))
+    `);
+    selectObjects.push("distance:distance");
+    sortBy.push("distance");
+  }
+  if (reactions.length) {
+    sortBy.push("matchedTags DESC");
+    selectQueries.push(`LET matchedReactions = LENGTH(
+      FOR mr IN reactions
+      FILTER mr.matched == true
+      RETURN mr
+    )`);
+    selectObjects.push("matchedReactions:matchedReactions");
+    filters.push("matchedReactions > 0");
+  }
+  sortBy.push("p.added DESC");
+  selectObjects.push("reactions:reactions");
+  const aqlQry = `FOR p, r IN OUTBOUND "${formatSessionId}" hasReactions
+    LET reactions = (
+      FOR reaction, hr IN 1..1 INBOUND p isTagged
+      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)
+      SORT reaction.name
+      RETURN MERGE(reaction, {matched:matched})
+    )
+    ${selectQueries.join("\n")}
+    FILTER ${filters.join(" && ")}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => (0, import_utils2.logError)({
+    action,
+    category: eventCategory,
+    label: "db_error"
+  }, error, context).then(() => []));
+};
+const getPostsByTags = (context, tags = [], options) => {
+  const { database, fields, session: { userId: sessionId } } = context;
+  const { latitude, limit, longitude, type } = parsePostOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+  const formatTagNames = JSON.stringify(tags.map((tag) => (0, import_utils.parseChar)(tag, 32).toLowerCase()));
+  const sortBy = [];
+  const filters = [`p.type == "${type}"`, 'p.privacy == "public"'];
+  const formatLatitude = (0, import_utils.parseNum)(latitude);
+  const formatLongitude = (0, import_utils.parseNum)(longitude);
+  if (formatLatitude && formatLongitude) {
+    selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
+      NOT_NULL(p.latitude, 0),
+      NOT_NULL(p.longitude, 0))
+    `);
+    selectObjects.push("distance:distance");
+    sortBy.push("distance");
+  }
+  if (tags.length) {
+    sortBy.push("matchedTags DESC");
+    selectQueries.push(`LET matchedTags = LENGTH(
+      FOR t IN tags
+      FILTER t.matched == true
+      RETURN t
+    )`);
+    selectObjects.push("matchedTags:matchedTags");
+    filters.push("matchedTags > 0");
+  }
+  sortBy.push("p.added DESC");
+  selectObjects.push("tags:tags");
+  const aqlQry = `FOR p IN posts
+    LET tags = (
+      FOR tag, it IN 1..1 INBOUND p isTagged
+      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)
+      SORT tag.name
+      RETURN MERGE(tag, {matched:matched})
+    )
+    ${selectQueries.join("\n")}
+    FILTER ${filters.join(" && ")}
+    ${limit.aql}
+    SORT ${sortBy.join(", ")}
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(", ")}})`;
+  console.log({ aqlQry, options });
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch(() => []);
+};
+const getPostsByUser = (context, userId, options) => {
+  const { database, fields, session: { userId: sessionId } } = context;
+  const { limit, type } = parsePostOptions(options);
+  const formatUserId = (0, import_utils.parseId)(userId);
+  const { objects: selectObjects, queries: selectQueries } = getPostOptional(fields, sessionId);
+  const aqlQry = `FOR p IN posts
+    FILTER p.userId == "${formatUserId}" && p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join("\n")}
+    ${limit.aql}
+    SORT p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).catch((error) => {
+    throw error;
+  });
+};
+const getPostComments = (context, itemId, options) => {
+  const { database, session: { userId: sessionId } } = context;
+  const { limit, type } = parsePostOptions(options);
+  const formatItemId = (0, import_utils.parseId)(itemId);
+  const db = database;
+  const aqlQry = import_arangojs.aql`FOR p IN posts
+    FILTER p.type == ${type} && p._key == ${formatItemId}
+    LIMIT 1
+    RETURN p`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((post = {}) => {
+    const {
+      _key,
+      groupId,
+      privacy = "public"
+    } = post;
+    let privacyAqlQry;
+    if (groupId && privacy === "group") {
+      privacyAqlQry = `FOR p IN posts
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          FOR group IN groups
+          FILTER group._key == p.groupId
+          FOR u, e IN OUTBOUND group._id isGrouped
+          FILTER u._key == "${sessionId}"
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+    } else if (privacy === "public") {
+      privacyAqlQry = `FOR p IN posts
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+    }
+    if (privacyAqlQry) {
+      return db.query(privacyAqlQry).then((cursor) => cursor.all()).catch((error) => {
+        throw error;
+      });
+    }
+    return [];
+  }).catch((error) => {
+    throw error;
+  });
+};
+const addPost = async (context, post) => {
+  const { database, session: { userId: sessionId } } = context;
+  const {
+    content = "",
+    endDate,
+    groupId = "",
+    location,
+    latitude,
+    longitude,
+    name = "",
+    parentId = null,
+    privacy = "public",
+    tags = [],
+    startDate,
+    type = "default"
+  } = post;
+  const now = Date.now();
+  const insert = {
+    _key: (0, import_utils.createHash)(`post-${sessionId}`),
+    added: now,
+    content: (0, import_utils.parseString)(content, MAX_CONTENT_LENGTH),
+    endDate: endDate ? (0, import_utils.parseNum)(endDate, 13) : void 0,
+    groupId: groupId ? (0, import_utils.parseId)(groupId) : void 0,
+    latitude: latitude !== void 0 ? (0, import_utils.parseNum)(latitude) : void 0,
+    location: location ? (0, import_utils.parseString)(location, 160) : void 0,
+    longitude: longitude !== void 0 ? (0, import_utils.parseNum)(longitude) : void 0,
+    modified: now,
+    name: (0, import_utils.parseString)(name, 160),
+    parentId: parentId ? (0, import_utils.parseId)(parentId) : void 0,
+    privacy: privacy ? (0, import_utils.parseVarChar)(privacy, 16) : void 0,
+    startDate: startDate ? (0, import_utils.parseNum)(startDate, 13) : void 0,
+    type: (0, import_utils.parseChar)(type, 32),
+    userId: sessionId
+  };
+  const db = database;
+  const aqlQry = import_arangojs.aql`INSERT ${insert} IN posts RETURN NEW`;
+  try {
+    const savedPost = await db.query(aqlQry).then((cursor) => cursor.next() || {});
+    const { _id: postDocId } = savedPost;
+    console.log({ tags });
+    if (tags && tags.length) {
+      const tagNames = tags.map(({ name: name2 }) => (0, import_utils.parseChar)(name2, 32));
+      console.log({ tagNames, postDocId });
+      await (0, import_tags.linkTags)(db, tagNames, postDocId);
+    } else {
+      const tagList = await (0, import_tags.extractTags)(db, postDocId, insert.content);
+      savedPost.tags = tagList;
+    }
+    return savedPost;
+  } catch (error) {
+    throw error;
+  }
+};
+const updatePost = async (context, post) => {
+  const { database, session: { userId: sessionId } } = context;
+  const now = Date.now();
+  const {
+    content,
+    endDate,
+    groupId,
+    name,
+    parentId,
+    postId,
+    privacy,
+    startDate,
+    tags = [],
+    type
+  } = post;
+  const update = {
+    content: content ? (0, import_utils.parseString)(content, MAX_CONTENT_LENGTH) : void 0,
+    endDate: endDate ? (0, import_utils.parseNum)(endDate, 13) : void 0,
+    modified: now,
+    name: name ? (0, import_utils.parseString)(name, 160) : void 0,
+    parentId: parentId ? (0, import_utils.parseString)(parentId, 160) : void 0,
+    privacy: privacy ? (0, import_utils.parseVarChar)(privacy, 16) : void 0,
+    startDate: startDate ? (0, import_utils.parseNum)(startDate, 13) : void 0,
+    type: type !== void 0 ? (0, import_utils.parseChar)(type, 16) : void 0
+  };
+  let formatId = (0, import_utils.parseId)(postId);
+  formatId = formatId === "" ? (0, import_utils.createHash)(`post-${sessionId}`) : formatId;
+  const formatGroupId = (0, import_utils.parseId)(groupId);
+  const insert = __spreadProps(__spreadValues({}, update), {
+    _key: formatId,
+    added: now,
+    groupId: formatGroupId,
+    privacy,
+    userId: sessionId
+  });
+  const db = database;
+  const aqlQry = import_arangojs.aql`UPSERT {_key: ${formatId}, userId: ${sessionId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN posts RETURN NEW`;
+  try {
+    const updatedPost = await db.query(aqlQry).then((cursor) => cursor.next() || {});
+    const { _id: updatedPostId } = updatedPost;
+    if (tags && tags.length) {
+      const tagNames = tags.map(({ name: name2 }) => (0, import_utils.parseChar)(name2, 32));
+      const tagQuery = import_arangojs.aql`FOR t IN tags
+        FILTER POSITION(${JSON.stringify(tagNames)}, t.name)
+        RETURN t`;
+      const existingTags = await db.query(tagQuery).then((cursor) => cursor.all());
+      const tagIds = existingTags.map(({ _id: tagId }) => tagId);
+      await (0, import_tags.linkTags)(db, tagIds, updatedPostId);
+    } else {
+      const tagList = await (0, import_tags.extractTags)(db, updatedPostId, update.content || "") || [];
+      updatedPost.tags = tagList;
+    }
+    const files = updatedPost.files || [];
+    if (files.length) {
+      const fileList = await (0, import_files.updateFiles)(db, formatId, files) || [];
+      updatedPost.files = fileList;
+    } else {
+      updatedPost.files = [];
+    }
+    return updatedPost;
+  } catch (error) {
+    throw error;
+  }
+};
+const deletePost = (context, postId) => {
+  const { database, session: { userId: sessionId } } = context;
+  const formatItemId = (0, import_utils.parseId)(postId);
+  const db = database;
+  const aqlQry = import_arangojs.aql`FOR p IN posts
+      FILTER p._key == ${formatItemId} && p.userId == ${sessionId}
+      LIMIT 1
+      REMOVE p IN posts
+      RETURN OLD`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((post = {}) => {
+    if (post) {
+      const edgeAqlQry = import_arangojs.aql`FOR t IN isTagged
+            FILTER t._to == ${formatItemId}
+            REMOVE t IN isTagged`;
+      return db.query(edgeAqlQry).then(() => {
+        const fileAqlQry = import_arangojs.aql`FOR f IN hasFile
+                FILTER f._to == ${formatItemId}
+                REMOVE f IN hasFile`;
+        return db.query(fileAqlQry).then(() => post).catch((error) => {
+          throw error;
+        });
+      }).catch((error) => {
+        throw error;
+      });
+    }
+    return {};
+  }).catch((error) => {
+    throw error;
+  });
+};
+const cleanPosts = (database) => {
+  const aqlQry = import_arangojs.aql`FOR p IN posts
+      FILTER p.added < DATE_TIMESTAMP(DATE_SUBTRACT(DATE_NOW(), 60, 'day')) && p.type == "default"
+      REMOVE p IN posts
+      RETURN OLD`;
+  return database.query(aqlQry).then((cursor) => cursor.all()).then((results = []) => results.length).catch((error) => {
+    throw error;
+  });
+};
+const createPostEdge = (db, file, postId) => {
+  const edgeCollection = db.collection("isPosted");
+  const { fileId } = file;
+  const formatFileId = (0, import_utils.parseId)(fileId);
+  const edgeId = (0, import_utils.createHash)(`file-${postId}-${formatFileId}`);
+  const formatPostId = (0, import_utils.parseId)(postId);
+  const fileType = (0, import_utils.parseChar)(file.fileType, 16);
+  const edge = {
+    _from: `posts/${formatPostId}`,
+    _key: edgeId,
+    _to: `files/${formatFileId}`,
+    added: Date.now(),
+    type: fileType
+  };
+  return edgeCollection.save(edge, { returnNew: true }).then(() => file).catch((error) => {
+    throw error;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPost,
+  cleanPosts,
+  createPostEdge,
+  deletePost,
+  getPost,
+  getPostComments,
+  getPostOptional,
+  getPostsByReactions,
+  getPostsByTags,
+  getPostsByUser,
+  parsePostOptions,
+  updatePost
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/posts.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, parseChar, parseId, parseNum, parseString, parseVarChar} from '@nlabs/utils';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\n\nimport {ApiContext, FileType, PostInputType, PostOptions, PostType, TagType} from '../types';\nimport {getLimit, logError} from '../utils';\nimport {updateFiles} from './files';\nimport {extractTags, linkTags} from './tags';\n\nconst MAX_CONTENT_LENGTH: number = 100000;\nconst eventCategory: string = 'posts';\n\nexport const parsePostOptions = (options: PostOptions = {}) => {\n  const {\n    from = 0,\n    latitude = 0,\n    longitude = 0,\n    to = 30,\n    type = 'post'\n  } = options;\n\n  return {\n    latitude: parseNum(latitude, 32),\n    limit: getLimit(from, to),\n    longitude: parseNum(longitude, 32),\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getPostOptional = (fields: string[], sessionId: string) =>\n  fields.reduce((selects: any, field: string) => {\n    switch(field) {\n      case 'hasRsvp': {\n        selects.queries.push(`LET hasRsvp = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReactions\n          FILTER r.name == \"rsvp\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('hasRsvp:hasRsvp');\n        return selects;\n      }\n      case 'isSaved': {\n        selects.queries.push(`LET isSaved = TO_BOOL(FIRST(\n          FOR post, r IN INBOUND p._id hasReactions\n          FILTER r.name == \"pin\" && r.type == \"posts\" && r._from == \"users/${sessionId}\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        ))`);\n        selects.objects.push('isSaved:isSaved');\n        return selects;\n      }\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR post, r IN INBOUND p._id hasReactions\n          COLLECT reactionName = r.value INTO reactionItems\n          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n        )`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'rsvpCount': {\n        selects.queries.push(`LET rsvpCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReactions\n          FILTER r.name == \"rsvp\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('rsvpCount:rsvpCount');\n        return selects;\n      }\n      case 'viewCount': {\n        selects.queries.push(`LET viewCount = FIRST(\n          FOR post, r IN INBOUND p._id hasReactions\n          FILTER r.name == \"view\" && r.type == \"posts\"\n          COLLECT WITH COUNT INTO count\n          RETURN count\n        )`);\n        selects.objects.push('viewCount:viewCount');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getPost = (context: ApiContext, itemId: string, options: PostOptions): Promise<Partial<PostType>> => {\n  const action: string = 'getPost';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const formatItemId: string = parseId(itemId);\n  const {type} = parsePostOptions(options);\n  const db = database;\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p._key == ${formatItemId} && p.type == ${type}\n    LIMIT 1\n    RETURN p`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((post: PostType = {}) => {\n      const {\n        _id: postDocId,\n        groupId,\n        privacy = 'default'\n      }: PostType = post;\n\n      // Query based on privacy level\n      let privacyAqlQry: string;\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id isGrouped\n          FILTER u._key == \"${sessionId}\"\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `LET p = DOCUMENT(\"${postDocId}\")\n          ${selectQueries.join('\\n')}\n          LIMIT 1\n          RETURN MERGE(p, {${selectObjects.join(', ')}})`;\n      }\n\n      if(privacyAqlQry) {\n        return db.query(privacyAqlQry)\n          .then((cursor: ArrayCursor) => cursor.next() || {})\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            label: 'db_error'\n          }, error, context).then(() => ({})));\n      }\n\n      return {};\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: 'db_error'\n    }, error, context).then(() => ({})));\n};\n\n// export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n//   // const action: string = 'getListByApp';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   console.log('getPostList::context', context);\n//   const {limit, type} = parsePostOptions(options);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   const aqlQry: string = `FOR p IN posts\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n//     ${selectQueries.join('\\n')}\n//     ${limit.aql}\n//     SORT p.added\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   return database.query(aqlQry)\n//     .then((cursor: ArrayCursor) => cursor.all())\n//     .catch((error: Error) => {\n//       console.log('getPostList::error', error);\n//       throw error;\n//     });\n// };\n\n// export const getPostsByArea = (\n//   context: ApiContext,\n//   latitude: number,\n//   longitude: number,\n//   options?: PostOptions\n// ): Promise<PostType[]> => {\n//   // const action: string = 'getListByUser';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {limit, type} = parsePostOptions(options);\n//   const formatLatitude: number = parseNum(latitude);\n//   const formatLongitude: number = parseNum(longitude);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   selectQueries.push(`LET distance = DISTANCE(\n//     ${formatLatitude},\n//     ${formatLongitude},\n//     NOT_NULL(p.latitude, 0),\n//     NOT_NULL(p.longitude, 0))\n//   `);\n//   selectObjects.push('distance:distance');\n\n//   const aqlQry: string = `FOR p IN posts\n//     ${selectQueries.join('\\n')}\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parentId == null\n//     ${limit.aql}\n//     SORT distance, p.added\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   return database.query(aqlQry)\n//     .then((cursor: ArrayCursor) => cursor.all())\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\n// export const getPostsByGroup = (\n//   context: ApiContext,\n//   groupId: string,\n//   options?: PostOptions\n// ): Promise<PostType[]> => {\n//   // const action: string = 'getListByGroup';\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n\n//   // Group id\n//   const formatGroupId: string = parseId(groupId);\n//   const db = database;\n//   const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup\n//       FILTER u._key == ${sessionId}\n//       RETURN g`;\n\n//   return db.query(aqlQry)\n//     .then((cursor: ArrayCursor) => cursor.all())\n//     .then((groups: GroupType[] = []) => {\n//       if(groups.length) {\n//         const {limit, type} = parsePostOptions(options);\n//         const postAqlQry: string = `FOR p IN posts\n//           FILTER p.type == \"${type}\" && p.groupId == \"${formatGroupId}\" && p.parent == null\n//           ${selectQueries.join('\\n')}\n//           ${limit.aql}\n//           SORT p.added\n//           RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//         return db.query(postAqlQry)\n//           .then((cursor: ArrayCursor) => cursor.all())\n//           .catch((error: Error) => {\n//             throw error;\n//           });\n//       }\n\n//       return [];\n//     })\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\n// export const getPostsByLatest = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {\n//   // const action: string = 'getListByLatest';\n//   console.log('getPostsByLatest::options', options);\n//   const {database, fields, session: {userId: sessionId}} = context;\n//   const {limit, type} = parsePostOptions(options);\n//   const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n//   const aqlQry: string = `FOR p IN posts\n//     FILTER p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n//     ${selectQueries.join('\\n')}\n//     ${limit.aql}\n//     SORT p.added DESC\n//     RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n//   console.log('getPostsByLatest::aqlQry', aqlQry);\n//   return database.query(aqlQry)\n//     .then((cursor: ArrayCursor) => cursor.all())\n//     .catch((error: Error) => {\n//       throw error;\n//     });\n// };\n\nexport const getPostsByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  const action: string = 'getPostsByReactions';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string = JSON.stringify(reactions.map((reaction) => parseChar(reaction, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(reactions.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedReactions = LENGTH(\n      FOR mr IN reactions\n      FILTER mr.matched == true\n      RETURN mr\n    )`);\n    selectObjects.push('matchedReactions:matchedReactions');\n    filters.push('matchedReactions > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('reactions:reactions');\n\n  // Get data from database\n  const aqlQry: string = `FOR p, r IN OUTBOUND \"${formatSessionId}\" hasReactions\n    LET reactions = (\n      FOR reaction, hr IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatReactions}) > 0 && POSITION(${formatReactions}, reaction.name)\n      SORT reaction.name\n      RETURN MERGE(reaction, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\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 getPostsByTags = (\n  context: ApiContext,\n  tags: string[] = [],\n  options?: PostOptions\n): Promise<PostType[]> => {\n  // const action: string = 'getListByTags';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const {latitude, limit, longitude, type} = parsePostOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const formatTagNames: string = JSON.stringify(tags.map((tag) => parseChar(tag, 32).toLowerCase()));\n  const sortBy: string[] = [];\n  const filters: string[] = [`p.type == \"${type}\"`, 'p.privacy == \"public\"'];\n  const formatLatitude: number = parseNum(latitude);\n  const formatLongitude: number = parseNum(longitude);\n\n  if(formatLatitude && formatLongitude) {\n    selectQueries.push(`LET distance = DISTANCE(\n      ${formatLatitude},\n      ${formatLongitude},\n      NOT_NULL(p.latitude, 0),\n      NOT_NULL(p.longitude, 0))\n    `);\n    selectObjects.push('distance:distance');\n    sortBy.push('distance');\n  }\n\n  if(tags.length) {\n    sortBy.push('matchedTags DESC');\n    selectQueries.push(`LET matchedTags = LENGTH(\n      FOR t IN tags\n      FILTER t.matched == true\n      RETURN t\n    )`);\n    selectObjects.push('matchedTags:matchedTags');\n    filters.push('matchedTags > 0');\n  }\n\n  sortBy.push('p.added DESC');\n  selectObjects.push('tags:tags');\n\n  const aqlQry: string = `FOR p IN posts\n    LET tags = (\n      FOR tag, it IN 1..1 INBOUND p isTagged\n      LET matched = LENGTH(${formatTagNames}) > 0 && POSITION(${formatTagNames}, tag.name)\n      SORT tag.name\n      RETURN MERGE(tag, {matched:matched})\n    )\n    ${selectQueries.join('\\n')}\n    FILTER ${filters.join(' && ')}\n    ${limit.aql}\n    SORT ${sortBy.join(', ')}\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  console.log({aqlQry, options});\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch(() => []);\n};\n\nexport const getPostsByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {\n  // const action: string = 'getListByUser';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatUserId: string = parseId(userId);\n  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields, sessionId);\n  const aqlQry: string = `FOR p IN posts\n    FILTER p.userId == \"${formatUserId}\" && p.type == \"${type}\" && p.privacy == \"public\" && p.parent == null\n    ${selectQueries.join('\\n')}\n    ${limit.aql}\n    SORT p.added\n    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getPostComments = (context: ApiContext, itemId: string, options?: PostOptions): Promise<PostType[]> => {\n  // const action: string = 'getComments';\n  const {database, session: {userId: sessionId}} = context;\n  const {limit, type} = parsePostOptions(options);\n  const formatItemId: string = parseId(itemId);\n\n  // Get the parent post to get restrictions\n  const db = database;\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n    FILTER p.type == ${type} && p._key == ${formatItemId}\n    LIMIT 1\n    RETURN p`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((post: PostType = {}) => {\n      const {\n        _key,\n        groupId,\n        privacy = 'public'\n      }: PostType = post;\n\n      // Query based on privacy level\n      let privacyAqlQry: string;\n\n      if(groupId && privacy === 'group') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          FOR group IN groups\n          FILTER group._key == p.groupId\n          FOR u, e IN OUTBOUND group._id isGrouped\n          FILTER u._key == \"${sessionId}\"\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      } else if(privacy === 'public') {\n        privacyAqlQry = `FOR p IN posts\n          FOR user IN users\n          FILTER p.parent == \"${_key}\" && user._key == p.userId\n          LET reactions = (\n            FOR post, r IN INBOUND p._id reactions\n            COLLECT reactionName = r.value INTO reactionItems\n            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n          )\n          SORT p.added\n          ${limit.aql}\n          RETURN MERGE(p, {user: user, reactions: reactions})`;\n      }\n\n      if(privacyAqlQry) {\n        return db.query(privacyAqlQry)\n          .then((cursor: ArrayCursor) => cursor.all())\n          .catch((error: Error) => {\n            throw error;\n          });\n      }\n\n      return [];\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const addPost = async (context: ApiContext, post: PostInputType): Promise<PostType> => {\n  // const action: string = 'add';\n  const {database, session: {userId: sessionId}} = context;\n\n  const {\n    content = '',\n    endDate,\n    groupId = '',\n    location,\n    latitude,\n    longitude,\n    name = '',\n    parentId = null,\n    privacy = 'public',\n    tags = [],\n    startDate,\n    type = 'default'\n  } = post;\n\n  const now: number = Date.now();\n\n  const insert: PostType = {\n    _key: createHash(`post-${sessionId}`),\n    added: now,\n    content: parseString(content, MAX_CONTENT_LENGTH),\n    endDate: endDate ? parseNum(endDate, 13) : undefined,\n    groupId: groupId ? parseId(groupId) : undefined,\n    latitude: latitude !== undefined ? parseNum(latitude) : undefined,\n    location: location ? parseString(location, 160) : undefined,\n    longitude: longitude !== undefined ? parseNum(longitude) : undefined,\n    modified: now,\n    name: parseString(name, 160),\n    parentId: parentId ? parseId(parentId) : undefined,\n    privacy: privacy ? parseVarChar(privacy, 16) : undefined,\n    startDate: startDate ? parseNum(startDate, 13) : undefined,\n    type: parseChar(type, 32),\n    userId: sessionId\n  };\n\n  const db: Database = database;\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;\n\n  try {\n    const savedPost: PostType = await db.query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next() || {});\n\n    const {_id: postDocId} = savedPost;\n\n    console.log({tags});\n    if(tags && tags.length) {\n      const tagNames: string[] = tags.map(({name}) => parseChar(name, 32));\n      console.log({tagNames, postDocId});\n      await linkTags(db, tagNames, postDocId);\n    } else {\n      // Update linked tags within posts\n      const tagList: TagType[] = await extractTags(db, postDocId, insert.content);\n      savedPost.tags = tagList;\n    }\n\n    return savedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const updatePost = async (context: ApiContext, post: PostInputType): Promise<PostType> => {\n  // const action: string = 'update';\n  const {database, session: {userId: sessionId}} = context;\n  const now: number = Date.now();\n  const {\n    content,\n    endDate,\n    groupId,\n    name,\n    parentId,\n    postId,\n    privacy,\n    startDate,\n    tags = [],\n    type\n  } = post;\n\n  const update: PostType = {\n    content: content ? parseString(content, MAX_CONTENT_LENGTH) : undefined,\n    endDate: endDate ? parseNum(endDate, 13) : undefined,\n    modified: now,\n    name: name ? parseString(name, 160) : undefined,\n    parentId: parentId ? parseString(parentId, 160) : undefined,\n    privacy: privacy ? parseVarChar(privacy, 16) : undefined,\n    startDate: startDate ? parseNum(startDate, 13) : undefined,\n    type: type !== undefined ? parseChar(type, 16) : undefined\n  };\n\n  let formatId: string = parseId(postId);\n  formatId = formatId === '' ? createHash(`post-${sessionId}`) : formatId;\n  const formatGroupId: string = parseId(groupId);\n  const insert: any = {\n    ...update,\n    _key: formatId,\n    added: now,\n    groupId: formatGroupId,\n    privacy,\n    userId: sessionId\n  };\n  const db: Database = database;\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${formatId}, userId: ${sessionId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN posts RETURN NEW`;\n\n  try {\n    const updatedPost: PostType = await db.query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next() || {});\n\n    const {_id: updatedPostId} = updatedPost;\n\n    if(tags && tags.length) {\n      const tagNames: string[] = tags.map(({name}) => parseChar(name, 32));\n      const tagQuery: AqlQuery = aql`FOR t IN tags\n        FILTER POSITION(${JSON.stringify(tagNames)}, t.name)\n        RETURN t`;\n\n      const existingTags = await db.query(tagQuery).then((cursor: ArrayCursor) => cursor.all());\n      const tagIds: string[] = existingTags.map(({_id: tagId}) => tagId);\n      await linkTags(db, tagIds, updatedPostId);\n    } else {\n      // Update linked tags\n      const tagList = await extractTags(db, updatedPostId, update.content || '') || [];\n      updatedPost.tags = tagList;\n    }\n\n    // Update linked files\n    const files: FileType[] = updatedPost.files || [];\n\n    if(files.length) {\n      const fileList = await updateFiles(db, formatId, files) || [];\n      updatedPost.files = fileList;\n    } else {\n      updatedPost.files = [];\n    }\n\n    return updatedPost;\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport const deletePost = (context: ApiContext, postId: string): Promise<PostType> => {\n  // const action: string = 'delete';\n  const {database, session: {userId: sessionId}} = context;\n  const formatItemId: string = parseId(postId);\n  const db: Database = database;\n  const aqlQry = aql`FOR p IN posts\n      FILTER p._key == ${formatItemId} && p.userId == ${sessionId}\n      LIMIT 1\n      REMOVE p IN posts\n      RETURN OLD`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((post: PostType = {}) => {\n      if(post) {\n        // Remove tag links\n        const edgeAqlQry: AqlQuery = aql`FOR t IN isTagged\n            FILTER t._to == ${formatItemId}\n            REMOVE t IN isTagged`;\n\n        return db.query(edgeAqlQry)\n          .then(() => {\n            // Remove attached files\n            const fileAqlQry: AqlQuery = aql`FOR f IN hasFile\n                FILTER f._to == ${formatItemId}\n                REMOVE f IN hasFile`;\n\n            return db.query(fileAqlQry)\n              .then(() => post)\n              .catch((error: Error) => {\n                throw error;\n              });\n          })\n          .catch((error: Error) => {\n            throw error;\n          });\n      }\n      return {};\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const cleanPosts = (database: Database): Promise<number> => {\n  // Remove all messages that are over 60 days and not saved\n  const aqlQry: AqlQuery = aql`FOR p IN posts\n      FILTER p.added < DATE_TIMESTAMP(DATE_SUBTRACT(DATE_NOW(), 60, 'day')) && p.type == \"default\"\n      REMOVE p IN posts\n      RETURN OLD`;\n\n  return database.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.all())\n    .then((results: PostType[] = []) => results.length)\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const createPostEdge = (db: Database, file: FileType, postId: string): Promise<FileType> => {\n  const edgeCollection: EdgeCollection = db.collection('isPosted');\n  const {fileId} = file;\n  const formatFileId: string = parseId(fileId);\n  const edgeId: string = createHash(`file-${postId}-${formatFileId}`);\n  const formatPostId: string = parseId(postId);\n  const fileType: string = parseChar(file.fileType, 16);\n\n  const edge: any = {\n    _from: `posts/${formatPostId}`,\n    _key: edgeId,\n    _to: `files/${formatFileId}`,\n    added: Date.now(),\n    type: fileType\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .then(() => file)\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n"],
  "mappings": "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",
  "names": []
}
