@nlabs/reaktor 0.1.0

package/src/data/files.ts

@@ -0,0 +1,352 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import {get as httpGet} from '@nlabs/rip-hunter';
+import {createHash, parseId, parseString} from '@nlabs/utils';
+import {aql, Database} from 'arangojs';
+import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import {google} from 'googleapis';
+import {UserError} from 'graphql-errors';
+import * as request from 'request-promise';
+import {ApiContext} from 'types/auth';
+
+import {Config} from '../config';
+import {FileType} from '../types/files';
+import {useDb} from '../utils';
+import {resizeSaveImage} from './images';
+import {createPostEdge} from './posts';
+
+const youtube = google.youtube({auth: Config.get('google.key'), version: 'v3'});
+request.defaults({encoding: null});
+
+// const eventCategory: string = 'files';
+
+// Upload file
+export const addFile = (context: ApiContext, item: FileType = {}): Promise<FileType> => {
+  const {appId: sessionApp, database, userId: sessionId, userType} = context;
+  const {
+    description = '',
+    fileType = '',
+    id,
+    name = '',
+    url = ''
+  } = item;
+
+  // Id
+  const fileId: string = id ? parseId(id) : createHash(`file-${sessionId}-${sessionApp}`);
+
+  // Name
+  const isUrl: boolean = url !== '';
+
+  // If no name, get it from url path
+  let formatName: string = parseString(name, 160);
+  let formatType: string = parseString(fileType, 16);
+
+  if(formatName === '' && isUrl) {
+    formatName = url.substring(url.lastIndexOf('/') + 1);
+  }
+
+  if(formatType === '') {
+    const nameArr: string[] = formatName.split('.');
+    const ext: string = nameArr[nameArr.length - 1];
+
+    switch(ext) {
+      case 'jpeg':
+      case 'jpg':
+        formatType = 'image/jpeg';
+        break;
+      case 'png':
+        formatType = 'image/png';
+        break;
+      case 'zip':
+        formatType = 'application/zip';
+        break;
+      default:
+        break;
+    }
+  }
+
+  let isImage: boolean;
+
+  switch(formatType) {
+    case 'image/jpeg':
+    case 'image/png':
+      isImage = true;
+      break;
+    default:
+      isImage = false;
+      break;
+  }
+
+  // Description
+  const formatDesc: string = parseString(description, 500);
+
+  // Only allow file uploads to premium users
+  if(!isImage && userType !== 2) {
+    throw new UserError('account_restriction');
+  }
+
+  const saveToDb = (insert: FileType) => {
+    const aqlQry: AqlQuery = aql`INSERT ${insert} IN files RETURN NEW`;
+
+    return useDb(database).query(aqlQry)
+      .then((cursor: ArrayCursor) => cursor.next())
+      .then((file = {}) => file)
+      .catch((error: Error) => {
+        throw error;
+      });
+  };
+
+  const uploadFile = (buf: Buffer, uploadType: string) => {
+    const now: number = Date.now();
+
+    // If image, resize and create a thumbnail
+    if(isImage) {
+      return resizeSaveImage(sessionId, fileId, buf, uploadType)
+        .then((resizedImage: FileType) => {
+          const insert: FileType = {
+            ...resizedImage,
+            _key: fileId,
+            added: now,
+            description: formatDesc,
+            fileType: formatType,
+            modified: now,
+            name: formatName,
+            userId: sessionId
+          };
+
+          return saveToDb(insert);
+        })
+        .catch((error: Error) => {
+          throw error;
+        });
+    }
+    const insert: FileType = {
+      _key: fileId,
+      added: now,
+      description: formatDesc,
+      fileType: formatType,
+      modified: now,
+      name: formatName,
+      userId: sessionId
+    };
+
+    return saveToDb(insert);
+  };
+
+  // If file is a url path, download the file and save
+  if(isUrl) {
+    return request.get({encoding: null, uri: url})
+      .then((body) => uploadFile(new Buffer(body, 'binary'), formatType))
+      .catch(() => {
+        throw new UserError('file_request');
+      });
+  } else if(item.base64 !== '') {
+    const buffer: Buffer = new Buffer(item.base64);
+    return uploadFile(buffer, formatType);
+  }
+  throw new Error('file_required');
+};
+
+// Giphy
+export const getGiphyTrends = (context: ApiContext, limit: number = 30): Promise<any[]> => {
+  const gifUrl: string = `http://api.giphy.com/v1/gifs/trending?api_key=${Config.get('giphy.key')}&limit=${limit}`;
+
+  return httpGet(gifUrl)
+    .then((res: Response) => res.json())
+    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {
+      const {
+        id,
+        images: {
+          original: {url = ''} = {},
+          fixed_height_small: {url: thumb = ''} = {}
+        } = {}
+      } = gifImage;
+
+      return {
+        id,
+        thumb,
+        type: 'giphy',
+        url
+      };
+    }));
+};
+
+export const getGiphySearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> => {
+  const formatQuery: string = encodeURI(query);
+  const gifUrl: string = `http://api.giphy.com/v1/gifs/search?q=${formatQuery}&api_key=${Config.get('giphy.key')}&limit=${limit}`;
+
+  return fetch(gifUrl)
+    .then((res: Response) => res.json())
+    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {
+      const {
+        id,
+        images: {
+          original: {url = ''} = {},
+          fixed_height_small: {url: thumb = ''} = {}
+        } = {}
+      } = gifImage;
+
+      return {
+        id,
+        thumb,
+        type: 'giphy',
+        url
+      };
+    }));
+};
+
+export const getYouTubeTrends = (context: ApiContext, limit: number = 30): Promise<any[]> => {
+  return new Promise((resolve, reject) => {
+    youtube.videos.list({
+      chart: 'mostPopular',
+      maxResults: limit,
+      part: 'snippet',
+      regionCode: 'US'
+    }, (error: Error, data: any) => {
+      if(error) {
+        console.error(error);
+        reject(new Error(error[0].message));
+      } else if(data) {
+        const list = data.items.map((item) => ({
+          id: item.id,
+          thumb: item.snippet.thumbnails.high.url,
+          type: 'youtube',
+          url: `http://www.youtube.com/embed/${item.id}`
+        }));
+
+        resolve(list);
+      }
+    });
+  });
+};
+
+export const getYouTubeSearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> => {
+  return new Promise((resolve, reject) => {
+    youtube.search.list({
+      maxResults: limit,
+      part: 'snippet',
+      q: query,
+      regionCode: 'US'
+    }, (error: Error, data: any) => {
+      if(error) {
+        console.error(error);
+        reject(new Error(error[0].message));
+      } else if(data) {
+        const {items} = data;
+        const list = items.map((item) => ({
+          id: item.id,
+          thumb: item.snippet.thumbnails.high.url,
+          type: 'youtube',
+          url: `http://www.youtube.com/embed/${item.id}`
+        }));
+
+        resolve(list);
+      }
+    });
+  });
+};
+
+// Files
+export const getPathUserFiles = (userId: string, filename: string): string => {
+  return `users/${userId}/files/${filename}`;
+};
+
+export const getUrlUserFiles = (userId: string, filename: string, dir: string = 'files', type: string = 'profile'): string => {
+  if(filename) {
+    return `https://box.${Config.get('app.url')}/users/${userId}/${dir}/${filename}`;
+  }
+
+  if(type === 'profile') {
+    return `https://box.${Config.get('app.url')}/defaults/user_bk.jpg`;
+  }
+
+  return `https://box.${Config.get('app.url')}/defaults/user_wh.jpg`;
+};
+
+export const linkFiles = (db: Database, files: FileType[], postId: string): Promise<any> => {
+  return Promise.all(
+    files.map((file: FileType) => createFile(db, file)
+      .then((file: FileType) => createPostEdge(db, file, postId)))
+  );
+};
+
+export const updateFiles = (db: Database, postId: string, files: FileType[]): Promise<any> => {
+  const edgeCollection = db.edgeCollection('isPosted');
+
+  return edgeCollection.inEdges(postId)
+    .then((edges) => {
+      if(edges.length) {
+        // Remove linked edges
+        return Promise.all(
+          edges.map((edge) => {
+            const {_key: edgeKey} = edge;
+            const aqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN isPosted`;
+
+            return db.query(aqlQry).catch((error: Error) => {
+              throw error;
+            });
+          }))
+          .then(() => {
+            if(files.length) {
+              // Link files
+              return linkFiles(db, files, postId).then(() => files);
+            }
+            return files;
+          });
+      } else if(files.length) {
+        // Link files
+        return linkFiles(db, files, postId).then(() => files);
+      }
+      return files;
+    })
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const createFile = (db: Database, file: FileType): Promise<FileType> => {
+  const insert: any = {
+    _key: file.id,
+    added: Date.now()
+  };
+
+  const aqlQry: AqlQuery = aql`UPSERT {_key: ${file.id}}
+    INSERT ${insert}
+    UPDATE {}
+    IN files RETURN NEW`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((updatedFile: FileType = {}) => updatedFile)
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const encodeBase64 = (buffer: Buffer): string => {
+  return new Buffer(buffer).toString('base64');
+}
+
+export const decodeBase64 = (dataString: string): object => {
+  // const getData = (str: string) => str.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/) || [];
+  const getData = (str: string) => str.match(/^data:([A-Za-z-+/]+);base64,(.+)$/) || [];
+  let matches = getData(dataString);
+
+  if(matches.length !== 3) {
+    // If invalid make sure we don't need to decode
+    matches = getData(decodeURIComponent(dataString));
+
+    // Check it again.
+    if(matches.length !== 3) {
+      throw Error('Invalid input string');
+    }
+  }
+
+  return {
+    data: new Buffer(matches[2], 'base64'),
+    type: matches[1]
+  };
+};

package/src/data/groups.ts

@@ -0,0 +1,308 @@
+import {createHash, parseChar, parseId} 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 {ArangoDBLimit} from '../types/arangodb';
+import {ApiContext} from '../types/auth';
+import {GroupEdgeType, GroupType, GroupUserType} from '../types/groups';
+import {getLimit, logError, useDb} from '../utils';
+import {extractTags} from './tags';
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+
+const eventCategory: string = 'groups';
+
+export const getGroupList = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {
+  const action: string = 'getListByApp';
+  const {database} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR g in groups
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+
+  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 getGroupListByUser = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {
+  // const action: string = 'getListByUser';
+  const {database, userId: sessionId} = context;
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR g, e IN INBOUND "${`users/${sessionId}`}" isGrouped
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getGroupListByTags = (context: ApiContext, tags: string[], from: number, to: number): Promise<GroupType[]> => {
+  const action: string = 'getListByTags';
+  const {database} = context;
+
+  return Promise.all(
+    (tags || []).map((tagName: string) => {
+      const formatTagName: string = parseId(tagName);
+      const limit: ArangoDBLimit = getLimit(from, to);
+      const aqlQry: string = `FOR p, e IN OUTBOUND "${`tags/${formatTagName}`}" isTagged
+          FOR u IN users
+          LET likes = (
+            FOR post, like IN INBOUND p._id likes
+            FILTER like.value == 'like'
+            RETURN like
+          )
+          LET dislikes = (
+            FOR post, like IN INBOUND p._id likes
+            FILTER like.value == 'dislike'
+            RETURN like
+          )
+          FILTER e.type == 'post' && p.userId == u._key
+          ${limit.aql}
+          SORT p.added
+          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;
+
+      return useDb(database).query(aqlQry).then((cursor: ArrayCursor) => cursor.all());
+    })
+  )
+    .then((results) => uniqBy(flatten(results), '_key'))
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {
+  const action: string = 'getItem';
+  const {database, userId: sessionId} = context;
+  const formatItemId: string = parseId(itemId);
+
+  const aqlQry: AqlQuery = aql`FOR g, e IN INBOUND ${`users/${sessionId}`} isGrouped
+      FILTER g._key == ${formatItemId}
+      LET users = (
+        FOR u, l IN OUTBOUND g._id isGrouped
+        RETURN MERGE (u, {type:l.type})
+      )
+      LIMIT 1
+      RETURN DISTINCT MERGE(g, {users:users})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((group: GroupType = {}) => group)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {
+  const action: string = 'getDetails';
+  const {database} = context;
+  const formatGroupId: string = parseId(groupId);
+  const aqlQry: AqlQuery = aql`FOR g IN groups
+      FILTER g._key == ${formatGroupId}
+      LIMIT 1
+      RETURN g`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((group: GroupType = {}) => group)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const addGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {
+  const action: string = 'add';
+  const {database, userId: sessionId} = context;
+  const now: number = Date.now();
+  const {
+    description = '',
+    name = 'Untitled',
+    type
+  }: GroupType = item;
+  const id: string = createHash(`group-${sessionId}`);
+  const formatDesc: string = description.substr(0, 640);
+  const formatType: string = parseChar(type, 16) || 'private';
+  const insert: GroupType = {
+    _key: id,
+    added: now,
+    description: formatDesc,
+    modified: now,
+    name,
+    type: formatType
+  };
+  const db: Database = useDb(database);
+  const aqlQry: AqlQuery = aql`INSERT ${insert} IN groups RETURN NEW`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((group: GroupType = {}) => {
+      const itemType: string = 'groups';
+
+      // Update linked tags
+      const {_key: groupId}: GroupType = group;
+      return extractTags(db, itemType, groupId, formatDesc)
+        .then(() => createGroupEdge(database, sessionId, groupId, 'admin').then(() => group));
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const updateGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {
+  const action: string = 'update';
+  const {database} = context;
+  const {
+    description = '',
+    id,
+    name = 'Untitled'
+  }: GroupType = item;
+  const itemId: string = parseId(id);
+  const now: number = Date.now();
+  const formatDesc: string = description.substr(0, 640);
+  const update: any = {
+    description: formatDesc,
+    modified: now,
+    name
+  };
+  const db: Database = useDb(database);
+  const aqlQry: AqlQuery = aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;
+
+  return db.query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((group: GroupType = {}) => {
+      const {_key: groupKey} = group;
+      const itemType: string = 'groups';
+
+      // Update linked tags
+      return extractTags(db, itemType, groupKey, description).then(() => group);
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {
+  const action: string = 'delete';
+  const {database} = context;
+  const formatItemId: string = parseId(itemId);
+  const aqlQry: AqlQuery = aql`FOR g IN groups
+      FILTER g._key == ${formatItemId}
+      REMOVE g IN groups
+      RETURN OLD`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((group: GroupType = {}) => group)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {
+  const action: string = 'getGroupsByReaction';
+  const {database, userId: sessionId} = context;
+  const formatReaction: string = parseChar(reaction, 32);
+  const userDocId: string = `users/${sessionId}`;
+
+  // Query
+  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction
+      FILTER r.value == ${formatReaction}
+      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 isGrouped = (database: string, userId: string, groupId: string): Promise<GroupUserType> => {
+  const action: string = 'isGrouped';
+  const formatUserId: string = parseId(userId);
+  const formatGroupId: string = parseId(groupId);
+  const aqlQry: AqlQuery = aql`FOR g IN groups
+    FILTER g._key == ${formatGroupId}
+    FOR u IN INBOUND g._id isGrouped
+    FILTER u._key == ${formatUserId}
+    LIMIT 1
+    RETURN u`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .then((results = []) => {
+      const isValid = !!results.length;
+
+      return {
+        groupId,
+        isValid,
+        userId
+      };
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {id: userId}).then(() => null));
+};
+
+export const createGroupEdge = (database: string, userId: string, groupId: string, type: string): Promise<GroupEdgeType> => {
+  const action: string = 'createGroupEdge';
+  const formatUserId: string = parseId(userId);
+  const formatGroupId: string = parseId(groupId);
+  const formatType: string = parseChar(type, 16);
+
+  const now: number = Date.now();
+  const edgeCollection = useDb(database).edgeCollection('isGrouped');
+  const edgeId: string = createHash(`group-${formatUserId}-${formatGroupId}`);
+
+  const edge: any = {
+    _key: edgeId,
+    added: now,
+    type: formatType
+  };
+
+  return edgeCollection.save(edge, `users/${formatUserId}`, `groups/${formatGroupId}`)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, {id: formatUserId}).then(() => null));
+};