@nlabs/reaktor 0.4.0 → 0.4.2

package/lib/actions/email.js

@@ -0,0 +1,177 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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, {
+  appTemplate: () => appTemplate,
+  sendEmail: () => sendEmail,
+  sendTemplate: () => sendTemplate,
+  sesSend: () => sesSend
+});
+var import_aws_sdk = __toModule(require("aws-sdk"));
+var import_isEmpty = __toModule(require("lodash/isEmpty"));
+var import_config = __toModule(require("../config"));
+var import_layout = __toModule(require("../templates/email/layout"));
+var import_passwordForgot = __toModule(require("../templates/email/passwordForgot"));
+var import_passwordRecovery = __toModule(require("../templates/email/passwordRecovery"));
+var import_verifyEmail = __toModule(require("../templates/email/verifyEmail"));
+var import_welcome = __toModule(require("../templates/email/welcome"));
+var import_passwordForgot2 = __toModule(require("../templates/sms/passwordForgot"));
+var import_passwordRecovery2 = __toModule(require("../templates/sms/passwordRecovery"));
+var import_verifyEmail2 = __toModule(require("../templates/sms/verifyEmail"));
+var import_welcome2 = __toModule(require("../templates/sms/welcome"));
+var import_s32 = __toModule(require("./s3"));
+const appTemplate = (app, message = "", vars = {}) => {
+  let updatedMessage = "";
+  if (!(0, import_isEmpty.default)(app)) {
+    updatedMessage = message.replace(/\[appName\]/g, app.name).replace(/\[appUrl\]/g, app.url).replace(/\[appEmail\]/g, app.email);
+  }
+  Object.keys(vars).forEach((key) => {
+    if (vars[key]) {
+      updatedMessage = message.replace(new RegExp(`\\[${key}\\]`, "g"), vars[key]);
+    }
+  });
+  return updatedMessage;
+};
+const sesSend = (params) => new Promise((resolve, reject) => {
+  import_aws_sdk.default.config.update(import_config.Config.get("aws"));
+  const ses = new import_aws_sdk.SES();
+  ses.sendEmail(params, (error, response) => {
+    if (error) {
+      return reject(error);
+    }
+    return resolve(response);
+  });
+});
+const sendEmail = (params) => {
+  const {
+    app = {},
+    html,
+    subject,
+    subTitle = "",
+    text,
+    title = "",
+    user = {}
+  } = params;
+  const to = [user.email];
+  let promise;
+  const formatSubject = appTemplate(app, subject);
+  const formatSubTitle = appTemplate(app, subTitle);
+  const formatTitle = appTemplate(app, title);
+  const formatText = appTemplate(app, text);
+  const formatHtml = appTemplate(app, html);
+  const { _key: hasCustomEmail, urlFacebook, urlTwitter } = app;
+  const parseTemplate = (body) => {
+    const templateBody = appTemplate(app, body || "");
+    let links = "";
+    const spacer = '<td width="5"><img width="1" height="1" border="0" title="" alt="" src="https://box.reaktor.io/images/email/spacer.gif"/></td>';
+    if (urlFacebook) {
+      links = `<td width="30"><a href="${urlFacebook}"><img width="30" height="30" border="0" title="Facebook" alt="Facebook" src="https://box.reaktor.io/images/email/icon-facebook.png"/></a></td>`;
+    }
+    if (urlTwitter) {
+      if (urlFacebook) {
+        links += spacer;
+      }
+      links += `<td width="30"><a href="${urlTwitter}"><img width="30" height="30" border="0" title="Twitter" alt="Twitter" src="https://box.reaktor.io/images/email/icon-twitter.png"/></a></td>`;
+    }
+    if (!links.length) {
+      links += spacer;
+    }
+    return templateBody.replace(/\[title\]/g, formatTitle).replace(/\[subTitle\]/g, formatSubTitle).replace(/\[subject\]/g, formatSubject).replace(/\[message\]/g, formatHtml).replace(/\[links\]/g, links);
+  };
+  if (hasCustomEmail) {
+    const s3Params = { Bucket: null, Key: "apps/templates/email.html" };
+    promise = (0, import_s32.s3Get)(s3Params).then((results) => parseTemplate(results.Body.toString()));
+  } else {
+    promise = Promise.resolve(parseTemplate(import_layout.default));
+  }
+  return promise.then((parsedHtml) => {
+    const emailParams = {
+      Destination: { ToAddresses: to },
+      Message: {
+        Body: {
+          Html: { Data: parsedHtml },
+          Text: { Data: formatText }
+        },
+        Subject: { Data: formatSubject }
+      },
+      Source: `"${app.supportName}" <noreply@${import_config.Config.get("app.url")}>`
+    };
+    return sesSend(emailParams);
+  });
+};
+const sendTemplate = (templateName, emailParams) => {
+  const { app, user, subject, subTitle, title, vars } = emailParams;
+  let html;
+  let text;
+  try {
+    switch (templateName) {
+      case "passwordForgot": {
+        html = import_passwordForgot.default;
+        text = import_passwordForgot2.default;
+        break;
+      }
+      case "passwordRecovery": {
+        html = import_passwordRecovery.default;
+        text = import_passwordRecovery2.default;
+        break;
+      }
+      case "verifyRecovery": {
+        html = import_verifyEmail.default;
+        text = import_verifyEmail2.default;
+        break;
+      }
+      case "verifyEmail": {
+        html = import_verifyEmail.default;
+        text = import_verifyEmail2.default;
+        break;
+      }
+      case "welcome": {
+        html = import_welcome.default;
+        text = import_welcome2.default;
+        break;
+      }
+    }
+    const templateHtml = appTemplate(app, html, vars);
+    const templateText = appTemplate(app, text, vars);
+    const params = {
+      app,
+      html: templateHtml,
+      subTitle,
+      subject,
+      text: templateText,
+      title,
+      user
+    };
+    return sendEmail(params).then(() => true).catch(() => false);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appTemplate,
+  sendEmail,
+  sendTemplate,
+  sesSend
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/email.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 aws, {SES} from 'aws-sdk';\nimport {GetObjectRequest} from 'aws-sdk/clients/s3';\nimport {SendEmailRequest, SendEmailResponse} from 'aws-sdk/clients/ses';\nimport isEmpty from 'lodash/isEmpty';\n\nimport {Config} from '../config';\nimport layoutTemplate from '../templates/email/layout';\nimport forgotEmailTemplate from '../templates/email/passwordForgot';\nimport recoveryEmailTemplate from '../templates/email/passwordRecovery';\nimport verifyEmailTemplate from '../templates/email/verifyEmail';\nimport welcomeEmailTemplate from '../templates/email/welcome';\nimport forgotSmsTemplate from '../templates/sms/passwordForgot';\nimport recoverySmsTemplate from '../templates/sms/passwordRecovery';\nimport verifySmsTemplate from '../templates/sms/verifyEmail';\nimport welcomeSmsTemplate from '../templates/sms/welcome';\nimport {AppType} from '../types/apps';\nimport {EmailType} from '../types/email';\nimport {s3Get} from './s3';\n\n// const eventCategory: string = 'email';\n\nexport const appTemplate = (app: AppType, message: string = '', vars = {}): string => {\n  let updatedMessage: string = '';\n\n  if(!isEmpty(app)) {\n    updatedMessage = message.replace(/\\[appName\\]/g, app.name)\n      .replace(/\\[appUrl\\]/g, app.url)\n      .replace(/\\[appEmail\\]/g, app.email);\n  }\n\n  Object.keys(vars).forEach((key: string) => {\n    if(vars[key]) {\n      updatedMessage = message.replace(new RegExp(`\\\\[${key}\\\\]`, 'g'), vars[key]);\n    }\n  });\n\n  return updatedMessage;\n};\n\n// AWS::SES\nexport const sesSend = (params: SendEmailRequest): Promise<SendEmailResponse> => new Promise((resolve, reject) => {\n  aws.config.update(Config.get('aws'));\n  const ses: SES = new SES();\n\n  ses.sendEmail(params, (error: Error, response: SendEmailResponse) => {\n    if(error) {\n      return reject(error);\n    }\n\n    return resolve(response);\n  });\n});\n\nexport const sendEmail = (params: EmailType): Promise<boolean> => {\n  const {\n    app = {},\n    html,\n    subject,\n    subTitle = '',\n    text,\n    title = '',\n    user = {}\n  } = params;\n\n  const to = [user.email];\n  let promise;\n\n  const formatSubject: string = appTemplate(app, subject);\n  const formatSubTitle: string = appTemplate(app, subTitle);\n  const formatTitle: string = appTemplate(app, title);\n  const formatText: string = appTemplate(app, text);\n  const formatHtml: string = appTemplate(app, html);\n  const {_key: hasCustomEmail, urlFacebook, urlTwitter} = app;\n\n  const parseTemplate = (body: string) => {\n    const templateBody: string = appTemplate(app, body || '');\n\n    // Links\n    let links: string = '';\n    const spacer = '<td width=\"5\"><img width=\"1\" height=\"1\" border=\"0\" title=\"\" alt=\"\" ' +\n      'src=\"https://box.reaktor.io/images/email/spacer.gif\"/></td>';\n\n    if(urlFacebook) {\n      links = `<td width=\"30\"><a href=\"${urlFacebook}\"><img width=\"30\" height=\"30\" border=\"0\" ` +\n        'title=\"Facebook\" alt=\"Facebook\" src=\"https://box.reaktor.io/images/email/icon-facebook.png\"/></a></td>';\n    }\n\n    if(urlTwitter) {\n      if(urlFacebook) {\n        links += spacer;\n      }\n\n      links += `<td width=\"30\"><a href=\"${urlTwitter}\"><img width=\"30\" height=\"30\" border=\"0\" ` +\n        'title=\"Twitter\" alt=\"Twitter\" src=\"https://box.reaktor.io/images/email/icon-twitter.png\"/></a></td>';\n    }\n\n    if(!links.length) {\n      links += spacer;\n    }\n\n    return templateBody.replace(/\\[title\\]/g, formatTitle)\n      .replace(/\\[subTitle\\]/g, formatSubTitle)\n      .replace(/\\[subject\\]/g, formatSubject)\n      .replace(/\\[message\\]/g, formatHtml)\n      .replace(/\\[links\\]/g, links);\n  };\n\n  if(hasCustomEmail) {\n    const s3Params: GetObjectRequest = {Bucket: null, Key: 'apps/templates/email.html'};\n    promise = s3Get(s3Params).then((results) => parseTemplate(results.Body.toString()));\n  } else {\n    promise = Promise.resolve(parseTemplate(layoutTemplate));\n  }\n\n  return promise.then((parsedHtml: string) => {\n    const emailParams: SendEmailRequest = {\n      Destination: {ToAddresses: to},\n      Message: {\n        Body: {\n          Html: {Data: parsedHtml},\n          Text: {Data: formatText}\n        },\n        Subject: {Data: formatSubject}\n      },\n      Source: `\"${app.supportName}\" <noreply@${Config.get('app.url')}>`\n    };\n\n    return sesSend(emailParams);\n  });\n};\n\nexport const sendTemplate = (templateName: string, emailParams: EmailType): Promise<boolean> => {\n  const {app, user, subject, subTitle, title, vars}: EmailType = emailParams;\n  let html: string;\n  let text: string;\n\n  try {\n    switch(templateName) {\n      case 'passwordForgot': {\n        html = forgotEmailTemplate;\n        text = forgotSmsTemplate;\n        break;\n      }\n      case 'passwordRecovery': {\n        html = recoveryEmailTemplate;\n        text = recoverySmsTemplate;\n        break;\n      }\n      case 'verifyRecovery': {\n        html = verifyEmailTemplate;\n        text = verifySmsTemplate;\n        break;\n      }\n      case 'verifyEmail': {\n        html = verifyEmailTemplate;\n        text = verifySmsTemplate;\n        break;\n      }\n      case 'welcome': {\n        html = welcomeEmailTemplate;\n        text = welcomeSmsTemplate;\n        break;\n      }\n    }\n\n    const templateHtml: string = appTemplate(app, html, vars);\n    const templateText: string = appTemplate(app, text, vars);\n\n    const params = {\n      app,\n      html: templateHtml,\n      subTitle,\n      subject,\n      text: templateText,\n      title,\n      user\n    };\n\n    return sendEmail(params)\n      .then(() => true)\n      .catch(() => false);\n  } catch(error) {\n    return Promise.reject(error);\n  }\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/actions/files.js

@@ -0,0 +1,319 @@
+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, {
+  addFile: () => addFile,
+  createFile: () => createFile,
+  decodeBase64: () => decodeBase64,
+  encodeBase64: () => encodeBase64,
+  getGiphySearch: () => getGiphySearch,
+  getGiphyTrends: () => getGiphyTrends,
+  getPathUserFiles: () => getPathUserFiles,
+  getUrlUserFiles: () => getUrlUserFiles,
+  getYouTubeSearch: () => getYouTubeSearch,
+  getYouTubeTrends: () => getYouTubeTrends,
+  linkFiles: () => linkFiles,
+  updateFiles: () => updateFiles
+});
+var import_rip_hunter = __toModule(require("@nlabs/rip-hunter"));
+var import_utils = __toModule(require("@nlabs/utils"));
+var import_arangojs = __toModule(require("arangojs"));
+var import_googleapis = __toModule(require("googleapis"));
+var import_graphql_errors = __toModule(require("graphql-errors"));
+var import_isEmpty = __toModule(require("lodash/isEmpty"));
+var request = __toModule(require("request-promise"));
+var import_config = __toModule(require("../config"));
+var import_images = __toModule(require("./images"));
+var import_posts = __toModule(require("./posts"));
+const youtube = import_googleapis.google.youtube({ auth: import_config.Config.get("google.key"), version: "v3" });
+request.defaults({ encoding: null });
+const addFile = (context, item = {}) => {
+  const { database, session: { userId: sessionId, userAccess } } = context;
+  const {
+    description,
+    fileId,
+    fileType,
+    name,
+    url
+  } = item;
+  const formatFileId = fileId ? (0, import_utils.parseId)(fileId) : (0, import_utils.createHash)(`file-${sessionId}`);
+  const isUrl = (0, import_isEmpty.default)(url);
+  let formatName = (0, import_utils.parseString)(name, 160);
+  let formatType = (0, import_utils.parseString)(fileType, 16);
+  if (formatName === "" && isUrl) {
+    formatName = url.substring(url.lastIndexOf("/") + 1);
+  }
+  if (formatType === "") {
+    const nameArr = formatName.split(".");
+    const ext = 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;
+  switch (formatType) {
+    case "image/jpeg":
+    case "image/png":
+      isImage = true;
+      break;
+    default:
+      isImage = false;
+      break;
+  }
+  const formatDesc = (0, import_utils.parseString)(description, 500);
+  if (!isImage && userAccess !== 2) {
+    throw new import_graphql_errors.UserError("account_restriction");
+  }
+  const saveToDb = (insert) => {
+    const aqlQry = import_arangojs.aql`INSERT ${insert} IN files RETURN NEW`;
+    return database.query(aqlQry).then((cursor) => cursor.next()).then((file = {}) => file).catch((error) => {
+      throw error;
+    });
+  };
+  const uploadFile = (buf, uploadType) => {
+    const now = Date.now();
+    if (isImage) {
+      return (0, import_images.resizeSaveImage)(context, formatFileId, buf, uploadType).then((resizedImage) => {
+        const insert2 = __spreadProps(__spreadValues({}, resizedImage), {
+          _key: formatFileId,
+          added: now,
+          description: formatDesc,
+          fileType: formatType,
+          modified: now,
+          name: formatName,
+          userId: sessionId
+        });
+        return saveToDb(insert2);
+      }).catch((error) => {
+        throw error;
+      });
+    }
+    const insert = {
+      _key: formatFileId,
+      added: now,
+      description: formatDesc,
+      fileType: formatType,
+      modified: now,
+      name: formatName,
+      userId: sessionId
+    };
+    return saveToDb(insert);
+  };
+  if (isUrl) {
+    return request.get({ encoding: null, uri: url }).then((body) => uploadFile(Buffer.from(body, "binary"), formatType)).catch(() => {
+      throw new import_graphql_errors.UserError("file_request");
+    });
+  } else if (item.base64 !== "") {
+    const buffer = Buffer.from(item.base64);
+    return uploadFile(buffer, formatType);
+  }
+  throw new Error("file_required");
+};
+const getGiphyTrends = (context, limit = 30) => {
+  const gifUrl = `http://api.giphy.com/v1/gifs/trending?api_key=${import_config.Config.get("giphy.key")}&limit=${limit}`;
+  return (0, import_rip_hunter.get)(gifUrl).then((res) => 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
+    };
+  }));
+};
+const getGiphySearch = (context, query, limit = 30) => {
+  const formatQuery = encodeURI(query);
+  const gifUrl = `http://api.giphy.com/v1/gifs/search?q=${formatQuery}&api_key=${import_config.Config.get("giphy.key")}&limit=${limit}`;
+  return fetch(gifUrl).then((res) => 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
+    };
+  }));
+};
+const getYouTubeTrends = (context, limit = 30) => new Promise((resolve, reject) => {
+  youtube.videos.list({
+    chart: "mostPopular",
+    maxResults: limit,
+    part: ["snippet"],
+    regionCode: "US"
+  }, (error, data) => {
+    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);
+    }
+  });
+});
+const getYouTubeSearch = (context, query, limit = 30) => new Promise((resolve, reject) => {
+  youtube.search.list({
+    maxResults: limit,
+    part: ["snippet"],
+    q: query,
+    regionCode: "US"
+  }, (error, data) => {
+    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);
+    }
+  });
+});
+const getPathUserFiles = (userId, filename) => `users/${userId}/files/${filename}`;
+const getUrlUserFiles = (userId, filename, dir = "files", type = "profile") => {
+  if (filename) {
+    return `https://box.${import_config.Config.get("app.url")}/users/${userId}/${dir}/${filename}`;
+  }
+  if (type === "profile") {
+    return `https://box.${import_config.Config.get("app.url")}/defaults/user_bk.jpg`;
+  }
+  return `https://box.${import_config.Config.get("app.url")}/defaults/user_wh.jpg`;
+};
+const createFile = (db, file) => {
+  const { fileId } = file;
+  const insert = {
+    _key: fileId,
+    added: Date.now()
+  };
+  const aqlQry = import_arangojs.aql`UPSERT {_key: ${fileId}}
+    INSERT ${insert}
+    UPDATE {}
+    IN files RETURN NEW`;
+  return db.query(aqlQry).then((cursor) => cursor.next()).then((updatedFile = {}) => updatedFile).catch((error) => {
+    throw error;
+  });
+};
+const linkFiles = (db, files, postId) => Promise.all(files.map((file) => createFile(db, file).then((file2) => (0, import_posts.createPostEdge)(db, file2, postId))));
+const updateFiles = (db, postId, files) => {
+  const edgeCollection = db.collection("isPosted");
+  return edgeCollection.inEdges(postId).then((edges) => {
+    if (edges.length) {
+      return Promise.all(edges.map((edge) => {
+        const { _key: edgeKey } = edge;
+        const aqlQry = import_arangojs.aql`REMOVE {_key:${edgeKey}} IN isPosted`;
+        return db.query(aqlQry).catch((error) => {
+          throw error;
+        });
+      })).then(() => {
+        if (files.length) {
+          return linkFiles(db, files, postId).then(() => files);
+        }
+        return files;
+      });
+    } else if (files.length) {
+      return linkFiles(db, files, postId).then(() => files);
+    }
+    return files;
+  }).catch((error) => {
+    throw error;
+  });
+};
+const encodeBase64 = (buffer) => Buffer.from(buffer).toString("base64");
+const decodeBase64 = (dataString) => {
+  const getData = (str) => str.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/) || [];
+  let matches = getData(dataString);
+  if (matches.length !== 3) {
+    matches = getData(decodeURIComponent(dataString));
+    if (matches.length !== 3) {
+      throw Error("Invalid input string");
+    }
+  }
+  return {
+    data: Buffer.from(matches[2], "base64"),
+    type: matches[1]
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addFile,
+  createFile,
+  decodeBase64,
+  encodeBase64,
+  getGiphySearch,
+  getGiphyTrends,
+  getPathUserFiles,
+  getUrlUserFiles,
+  getYouTubeSearch,
+  getYouTubeTrends,
+  linkFiles,
+  updateFiles
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/actions/files.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 {get as httpGet} from '@nlabs/rip-hunter';\nimport {createHash, parseId, parseString} from '@nlabs/utils';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {google} from 'googleapis';\nimport {UserError} from 'graphql-errors';\nimport isEmpty from 'lodash/isEmpty';\nimport * as request from 'request-promise';\nimport {ApiContext} from 'types/auth';\n\nimport {Config} from '../config';\nimport {FileType} from '../types/files';\nimport {resizeSaveImage} from './images';\nimport {createPostEdge} from './posts';\n\nconst youtube = google.youtube({auth: Config.get('google.key'), version: 'v3'});\nrequest.defaults({encoding: null});\n\n// const eventCategory: string = 'files';\n\n// Upload file\nexport const addFile = (context: ApiContext, item: FileType = {}): Promise<FileType> => {\n  const {database, session: {userId: sessionId, userAccess}} = context;\n  const {\n    description,\n    fileId,\n    fileType,\n    name,\n    url\n  } = item;\n\n  // Id\n  const formatFileId: string = fileId ? parseId(fileId) : createHash(`file-${sessionId}`);\n\n  // Name\n  const isUrl: boolean = isEmpty(url);\n\n  // If no name, get it from url path\n  let formatName: string = parseString(name, 160);\n  let formatType: string = parseString(fileType, 16);\n\n  if(formatName === '' && isUrl) {\n    formatName = url.substring(url.lastIndexOf('/') + 1);\n  }\n\n  if(formatType === '') {\n    const nameArr: string[] = formatName.split('.');\n    const ext: string = nameArr[nameArr.length - 1];\n\n    switch(ext) {\n      case 'jpeg':\n      case 'jpg':\n        formatType = 'image/jpeg';\n        break;\n      case 'png':\n        formatType = 'image/png';\n        break;\n      case 'zip':\n        formatType = 'application/zip';\n        break;\n      default:\n        break;\n    }\n  }\n\n  let isImage: boolean;\n\n  switch(formatType) {\n    case 'image/jpeg':\n    case 'image/png':\n      isImage = true;\n      break;\n    default:\n      isImage = false;\n      break;\n  }\n\n  // Description\n  const formatDesc: string = parseString(description, 500);\n\n  // Only allow file uploads to premium users\n  if(!isImage && userAccess !== 2) {\n    throw new UserError('account_restriction');\n  }\n\n  const saveToDb = (insert: FileType) => {\n    const aqlQry: AqlQuery = aql`INSERT ${insert} IN files RETURN NEW`;\n\n    return database.query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next())\n      .then((file = {}) => file)\n      .catch((error: Error) => {\n        throw error;\n      });\n  };\n\n  const uploadFile = (buf: Buffer, uploadType: string) => {\n    const now: number = Date.now();\n\n    // If image, resize and create a thumbnail\n    if(isImage) {\n      return resizeSaveImage(context, formatFileId, buf, uploadType)\n        .then((resizedImage: FileType) => {\n          const insert: FileType = {\n            ...resizedImage,\n            _key: formatFileId,\n            added: now,\n            description: formatDesc,\n            fileType: formatType,\n            modified: now,\n            name: formatName,\n            userId: sessionId\n          };\n\n          return saveToDb(insert);\n        })\n        .catch((error: Error) => {\n          throw error;\n        });\n    }\n    const insert: FileType = {\n      _key: formatFileId,\n      added: now,\n      description: formatDesc,\n      fileType: formatType,\n      modified: now,\n      name: formatName,\n      userId: sessionId\n    };\n\n    return saveToDb(insert);\n  };\n\n  // If file is a url path, download the file and save\n  if(isUrl) {\n    return request.get({encoding: null, uri: url})\n      .then((body) => uploadFile(Buffer.from(body, 'binary'), formatType))\n      .catch(() => {\n        throw new UserError('file_request');\n      });\n  } else if(item.base64 !== '') {\n    const buffer: Buffer = Buffer.from(item.base64);\n    return uploadFile(buffer, formatType);\n  }\n  throw new Error('file_required');\n};\n\n// Giphy\nexport const getGiphyTrends = (context: ApiContext, limit: number = 30): Promise<any[]> => {\n  const gifUrl: string = `http://api.giphy.com/v1/gifs/trending?api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return httpGet(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {\n      const {\n        id,\n        images: {\n          original: {url = ''} = {},\n          fixed_height_small: {url: thumb = ''} = {}\n        } = {}\n      } = gifImage;\n\n      return {\n        id,\n        thumb,\n        type: 'giphy',\n        url\n      };\n    }));\n};\n\nexport const getGiphySearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> => {\n  const formatQuery: string = encodeURI(query);\n  const gifUrl: string = `http://api.giphy.com/v1/gifs/search?q=${formatQuery}&api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return fetch(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {\n      const {\n        id,\n        images: {\n          original: {url = ''} = {},\n          fixed_height_small: {url: thumb = ''} = {}\n        } = {}\n      } = gifImage;\n\n      return {\n        id,\n        thumb,\n        type: 'giphy',\n        url\n      };\n    }));\n};\n\nexport const getYouTubeTrends = (context: ApiContext, limit: number = 30): Promise<any[]> =>\n  new Promise((resolve, reject) => {\n    youtube.videos.list({\n      chart: 'mostPopular',\n      maxResults: limit,\n      part: ['snippet'],\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(error[0].message));\n      } else if(data) {\n        const list = data.items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n\n\nexport const getYouTubeSearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> =>\n  new Promise((resolve, reject) => {\n    youtube.search.list({\n      maxResults: limit,\n      part: ['snippet'],\n      // eslint-disable-next-line\n      q: query,\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(error[0].message));\n      } else if(data) {\n        const {items} = data;\n        const list = items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n\n// Files\nexport const getPathUserFiles = (userId: string, filename: string): string => `users/${userId}/files/${filename}`;\n\nexport const getUrlUserFiles = (userId: string, filename: string, dir: string = 'files', type: string = 'profile'): string => {\n  if(filename) {\n    return `https://box.${Config.get('app.url')}/users/${userId}/${dir}/${filename}`;\n  }\n\n  if(type === 'profile') {\n    return `https://box.${Config.get('app.url')}/defaults/user_bk.jpg`;\n  }\n\n  return `https://box.${Config.get('app.url')}/defaults/user_wh.jpg`;\n};\n\nexport const createFile = (db: Database, file: FileType): Promise<FileType> => {\n  const {fileId} = file;\n  const insert: any = {\n    _key: fileId,\n    added: Date.now()\n  };\n\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${fileId}}\n    INSERT ${insert}\n    UPDATE {}\n    IN files RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((updatedFile: FileType = {}) => updatedFile)\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const linkFiles = (db: Database, files: FileType[], postId: string): Promise<any> =>\n  Promise.all(\n    files.map((file: FileType) => createFile(db, file)\n      .then((file: FileType) => createPostEdge(db, file, postId)))\n  );\n\nexport const updateFiles = (db: Database, postId: string, files: FileType[]): Promise<any> => {\n  const edgeCollection: EdgeCollection = db.collection('isPosted');\n\n  return edgeCollection.inEdges(postId)\n    .then((edges: any) => {\n      if(edges.length) {\n        // Remove linked edges\n        return Promise.all(\n          edges.map((edge) => {\n            const {_key: edgeKey} = edge;\n            const aqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN isPosted`;\n\n            return db.query(aqlQry).catch((error: Error) => {\n              throw error;\n            });\n          }))\n          .then(() => {\n            if(files.length) {\n              // Link files\n              return linkFiles(db, files, postId).then(() => files);\n            }\n            return files;\n          });\n      } else if(files.length) {\n        // Link files\n        return linkFiles(db, files, postId).then(() => files);\n      }\n      return files;\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const encodeBase64 = (buffer: Buffer): string => Buffer.from(buffer).toString('base64');\n\nexport const decodeBase64 = (dataString: string): object => {\n  const getData = (str: string) => str.match(/^data:([A-Za-z-+\\/]+);base64,(.+)$/) || [];\n  // const getData = (base64: string) => base64.substr(base64.indexOf(',') + 1);\n  let matches = getData(dataString);\n\n  if(matches.length !== 3) {\n    // If invalid make sure we don't need to decode\n    matches = getData(decodeURIComponent(dataString));\n\n    // Check it again.\n    if(matches.length !== 3) {\n      throw Error('Invalid input string');\n    }\n  }\n\n  return {\n    data: Buffer.from(matches[2], 'base64'),\n    type: matches[1]\n  };\n};\n"],
  "mappings": "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",
  "names": []
}


