@inboxsdk/core 0.2.27 → 0.2.28-alpha.1

package/src/injected-js/inbox/setupAjaxInterceptor.js

@@ -0,0 +1,268 @@
+/* @flow */
+
+import intersection from 'lodash/intersection';
+import censorJSONTree from '../../common/censorJSONTree';
+import * as logger from '../injected-logger';
+import XHRProxyFactory from '../xhr-proxy-factory';
+
+import type { XHRProxyConnectionDetails } from '../xhr-proxy-factory';
+
+function logErrorExceptEventListeners(err, details) {
+  // Don't log the page's own errors
+  if (details !== 'XMLHttpRequest event listener error') {
+    logger.error(err, details);
+  } else {
+    setTimeout(function () {
+      // let window.onerror log this
+      throw err;
+    }, 1);
+  }
+}
+
+function triggerEvent(detail) {
+  document.dispatchEvent(
+    new CustomEvent('inboxSDKajaxIntercept', {
+      bubbles: true,
+      cancelable: false,
+      detail,
+    })
+  );
+}
+
+export default function setupAjaxInterceptor() {
+  const main_wrappers = [];
+
+  global.XMLHttpRequest = XHRProxyFactory(
+    global.XMLHttpRequest,
+    main_wrappers,
+    { logError: logErrorExceptEventListeners }
+  );
+
+  {
+    let currentSuggestionsConnection;
+    main_wrappers.push({
+      isRelevantTo(connection) {
+        if (/sync(?:\/u\/\d+)?\/suggest/.test(connection.url)) {
+          // we only want to keep track of the most recent search —
+          // if the user is typing 'hello' there's no point in worrying about
+          // each of the individual letters. In fact, sending them to our
+          // suggestion-handling code leads to extra complexity.
+          currentSuggestionsConnection = connection;
+          return true;
+        } else {
+          return false;
+        }
+      },
+      afterListeners(connection) {
+        if (
+          connection.status === 200 &&
+          connection.originalSendBody &&
+          connection === currentSuggestionsConnection
+        ) {
+          const originalRequest = JSON.parse(connection.originalSendBody);
+          // The suggestions request object contains two keys — one is always '1',
+          // the other is a number that seems somewhat consistent but not consistent
+          // enough to be safe to hard-code. The search query lives inside the
+          // property the latter property.
+          const queryKey = Object.keys(originalRequest).find(
+            (key) => key !== '1'
+          );
+          // Descend into the object that has the query inside it.
+          const queryObj = originalRequest[queryKey];
+          // When an empty search box is first focused, a suggestions request
+          // goes out that is some kind of special query (it doesn't include
+          // a user-supplied query). This initial request has multiple keys inside
+          // the object that usually contains the query, so we avoid taking action
+          // on requests where the object that contains the query has more
+          // than one key. If we confirm that there is only a single key, we grab
+          // the value out of the '1' key since that is always what holds a
+          // user-supplied query.
+          const query = Object.keys(queryObj).length === 1 && queryObj['1'];
+
+          if (query) {
+            triggerEvent({ type: 'searchSuggestionsReceieved', query });
+          }
+        }
+      },
+    });
+  }
+
+  {
+    let isComposeViewSending = false;
+    let sendRequestMisses = [];
+    document.addEventListener('inboxSDKcomposeViewIsSending', () => {
+      isComposeViewSending = true;
+      sendRequestMisses = [];
+    });
+    document.addEventListener('inboxSDKcomposeViewSendCanceled', () => {
+      isComposeViewSending = false;
+      sendRequestMisses = [];
+    });
+    const logIfParseFailed = (request) => {
+      if (!isComposeViewSending) return;
+
+      sendRequestMisses.push(request);
+
+      if (sendRequestMisses.length < 3) return;
+
+      logger.error(new Error('Failed to identify outgoing send request'), {
+        requestPayloadList: censorJSONTree(sendRequestMisses),
+      });
+
+      isComposeViewSending = false;
+      sendRequestMisses = [];
+    };
+
+    const SEND_ACTIONS = ['^pfg', '^f_bt', '^f_btns', '^f_cl'];
+    const currentConnectionIDs: WeakMap<XHRProxyConnectionDetails, string> =
+      new WeakMap();
+    main_wrappers.push({
+      isRelevantTo(connection) {
+        return /sync(?:\/u\/\d+)?\/i\/s/.test(connection.url);
+      },
+      originalSendBodyLogger(connection) {
+        if (connection.originalSendBody) {
+          const originalRequest = JSON.parse(connection.originalSendBody);
+
+          const updateList = originalRequest[2] && originalRequest[2][1];
+          if (!updateList) {
+            logIfParseFailed(originalRequest);
+            return;
+          }
+
+          const sendUpdateMatch = updateList.find((update) => {
+            const updateWrapper =
+              update[2] &&
+              update[2][2] &&
+              (update[2][2][14] || update[2][2][2]);
+            const isMessageUpdate =
+              updateWrapper &&
+              updateWrapper[1] &&
+              updateWrapper[1][1] &&
+              updateWrapper[1][1].indexOf('msg-a:') > -1;
+
+            return (
+              isMessageUpdate &&
+              updateWrapper[1][11] &&
+              intersection(updateWrapper[1][11], SEND_ACTIONS).length ===
+                SEND_ACTIONS.length
+            );
+          });
+          if (!sendUpdateMatch) {
+            logIfParseFailed(originalRequest);
+            return;
+          }
+
+          const sendUpdateWrapper =
+            sendUpdateMatch[2] &&
+            sendUpdateMatch[2][2] &&
+            (sendUpdateMatch[2][2][14] || sendUpdateMatch[2][2][2]);
+          const sendUpdate = sendUpdateWrapper[1];
+
+          const draftID = sendUpdate[1].replace('msg-a:', '');
+          const actionList = sendUpdate[11];
+
+          currentConnectionIDs.set(connection, draftID);
+          triggerEvent({ type: 'emailSending', draftID });
+          isComposeViewSending = false;
+          sendRequestMisses = [];
+        }
+      },
+      afterListeners(connection) {
+        if (currentConnectionIDs.has(connection)) {
+          const sendFailed = () => {
+            triggerEvent({ type: 'emailSendFailed', draftID });
+            currentConnectionIDs.delete(connection);
+          };
+
+          const draftID = currentConnectionIDs.get(connection);
+
+          if (connection.status !== 200 || !connection.originalResponseText) {
+            sendFailed();
+            return;
+          }
+
+          const originalResponse = JSON.parse(connection.originalResponseText);
+
+          const updateList = originalResponse[2] && originalResponse[2][6];
+          if (!updateList) {
+            sendFailed();
+            return;
+          }
+
+          const sendUpdateMatch = updateList.find(
+            (update) =>
+              update[1] &&
+              update[1][3] &&
+              update[1][3][7] &&
+              update[1][3][7][1] &&
+              update[1][3][7][1][5] &&
+              update[1][3][7][1][5][0] &&
+              update[1][3][7][1][5][0][14]
+          );
+          if (!sendUpdateMatch) {
+            sendFailed();
+            return;
+          }
+
+          const sendUpdate =
+            sendUpdateMatch[1] &&
+            sendUpdateMatch[1][3] &&
+            sendUpdateMatch[1][3][7] &&
+            sendUpdateMatch[1][3][7][1] &&
+            sendUpdateMatch[1][3][7][1][5] &&
+            sendUpdateMatch[1][3][7][1][5][0];
+
+          const rfcID = sendUpdate[14];
+
+          triggerEvent({
+            type: 'emailSent',
+            rfcID,
+            draftID,
+          });
+
+          currentConnectionIDs.delete(connection);
+        }
+      },
+    });
+  }
+
+  // sync token savers
+  {
+    const saveBTAIHeader = (header) => {
+      (document.head: any).setAttribute('data-inboxsdk-btai-header', header);
+      triggerEvent({ type: 'btaiHeaderReceived' });
+    };
+    main_wrappers.push({
+      isRelevantTo(connection) {
+        return (
+          /sync(?:\/u\/\d+)?\//.test(connection.url) &&
+          !(document.head: any).hasAttribute('data-inboxsdk-btai-header')
+        );
+      },
+      originalSendBodyLogger(connection) {
+        if (connection.headers['X-Gmail-BTAI']) {
+          saveBTAIHeader(connection.headers['X-Gmail-BTAI']);
+        }
+      },
+    });
+
+    const saveXsrfTokenHeader = (header) => {
+      (document.head: any).setAttribute('data-inboxsdk-xsrf-token', header);
+      triggerEvent({ type: 'xsrfTokenHeaderReceived' });
+    };
+    main_wrappers.push({
+      isRelevantTo(connection) {
+        return (
+          /sync(?:\/u\/\d+)?\//.test(connection.url) &&
+          !(document.head: any).hasAttribute('data-inboxsdk-xsrf-token')
+        );
+      },
+      originalSendBodyLogger(connection) {
+        if (connection.headers['X-Framework-Xsrf-Token']) {
+          saveXsrfTokenHeader(connection.headers['X-Framework-Xsrf-Token']);
+        }
+      },
+    });
+  }
+}

