@inboxsdk/core 0.2.28-alpha.3 → 0.2.28-alpha.5

package/src/injected-js/gmail/setup-gmonkey-handler.js

@@ -0,0 +1,49 @@
+export default function setupGmonkeyHandler() {
+    const gmonkeyPromise = setupGmonkey();
+    document.addEventListener('inboxSDKtellMeIsConversationViewDisabled', function () {
+        gmonkeyPromise.then((gmonkey) => {
+            const answer = gmonkey.isConversationViewDisabled();
+            const event = document.createEvent('CustomEvent');
+            event.initCustomEvent('inboxSDKgmonkeyResponse', false, false, answer);
+            document.dispatchEvent(event);
+        });
+    });
+    document.addEventListener('inboxSDKtellMeCurrentThreadId', function (event) {
+        let threadId;
+        if (event.detail.isPreviewedThread) {
+            const rows = Array.from(document.querySelectorAll('[gh=tl] tr.aps'));
+            if (rows.length > 0) {
+                const elementWithId = rows
+                    .map((row) => row.querySelector('[data-thread-id]'))
+                    .filter(Boolean)[0];
+                if (elementWithId) {
+                    threadId = elementWithId.getAttribute('data-thread-id');
+                }
+                else {
+                    threadId = rows[0].getAttribute('data-inboxsdk-threadid');
+                }
+            }
+        }
+        else {
+            threadId = window.gmonkey?.v2?.getCurrentThread?.()?.getThreadId();
+        }
+        if (threadId) {
+            // hash is included in the sync id route url, so we also need to take it out
+            threadId = threadId.replace('#', '');
+            event.target.setAttribute('data-inboxsdk-currentthreadid', threadId);
+        }
+    });
+}
+function setupGmonkey() {
+    return new Promise((resolve) => {
+        function check() {
+            if (!window.gmonkey) {
+                setTimeout(check, 500);
+            }
+            else {
+                window.gmonkey.load('2.0', resolve);
+            }
+        }
+        check();
+    });
+}

package/src/injected-js/gmail/sync-compose-processor-20220909.js

