zapier-platform-core 11.3.1 → 12.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "11.3.1",
+  "version": "12.0.0",
   "description": "The core SDK for CLI apps in the Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
@@ -50,7 +50,7 @@
     "node-fetch": "2.6.7",
     "oauth-sign": "0.9.0",
     "semver": "7.3.5",
-    "zapier-platform-schema": "11.3.1"
+    "zapier-platform-schema": "12.0.0"
   },
   "devDependencies": {
     "adm-zip": "0.5.5",

package/src/http-middlewares/after/prepare-response.js

@@ -2,9 +2,17 @@
 
 const _ = require('lodash');
 const querystring = require('querystring');
-const throwForStatus = require('./throw-for-status');
 const { replaceHeaders } = require('./middleware-utils');
 const { FORM_TYPE } = require('../../tools/http');
+const errors = require('../../errors');
+
+const _throwForStatus = (response) => {
+  // calling this always throws, regardless of the skipThrowForStatus value
+  // eslint-disable-next-line yoda
+  if (400 <= response.status && response.status < 600) {
+    throw new errors.ResponseError(response);
+  }
+};
 
 const prepareRawResponse = (resp, request) => {
   // TODO: if !2xx should we go ahead and get response.content for them?
@@ -14,7 +22,11 @@ const prepareRawResponse = (resp, request) => {
     skipThrowForStatus: request.skipThrowForStatus,
   };
   const outResp = _.extend(resp, extendedResp, replaceHeaders(resp));
-  outResp.throwForStatus = () => throwForStatus(outResp) && undefined;
+
+  outResp.throwForStatus = () => {
+    _throwForStatus(outResp);
+  };
+
   Object.defineProperty(outResp, 'content', {
     get: function () {
       throw new Error(
@@ -27,30 +39,36 @@ const prepareRawResponse = (resp, request) => {
   return outResp;
 };
 
-const prepareContentResponse = (resp, request) => {
+const prepareContentResponse = async (resp, request) => {
   // TODO: does it make sense to not trim the signature? more equivalence to raw...
-  return resp.text().then((content) => {
-    // trim down the response signature a ton for simplicity
-    const preppedResp = {
-      status: resp.status,
-      json: undefined,
-      data: undefined,
-      content: content,
-      request: request,
-      skipThrowForStatus: request.skipThrowForStatus,
-    };
-    const outResp = _.extend(preppedResp, replaceHeaders(resp));
-    try {
-      if (outResp.headers.get('content-type') === FORM_TYPE) {
-        outResp.data = querystring.parse(content);
-      } else {
-        outResp.data = JSON.parse(content);
-        outResp.json = JSON.parse(content); // DEPRECATED (not using reference to isolate)
-      }
-    } catch (_e) {}
-    outResp.throwForStatus = () => throwForStatus(outResp) && undefined;
-    return outResp;
-  });
+  const content = await resp.text();
+
+  // trim down the response signature a ton for simplicity
+  const preppedResp = {
+    status: resp.status,
+    json: undefined,
+    data: undefined,
+    content: content,
+    request: request,
+    // only controls if _we_ call throwForStatus automatically
+    skipThrowForStatus: request.skipThrowForStatus,
+  };
+  const outResp = _.extend(preppedResp, replaceHeaders(resp));
+
+  try {
+    if (outResp.headers.get('content-type') === FORM_TYPE) {
+      outResp.data = querystring.parse(content);
+    } else {
+      outResp.data = JSON.parse(content);
+      outResp.json = JSON.parse(content); // DEPRECATED (not using reference to isolate)
+    }
+  } catch (_e) {}
+
+  outResp.throwForStatus = () => {
+    _throwForStatus(outResp);
+  };
+
+  return outResp;
 };
 
 // Provide a standardized plain JS responseObj for common consumption, or raw response for streaming.
@@ -58,11 +76,11 @@ const prepareResponse = (resp) => {
   const request = resp.input;
   delete resp.input;
 
-  if (request.raw) {
-    return prepareRawResponse(resp, request);
-  } else {
-    return prepareContentResponse(resp, request);
-  }
+  const responseFunc = request.raw
+    ? prepareRawResponse
+    : prepareContentResponse;
+
+  return responseFunc(resp, request);
 };
 
 module.exports = prepareResponse;

package/src/http-middlewares/after/throw-for-stale-auth.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { RefreshAuthError } = require('../../errors');
+
+/**
+ * Raise a RefreshAuthError _before_ any other error handling happens. Behaves more closely to the 9.x behavior rather than 10.x
+ */
+const throwForStaleAuth = (resp) => {
+  if (resp.status === 401) {
+    throw new RefreshAuthError();
+  }
+
+  return resp;
+};
+
+module.exports = throwForStaleAuth;

package/src/http-middlewares/after/throw-for-status.js

@@ -1,17 +1,10 @@
 'use strict';
 
-const errors = require('../../errors');
-
-const throwForStatus = (response) => {
-  if (
-    !response.skipThrowForStatus &&
-    response.status >= 400 &&
-    response.status < 600
-  ) {
-    throw new errors.ResponseError(response);
+const throwForStatusMiddleware = (response) => {
+  if (!response.skipThrowForStatus) {
+    response.throwForStatus();
   }
-
   return response;
 };
 
-module.exports = throwForStatus;
+module.exports = throwForStatusMiddleware;

package/src/http-middlewares/before/add-query-params.js

@@ -14,7 +14,24 @@ const addQueryParams = (req) => {
 
     normalizeEmptyParamFields(req);
 
-    const stringifiedParams = querystring.stringify(req.params);
+    let stringifiedParams = querystring.stringify(req.params);
+
+    // it goes against spec, but for compatibility, some APIs want certain
+    // characters (mostly $) unencoded
+    if (req.skipEncodingChars) {
+      for (let i = 0; i < req.skipEncodingChars.length; i++) {
+        const char = req.skipEncodingChars.charAt(i);
+        const valToReplace = querystring.escape(char);
+        if (valToReplace === char) {
+          continue;
+        }
+        // no replaceAll in JS yet, coming in a node version soon!
+        stringifiedParams = stringifiedParams.replace(
+          new RegExp(valToReplace, 'g'),
+          char
+        );
+      }
+    }
 
     if (stringifiedParams) {
       req.url += `${splitter}${stringifiedParams}`;

package/src/http-middlewares/before/prepare-request.js

@@ -113,7 +113,12 @@ const prepareRequest = function (req) {
       body: false,
     },
     replace: true, // always replace curlies
-    skipThrowForStatus: false,
+    // read default from app flags, but always defer to the request object if the value was set
+    skipThrowForStatus: _.get(
+      input,
+      ['_zapier', 'app', 'flags', 'skipThrowForStatus'],
+      false
+    ),
     _addContext: () => {},
   });
 

package/src/tools/create-app-request-client.js

@@ -18,7 +18,8 @@ const prepareRequest = require('../http-middlewares/before/prepare-request');
 // after middles
 const logResponse = require('../http-middlewares/after/log-response');
 const prepareResponse = require('../http-middlewares/after/prepare-response');
-const throwForStatus = require('../http-middlewares/after/throw-for-status');
+const throwForStaleAuth = require('../http-middlewares/after/throw-for-stale-auth');
+const throwForStatusMiddleware = require('../http-middlewares/after/throw-for-status');
 
 const createAppRequestClient = (input, options) => {
   input = ensurePath(input, '_zapier.app');
@@ -51,11 +52,22 @@ const createAppRequestClient = (input, options) => {
     httpBefores.push(disableSSLCertCheck);
   }
 
+  let includeAutoRefresh = false;
+  if (
+    app.authentication &&
+    (app.authentication.type === 'session' ||
+      (app.authentication.type === 'oauth2' &&
+        _.get(app, 'authentication.oauth2Config.autoRefresh')))
+  ) {
+    includeAutoRefresh = true;
+  }
+
   const httpAfters = [
     prepareResponse,
     logResponse,
+    ...(includeAutoRefresh ? [throwForStaleAuth] : []),
     ...ensureArray(app.afterResponse),
-    throwForStatus,
+    throwForStatusMiddleware,
   ];
 
   return createRequestClient(httpBefores, httpAfters, options);

package/src/tools/create-logger.js

@@ -167,6 +167,7 @@ class LogStream extends Transform {
 class LogStreamFactory {
   constructor() {
     this._logStream = null;
+    this.ended = false;
   }
 
   getOrCreate(url, token) {
@@ -185,6 +186,10 @@ class LogStreamFactory {
   }
 
   async end() {
+    // Mark the factory as ended. This suggests that any logStream.write() that
+    // follows should end() right away.
+    this.ended = true;
+
     if (this._logStream) {
       this._logStream.end();
       const response = await this._logStream.request;
@@ -240,6 +245,14 @@ const sendLog = async (logStreamFactory, options, event, message, data) => {
       // no line breaks, and after an object it ends with a line break.
       JSON.stringify({ message: safeMessage, data: safeData }) + '\n'
     );
+
+    if (logStreamFactory.ended) {
+      // Lambda handler calls logger.end() at the end. But what if there's a
+      // (bad) callback that is still running after the Lambda handler returns?
+      // We need to make sure the bad callback ends the logger as well.
+      // Otherwise, it will hang!
+      logStreamFactory.end();
+    }
   }
 };