package/src/injected-js/inbox/setupClickAndGetNewIframeSrc.js

@@ -0,0 +1,80 @@
+/* @flow */
+
+import once from 'lodash/once';
+import Kefir from 'kefir';
+import { simulateClick } from '../../platform-implementation-js/lib/dom/simulate-mouse-event';
+import makeElementChildStream from '../../platform-implementation-js/lib/dom/make-element-child-stream';
+
+export default function setupClickAndGetNewIframeSrc() {
+  makeElementChildStream(((document.body: any): HTMLElement))
+    .filter(({ el }) => el.nodeName === 'IFRAME' && !el.hasAttribute('src'))
+    .onValue(({ el }) => {
+      const document = (el: any).contentDocument;
+      document.addEventListener(
+        'inboxSDKclickAndGetNewIframeSrc',
+        function (event: Object) {
+          clickAndGetNewIframeSrc(event.target)
+            .then((src) => {
+              event.target.dispatchEvent(
+                new CustomEvent('inboxSDKclickAndGetNewIframeSrcResult', {
+                  bubbles: false,
+                  cancelable: false,
+                  detail: { type: 'success', src },
+                })
+              );
+            })
+            .catch((err) => {
+              event.target.dispatchEvent(
+                new CustomEvent('inboxSDKclickAndGetNewIframeSrcResult', {
+                  bubbles: false,
+                  cancelable: false,
+                  detail: {
+                    type: 'error',
+                    message: err.message,
+                    stack: err.stack,
+                  },
+                })
+              );
+            });
+        }
+      );
+    });
+}
+
+const getIframeProto = once(() =>
+  Object.getPrototypeOf(document.createElement('iframe'))
+);
+
+const getIframeSrcDescriptor = once(() =>
+  Object.getOwnPropertyDescriptor(getIframeProto(), 'src')
+);
+
+const iframeSrcSets: Kefir.Observable<string> = Kefir.stream((emitter) => {
+  const iframeProto = getIframeProto();
+  const originalDescriptor = getIframeSrcDescriptor();
+  (Object: any).defineProperty(iframeProto, 'src', {
+    enumerable: true,
+    configurable: true,
+    set(src) {
+      emitter.emit(src);
+    },
+  });
+  return () => {
+    (Object: any).defineProperty(iframeProto, 'src', originalDescriptor);
+  };
+});
+
+function clickAndGetNewIframeSrc(el: HTMLElement): Promise<string> {
+  const pr = iframeSrcSets
+    .merge(Kefir.later(10 * 1000, null))
+    .take(1)
+    .flatMap((result) =>
+      result
+        ? Kefir.constant(result)
+        : Kefir.constantError(new Error('timed out waiting for iframe src set'))
+    )
+    .toPromise();
+
+  simulateClick(el);
+  return pr;
+}

