⚡️ improved media sending process #2675

smashah · smashah · commit c5c4e0d4bb6f · 2022-11-15T19:55:53.000Z
diff --git a/src/api/Client.ts b/src/api/Client.ts
@@ -34,7 +34,7 @@ import { Listener } from 'eventemitter2';
 import PriorityQueue from 'p-queue/dist/priority-queue';
 import { MessagePreprocessors } from '../structures/preProcessors';
 import { NextFunction, Request, Response } from 'express';
-import { base64MimeType, ensureDUrl, generateGHIssueLink, getDUrl, isBase64, isDataURL, now } from '../utils/tools';
+import { assertFile, base64MimeType, ensureDUrl, FileOutputTypes, generateGHIssueLink, getDUrl, isBase64, isDataURL, now, rmFileAsync } from '../utils/tools';
 import { Call } from './model/call';
 import { AdvancedButton, Button, LocationButtonBody, Section } from './model/button';
 import { JsonObject } from 'type-fest';
@@ -102,6 +102,7 @@ declare module WAPI {
   const getMessageById: (mesasgeId: string) => Message;
   const getMessageInfo: (mesasgeId: string) => Promise<any>;
   const getOrder: (id: string) => Order;
+  const createTemporaryFileInput: () => any;
   const getMyLastMessage: (chatId: string) => Promise<Message>;
   const getStarredMessages: (chatId: string) => Promise<Message[]>;
   const starMessage: (messageId: string) => Promise<boolean>;
@@ -1743,32 +1744,47 @@ public async testCallback(callbackToTest: SimpleListener, testData: any)  : Prom
     ptt?:boolean,
     withoutPreview?:boolean,
     hideTags ?: boolean,
-    viewOnce ?: boolean
+    viewOnce ?: boolean,
+    requestConfig ?: any
   ) : Promise<MessageId | boolean> {
-      //check if the 'base64' file exists
-      if(!isDataURL(file) && !isBase64(file) && !file.includes("data:")) {
-        //must be a file then
-        const relativePath = path.join(path.resolve(process.cwd(),file|| ''));
-        if(fs.existsSync(file) || fs.existsSync(relativePath)) {
-          file = await datauri(fs.existsSync(file)  ? file : relativePath);
-        } else if(isUrl(file)){
-          return await this.sendFileFromUrl(to,file,filename,caption,quotedMsgId,{},waitForId,ptt,withoutPreview, hideTags, viewOnce);
-        } else throw new CustomError(ERROR_NAME.FILE_NOT_FOUND,`Cannot find file. Make sure the file reference is relative, a valid URL or a valid DataURL: ${file.slice(0,25)}`)
-      } else if(file.includes("data:") && file.includes("undefined") || file.includes("application/octet-stream") && filename && mime.lookup(filename)) {
-        file = `data:${mime.lookup(filename)};base64,${file.split(',')[1]}`
-      }
+    const err = [
+     'Not able to send message to broadcast',
+     'Not a contact',
+     'Error: Number not linked to WhatsApp Account',
+     'ERROR: Please make sure you have at least one chat'
+    ];
+
+    /**
+     * TODO: File upload improvements
+     * 1. *Create an arbitrary file input element
+     * 2. *Take the file parameter and create a tempfile in temp dir
+     * 3. Forward the tempfile path to the file input, upload the file to the browser context.
+     * 4. Instruct the WAPI.sendImage function to consume the file from the element in step 1.
+     * 5. *Destroy the input element from the page (happens in wapi.sendimage)
+     * 6. *Unlink/rm the tempfile
+     * 7. Return the ID of the WAPI.sendImage function.
+     */
+    const [[inputElementId, inputElement], fileAsLocalTemp] = await Promise.all([
+      (async ()=>{
+        const inputElementId = await this._page.evaluate(()=>WAPI.createTemporaryFileInput());
+        const inputElement = await this._page.$(`#${inputElementId}`);
+        return [inputElementId, inputElement];
+      })(),
+      assertFile(file, filename, FileOutputTypes.TEMP_FILE_PATH as any,requestConfig || {})
+    ])
+    await inputElement.uploadFile(fileAsLocalTemp as string);
+    file = inputElementId;
     
-   const err = [
-    'Not able to send message to broadcast',
-    'Not a contact',
-    'Error: Number not linked to WhatsApp Account',
-    'ERROR: Please make sure you have at least one chat'
-   ];
+    /**
+     * Old method of asserting that the file be a data url - cons = time wasted serializing/deserializing large file to and from b64.
+     */
+    // file = await assertFile(file, filename, FileOutputTypes.DATA_URL as any,requestConfig || {}) as string
 
     const res = await this.pup(
       ({ to, file, filename, caption, quotedMsgId, waitForId, ptt, withoutPreview, hideTags, viewOnce}) =>  WAPI.sendImage(file, to, filename, caption, quotedMsgId, waitForId, ptt, withoutPreview, hideTags, viewOnce),
       { to, file, filename, caption, quotedMsgId, waitForId, ptt, withoutPreview, hideTags, viewOnce}
     )
+    if(fileAsLocalTemp) await rmFileAsync(fileAsLocalTemp as string)
     if(err.includes(res)) console.error(res);
     return (err.includes(res) ? false : res)  as MessageId | boolean;
   }
