zapier-platform-core 15.18.0 → 15.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "15.18.0",
+  "version": "15.18.1",
   "description": "The core SDK for CLI apps in the Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
@@ -53,7 +53,7 @@
     "node-fetch": "2.6.7",
     "oauth-sign": "0.9.0",
     "semver": "7.5.2",
-    "zapier-platform-schema": "15.18.0"
+    "zapier-platform-schema": "15.18.1"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",

package/src/tools/create-http-patch.js

@@ -48,7 +48,7 @@ const createHttpPatch = (event) => {
         return originalRequest(options, callback);
       }
 
-      // Ignore requests made via the request client
+      // Ignore requests made via the request client (z.request)
       if (_.get(options.headers, 'user-agent', []).indexOf('Zapier') !== -1) {
         return originalRequest(options, callback);
       }
@@ -112,7 +112,14 @@ const createHttpPatch = (event) => {
           }
         };
 
-        response.on('data', (chunk) => chunks.push(chunk));
+        const originalEmit = response.emit;
+
+        response.emit = function (event, ...args) {
+          if (event === 'data') {
+            chunks.push(args[0]);
+          }
+          return originalEmit.apply(this, [event, ...args]);
+        };
         response.on('end', logResponse);
         response.on('error', logResponse);
 

package/src/tools/create-lambda-handler.js

@@ -17,6 +17,7 @@ const createLogger = require('./create-logger');
 const createRpcClient = require('./create-rpc-client');
 const environmentTools = require('./environment');
 const schemaTools = require('./schema');