package/src/injected-js/inbox/setupComposeViewDraftIDFinder.js

@@ -0,0 +1,51 @@
+/* @flow */
+
+const MAX_SEARCH_DEPTH = 3;
+
+const searchCollection = (
+  collection: Object,
+  predicate: (?Object) => boolean,
+  maxDepth: number,
+  currentDepth: number = 0
+) => {
+  const ownKeys = Object.keys(collection);
+  for (let i = 0; i < ownKeys.length; i++) {
+    const value = collection[ownKeys[i]];
+    if (predicate(value)) {
+      return value;
+    } else if (currentDepth <= maxDepth && value instanceof Object) {
+      const match = searchCollection(
+        value,
+        predicate,
+        maxDepth,
+        currentDepth + 1
+      );
+      if (match) return match;
+    }
+  }
+  return null;
+};
+
+const findDraftID = (target) => {
+  const match = searchCollection(
+    target.__cdn.context,
+    (value) => typeof value === 'string' && value.indexOf('#msg-a:') > -1,
+    MAX_SEARCH_DEPTH
+  );
+  return match ? match.replace('#msg-a:', '') : null;
+};
+
+export default function setupComposeViewDraftIDFinder() {
+  document.addEventListener(
+    'inboxSDKgetDraftIDforComposeView',
+    ({ target }: Event) => {
+      const draftID = findDraftID((target: any));
+
+      if (!draftID)
+        throw new Error('could not retrieve draft ID for compose view');
+
+      (target: any).setAttribute('data-inboxsdk-draft-id', draftID);
+    },
+    true
+  );
+}