diff --git a/src/utils/tools.ts b/src/utils/tools.ts
@@ -1,15 +1,20 @@
+import Crypto from "crypto";
 import * as fs from 'fs'
 import * as path from 'path';
 import datauri from 'datauri'
 import isUrl from 'is-url-superb'
 import { JsonObject } from 'type-fest';
-import { ConfigObject, CustomError, DataURL, ERROR_NAME } from '../api/model';
+import { AdvancedFile, ConfigObject, CustomError, DataURL, ERROR_NAME } from '../api/model';
 import { default as axios, AxiosRequestConfig } from 'axios';
 import { SessionInfo } from '../api/model/sessionInfo';
 import { execSync } from 'child_process';
 import {
   performance
 } from 'perf_hooks';
+import mime from 'mime';
+import { tmpdir } from 'os';
+import { Readable } from "stream";
+import { log } from "../logging/logging";
 
 //@ts-ignore
 process.send = process.send || function () {};
@@ -248,9 +253,13 @@ export const generateGHIssueLink = (config : ConfigObject, sessionInfo: SessionI
  * download it and convert it to a DataURL. If Base64, returns it.
  * @param {string} file - The file to be converted to a DataURL.
  * @param {AxiosRequestConfig} requestConfig - AxiosRequestConfig = {}
+ * @param {string} filename - Filename with an extension so a datauri mimetype can be inferred.
  * @returns A DataURL
  */
-export const ensureDUrl = async (file : string, requestConfig: AxiosRequestConfig = {}) => {
+export const ensureDUrl = async (file : string | Buffer, requestConfig: AxiosRequestConfig = {}, filename?: string) => {
+  if(Buffer.isBuffer(file)) {
+    return `data:${mime.lookup(filename)};base64,${file.toString('base64').split(',')[1]}`
+  } else
   if(!isDataURL(file) && !isBase64(file)) {
       //must be a file then
       const relativePath = path.join(path.resolve(process.cwd(),file|| ''));
@@ -260,5 +269,104 @@ export const ensureDUrl = async (file : string, requestConfig: AxiosRequestConfi
         file = await getDUrl(file, requestConfig);
       } else throw new CustomError(ERROR_NAME.FILE_NOT_FOUND,'Cannot find file. Make sure the file reference is relative, a valid URL or a valid DataURL')
     }
+    if(file.includes("data:") && file.includes("undefined") || file.includes("application/octet-stream") && filename && mime.lookup(filename)) {
+      file = `data:${mime.lookup(filename)};base64,${file.split(',')[1]}`
+    }
     return file;
-}
+}
+
+export const FileInputTypes = {
+  "VALIDATED_FILE_PATH": "VALIDATED_FILE_PATH",
+  "URL": "URL",
+  "DATA_URL": "DATA_URL",
+  "BASE_64": "BASE_64",
+  "BUFFER": "BUFFER",
+  "READ_STREAM": "READ_STREAM",
+}
+
+export const FileOutputTypes = {
+  ...FileInputTypes,
+  "TEMP_FILE_PATH": "TEMP_FILE_PATH",
+}
+
+/**
+ * Remove file asynchronously
+ * @param file Filepath
+ * @returns 
+ */
+export function rmFileAsync(file: string) {
+  return new Promise((resolve, reject) => {
+    fs.unlink(file, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(true);
+      }
+    })
+  })
+}
+
+/**
+ * Takes a file parameter and consistently returns the desired type of file.
+ * @param file The file path, URL, base64 or DataURL string of the file
+ * @param outfileName The ouput filename of the file
+ * @param desiredOutputType The type of file output required from this function
+ * @param requestConfig optional axios config if file parameter is a url
+ */
+export const assertFile : (file: AdvancedFile | Buffer, outfileName: string, desiredOutputType: keyof typeof FileOutputTypes, requestConfig ?: any ) => Promise<string | Buffer | Readable > = async (file, outfileName,  desiredOutputType, requestConfig) => {
+  let inputType;
+  if(typeof file == 'string') {
+    if(isDataURL(file)) inputType = FileInputTypes.DATA_URL
+    else if(isBase64(file)) inputType = FileInputTypes.BASE_64
+    /**
+     * Check if it is a path
+     */
+    else {
+      const relativePath = path.join(path.resolve(process.cwd(),file|| ''));
+      if(fs.existsSync(file) || fs.existsSync(relativePath)) {
+        // file = await datauri(fs.existsSync(file)  ? file : relativePath);
+        inputType = FileInputTypes.VALIDATED_FILE_PATH; 
+      } else if(isUrl(file)) inputType = FileInputTypes.URL; 
+      /**
+       * If not file type is determined by now then it is some sort of unidentifiable string. Throw an error.
+       */
+      if(!inputType) throw new CustomError(ERROR_NAME.FILE_NOT_FOUND,`Cannot find file. Make sure the file reference is relative, a valid URL or a valid DataURL: ${file.slice(0,25)}`)
+    }
+  } else {
+    if(Buffer.isBuffer(file)) inputType = FileInputTypes.BUFFER
+    /**
+     * Leave space to determine if incoming file parameter is any other type of object (maybe one day people will submit a path object as a param?)
+     */
+  }
+  if(inputType === desiredOutputType) return file;
+  switch(desiredOutputType) {
+    case FileOutputTypes.DATA_URL:
+    case FileOutputTypes.BASE_64:
+      return await ensureDUrl(file as string, requestConfig, outfileName);
+      break;
+    case FileOutputTypes.TEMP_FILE_PATH: {
+      /**
+       * Create a temp file in tempdir, return the tempfile.
+       */
+      const tempFilePath = path.join(tmpdir(),`${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.${outfileName}`);
+      log.info(`Saved temporary file to ${tempFilePath}`)
+      if(inputType != FileInputTypes.BUFFER){
+        file = await ensureDUrl(file as string, requestConfig, outfileName);
+        file = Buffer.from(file.split(',')[1], 'base64')
+      }
+      await fs.writeFileSync(tempFilePath, file);
+      return tempFilePath
+      break;
+    }
+    case FileOutputTypes.BUFFER:
+      return Buffer.from((await ensureDUrl(file as string, requestConfig, outfileName)).split(',')[1], 'base64');
+      break;
+    case FileOutputTypes.READ_STREAM: {
+      if(inputType === FileInputTypes.VALIDATED_FILE_PATH) return fs.createReadStream(file)
+      else if(inputType != FileInputTypes.BUFFER) file = Buffer.from((await ensureDUrl(file as string, requestConfig, outfileName)).split(',')[1], 'base64')
+      return Readable.from(file)
+      break;
+    }
+  }
+  return file;
+} 