+const wrapFetchWithLogger = require('./fetch-logger');
 const ZapierPromise = require('./promise');
 
 const isDefinedPrimitive = (value) => {
@@ -189,10 +190,15 @@ const createLambdaHandler = (appRawOrPath) => {
     // Wait for all async events to complete before callback returns.
     // This is not strictly necessary since this is the default now when
     // using the callback; just putting it here to be explicit.
+    // In some cases, the code hangs and never exits because the event loop is not
+    // empty, so we can override the default behavior and exit after the app is done.
     context.callbackWaitsForEmptyEventLoop = true;
+    if (event.skipWaitForAsync === true) {
+      context.callbackWaitsForEmptyEventLoop = false;
+    }
 
     // replace native Promise with bluebird (works better with domains)
-    if (!event.calledFromCli) {
+    if (!event.calledFromCli || event.calledFromCliInvoke) {
       ZapierPromise.patchGlobal();
     }
 
@@ -253,10 +259,16 @@ const createLambdaHandler = (appRawOrPath) => {
 
           const { skipHttpPatch } = appRaw.flags || {};
           // Adds logging for _all_ kinds of http(s) requests, no matter the library
-          if (!skipHttpPatch && !event.calledFromCli) {
+          if (
+            !skipHttpPatch &&
+            (!event.calledFromCli || event.calledFromCliInvoke)
+          ) {
             const httpPatch = createHttpPatch(event);
             httpPatch(require('http'), logger);
             httpPatch(require('https'), logger); // 'https' needs to be patched separately
+            if (global.fetch) {
+              global.fetch = wrapFetchWithLogger(global.fetch, logger);
+            }
           }
 
           // TODO: Avoid calling prepareApp(appRaw) repeatedly here as createApp()
@@ -264,6 +276,7 @@ const createLambdaHandler = (appRawOrPath) => {
           const compiledApp = schemaTools.prepareApp(appRaw);
 
           const input = createInput(compiledApp, event, logger, logBuffer, rpc);
+
           return app(input);
         })
         .then((output) => {

package/src/tools/fetch-logger.js

@@ -0,0 +1,107 @@
+const _ = require('lodash');
+
+const { ALLOWED_HTTP_DATA_CONTENT_TYPES } = require('./http');
+
+const stringifyRequestData = (data) => {
+  // Be careful not to consume the data if it's a stream
+  if (typeof data === 'string') {
+    return data;
+  } else if (data instanceof URLSearchParams) {
+    return data.toString();
+  } else if (global.FormData && data instanceof global.FormData) {
+    return '<FormData>';
+  } else {
+    // See https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#setting_a_body
+    // for other possible body types
+    return '<unsupported format>';
+  }
+};
+
+const normalizeRequestInfo = (input, init) => {
+  const result = {
+    method: 'GET',
+    headers: {},
+    data: '',
+  };
+
+  if (global.Request && input instanceof global.Request) {
+    result.url = input.url;
+    result.method = input.method || result.method;
+    result.headers =
+      Object.fromEntries(input.headers.entries()) || result.headers;
+    if (input.body) {
+      result.data = stringifyRequestData(input.body);
+    }
+  } else if (typeof input.toString === 'function') {
+    // This condition includes `typeof input === 'string'` as well
+    result.url = input.toString();
+  } else {
+    // Don't log if we don't recognize the input type
+    return null;
+  }
+
+  if (init) {
+    result.method = init.method || result.method;
+    result.headers = init.headers || result.headers;
+    if (init.body) {
+      result.data = stringifyRequestData(init.body);
+    }
+  }
+
+  return result;
+};
+
+// Is this request made by z.request()?
+const isZapierUserAgent = (headers) =>
+  _.get(headers, 'user-agent', []).indexOf('Zapier') !== -1;
+
+const shouldIncludeResponseContent = (contentType) => {
+  for (const ctype of ALLOWED_HTTP_DATA_CONTENT_TYPES) {
+    if (contentType.includes(ctype)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const stringifyResponseContent = async (response) => {
+  // Be careful not to consume the original response body, which is why we clone it
+  return response.clone().text();
+};
+
+// Usage:
+//   global.fetch = wrapFetchWithLogger(global.fetch, logger);
+const wrapFetchWithLogger = (fetchFunc, logger) => {
+  if (fetchFunc.patchedByZapier) {
+    return fetchFunc;
+  }
+
+  const newFetch = async function (input, init) {
+    const response = await fetchFunc(input, init);
+    const requestInfo = normalizeRequestInfo(input, init);
+    if (requestInfo && !isZapierUserAgent(requestInfo.headers)) {
+      const responseContentType = response.headers.get('content-type');
+
+      logger(`${response.status} ${requestInfo.method} ${requestInfo.url}`, {
+        log_type: 'http',
+        request_type: 'patched-devplatform-outbound',
+        request_url: requestInfo.url,
+        request_method: requestInfo.method,
+        request_headers: requestInfo.headers,
+        request_data: requestInfo.data,
+        request_via_client: false,
+        response_status_code: response.status,
+        response_headers: Object.fromEntries(response.headers.entries()),
+        response_content: shouldIncludeResponseContent(responseContentType)
+          ? await stringifyResponseContent(response)
+          : '<unsupported format>',
+      });
+    }
+    return response;
+  };
+
+  newFetch.patchedByZapier = true;
+  return newFetch;
+};
+
+module.exports = wrapFetchWithLogger;

package/src/tools/http.js

@@ -7,6 +7,7 @@ const JSON_TYPE_UTF8 = 'application/json; charset=utf-8';
 const BINARY_TYPE = 'application/octet-stream';
 const HTML_TYPE = 'text/html';
 const TEXT_TYPE = 'text/plain';
+const TEXT_TYPE_UTF8 = 'text/plain; charset=utf-8';
 const YAML_TYPE = 'application/yaml';
 const XML_TYPE = 'application/xml';
 const JSONAPI_TYPE = 'application/vnd.api+json';
@@ -17,6 +18,7 @@ const ALLOWED_HTTP_DATA_CONTENT_TYPES = new Set([
   JSON_TYPE_UTF8,
   HTML_TYPE,
   TEXT_TYPE,
+  TEXT_TYPE_UTF8,
   YAML_TYPE,
   XML_TYPE,
   JSONAPI_TYPE,

package/types/zapier.generated.d.ts

@@ -4,7 +4,7 @@
  * files, and/or the schema-to-ts tool and run its CLI to regenerate
  * these typings.
  *
- * zapier-platform-schema version: 15.17.0
+ * zapier-platform-schema version: 15.18.1
  *  schema-to-ts compiler version: 0.1.0
  */