@@ -0,0 +1,298 @@
+import sortBy from 'lodash/sortBy';
+import intersection from 'lodash/intersection';
+import isNotNil from '../../platform-implementation-js/lib/isNotNil';
+import { DRAFT_SAVING_ACTIONS, SEND_ACTIONS, } from './constants';
+const ACTION_TYPE_PRIORITY_RANK = [
+    'SEND',
+    'DRAFT_SAVE',
+];
+export function parseComposeRequestBody_2022_09_09(request) {
+    return parseCreateUpdateSendDraftRequestBody(request);
+}
+export function parseComposeResponseBody_2022_09_09(response) {
+    return parseCreateUpdateSendDraftResponseBody(response);
+}
+export function replaceBodyContentInComposeSendRequestBody_2022_09_09(request, newBodyHtmlContent) {
+    return replaceBodyContentInSendRequestBody(request, newBodyHtmlContent);
+}
+/**
+ * Parses request body when compose window either saves a draft for the first time,
+ * updates the draft or sends the draft.
+ * NOTE: request could contain multiple threads and messages within it,
+ * prioritize SEND to DRAFT_SAVE message.
+ */
+function parseCreateUpdateSendDraftRequestBody(request) {
+    const updateList = request[1]?.[0];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return null;
+    }
+    const parsedMessages = updateList.map(parseRequestThread).filter(isNotNil);
+    const sorted = sortBy(parsedMessages, (m) => ACTION_TYPE_PRIORITY_RANK.indexOf(m.type));
+    return sorted[0] || null;
+}
+/**
+ * Parses response body when compose window either saved a draft for the first time,
+ * updated the draft, or sent the draft.
+ * NOTE: response could contain multiple threads and messages within it
+ * even not related to a message/thread in the request body.
+ * So the calling code should find needed message manually.
+ */
+function parseCreateUpdateSendDraftResponseBody(response) {
+    const updateList = response[1]?.[5];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return [];
+    }
+    return updateList
+        .map(parseResponseThread)
+        .filter(isNotNil)
+        .flatMap((parsedThread) => {
+        const { threadId, oldThreadId, parsedMessages } = parsedThread;
+        return parsedMessages.map((parsedMessage) => {
+            const { messageId, to, cc, bcc, actions, rfcID, oldMessageId } = parsedMessage;
+            const actionType = actionsToComposeRequestType(actions);
+            if (!actionType) {
+                // unsupported actions within a message
+                return null;
+            }
+            return {
+                threadId,
+                messageId,
+                to,
+                cc,
+                bcc,
+                actions,
+                rfcID,
+                oldMessageId,
+                oldThreadId,
+                type: actionType,
+            };
+        });
+    })
+        .filter(isNotNil);
+}
+function replaceBodyContentInSendRequestBody(request, newBodyHtmlContent) {
+    // since draftID is not passed from outside,
+    // use parse function to find a message which body needs to be replaced
+    const parsed = parseCreateUpdateSendDraftRequestBody(request);
+    if (!parsed) {
+        return null;
+    }
+    const replaceBodyInThisMessageId = parsed.messageId;
+    const updateList = request[1]?.[0];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return null;
+    }
+    for (const threadWrapper of updateList) {
+        if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[1])) {
+            // cannot parse
+            return null;
+        }
+        const thread = threadWrapper[1];
+        const threadId = parseThreadId(thread[0]);
+        if (!threadId) {
+            // cannot parse
+            return null;
+        }
+        const parseResult = findAndParseRequestMessage(thread);
+        if (parseResult?.parsedMsg.messageId === replaceBodyInThisMessageId) {
+            const actionType = actionsToComposeRequestType(parseResult.parsedMsg.actions);
+            if (actionType === 'SEND') {
+                // find first message with needed messageId and 'SEND' action and replace the body content
+                replaceBodyInRequestMsg(parseResult.originalMsg, newBodyHtmlContent);
+                return request;
+            }
+        }
+    }
+    return null;
+}
+function parseThreadId(threadId) {
+    if (!threadId.startsWith('thread-')) {
+        return null;
+    }
+    if (threadId.includes('|')) {
+        return threadId.split('|')[0];
+    }
+    return threadId;
+}
+function parseMsgId(messageId) {
+    if (!messageId.startsWith('msg-')) {
+        // cannot parse
+        return null;
+    }
+    return messageId;
+}
+function parseContacts(contacts) {
+    if (!Array.isArray(contacts)) {
+        // cannot parse
+        return null;
+    }
+    return contacts
+        .filter((c) => !!c[1])
+        .map((c) => ({ emailAddress: c[1], name: c[2] ?? null }));
+}
+function findAndParseRequestMessage(thread) {
+    const originalMsgs = [
+        thread[1]?.[2]?.[0]?.[4]?.[0],
+        thread[1]?.[1]?.[0],
+        thread[1]?.[13]?.[0],
+    ];
+    for (const originalMsg of originalMsgs) {
+        const parsedMsg = parseRequestMsg(originalMsg);
+        if (parsedMsg) {
+            return { parsedMsg, originalMsg };
+        }
+    }
+    return null;
+}
+function parseRequestThread(threadWrapper) {
+    if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[1])) {
+        // cannot parse
+        return null;
+    }
+    const thread = threadWrapper[1];
+    const threadId = parseThreadId(thread[0]);
+    if (!threadId) {
+        // cannot parse
+        return null;
+    }
+    const parseResult = findAndParseRequestMessage(thread);
+    if (!parseResult) {
+        // cannot parse
+        return null;
+    }
+    const { parsedMsg: message, originalMsg } = parseResult;
+    const { messageId, to, cc, bcc, subject, body, actions } = message;
+    let actionType = actionsToComposeRequestType(actions);
+    if (!actionType) {
+        // exit if doesn't have required actions
+        return null;
+    }
+    // usually for draft_save action when draft or reply got saved for first time, response could be different
+    // from usual update response, so replace draft_save action with first_draft_save in this case.
+    if (actionType === 'DRAFT_SAVE' &&
+        (originalMsg === thread[1]?.[2]?.[0]?.[4]?.[0] ||
+            originalMsg === thread[1]?.[1]?.[0])) {
+        actionType = 'FIRST_DRAFT_SAVE';
+    }
+    return {
+        threadId,
+        messageId,
+        to,
+        cc,
+        bcc,
+        subject,
+        body,
+        actions,
+        type: actionType,
+    };
+}
+function parseRequestMsg(msg) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    const messageId = parseMsgId(msg[0]);
+    if (!messageId) {
+        // cannot parse
+        return null;
+    }
+    const subject = msg[7];
+    const to = parseContacts(msg[2]);
+    const cc = parseContacts(msg[3]);
+    const bcc = parseContacts(msg[4]);
+    const body = msg[8][1][0][1];
+    const actions = msg[10];
+    const rfcID = msg[13];
+    const oldMessageId = msg[55];
+    return {
+        messageId,
+        to,
+        cc,
+        bcc,
+        subject,
+        body,
+        actions,
+        rfcID,
+        oldMessageId,
+    };
+}
+function replaceBodyInRequestMsg(msg, newBodyHtmlContent) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    msg[8][1][0][1] = newBodyHtmlContent;
+}
+function parseResponseThread(threadWrapper) {
+    if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[0])) {
+        // cannot parse
+        return null;
+    }
+    const thread = threadWrapper[0];
+    const threadId = parseThreadId(thread[0]);
+    if (!threadId) {
+        // cannot parse
+        return null;
+    }
+    const threadInner = thread[2]?.[6]?.[0];
+    if (!Array.isArray(threadInner)) {
+        // cannot parse
+        return null;
+    }
+    const oldThreadId = threadInner[19];
+    const parsedMessages = Array.isArray(threadInner[4])
+        ? threadInner[4]
+            .map((msg) => {
+            if (!Array.isArray(msg)) {
+                // cannot parse
+                return null;
+            }
+            return parseResponseMsg(msg);
+        })
+            .filter(isNotNil)
+        : [];
+    return {
+        threadId,
+        oldThreadId,
+        parsedMessages,
+    };
+}
+function parseResponseMsg(msg) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    const messageId = parseMsgId(msg[0]);
+    if (!messageId) {
+        // cannot parse
+        return null;
+    }
+    const actions = msg[10];
+    const to = parseContacts(msg[2]);
+    const cc = parseContacts(msg[3]);
+    const bcc = parseContacts(msg[4]);
+    const rfcID = msg[13];
+    const oldMessageId = msg[55];
+    return {
+        messageId,
+        to,
+        cc,
+        bcc,
+        actions,
+        rfcID,
+        oldMessageId,
+    };
+}
+export function actionsToComposeRequestType(actions) {
+    if (intersection(actions, DRAFT_SAVING_ACTIONS).length ===
+        DRAFT_SAVING_ACTIONS.length) {
+        return 'DRAFT_SAVE';
+    }
+    if (intersection(actions, SEND_ACTIONS).length === SEND_ACTIONS.length) {
+        return 'SEND';
+    }
+    return null;
+}

