@nlabs/reaktor 0.1.0

package/src/data/images.ts

@@ -0,0 +1,606 @@
+import {get as httpGet} from '@nlabs/rip-hunter';
+import {createHash, parseChar, parseId, parseNum} from '@nlabs/utils';
+import {aql} from 'arangojs';
+import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
+import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
+import {DeleteObjectsRequest, PutObjectRequest} from 'aws-sdk/clients/s3';
+import * as gm from 'gm';
+import cloneDeep from 'lodash/cloneDeep';
+import isEmpty from 'lodash/isEmpty';
+import {DateTime} from 'luxon';
+
+import {Config} from '../config';
+import {
+  ApiContext,
+  ArangoDBLimit,
+  FileDecodedType,
+  FileEdgeType,
+  FileType,
+  GroupType,
+  GroupUserType,
+  ImageIdentifyType,
+  ImageType,
+  ImageUrlData,
+  QueryFilter
+} from '../types';
+import {defaultObject, getLimit, logError, logException, lowerCaseKeys, useDb} from '../utils';
+import {decodeBase64} from './files';
+import {getGroupDetails, isGrouped} from './groups';
+import {s3DeleteList, s3Put} from './s3';
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+const eventCategory: string = 'images';
+
+export const getImageListByUser = (context: ApiContext, userId: string, from: number, to: number): Promise<ImageType[]> => {
+  const action: string = 'getListByUser';
+  const {database} = context;
+  const formatUserId: string = parseId(userId);
+  const limit: ArangoDBLimit = getLimit(from, to);
+  const aqlQry: string = `FOR i IN images
+      FILTER i.userId == "${formatUserId}"
+      LET user = (
+        FOR u IN users
+        FILTER u._key == i.userId
+        LIMIT 1
+        RETURN u
+      )
+      ${limit.aql}
+      SORT i.added
+      RETURN MERGE(i, {user: FIRST(user)})`;
+
+  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 getImageListByGroup = (context: ApiContext, params): Promise<ImageType[]> => {
+  const action: string = 'getListByGroup';
+  const {database, userId: sessionId} = context;
+  const {filters = [], groupId, from, to} = params;
+  const formatGroupId: string = parseId(groupId);
+  const limit = getLimit(from, to);
+
+  filters
+    .map((filter: QueryFilter) => {
+      const {conditional, name, value} = filter;
+      let formatCond: string = conditional;
+
+      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {
+        formatCond = '==';
+      }
+
+      switch(name) {
+        case 'added':
+          return `p.added ${formatCond} ${parseNum(value)}`;
+        default:
+          return '';
+      }
+    });
+
+  return getGroupDetails(context, formatGroupId)
+    .then((group: GroupType) => {
+      if(group.privacy === 'public') {
+        filters.push(`p.groupId == "${groupId}"`);
+        const filterStr = filters.join(' && ');
+        const aqlQry: string = `FOR i IN
+          FLATTEN(
+            FOR p IN posts
+            FILTER ${filterStr}
+            LET images = (
+              FOR i, e IN INBOUND p._id hasImage
+              RETURN i
+            )
+            SORT p.added DESC
+            RETURN images
+          )
+          SORT i.added DESC
+          ${limit.aql}
+          RETURN i`;
+
+        return useDb(database).query(aqlQry)
+          .then((cursor: ArrayCursor) => cursor.all())
+          .catch((error: Error) => logError({
+            action,
+            category: eventCategory,
+            label: 'db_error'
+          }, error, context).then(() => null));
+      }
+      return isGrouped(database, sessionId, groupId)
+        .then((grouped: GroupUserType) => {
+          if(grouped.isValid) {
+            filters.push(`p.groupId == "${grouped.groupId}"`);
+            const filterList: string = filters.join(' && ');
+            const aqlQry: string = `FOR p IN post
+                FILTER ${filterList}
+                FOR f IN p.files
+                FILTER f.type == "image/jpeg" || f.type == "image/png"
+                ${limit.aql}
+                SORT p.added DESC
+                RETURN f`;
+
+            return useDb(database).query(aqlQry)
+              .then((cursor: ArrayCursor) => cursor.all())
+              .catch((error: Error) => logError({
+                action,
+                category: eventCategory,
+                label: 'db_error'
+              }, error, context).then(() => null));
+          }
+          return [];
+        });
+    });
+};
+
+export const getImage = (context: ApiContext, id: string): Promise<ImageType> => {
+  const action: string = 'getItem';
+  const {database} = context;
+  const formatId: string = parseId(id);
+  const aqlQry: AqlQuery = aql`FOR i IN images
+    FILTER i._key==${formatId}
+    LIMIT 1
+    RETURN i`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((image: ImageType = {}) => image)
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+export const updateImage = (context: ApiContext, item: FileType): Promise<ImageType> => {
+  const action: string = 'update';
+  const {database, userId: sessionId} = context;
+
+  // Item props
+  const {
+    base64 = '',
+    description = '',
+    fileType = '',
+    id,
+    itemId,
+    itemType,
+    url = ''
+  } = item;
+
+  // Save Base64 data
+  const photoId: string = id || createHash(`image-${sessionId}`);
+  const now: number = Date.now();
+  let contentType: string = fileType;
+  const formatItemId: string = parseId(itemId);
+  const formatItemType: string = parseChar(itemType).toLowerCase();
+
+  if(base64 !== '') {
+    let decodedBase64: FileDecodedType;
+
+    try {
+      decodedBase64 = decodeBase64(base64);
+    } catch(error) {
+      return logError({
+        action,
+        category: eventCategory,
+        label: 'decode_base64'
+      }, error, context).then(() => null);
+    }
+
+    const {data, type} = decodedBase64;
+    const imgParams: FileType = {
+      buffer: data,
+      description,
+      fileType: type,
+      id: photoId,
+      userId: sessionId
+    };
+
+    return addImage(context, imgParams)
+      .then((image: ImageType) => {
+        if(formatItemId && formatItemType) {
+          const imageEdge: FileEdgeType = {imgId: photoId, itemId: formatItemId, itemType: formatItemType};
+          return addImageEdge(context, imageEdge).then(() => image);
+        }
+        return image;
+      })
+      .catch((error) => logError({
+        action,
+        category: eventCategory,
+        label: 'image_save_error'
+      }, error, context).then(() => null));
+  } else if(url !== '') {
+    // Download image from the web
+    return httpGet(url)
+      .then((res: Response) => {
+        if(res.status !== 200) {
+          return logException({
+            action,
+            category: eventCategory,
+            label: 'fetch_image_url',
+            value: res.statusText
+          }, context).then(() => null);
+        }
+
+        contentType = res.headers.get('content-type');
+
+        return res;
+      })
+      .then((res) => res.buffer())
+      .then((buffer: Buffer) => {
+        const imgParams = {
+          buffer,
+          description,
+          id: photoId,
+          type: contentType,
+          userId: sessionId
+        };
+        return addImage(context, imgParams).then((image: ImageType) => {
+          if(formatItemId && formatItemType) {
+            const imageEdge: FileEdgeType = {imgId: id, itemId: formatItemId, itemType: formatItemType};
+            return addImageEdge(context, imageEdge).then(() => image);
+          }
+
+          return image;
+        });
+      })
+      .catch((error: Error) => logError({
+        action,
+        category: eventCategory,
+        label: 'fetch_error'
+      }, error, context).then(() => null));
+  } else if(id !== '') {
+    // Update metadata
+    const update: any = {
+      description,
+      modified: now
+    };
+    const aqlQry: AqlQuery = aql`UPDATE ${id} WITH ${update} IN images RETURN NEW`;
+
+    return useDb(database).query(aqlQry)
+      .then((cursor: ArrayCursor) => cursor.next())
+      .catch((error: Error) => logError({
+        action,
+        category: eventCategory,
+        label: 'db_error'
+      }, error, context).then(() => null));
+  }
+
+  return null;
+};
+
+export const addImage = (context: ApiContext, image: ImageType): Promise<ImageType> => {
+  const action: string = 'addImage';
+  const {database} = context;
+  const {userId, id, description, buffer, fileType} = image;
+  const now: number = Date.now();
+
+  return resizeSaveImage(userId, id, buffer, fileType)
+    .then((resizedImage: any) => {
+      const insert: ImageType = {
+        ...resizedImage,
+        _key: id,
+        added: now,
+        description,
+        fileType,
+        modified: now,
+        userId
+      };
+
+      const aqlQry: AqlQuery = aql`INSERT ${insert} IN images RETURN NEW`;
+
+      return useDb(database).query(aqlQry)
+        .then((cursor: ArrayCursor) => cursor.next())
+        .then(defaultObject)
+        .catch((error: Error) => logError({
+          action,
+          category: eventCategory,
+          isInternal: true,
+          label: 'db_error'
+        }, error, context).then(() => null));
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      isInternal: true,
+      label: 'image_resize'
+    }, error, context).then(() => null));
+};
+
+export const addImageEdge = (context: ApiContext, imageEdge: FileEdgeType): Promise<object> => {
+  const action: string = 'addImageEdge';
+  const {database, userId: sessionId} = context;
+  const {imgId, itemId, itemType} = imageEdge;
+  const now: number = Date.now();
+  const edgeCollection = useDb(database).edgeCollection('hasImage');
+  const edgeId: string = createHash(`hasImage-${imgId}-${itemId}-${sessionId}`);
+  const edge: any = {
+    _key: edgeId,
+    added: now
+  };
+
+  const formatItemType: string = parseChar(itemType).toLowerCase();
+  const formatItemId: string = parseId(itemId);
+  let itemDocId: string;
+  const formatImgId: string = parseId(imgId);
+  const imageDocId = `images/${formatImgId}`;
+
+  switch(formatItemType) {
+    case 'posts':
+      itemDocId = `posts/${formatItemId}`;
+      break;
+    default:
+      itemDocId = '';
+      break;
+  }
+
+  if(itemDocId) {
+    return edgeCollection.save(edge, imageDocId, itemDocId)
+      .then((fileEdge) => edgeCollection.edge(fileEdge))
+      .catch((error: Error) => logError({
+        action,
+        category: eventCategory,
+        isInternal: true,
+        label: 'db_error'
+      }, error, context).then(() => null));
+  }
+
+  return Promise.resolve({});
+};
+
+export const deleteImage = (context: ApiContext, imgId): Promise<ImageType> => {
+  const action: string = 'delete';
+  const {database, userId: sessionId} = context;
+  const formatImgId = parseId(imgId);
+
+  const aqlQry = aql`FOR i IN images
+    FILTER i._key == ${formatImgId} && i.userId == ${sessionId}
+    REMOVE i IN images
+    RETURN OLD`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.next())
+    .then((image: ImageType = {}) => {
+      if(!isEmpty(image)) {
+        const {_key: imageKey} = image;
+        const params: DeleteObjectsRequest = {
+          Bucket: null,
+          Delete: {
+            Objects: [
+              {Key: `users/${sessionId}/images/${imageKey}.jpg`},
+              {Key: `users/${sessionId}/thumbs/${imageKey}.jpg`}
+            ],
+            Quiet: true
+          }
+        };
+
+        return s3DeleteList(params).then(() => image);
+      }
+      return {};
+    })
+    .catch((error: Error) => logError({
+      action,
+      category: eventCategory,
+      label: 'db_error'
+    }, error, context).then(() => null));
+};
+
+// Images
+export const getPathUserImages = (userID: string, photoId: string, type: string, dir: string = 'images'): string => {
+  let filename: string = photoId;
+
+  switch(type) {
+    case 'image/png':
+      filename = `${photoId}.png`;
+      break;
+    default:
+      filename = `${photoId}.jpg`;
+      break;
+  }
+
+  return `users/${userID}/${dir}/${filename}`;
+};
+
+export const getUrlImages = (data: ImageUrlData): string => {
+  const {appId, imgId, directory = 'images', imgType = 'profile', isThumb, type, typeId} = data;
+  const host: string = Config.get('environment') === 'production'
+    ? `https://box.${Config.get('app.url')}`
+    : `https://s3.amazonaws.com/dev.${Config.get('app.url')}`;
+  const suffix: string = isThumb ? '-th' : '';
+
+  if(imgId) {
+    switch(type) {
+      case 'app':
+        // https://box.reaktor.io/myApp/app/images/123.jpg
+        return `${host}/${appId}/${type}/${directory}/${imgId}${suffix}.jpg`;
+      case 'users':
+        // https://box.reaktor.io/myApp/users/demoUser/images/123.jpg
+        return `${host}/${appId}/${type}/${typeId}/${directory}/${imgId}${suffix}.jpg`;
+    }
+
+    if(imgType === 'profile') {
+      return `${host}/${appId}/defaults/${type}_bk${suffix}.jpg`;
+    }
+
+    return `${host}/${appId}/defaults/${type}_wh${suffix}.jpg`;
+  }
+
+  return '';
+};
+
+export const resizeSaveImage = (userId: string,
+  photoId: string,
+  buffer: Buffer,
+  type: string = 'image/jpeg'): Promise<ImageType> => {
+  const action: string = 'resizeSaveImage';
+  const imgW: number = Config.get('image.imgSize');
+  const imgQ: number = Config.get('image.imgQuality');
+  let photo: ImageType = {};
+  const format: string = (type.split('/'))[1];
+
+  return new Promise((resolve) => {
+    gm(buffer, 'img')
+      .setFormat(format)
+      .quality(imgQ)
+      .autoOrient()
+      .resize(imgW, imgW, '>')
+      .identify({bufferStream: true}, (error: Error, val: ImageIdentifyType = {}): any => {
+        if(error) {
+          logError({
+            action,
+            category: eventCategory,
+            label: 'image_save',
+            value: 'gm_image_identify'
+          }, error, {id: userId}).catch((error) => {
+            throw error;
+          });
+        } else {
+          const formatVals = lowerCaseKeys(val);
+          const {make: cameraMake, model: cameraModel, datetimeoriginal: taken}: ImageIdentifyType = formatVals;
+          photo = {
+            ...cloneDeep(photo),
+            make: cameraMake,
+            model: cameraModel,
+            taken: DateTime.fromMillis(taken).millisecond
+          };
+
+          // If no background color, get the mean color value
+          const stats = formatVals['channel statistics'];
+
+          if(stats) {
+            let {red, green, blue, mean} = stats;
+
+            if(red) {
+              mean = red['standard deviation'] || red.mean;
+              red = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;
+            } else {
+              red = 0;
+            }
+
+            if(green) {
+              mean = green['standard deviation'] || green.mean;
+              green = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;
+            } else {
+              green = 0;
+            }
+
+            if(blue) {
+              mean = blue['standard deviation'] || blue.mean;
+              blue = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;
+            } else {
+              blue = 0;
+            }
+
+            const rgb = blue | (green << 8) | (red << 16);
+            const color = rgb.toString(16);
+            photo.color = color === '0' ? '000000' : color;
+          }
+        }
+      })
+      .stream((error: Error, stdout): any => {
+        if(error) {
+          logError({
+            action,
+            category: eventCategory,
+            isInternal: true,
+            label: 'image_save',
+            value: 'gm_image_steam'
+          }, error, {id: userId}).then(() => null);
+        } else {
+          let imageBuffer: Buffer = new Buffer('');
+
+          stdout.on('data', (data) => {
+            imageBuffer = Buffer.concat([imageBuffer, data]);
+          });
+
+          stdout.on('end', () => {
+            // Get file size
+            photo.fileSize = imageBuffer.length;
+
+            // Upload data
+            const imageObj: PutObjectRequest = {
+              ACL: 'public-read',
+              Body: imageBuffer,
+              Bucket: null,
+              ContentType: type,
+              Key: getPathUserImages(userId, photoId, type, 'images')
+            };
+
+            s3Put(imageObj)
+              .then(() => {
+                const thmW = Config.get('image.thmSize');
+                const thmQ = Config.get('image.thmQuality');
+
+                // Upload thumbnail
+                gm(imageBuffer, 'img')
+                  .setFormat('jpeg')
+                  .size((thumbError: Error, resizeVal) => {
+                    if(!thumbError) {
+                      // Get updated resize values
+                      const {height, width} = resizeVal;
+                      photo = {...cloneDeep(photo), height, width};
+                    }
+                  })
+                  .gravity('Center')
+                  .resize(thmW, thmW, '^')
+                  .extent(thmW, thmW)
+                  .quality(thmQ)
+                  .stream((streamError: Error, thumbStdout): any => {
+                    if(streamError) {
+                      logError({
+                        action,
+                        category: eventCategory,
+                        label: 'image_save',
+                        value: 'gm_thumbnail_steam'
+                      }, streamError, {id: userId})
+                        .catch((error) => {
+                          throw error;
+                        });
+                    } else {
+                      let thumbBuffer: Buffer = new Buffer('');
+
+                      thumbStdout.on('data', (data) => {
+                        thumbBuffer = Buffer.concat([thumbBuffer, data]);
+                      });
+
+                      thumbStdout.on('end', () => {
+                        // Upload data
+                        const thumbObj: PutObjectRequest = {
+                          ACL: 'public-read',
+                          Body: thumbBuffer,
+                          Bucket: null,
+                          ContentType: type,
+                          Key: getPathUserImages(userId, photoId, type, 'thumbs')
+                        };
+
+                        s3Put(thumbObj)
+                          .then(() => {
+                            resolve(photo);
+                          })
+                          .catch(() => logError({
+                            action,
+                            category: eventCategory,
+                            label: 'image_save',
+                            value: 's3_put_image'
+                          }, streamError, {id: userId}).then(() => null));
+                      });
+                    }
+                  });
+              })
+              .catch(() => logError({
+                action,
+                category: eventCategory,
+                isInternal: true,
+                label: 'image_save',
+                value: 's3_image_save'
+              }, error, {id: userId}).then(() => null));
+          });
+        }
+      });
+  });
+};

package/src/data/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export * from './conversations';
+export * from './dynamodb';
+export * from './email';
+export * from './files';
+export * from './groups';
+export * from './images';
+export * from './ios';
+export * from './locations';
+export * from './messages';
+export * from './notifications';
+export * from './payments';
+export * from './posts';
+export * from './reactions';
+export * from './s3';
+export * from './search';
+export * from './sms';
+export * from './subscription';
+export * from './tags';
+export * from './users';