package/lib/{data → actions}/groups.d.ts

@@ -1,13 +1,14 @@
+import { Database } from 'arangojs';
 import { ApiContext } from '../types/auth';
-import { GroupEdgeType, GroupType, GroupUserType } from '../types/groups';
+import { GroupEdgeType, GroupType, GroupUser } from '../types/groups';
 export declare const getGroupList: (context: ApiContext, from: number, to: number) => Promise<GroupType[]>;
 export declare const getGroupListByUser: (context: ApiContext, from: number, to: number) => Promise<GroupType[]>;
 export declare const getGroupListByTags: (context: ApiContext, tags: string[], from: number, to: number) => Promise<GroupType[]>;
 export declare const getGroup: (context: ApiContext, itemId: string) => Promise<GroupType>;
 export declare const getGroupDetails: (context: ApiContext, groupId: string) => Promise<GroupType>;
-export declare const createGroupEdge: (database: string, userId: string, groupId: string, type: string) => Promise<GroupEdgeType>;
+export declare const createGroupEdge: (database: Database, userId: string, groupId: string) => Promise<GroupEdgeType>;
 export declare const addGroup: (context: ApiContext, item?: GroupType) => Promise<GroupType>;
 export declare const updateGroup: (context: ApiContext, item?: GroupType) => Promise<GroupType>;
 export declare const deleteGroup: (context: ApiContext, itemId: string) => Promise<GroupType>;
 export declare const getGroupsByReaction: (context: ApiContext, reaction: string) => Promise<GroupType[]>;
-export declare const isGrouped: (database: string, userId: string, groupId: string) => Promise<GroupUserType>;
+export declare const isGrouped: (database: Database, userId: string, groupId: string) => Promise<GroupUser>;