@nlabs/reaktor 0.1.2 → 0.1.3

package/src/data/posts.ts

@@ -1,580 +0,0 @@
-/**
- * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
- * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
- */
-import {createHash, parseChar, parseId, parseNum, 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, FileType, GroupType, PostOptions, PostType, TagType} from '../types';
-import {getLimit, useDb} from '../utils';
-import {updateFiles} from './files';
-import {extractTags} from './tags';
-
-// const eventCategory: string = 'posts';
-const MAX_CONTENT_LENGTH: number = 100000;
-
-export const parsePostOptions = (options: PostOptions = {}) => {
-  const {
-    from = 0,
-    latitude,
-    longitude,
-    to = 30,
-    type = 'default'
-  } = options;
-
-
-  return {
-    latitude: parseNum(latitude, 32),
-    longitude: parseNum(longitude, 32),
-    limit: getLimit(from, to),
-    type: parseChar(type, 32)
-  };
-};
-
-export const getPostOptional = (fields: string[]) =>
-  fields.reduce((selects: any, field: string) => {
-    switch(field) {
-      case 'reactions': {
-        selects.queries.push(`LET reactions = (
-          FOR post, r IN INBOUND p._id reactions
-          COLLECT reactionName = r.value INTO reactionItems
-          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-        )`);
-        selects.objects.push('reactions:reactions');
-        return selects;
-      }
-      case 'tags': {
-        selects.queries.push(`LET tags = (
-          FOR t, pl IN INBOUND p._id isTagged
-          RETURN t
-        )`);
-        selects.objects.push('tags:tags');
-        return selects;
-      }
-      case 'user': {
-        selects.queries.push(`LET user = FIRST(
-          FOR u IN users
-          FILTER p.userId == u._key
-          LIMIT 1
-          RETURN u
-        )`);
-        selects.objects.push('user:user');
-        return selects;
-      }
-      default: {
-        return selects;
-      }
-    }
-  }, {objects: [], queries: []});
-
-export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {
-  // const action: string = 'getListByApp';
-  const {database, fields} = context;
-  const {limit, type} = parsePostOptions(options);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  const aqlQry: string = `FOR p IN posts
-    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
-    ${selectQueries.join('\n')}
-    ${limit.aql}
-    SORT p.added
-    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => {
-      throw error;
-    });
-};
-
-export const getPostListByGroup = (context: ApiContext, groupId: string, options?: PostOptions): Promise<PostType[]> => {
-  // const action: string = 'getListByGroup';
-  const {database, fields, userId: sessionId} = context;
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-
-  // 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, type} = parsePostOptions(options);
-        const postAqlQry: string = `FOR p IN posts
-          FILTER p.type == "${type}" && p.groupId == "${formatGroupId}" && p.parent == null
-          ${selectQueries.join('\n')}
-          ${limit.aql}
-          SORT p.added
-          RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
-
-        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, options?: PostOptions): Promise<PostType[]> => {
-  // const action: string = 'getListByLatest';
-  const {database, fields} = context;
-  const {limit, type} = parsePostOptions(options);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  const aqlQry: string = `FOR p IN posts
-    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
-    ${selectQueries.join('\n')}
-    ${limit.aql}
-    SORT p.added
-    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => {
-      throw error;
-    });
-};
-
-export const getPostListByTags = (
-  context: ApiContext,
-  tagNames: string[],
-  options?: PostOptions
-): Promise<PostType[]> => {
-  // const action: string = 'getListByTags';
-  const {database, fields} = context;
-  const {latitude, longitude, limit, type} = parsePostOptions(options);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  const sortBy: string[] = [];
-
-  if(latitude !== undefined && longitude !== undefined) {
-    const formatLatitude: number = parseNum(latitude);
-    const formatLongitude: number = parseNum(longitude);
-    selectQueries.push(`LET distance = DISTANCE(
-      ${formatLatitude},
-      ${formatLongitude},
-      NOT_NULL(p.latitude, 0),
-      NOT_NULL(p.longitude, 0))
-    `);
-    selectObjects.push('distance:distance');
-    sortBy.push('distance');
-  }
-
-  sortBy.push('p.added');
-
-  return Promise.all(
-    tagNames.map((tagName: string) => {
-      const aqlQry: string = `FOR targetTag IN tags
-        FILTER targetTag.name == "${tagName}"
-        FOR p, e IN OUTBOUND targetTag._id isTagged
-        ${selectQueries.join('\n')}
-        FILTER p.type = "${type}" && p.privacy == "public" && e.type == 'posts'
-        ${limit.aql}
-        SORT ${sortBy.join(', ')}
-        RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
-
-      console.log(aqlQry);
-      return useDb(database).query(aqlQry)
-        .then((cursor: ArrayCursor) => cursor.all())
-        .catch(() => []);
-    }))
-    .then((results) => uniqBy(flatten(results), '_key'))
-    .catch((error: Error) => {
-      throw error;
-    });
-};
-
-export const getPostListByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {
-  // const action: string = 'getListByUser';
-  const {database, fields} = context;
-  const {limit, type} = parsePostOptions(options);
-  const formatUserId: string = parseId(userId);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  const aqlQry: string = `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 useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => {
-      throw error;
-    });
-};
-
-export const getPostListByArea = (
-  context: ApiContext,
-  latitude: number,
-  longitude: number,
-  options?: PostOptions
-): Promise<PostType[]> => {
-  // const action: string = 'getListByUser';
-  const {database, fields} = context;
-  const {limit, type} = parsePostOptions(options);
-  const formatLatitude: number = parseNum(latitude);
-  const formatLongitude: number = parseNum(longitude);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  selectQueries.push(`LET distance = DISTANCE(
-    ${formatLatitude},
-    ${formatLongitude},
-    NOT_NULL(p.latitude, 0),
-    NOT_NULL(p.longitude, 0))
-  `);
-  selectObjects.push('distance:distance');
-
-  const aqlQry: string = `FOR p IN posts
-    ${selectQueries.join('\n')}
-    FILTER p.type == "${type}" && p.privacy == "public" && p.parentId == null
-    ${limit.aql}
-    SORT distance, p.added
-    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
-
-  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, fields, userId: sessionId} = context;
-  const formatItemId: string = parseId(itemId);
-  const db = useDb(database);
-  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
-  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: string;
-
-      if(groupId && privacy === 'group') {
-        privacyAqlQry = `FOR p IN posts
-          FILTER p._key == "${_key}"
-          ${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 = `FOR p IN posts
-          FILTER p._key == "${_key}"
-          ${selectQueries.join('\n')}
-          LIMIT 1
-          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
-      }
-
-      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, options?: PostOptions): Promise<PostType[]> => {
-  // const action: string = 'getComments';
-  const {database, userId: sessionId} = context;
-  const {limit, type} = parsePostOptions(options);
-  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.type == ${type} && 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;
-
-      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 {
-    content = '',
-    groupId = '',
-    location,
-    latitude,
-    longitude,
-    name = '',
-    parentId = null,
-    privacy = 'public',
-    type = 'default'
-  }: PostType = item;
-
-  const now: number = Date.now();
-
-  const insert: PostType = {
-    _key: createHash(`post-${sessionId}`),
-    added: now,
-    content: parseString(content, MAX_CONTENT_LENGTH),
-    groupId: groupId ? parseId(groupId) : undefined,
-    latitude: latitude !== undefined ? parseNum(latitude) : undefined,
-    location: location ? parseString(location, 160) : undefined,
-    longitude: longitude !== undefined ? parseNum(longitude) : undefined,
-    modified: now,
-    name: parseString(name, 160),
-    parentId: parentId ? parseId(parentId) : undefined,
-    privacy: privacy ? parseVarChar(privacy, 16) : undefined,
-    type: parseChar(type, 32),
-    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.content)
-        .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 {
-    content,
-    groupId,
-    name,
-    parentId,
-    postId,
-    privacy,
-    type
-  }: PostType = item;
-
-  const update: PostType = {
-    content: content ? parseString(content, MAX_CONTENT_LENGTH) : undefined,
-    modified: now,
-    name: name ? parseString(name, 160) : undefined,
-    parentId: parentId ? parseString(parentId, 160) : undefined,
-    privacy: privacy ? parseVarChar(privacy, 16) : undefined,
-    type: type !== undefined ? parseChar(type, 16) : undefined
-  };
-
-  let formatId: string = parseId(postId);
-  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: ${formatId}, 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.content || '')
-        .then((tagList = []) => {
-          updatedPost.tags = tagList;
-
-          // Update linked files
-          const files: FileType[] = updatedPost.files || [];
-
-          if(files.length) {
-            return updateFiles(db, formatId, 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 == "default"
-      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;
-    });
-};