package/src/injected-js/inbox/setupInboxFakeWindowResizeListener.js

@@ -0,0 +1,29 @@
+/* @flow */
+
+export default function setupInboxFakeWindowResizeListener() {
+  document.addEventListener('inboxSDKinboxFakeWindowResize', fakeWindowResize);
+}
+
+function fakeWindowResize() {
+  (Object: any).defineProperty(document.documentElement, 'clientWidth', {
+    configurable: true,
+    value: window.innerWidth - 1,
+  });
+
+  {
+    const event = document.createEvent('HTMLEvents');
+    (event: any).initEvent('resize', true, false);
+    window.dispatchEvent(event);
+  }
+
+  (Object: any).defineProperty(document.documentElement, 'clientWidth', {
+    configurable: true,
+    get: () => window.innerWidth,
+  });
+
+  {
+    const event = document.createEvent('HTMLEvents');
+    (event: any).initEvent('resize', true, false);
+    window.dispatchEvent(event);
+  }
+}

package/src/injected-js/injected-logger.d.ts

@@ -0,0 +1,3 @@
+export declare function error(err: Error | unknown, details?: any): void;
+export declare function eventSdkPassive(name: string, details?: any, sensitive?: boolean): void;
+//# sourceMappingURL=injected-logger.d.ts.map

package/src/injected-js/injected-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injected-logger.d.ts","sourceRoot":"","sources":["../../../../src/injected-js/injected-logger.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,QAsCxD;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,GAAG,EACb,SAAS,CAAC,EAAE,OAAO,QAepB"}

package/src/injected-js/main.js

@@ -0,0 +1,70 @@
+/* eslint-disable flowtype/require-valid-file-annotation, no-undef */
+
+if (!global.__InboxSDKInjected) {
+  global.__InboxSDKInjected = true;
+
+  const logger = require('./injected-logger');
+  let oldDefine;
+  try {
+    if (typeof define !== 'undefined' && define && define.amd) {
+      // work around amd compatibility issue
+      // https://groups.google.com/forum/#!msg/inboxsdk/U_bq82Exmwc/I3iIinxxCAAJ
+      oldDefine = define;
+      define = null;
+    }
+    const extCorbWorkaroundPageWorld = require('ext-corb-workaround/dist/src/pageWorld');
+    const xhrHelper = require('./xhr-helper').default;
+    const setupDataExposer = require('./setup-data-exposer').default;
+    const setupEventReemitter = require('./setup-event-reemitter').default;
+    const setupErrorSilencer = require('./setup-error-silencer').default;
+    const setupCustomViewEventAssassin =
+      require('./setupCustomViewEventAssassin').default;
+    const setupPushStateListener = require('./setupPushStateListener').default;
+    const setupInboxCustomViewLinkFixer =
+      require('./setupInboxCustomViewLinkFixer').default;
+
+    const gmailInterceptor = require('./gmail/setup-gmail-interceptor').default;
+    const setupGmonkeyHandler =
+      require('./gmail/setup-gmonkey-handler').default;
+
+    const setupClickAndGetNewIframeSrc =
+      require('./inbox/setupClickAndGetNewIframeSrc').default;
+    const setupInboxFakeWindowResizeListener =
+      require('./inbox/setupInboxFakeWindowResizeListener').default;
+    const setupComposeViewDraftIDFinder =
+      require('./inbox/setupComposeViewDraftIDFinder').default;
+    const setupInboxAjaxInterceptor =
+      require('./inbox/setupAjaxInterceptor').default;
+
+    const pageOrigin: string =
+      (process.env.NODE_ENV === 'test' && global.__test_origin) ||
+      document.location.origin;
+
+    if (pageOrigin === 'https://mail.google.com') {
+      gmailInterceptor();
+      setupGmonkeyHandler();
+    } else if (pageOrigin === 'https://inbox.google.com') {
+      setupClickAndGetNewIframeSrc();
+      setupInboxFakeWindowResizeListener();
+      setupComposeViewDraftIDFinder();
+      setupInboxAjaxInterceptor();
+    } else {
+      throw new Error('Should not happen');
+    }
+
+    extCorbWorkaroundPageWorld.init();
+    xhrHelper();
+    setupDataExposer();
+    setupEventReemitter();
+    setupErrorSilencer();
+    setupCustomViewEventAssassin();
+    setupPushStateListener();
+    setupInboxCustomViewLinkFixer();
+  } catch (err) {
+    logger.error(err);
+  } finally {
+    if (oldDefine) {
+      define = oldDefine;
+    }
+  }
+}

