Merge pull request #1312 from AutomaApp/dev

v1.28.4

package.json

@@ -1,6 +1,6 @@
 {
   "name": "automa",
-  "version": "1.28.1",
+  "version": "1.28.4",
   "description": "An extension for automating your browser by connecting blocks",
   "repository": {
     "type": "git",

src/components/newtab/workflow/edit/EditGoogleSheetsDrive.vue

@@ -91,7 +91,11 @@ function updateData(value) {
   emit('update:data', { ...props.data, ...value });
 }
 function connectSheet() {
-  openGDriveFilePicker().then(({ name, id, mimeType }) => {
+  openGDriveFilePicker().then((result) => {
+    if (!result) return;
+
+    const { name, id, mimeType } = result;
+
     if (mimeType !== 'application/vnd.google-apps.spreadsheet') {
       toast.error('File is not a google spreadsheet');
       return;

src/content/handleSelector.js

@@ -36,7 +36,7 @@ export function queryElements(data, documentCtx = document) {
       if (isElNotFound && data.waitForSelector) {
         setTimeout(findSelector, 200);
       } else {
-        clearTimeout(timeout);
+        if (timeout) clearTimeout(timeout);
         resolve(elements);
       }
     };

src/content/index.js

@@ -33,25 +33,20 @@ function messageToFrame(frameElement, blockData) {
     }
     window.addEventListener('message', onMessage);
 
-    frameElement.contentWindow.postMessage(
-      {
-        type: 'automa:execute-block',
-        blockData: { ...blockData, frameSelector: '' },
-      },
-      '*'
-    );
+    const messageId = `message:${nanoid(4)}`;
+    browser.storage.local.set({ [messageId]: true }).then(() => {
+      frameElement.contentWindow.postMessage(
+        {
+          messageId,
+          type: 'automa:execute-block',
+          blockData: { ...blockData, frameSelector: '' },
+        },
+        '*'
+      );
+    });
   });
 }
 async function executeBlock(data) {
-  if ((data.name || data.label) === 'javascript-code') {
-    const { workflowStates } = await browser.storage.local.get(
-      'workflowStates'
-    );
-    if (workflowStates && workflowStates.length === 0) {
-      throw new Error('Invalid execution');
-    }
-  }
-
   const removeExecutedBlock = showExecutedBlock(data, data.executedBlockOnWeb);
   if (data.data?.selector?.includes('|>')) {
     const [frameSelector, selector] = data.data.selector.split(/\|>(.+)/);
@@ -112,52 +107,74 @@ async function executeBlock(data) {
 
   throw error;
 }
-function messageListener({ data, source }) {
-  if (data.type === 'automa:get-frame' && isMainFrame) {
-    let frameRect = { x: 0, y: 0 };
+async function messageListener({ data, source }) {
+  try {
+    if (data.type === 'automa:get-frame' && isMainFrame) {
+      let frameRect = { x: 0, y: 0 };
 
-    document.querySelectorAll('iframe').forEach((iframe) => {
-      if (iframe.contentWindow !== source) return;
+      document.querySelectorAll('iframe').forEach((iframe) => {
+        if (iframe.contentWindow !== source) return;
 
-      frameRect = iframe.getBoundingClientRect();
-    });
+        frameRect = iframe.getBoundingClientRect();
+      });
 
-    source.postMessage(
-      {
-        frameRect,
-        type: 'automa:the-frame-rect',
-      },
-      '*'
-    );
+      source.postMessage(
+        {
+          frameRect,
+          type: 'automa:the-frame-rect',
+        },
+        '*'
+      );
 
-    return;
-  }
+      return;
+    }
 
-  if (data.type === 'automa:execute-block') {
-    executeBlock(data.blockData)
-      .then((result) => {
-        window.top.postMessage(
-          {
-            result,
-            type: 'automa:block-execute-result',
-          },
-          '*'
-        );
-      })
-      .catch((error) => {
-        console.error(error);
+    if (data.type === 'automa:execute-block') {
+      const messageToken = await browser.storage.local.get(data.messageId);
+      if (!data.messageId || !messageToken[data.messageId]) {
         window.top.postMessage(
           {
             result: {
               $isError: true,
-              message: error.message,
-              data: error.data || {},
+              message: 'Block id is empty',
+              data: {},
             },
             type: 'automa:block-execute-result',
           },
           '*'
         );
-      });
+        return;
+      }
+
+      await browser.storage.local.remove(data.messageId);
+
+      executeBlock(data.blockData)
+        .then((result) => {
+          window.top.postMessage(
+            {
+              result,
+              type: 'automa:block-execute-result',
+            },
+            '*'
+          );
+        })
+        .catch((error) => {
+          console.error(error);
+          window.top.postMessage(
+            {
+              result: {
+                $isError: true,
+                message: error.message,
+                data: error.data || {},
+              },
+              type: 'automa:block-execute-result',
+            },
+            '*'
+          );
+        });
+    }
+  } catch (error) {
+    console.error(error);
   }
 }
 

src/content/services/webService.js

@@ -210,7 +210,6 @@ window.addEventListener('app-mounted', async () => {
     ]);
 
     const setUserSession = async () => {
-      console.log(session);
       const saveToStorage = { session };
 
       const isGoogleProvider =

src/utils/api.js

@@ -110,7 +110,8 @@ export async function getUserWorkflows(useCache = true) {
       try {
         const { lastBackup } = await browser.storage.local.get('lastBackup');
         const response = await fetchApi(
-          `/me/workflows?lastBackup=${(useCache && lastBackup) || null}`
+          `/me/workflows?lastBackup=${(useCache && lastBackup) || null}`,
+          { auth: true }
         );
 
         if (!response.ok) throw new Error(response.statusText);

src/utils/openGDriveFilePicker.js

@@ -86,7 +86,7 @@ export default async function () {
   if (!sessionToken || !sessionToken.access) return null;
 
   const isGoogleProvider =
-    session?.user?.user_metadata?.iss.includes('googleapis.com');
+    session?.user?.user_metadata?.iss.includes('google.com');
   if (!isGoogleProvider) return null;
 
   const result = await selectFile(sessionToken.access);

src/workflowEngine/WorkflowState.js

@@ -8,6 +8,8 @@ class WorkflowState {
 
     this.states = new Map();
     this.eventListeners = {};
+
+    this.storageTimeout = null;
   }
 
   _updateBadge() {
@@ -16,8 +18,14 @@ class WorkflowState {
   }
 
   _saveToStorage() {
-    const states = Object.fromEntries(this.states);
-    return this.storage.set(this.key, states);
+    if (this.storageTimeout) return;
+
+    this.storageTimeout = setTimeout(() => {
+      this.storageTimeout = null;
+
+      const states = Object.fromEntries(this.states);
+      this.storage.set(this.key, states);
+    }, 1000);
   }
 
   dispatchEvent(name, params) {
@@ -65,7 +73,7 @@ class WorkflowState {
   async add(id, data = {}) {
     this.states.set(id, data);
     this._updateBadge();
-    await this._saveToStorage(this.key);
+    this._saveToStorage(this.key);
   }
 
   async stop(id) {
@@ -89,7 +97,7 @@ class WorkflowState {
       ...state,
       status: 'running',
     });
-    await this._saveToStorage();
+    this._saveToStorage();
 
     this.dispatchEvent('resume', { id, nextBlock });
   }
@@ -105,14 +113,14 @@ class WorkflowState {
 
     this.states.set(id, { ...state, ...data });
     this.dispatchEvent('update', { id, data });
-    await this._saveToStorage();
+    this._saveToStorage();
   }
 
   async delete(id) {
     this.states.delete(id);
     this.dispatchEvent('delete', id);
     this._updateBadge();
-    await this._saveToStorage();
+    this._saveToStorage();
   }
 }
 

src/workflowEngine/WorkflowWorker.js

@@ -30,7 +30,7 @@ function blockExecutionWrapper(blockHandler, blockData) {
         reject(error);
       })
       .finally(() => {
-        clearTimeout(timeout);
+        if (timeout) clearTimeout(timeout);
       });
   });
 }
@@ -319,9 +319,13 @@ class WorkflowWorker {
       }
 
       if (result.nextBlockId && !result.destroyWorker) {
-        setTimeout(() => {
+        if (blockDelay > 0) {
+          setTimeout(() => {
+            executeBlocks(result.nextBlockId, result.data);
+          }, blockDelay);
+        } else {
           executeBlocks(result.nextBlockId, result.data);
-        }, blockDelay);
+        }
       } else {
         this.engine.destroyWorker(this.id);
       }

src/workflowEngine/blocksHandler/handlerCreateElement.js

@@ -11,6 +11,9 @@ function getAutomaScript(refData) {
 const ${varName} = ${JSON.stringify(refData)};
 ${automaRefDataStr(varName)}
 function automaSetVariable(name, value) {
+  const variables = ${varName}.variables;
+  if (!variables) ${varName}.variables = {}
+
   ${varName}.variables[name] = value;
 }
 function automaExecWorkflow(options = {}) {

src/workflowEngine/blocksHandler/handlerJavascriptCode.js

@@ -16,11 +16,14 @@ import {
 
 const nanoid = customAlphabet('1234567890abcdef', 5);
 
-function getAutomaScript(varName, refData, everyNewTab, isEval = false) {
+function getAutomaScript({ varName, refData, everyNewTab, isEval = false }) {
   let str = `
 const ${varName} = ${JSON.stringify(refData)};
 ${automaRefDataStr(varName)}
 function automaSetVariable(name, value) {
+  const variables = ${varName}.variables;
+  if (!variables) ${varName}.variables = {}
+
   ${varName}.variables[name] = value;
 }
 function automaNextBlock(data, insert = true) {
@@ -74,12 +77,12 @@ async function executeInWebpage(args, target, worker) {
   const { debugMode } = worker.engine.workflow.settings;
   const cspResult = await checkCSPAndInject({ target, debugMode }, () => {
     const { 0: blockData, 1: preloadScripts, 3: varName } = args;
-    const automaScript = getAutomaScript(
+    const automaScript = getAutomaScript({
       varName,
-      blockData.refData,
-      blockData.data.everyNewTab,
-      true
-    );
+      isEval: true,
+      refData: blockData.refData,
+      everyNewTab: blockData.data.everyNewTab,
+    });
     const jsCode = jsContentHandlerEval({
       blockData,
       automaScript,
@@ -124,7 +127,14 @@ export async function javascriptCode({ outputs, data, ...block }, { refData }) {
     frameSelector: this.frameSelector,
   };
   if (data.code.includes('automaRefData')) {
-    payload.refData = { ...refData, secrets: {} };
+    const newRefData = {};
+    Object.keys(refData).forEach((keyword) => {
+      if (!data.code.includes(keyword)) return;
+
+      newRefData[keyword] = refData[keyword];
+    });
+
+    payload.refData = { ...newRefData, secrets: {} };
   }
 
   const preloadScriptsPromise = await Promise.allSettled(
@@ -155,7 +165,11 @@ export async function javascriptCode({ outputs, data, ...block }, { refData }) {
   const automaScript =
     data.everyNewTab && (!data.context || data.context !== 'background')
       ? ''
-      : getAutomaScript(instanceId, payload.refData, data.everyNewTab);
+      : getAutomaScript({
+          varName: instanceId,
+          refData: payload.refData,
+          everyNewTab: data.everyNewTab,
+        });
 
   if (data.context !== 'background') {
     await waitTabLoaded({

src/workflowEngine/utils/testConditions.js

@@ -88,20 +88,27 @@ export default async function (conditionsArr, workflowData) {
     if (type.startsWith('code')) {
       let conditionValue;
 
+      const newRefData = {};
+      Object.keys(workflowData.refData).forEach((keyword) => {
+        if (!copyData.code.includes(keyword)) return;
+
+        newRefData[keyword] = workflowData.refData[keyword];
+      });
+
       if (workflowData.isMV2) {
         conditionValue = await workflowData.sendMessage({
           type: 'condition-builder',
           data: {
             type,
             data: copyData,
-            refData: workflowData.refData,
+            refData: newRefData,
           },
         });
       } else {
         conditionValue = await workflowData.checkCodeCondition({
           data: copyData,
+          refData: newRefData,
           isPopup: workflowData.isPopup,
-          refData: workflowData.refData,
         });
       }