@nlabs/reaktor 0.1.0

package/src/data/posts.ts

@@ -0,0 +1,508 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import {createHash, parseChar, parseId, parseString, parseVarChar} from '@nlabs/utils';
+import {aql, Database} from 'arangojs';
+import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+
+import {ApiContext, ArangoDBLimit, FileType, GroupType, PostType, TagType} from '../types';
+import {getLimit, useDb} from '../utils';
+import {updateFiles} from './files';
+import {extractTags} from './tags';
+
+// const eventCategory: string = 'posts';
+
+export const getPostList = (context: ApiContext, from: number, to: number): Promise<PostType[]> => {
+  // const action: string = 'getListByApp';
+  const {database} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR p IN posts
+      FILTER !!p.parent == false
+      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 u IN users
+      FILTER p.userId == u._key
+      ${limit.aql}
+      SORT p.added
+      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostListByGroup = (context: ApiContext, groupId: string, from: number, to: number): Promise<PostType[]> => {
+  // const action: string = 'getListByGroup';
+  const {database, userId: sessionId} = context;
+
+  // Group id
+  const formatGroupId: string = parseId(groupId);
+  const db = useDb(database);
+  const aqlQry: string = `FOR u, g IN INBOUND ${formatGroupId} hasGroup
+      FILTER u._key == ${sessionId}
+      RETURN g`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .then((groups: GroupType[] = []) => {
+      if(groups.length) {
+        const limit: ArangoDBLimit = getLimit(from, to);
+        const postAqlQry: string = `FOR p IN posts
+            FILTER p.groupId == "${formatGroupId}" && !!p.parent == false
+            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 u IN users
+            FILTER p.userId == u._key
+            ${limit.aql}
+            SORT p.added
+            RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+
+        return db.query(postAqlQry)
+          .then((cursor: ArrayCursor) => cursor.all())
+          .catch((error: Error) => {
+            throw error;
+          });
+      }
+
+      return [];
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostListByLatest = (context: ApiContext, from: number, to: number): Promise<PostType[]> => {
+  // const action: string = 'getListByLatest';
+  const {database} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR p IN posts
+      FILTER p.privacy == "public" && !!p.parent == false
+      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 u IN users
+      FILTER p.userId == u._key
+      ${limit.aql}
+      SORT p.added
+      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostListByTags = (context: ApiContext, tagNames: string[], from?: number, to?: number): Promise<PostType[]> => {
+  // const action: string = 'getListByTags';
+  const {database} = context;
+
+  return Promise.all(
+    tagNames.map((tagName: string) => {
+      const formatTagId: string = createHash(`tag-${tagName}`, null);
+      const limit: ArangoDBLimit = getLimit(from, to);
+      const aqlQry: string = `FOR p, e IN OUTBOUND "${`tags/${formatTagId}`}" isTagged
+          FOR u IN users
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          FILTER e.type == 'posts' && p.userId == u._key
+          ${limit.aql}
+          SORT p.added
+          RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+
+      return useDb(database).query(aqlQry)
+        .then((cursor: ArrayCursor) => cursor.all())
+        .catch((error: Error) => {
+          throw error;
+        });
+    }))
+    .then((results) => uniqBy(flatten(results), '_key'))
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostListByUser = (context: ApiContext, userId: string, from: number, to: number): Promise<PostType[]> => {
+  // const action: string = 'getListByUser';
+  const {database} = context;
+  const formatUserId: string = parseId(userId);
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR p IN posts
+      FILTER p.userId == "${formatUserId}" && !!p.parent == false
+      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 u IN users
+      FILTER p.userId == u._key
+      ${limit.aql}
+      SORT p.added
+      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPost = (context: ApiContext, itemId: string): Promise<PostType> => {
+  // const action: string = 'getItem';
+  const {database, userId: sessionId} = context;
+  const formatItemId: string = parseId(itemId);
+  const db = useDb(database);
+  const aqlQry: AqlQuery = aql`FOR p IN posts
+      FILTER p._key == ${formatItemId}
+      LIMIT 1
+      RETURN p`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((post: PostType = {}) => {
+      const {
+        _key,
+        groupId,
+        privacy = 'default'
+      }: PostType = post;
+
+      // Query based on privacy level
+      let privacyAqlQry: AqlQuery;
+
+      if(groupId && privacy === 'group') {
+        privacyAqlQry = aql`FOR p IN posts
+          FOR user IN users
+          FILTER p._key == ${_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}
+          LIMIT 1
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+      } else if(privacy === 'public') {
+        privacyAqlQry = aql`FOR p IN posts
+          FOR user IN users
+          FILTER p._key == ${_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)}
+          )
+          LIMIT 1
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
+      }
+
+      if(privacyAqlQry) {
+        return db.query(privacyAqlQry)
+          .then((cursor: ArrayCursor) => cursor.next())
+          .then((filteredPost: PostType = {}) => filteredPost)
+          .catch((error: Error) => {
+            throw error;
+          });
+      }
+
+      return {};
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostComments = (context: ApiContext, itemId: string, from: number, to: number): Promise<PostType[]> => {
+  // const action: string = 'getComments';
+  const {database, userId: sessionId} = context;
+  const formatItemId: string = parseId(itemId);
+
+  // Get the parent post to get restrictions
+  const db = useDb(database);
+  const aqlQry: AqlQuery = aql`FOR p IN posts
+      FILTER p._key == ${formatItemId}
+      LIMIT 1
+      RETURN p`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((post: PostType = {}) => {
+      const {
+        _key,
+        groupId,
+        privacy = 'public'
+      }: PostType = post;
+
+      // Query based on privacy level
+      let privacyAqlQry: string;
+      const limit = getLimit(from, to);
+
+      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: ArrayCursor) => cursor.all())
+          .catch((error: Error) => {
+            throw error;
+          });
+      }
+
+      return [];
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const addPost = (context: ApiContext, item: PostType): Promise<PostType> => {
+  // const action: string = 'add';
+  const {database, userId: sessionId} = context;
+
+  const {
+    groupId = '',
+    name = '',
+    parentId = '',
+    privacy = 'public',
+    text = '',
+    title = ''
+  }: PostType = item;
+
+  const now: number = Date.now();
+
+  const insert: PostType = {
+    _key: createHash(`post-${sessionId}`),
+    added: now,
+    groupId: parseId(groupId),
+    modified: now,
+    name: parseString(name, 160),
+    parentId: parseId(parentId),
+    privacy: parseVarChar(privacy, 16),
+    text: parseString(text, 20000),
+    title: parseString(title, 160),
+    userId: sessionId
+  };
+  const db: Database = useDb(database);
+  const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((post: PostType = {}) => {
+      const {_key: postKey} = post;
+
+      // Update linked tags within posts
+      return extractTags(db, 'posts', postKey, insert.text)
+        .then((tagList: TagType[]) => {
+          post.tags = tagList;
+          return post;
+        });
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const updatePost = (context: ApiContext, item: PostType): Promise<PostType> => {
+  // const action: string = 'update';
+  const {database, userId: sessionId} = context;
+  const now: number = Date.now();
+  const {
+    groupId,
+    id,
+    name,
+    parentId,
+    privacy,
+    text
+  }: PostType = item;
+
+  const updatedPost: PostType = {
+    modified: now
+  };
+
+  if(name) {
+    updatedPost.name = parseString(name, 160);
+  }
+
+  if(text) {
+    updatedPost.text = parseString(text, 640);
+  }
+
+  if(privacy) {
+    updatedPost.privacy = parseVarChar(privacy, 16);
+  }
+
+  if(parent) {
+    updatedPost.parentId = parseId(parentId);
+  }
+  const update: any = updatedPost;
+
+  let formatId: string = parseId(id);
+  formatId = formatId === '' ? createHash(`post-${sessionId}`) : formatId;
+  const formatGroupId: string = parseId(groupId);
+  const insert: any = {
+    ...update,
+    _key: formatId,
+    added: now,
+    groupId: formatGroupId,
+    privacy,
+    userId: sessionId
+  };
+  const db: Database = useDb(database);
+  const aqlQry: AqlQuery = aql`UPSERT {_key: ${id}, userId: ${sessionId}}
+      INSERT ${insert}
+      UPDATE ${update}
+      IN posts RETURN NEW`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((updatedPost: PostType = {}) => {
+      const {_key: updatedPostKey} = updatedPost;
+
+      // Update linked tags
+      return extractTags(db, 'posts', updatedPostKey, update.text || '')
+        .then((tagList = []) => {
+          updatedPost.tags = tagList;
+
+          // Update linked files
+          const files: FileType[] = updatedPost.files || [];
+
+          if(files.length) {
+            return updateFiles(db, id, files)
+              .then((fileList = []) => {
+                updatedPost.files = fileList;
+                return updatedPost;
+              });
+          }
+
+          updatedPost.files = [];
+          return updatedPost;
+        });
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const deletePost = (context: ApiContext, itemId: string): Promise<PostType> => {
+  // const action: string = 'delete';
+  const {database, userId: sessionId} = context;
+  const formatItemId: string = parseId(itemId);
+  const db: Database = useDb(database);
+  const aqlQry = 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: ArrayCursor) => cursor.next())
+    .then((post: PostType = {}) => {
+      if(post) {
+        // Remove tag links
+        const edgeAqlQry: AqlQuery = aql`FOR t IN isTagged
+            FILTER t._to == ${formatItemId}
+            REMOVE t IN isTagged`;
+
+        return db.query(edgeAqlQry)
+          .then(() => {
+            // Remove attached files
+            const fileAqlQry: AqlQuery = aql`FOR f IN hasFile
+                FILTER f._to == ${formatItemId}
+                REMOVE f IN hasFile`;
+
+            return db.query(fileAqlQry)
+              .then(() => post)
+              .catch((error: Error) => {
+                throw error;
+              });
+          })
+          .catch((error: Error) => {
+            throw error;
+          });
+      }
+      return {};
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const cleanPosts = (database: string): Promise<number> => {
+  // Remove all messages that are over 60 days and not saved
+  const aqlQry: AqlQuery = aql`FOR p IN posts
+      FILTER p.added < DATE_TIMESTAMP(DATE_SUBTRACT(DATE_NOW(), 60, 'day')) && p.type == 1
+      REMOVE p IN posts
+      RETURN OLD`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .then((results: PostType[] = []) => results.length)
+    .catch((error: Error) => {
+      throw error;
+    });
+}
+
+export const createPostEdge = (db: Database, file: FileType, postId: string): Promise<FileType> => {
+  const edgeCollection = db.edgeCollection('isPosted');
+  const fileId: string = parseId(file.id);
+  const edgeId: string = createHash(`file-${postId}-${fileId}`);
+  const formatPostId: string = parseId(postId);
+  const fileType: string = parseChar(file.fileType, 16);
+
+  const edge: any = {
+    _key: edgeId,
+    added: Date.now(),
+    type: fileType
+  };
+
+  return edgeCollection.save(edge, `posts/${formatPostId}`, `files/${fileId}`)
+    .then(() => file)
+    .catch((error: Error) => {
+      throw error;
+    });
+};

package/src/data/reactions.ts

@@ -0,0 +1,186 @@
+import {createHash, parseChar, parseId, parseNum} from '@nlabs/utils';
+import {aql, Database, EdgeCollection} from 'arangojs';
+import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+
+import {ApiContext, QueryFilter, ReactionType, UserReactionQuery, UserReactionType, UserType} from '../types';
+import {logError, logException, useDb} from '../utils';
+
+const eventCategory: string = 'reactions';
+
+export const addGroupReaction = (context: ApiContext, params: UserReactionType = {}): Promise<boolean> => {
+  const action: string = 'reaction';
+  const {database, userId: sessionId} = context;
+
+  if(!sessionId) {
+    return logException({
+      action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(() => null);
+  }
+
+  const {id: itemId, value: itemValue = 'like'} = params;
+  const formatItemId: string = parseId(itemId);
+  const formatValue: string = parseChar(itemValue, 32);
+  const edgeCollection = useDb(database).edgeCollection('hasReaction');
+
+  // Remove existing likes
+  const groupDocId: string = `groups/${formatItemId}`;
+  const userDocId: string = `users/${sessionId}`;
+  const edgeId: string = createHash(`reaction-${formatItemId}-${sessionId}`);
+  const edge: any = {
+    _key: edgeId,
+    added: Date.now(),
+    type: 'group',
+    value: formatValue
+  };
+
+  return edgeCollection.save(edge, userDocId, groupDocId).then(() => true);
+};
+
+export const getGroupReactions = (context: ApiContext, params: UserReactionType = {}): Promise<UserReactionType> => {
+  const action: string = 'getReactions';
+  const {database} = context;
+  const {id: groupId}: UserReactionType = params;
+  const groupDocId: string = `groups/${parseId(groupId)}`;
+
+  // Query
+  const aqlQry: AqlQuery = aql`FOR g, r IN INBOUND ${groupDocId} hasReaction
+      COLLECT reactionName = r.value INTO reactionItems
+      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getReactionsByUser = (context: ApiContext, groupId: string): Promise<UserReactionType[]> => {
+  const action: string = 'getReactionsByUser';
+  const {database, userId: sessionId} = context;
+  const groupDocId: string = `groups/${parseId(groupId)}`;
+  const userDocId: string = `users/${sessionId}`;
+
+  // Query
+  const aqlQry: AqlQuery = aql`FOR g, r IN INBOUND ${groupDocId} hasReaction
+      FILTER r._from == ${userDocId}
+      COLLECT reactionName = r.value INTO reactionItems
+      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getUsersByReaction = (context: ApiContext, params: UserReactionQuery = {}): Promise<UserType[]> => {
+  const action: string = 'getUsersByReaction';
+  const {database, userId: sessionId} = context;
+
+  if(!sessionId) {
+    return logException({
+      action,
+      category: eventCategory,
+      label: 'unauthorized',
+      value: 'invalid_session'
+    }, context).then(() => null);
+  }
+
+  const {filters = [], id: groupId, value}: UserReactionQuery = params;
+  const reaction = parseChar(value, 32);
+  const groupDocId = `groups/${parseId(groupId)}`;
+  const filterStr: string = filters
+    .map((filter: QueryFilter) => {
+      const {conditional, name, value: queryValue}: QueryFilter = filter;
+      let filterCond: string = conditional;
+
+      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {
+        filterCond = '==';
+      }
+
+      switch(name) {
+        case 'added':
+          return `r.added ${filterCond} ${parseNum(queryValue)}`;
+        default:
+          return '';
+      }
+    })
+    .concat([
+      `r.value == "${reaction}"`,
+      'u._id == r._from'
+    ])
+    .join(' && ');
+
+  // Query
+  const aqlQry: string = `FOR g, r IN INBOUND "${groupDocId}" hasReaction
+      FOR u IN users
+      FILTER  ${filterStr}
+      RETURN u`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+
+export const postReaction = (context: ApiContext, postId: string, type: string = 'like'): Promise<ReactionType> => {
+  const {database, userId: sessionId} = context;
+  const formatItemId: string = parseId(postId);
+  const db: Database = useDb(database);
+  const edgeCollection: EdgeCollection = db.edgeCollection('reactions');
+  const now: number = Date.now();
+
+  // Remove existing reaction to post
+  const postDocId: string = `posts/${formatItemId}`;
+  const userDocId: string = `users/${sessionId}`;
+  const aqlQry: AqlQuery = aql`FOR p, r IN INBOUND ${postDocId} reaction
+    FILTER r.type == "posts" && r._from == ${userDocId}
+    REMOVE r IN reactions
+    RETURN r`;
+
+  return db.query(aqlQry)
+    .then(() => {
+      const edgeId = createHash(`reaction-${postId}-${sessionId}`);
+      const edge: any = {
+        _key: edgeId,
+        added: now,
+        type: 'posts',
+        value: type
+      };
+
+      return edgeCollection.save(edge, userDocId, postDocId)
+        .then(() => {
+          const reactionAqlQry: AqlQuery = aql`LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {id: p._id, type: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          RETURN reactions`;
+
+          return db.query(reactionAqlQry)
+            .then((cursor: ArrayCursor) => cursor.next())
+            .then((result = {reactions: []}) => result)
+            .catch((error: Error) => {
+              throw error;
+            });
+        })
+        .catch((error: Error) => {
+          throw error;
+        });
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};