package/src/injected-js/gmail/sync-compose-processor.js

@@ -0,0 +1,55 @@
+import { parseComposeRequestBody_2022_09_09, parseComposeResponseBody_2022_09_09, replaceBodyContentInComposeSendRequestBody_2022_09_09, } from './sync-compose-processor-20220909';
+import { getDetailsOfComposeRequest, replaceEmailBodyForSendRequest, } from './sync-compose-request-processor';
+import * as logger from '../injected-logger';
+export function parseComposeRequestBody(request) {
+    const requestParsed = JSON.parse(request);
+    try {
+        if (Array.isArray(requestParsed)) {
+            const parsed = parseComposeRequestBody_2022_09_09(requestParsed);
+            if (parsed) {
+                return {
+                    type: parsed.type,
+                    to: parsed.to,
+                    cc: parsed.cc,
+                    bcc: parsed.bcc,
+                    draftID: parsed.messageId.replace('msg-a:', ''),
+                    subject: parsed.subject,
+                    body: parsed.body,
+                };
+            }
+            return null;
+        }
+    }
+    catch (err) {
+        logger.eventSdkPassive('connection.requestResponseParsingFailed', {
+            requestParseError: err,
+        });
+    }
+    return getDetailsOfComposeRequest(requestParsed);
+}
+export function parseComposeResponseBody(response) {
+    const responseParsed = JSON.parse(response);
+    if (Array.isArray(responseParsed)) {
+        return parseComposeResponseBody_2022_09_09(responseParsed);
+    }
+    return [];
+}
+export function replaceBodyContentInComposeSendRequestBody(request, newBodyHtmlContent) {
+    const requestParsed = JSON.parse(request);
+    try {
+        if (Array.isArray(requestParsed)) {
+            const replacedRequestObj = replaceBodyContentInComposeSendRequestBody_2022_09_09(requestParsed, newBodyHtmlContent);
+            if (replacedRequestObj) {
+                return JSON.stringify(replacedRequestObj);
+            }
+            // if couldn't parse and replace body content, return original object
+            return request;
+        }
+    }
+    catch (err) {
+        logger.eventSdkPassive('connection.requestResponseParsingFailed', {
+            replaceBodyFailed: err,
+        });
+    }
+    return replaceEmailBodyForSendRequest(request, newBodyHtmlContent);
+}