package/src/injected-js/message-metadata-holder.js

@@ -0,0 +1,141 @@
+/* @flow */
+
+import querystring from 'querystring';
+import startsWith from 'lodash/startsWith';
+import type { Message } from '../platform-implementation-js/dom-driver/gmail/gmail-response-processor';
+import { extractMessages } from '../platform-implementation-js/dom-driver/gmail/gmail-response-processor';
+import { getThreadFromSyncThreadIdUsingHeaders } from '../platform-implementation-js/dom-driver/gmail/gmail-driver/getSyncThreadFromSyncThreadId';
+import * as logger from './injected-logger';
+import requestGmailThread from '../platform-implementation-js/driver-common/requestGmailThread';
+
+const threadIdToMessages: Map<string, Message[]> = new Map();
+
+export function setup() {
+  document.addEventListener(
+    'inboxSDKtellMeThisMessageDate',
+    function (event: Object) {
+      exposeMetadata(event, 'data-inboxsdk-sortdate', (m) => m.date);
+    }
+  );
+
+  document.addEventListener(
+    'inboxSDKtellMeThisMessageRecipients',
+    function (event: Object) {
+      exposeMetadata(event, 'data-inboxsdk-recipients', (m) => {
+        if (m.recipients) return m.recipients;
+        else return null;
+      });
+    }
+  );
+}
+
+function exposeMetadata(event, attribute, processor) {
+  const {
+    target,
+    detail: { threadId, ikValue, btaiHeader, xsrfToken },
+  } = event;
+
+  (async () => {
+    const messageIndex = Array.from(target.parentElement.children)
+      .filter((el) => !el.classList.contains('inboxsdk__custom_message_view'))
+      .indexOf(target);
+    if (messageIndex < 0) {
+      throw new Error('Should not happen');
+    }
+
+    let message = getMessage(threadId, messageIndex);
+
+    if (message == null || !message.recipients) {
+      try {
+        await addDataForThread(threadId, ikValue, btaiHeader, xsrfToken);
+      } catch (err) {
+        logger.error(err);
+      }
+      message = getMessage(threadId, messageIndex);
+      if (message == null) {
+        throw new Error(
+          'Failed to find message date after re-requesting thread'
+        );
+      }
+    }
+
+    target.setAttribute(attribute, JSON.stringify(processor(message)));
+  })().catch((err) => {
+    target.setAttribute(attribute, 'error');
+    logger.error(err);
+  });
+}
+
+function getMessage(threadId: string, messageIndex: number): ?Message {
+  const messages = threadIdToMessages.get(threadId);
+  if (messages) {
+    const message = messages[messageIndex];
+    if (message) {
+      return message;
+    }
+  }
+}
+
+export function add(
+  groupedMessages: Array<{ threadID: string, messages: Message[] }>
+) {
+  groupedMessages.forEach((group) => {
+    threadIdToMessages.set(group.threadID, group.messages);
+  });
+}
+
+const activeThreadRequestPromises: Map<string, Promise<void>> = new Map();
+
+function addDataForThread(
+  threadId: string,
+  ikValue: string,
+  btaiHeader: ?string,
+  xsrfToken: ?string
+): Promise<void> {
+  const existingRequestPromise = activeThreadRequestPromises.get(threadId);
+  if (existingRequestPromise) {
+    return existingRequestPromise;
+  }
+
+  const newPromise = (async () => {
+    try {
+      if (startsWith(threadId, 'thread')) {
+        // new data layer
+        if (!btaiHeader || !xsrfToken) {
+          throw new Error(
+            'Need btaiHeader and xsrfToken when in new data layer'
+          );
+        }
+        const syncThread = await getThreadFromSyncThreadIdUsingHeaders(
+          threadId,
+          btaiHeader,
+          xsrfToken
+        );
+        if (syncThread) {
+          add([
+            {
+              threadID: syncThread.syncThreadID,
+              messages: syncThread.extraMetaData.syncMessageData.map(
+                (syncMessage) => ({
+                  date: syncMessage.date,
+                  recipients: syncMessage.recipients,
+                })
+              ),
+            },
+          ]);
+        }
+      } else {
+        // legacy gmail
+        const text = await requestGmailThread(ikValue, threadId);
+        add(extractMessages(text));
+      }
+    } catch (err) {
+      logger.error(err);
+    } finally {
+      activeThreadRequestPromises.delete(threadId);
+    }
+  })();
+
+  activeThreadRequestPromises.set(threadId, newPromise);
+  return newPromise;
+}