package/src/injected-js/gmail/sync-compose-request-processor.js

@@ -0,0 +1,110 @@
+/* @flow */
+import intersection from 'lodash/intersection';
+import { SEND_ACTIONS } from './constants';
+export function getDetailsOfComposeRequest(parsed) {
+    const updateList = parsed[2] && parsed[2][1];
+    if (!updateList)
+        return null;
+    const messageUpdates = updateList.filter((update) => {
+        const updateWrapper = update[2] && update[2][2] && (update[2][2][14] || update[2][2][2]);
+        return (updateWrapper &&
+            updateWrapper[1] &&
+            updateWrapper[1][1] &&
+            updateWrapper[1][1].indexOf('msg-a:') > -1);
+    });
+    if (messageUpdates.length) {
+        const sendUpdateMatch = messageUpdates.find((update) => {
+            const updateWrapper = update[2] && update[2][2] && (update[2][2][14] || update[2][2][2]);
+            return (updateWrapper[1][11] &&
+                intersection(updateWrapper[1][11], SEND_ACTIONS).length ===
+                    SEND_ACTIONS.length);
+        });
+        if (sendUpdateMatch) {
+            const sendUpdateWrapper = sendUpdateMatch[2] &&
+                sendUpdateMatch[2][2] &&
+                (sendUpdateMatch[2][2][14] || sendUpdateMatch[2][2][2]);
+            const sendUpdate = sendUpdateWrapper[1];
+            return getComposeRequestFromUpdate(sendUpdate, 'SEND');
+        }
+        else {
+            // There's a small chance that an update list could contain the
+            // draft saves for multiple drafts in some situations — we've never
+            // seen this so currently just picking the first update and assuming
+            // that if there are multiple updates in the request they are for
+            // queued up versions of the same draft.
+            const firstMessageUpdate = messageUpdates[0];
+            const updateWrapper = firstMessageUpdate[2] &&
+                firstMessageUpdate[2][2] &&
+                (firstMessageUpdate[2][2][14] || firstMessageUpdate[2][2][2]);
+            const update = updateWrapper[1];
+            return getComposeRequestFromUpdate(update, 'DRAFT_SAVE');
+        }
+    }
+    else {
+        // the first time a draft is saved it has a different response format
+        const messageUpdates = updateList
+            .map((update) => update[2] &&
+            update[2][2] &&
+            update[2][2][3] &&
+            update[2][2][3][1] &&
+            update[2][2][3][1][5] &&
+            update[2][2][3][1][5][0])
+            .filter(Boolean);
+        if (messageUpdates.length === 0)
+            return null;
+        const firstMessageUpdate = messageUpdates[0];
+        return getComposeRequestFromUpdate(firstMessageUpdate, 'FIRST_DRAFT_SAVE');
+    }
+}
+function getComposeRequestFromUpdate(update, type) {
+    const body = update[9] && update[9][2] && update[9][2][0] && update[9][2][0][2];
+    if (body == null)
+        return null;
+    return {
+        body,
+        type,
+        to: parseContacts(update[3]),
+        cc: parseContacts(update[4]),
+        bcc: parseContacts(update[5]),
+        draftID: update[1].replace('msg-a:', ''),
+        subject: update[8],
+    };
+}
+function parseContacts(contacts) {
+    if (!Array.isArray(contacts)) {
+        // exit cuz cannot parse
+        return null;
+    }
+    return contacts.map((c) => ({ emailAddress: c[2], name: c[3] || null }));
+}
+export function replaceEmailBodyForSendRequest(request, newBody) {
+    if (!newBody)
+        return request;
+    const parsed = JSON.parse(request);
+    const updateList = parsed[2] && parsed[2][1];
+    if (!updateList)
+        return request;
+    const messageUpdates = updateList.filter((update) => {
+        const updateWrapper = update[2] && update[2][2] && (update[2][2][14] || update[2][2][2]);
+        return (updateWrapper &&
+            updateWrapper[1] &&
+            updateWrapper[1][1] &&
+            updateWrapper[1][1].indexOf('msg-a:') > -1);
+    });
+    if (!messageUpdates.length)
+        return request;
+    const sendUpdateMatch = messageUpdates.find((update) => {
+        const updateWrapper = update[2] && update[2][2] && (update[2][2][14] || update[2][2][2]);
+        return (updateWrapper[1][11] &&
+            intersection(updateWrapper[1][11], SEND_ACTIONS).length ===
+                SEND_ACTIONS.length);
+    });
+    if (!sendUpdateMatch)
+        return request;
+    const sendUpdateWrapper = sendUpdateMatch[2] &&
+        sendUpdateMatch[2][2] &&
+        (sendUpdateMatch[2][2][14] || sendUpdateMatch[2][2][2]);
+    const sendUpdate = sendUpdateWrapper[1];
+    sendUpdate[9][2][0][2] = newBody;
+    return JSON.stringify(parsed);
+}

package/src/injected-js/gmail/sync-compose-request-processor.test.js

@@ -1,16 +1,12 @@
-/* @flow */
-
-import fs from 'fs';
-
-import * as SCRP from './sync-compose-request-processor';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _fs = _interopRequireDefault(require("fs"));
+var SCRP = _interopRequireWildcard(require("./sync-compose-request-processor"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 it('handles first draft save', () => {
-  const request = fs.readFileSync(
-    __dirname +
-      '/../../../__tests__/sync-compose-request-processor/first-draft-save-request-2018-01-25.json',
-    'utf8'
-  );
-
+  const request = _fs.default.readFileSync(__dirname + '/../../../__tests__/sync-compose-request-processor/first-draft-save-request-2018-01-25.json', 'utf8');
   const composeRequest = SCRP.getDetailsOfComposeRequest(JSON.parse(request));
   expect(composeRequest).toMatchObject({
     body: '<div dir="ltr">new new draft</div>',
@@ -19,17 +15,11 @@ it('handles first draft save', () => {
     subject: 'new draft',
     to: null,
     cc: null,
-    bcc: null,
+    bcc: null
   });
 });
-
 it('handles regular draft save', () => {
-  const request = fs.readFileSync(
-    __dirname +
-      '/../../../__tests__/sync-compose-request-processor/draft-save-request-2018-01-25.json',
-    'utf8'
-  );
-
+  const request = _fs.default.readFileSync(__dirname + '/../../../__tests__/sync-compose-request-processor/draft-save-request-2018-01-25.json', 'utf8');
   const composeRequest = SCRP.getDetailsOfComposeRequest(JSON.parse(request));
   expect(composeRequest).toMatchObject({
     body: '<div dir="ltr">new new draft 2</div>',
@@ -38,53 +28,53 @@ it('handles regular draft save', () => {
     subject: 'new draft',
     to: null,
     cc: null,
-    bcc: null,
+    bcc: null
   });
 });
-
 it('handles regular draft save with recipients', () => {
-  const request = fs.readFileSync(
-    __dirname +
-      '/../../../__tests__/sync-compose-request-processor/draft-save-request-2018-01-25-with-recipients.json',
-    'utf8'
-  );
-
+  const request = _fs.default.readFileSync(__dirname + '/../../../__tests__/sync-compose-request-processor/draft-save-request-2018-01-25-with-recipients.json', 'utf8');
   const composeRequest = SCRP.getDetailsOfComposeRequest(JSON.parse(request));
   expect(composeRequest).toMatchObject({
     body: '<div dir="ltr">new new draft 2</div>',
     type: 'DRAFT_SAVE',
     draftID: 'r-5205311597211900881',
     subject: 'new draft',
-    to: [
-      { emailAddress: 'test+to@gmail.com', name: null },
-      { emailAddress: 'test+to2@gmail.com', name: 'test to2' },
-    ],
-    cc: [
-      { emailAddress: 'test+cc@gmail.com', name: null },
-      { emailAddress: 'test+cc2@gmail.com', name: 'test cc2' },
-    ],
-    bcc: [
-      { emailAddress: 'test+bcc@gmail.com', name: null },
-      { emailAddress: 'test+bcc2@gmail.com', name: 'test bcc2' },
-    ],
+    to: [{
+      emailAddress: 'test+to@gmail.com',
+      name: null
+    }, {
+      emailAddress: 'test+to2@gmail.com',
+      name: 'test to2'
+    }],
+    cc: [{
+      emailAddress: 'test+cc@gmail.com',
+      name: null
+    }, {
+      emailAddress: 'test+cc2@gmail.com',
+      name: 'test cc2'
+    }],
+    bcc: [{
+      emailAddress: 'test+bcc@gmail.com',
+      name: null
+    }, {
+      emailAddress: 'test+bcc2@gmail.com',
+      name: 'test bcc2'
+    }]
   });
 });
-
 it('handles sending', () => {
-  const request = fs.readFileSync(
-    __dirname +
-      '/../../../__tests__/sync-compose-request-processor/send-request-2018-01-25.json',
-    'utf8'
-  );
-
+  const request = _fs.default.readFileSync(__dirname + '/../../../__tests__/sync-compose-request-processor/send-request-2018-01-25.json', 'utf8');
   const composeRequest = SCRP.getDetailsOfComposeRequest(JSON.parse(request));
   expect(composeRequest).toMatchObject({
     body: '<div dir="ltr">new new draft 2</div>',
     type: 'SEND',
     draftID: 'r-5205311597211900881',
     subject: 'new draft',
-    to: [{ emailAddress: 'test+to@test.com', name: null }],
+    to: [{
+      emailAddress: 'test+to@test.com',
+      name: null
+    }],
     cc: null,
-    bcc: null,
+    bcc: null
   });
-});
+});