zapier-platform-core 16.5.0 → 17.0.0

package/include/zapierwrapper.mjs

@@ -0,0 +1,21 @@
+// not intended to be loaded via require() or import() - copied during build step
+import zapier from 'zapier-platform-core';
+
+let _appRaw;
+try {
+  _appRaw = await import('{REPLACE_ME_PACKAGE_NAME}');
+} catch (err) {
+  if (err.code === 'ERR_MODULE_NOT_FOUND') {
+    err.message +=
+      '\nMake sure you specify a valid entry point using `exports` in package.json.';
+  }
+  throw err;
+}
+
+// Allows a developer to use named exports or default export in entry point
+if (_appRaw && _appRaw.default) {
+  _appRaw = _appRaw.default;
+}
+
+export const appRaw = _appRaw;
+export const handler = zapier.createAppHandler(_appRaw);

package/index.js

@@ -1,5 +1,4 @@
 const zapier = require('./src');
 zapier.version = require('./package.json').version;
-zapier.Promise = zapier.ZapierPromise = require('./src/tools/promise');
 zapier.tools = require('./src/tools/exported');
 module.exports = zapier;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "16.5.0",
+  "version": "17.0.0",
   "description": "The core SDK for CLI apps in the Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
@@ -19,7 +19,7 @@
     "version": "node bin/bump-dependencies.js && yarn && git add package.json yarn.lock",
     "postversion": "git push && git push --tags",
     "main-tests": "mocha -t 20s --recursive test --exit",
-    "type-tests": "tsd",
+    "type-tests": "tsd --files types/**/*.test-d.ts",
     "solo-test": "test $(OPT_OUT_PATCH_TEST_ONLY=yes mocha --recursive test -g 'should be able to opt out of patch' -R json | jq '.stats.passes') -eq 1 && echo 'Ran 1 test and it passed!'",
     "test": "yarn main-tests && yarn solo-test && yarn type-tests",
     "test:debug": "mocha inspect -t 10s --recursive test",
@@ -43,25 +43,24 @@
   "engineStrict": true,
   "dependencies": {
     "@zapier/secret-scrubber": "^1.1.2",
-    "bluebird": "3.7.2",
     "content-disposition": "0.5.4",
-    "dotenv": "16.4.6",
+    "dotenv": "16.5.0",
     "form-data": "4.0.1",
     "lodash": "4.17.21",
     "mime-types": "2.1.35",
     "node-abort-controller": "3.1.1",
     "node-fetch": "2.7.0",
     "oauth-sign": "0.9.0",
-    "semver": "7.6.3",
-    "zapier-platform-schema": "16.5.0"
+    "semver": "7.7.1",
+    "zapier-platform-schema": "17.0.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",
     "adm-zip": "0.5.16",
     "aws-sdk": "^2.1397.0",
     "dicer": "^0.3.1",
-    "fs-extra": "^11.1.1",
-    "mock-fs": "^5.3.0",
+    "fs-extra": "^11.3.0",
+    "mock-fs": "^5.5.0",
     "nock": "^13.5.4",
     "tsd": "^0.31.1"
   },

package/src/app-middlewares/after/wait-for-promises.js

@@ -1,12 +1,10 @@
 'use strict';
 
-const ZapierPromise = require('../../tools/promise');
-
 /*
   After app middlewares that waits for all pending promises to resolve.
 */
 const waitForPromises = (output) => {
-  return ZapierPromise.all(output.input._zapier.promises || [])
+  return Promise.all(output.input._zapier.promises || [])
     .catch(() => {}) // drop any errors in waiting promises
     .then(() => output);
 };

package/src/app-middlewares/before/add-app-context.js

@@ -12,12 +12,13 @@ const logSafeBundle = (bundle) => {
 */
 const addAppContext = (input) => {
   const methodName = _.get(input, '_zapier.event.method');
+  input._zapier.whatHappened.push(`Executing ${methodName} with bundle`);
+
   const bundle = _.get(input, '_zapier.event.bundle', {});
+  if (Object.keys(bundle).length > 0) {
+    input._zapier.whatHappened.push(JSON.stringify(logSafeBundle(bundle)));
+  }
 
-  input._addContext(
-    `Executing ${methodName} with bundle`,
-    JSON.stringify(logSafeBundle(bundle)),
-  );
   return input;
 };
 

package/src/execute.js

@@ -6,7 +6,6 @@ const addQueryParams = require('./http-middlewares/before/add-query-params');
 const ensureArray = require('./tools/ensure-array');
 const injectInput = require('./http-middlewares/before/inject-input');
 const prepareRequest = require('./http-middlewares/before/prepare-request');
-const ZapierPromise = require('./tools/promise');
 
 const constants = require('./constants');
 
@@ -36,7 +35,7 @@ const executeHttpRequest = (input, options) => {
 const executeInputOutputFields = (inputOutputFields, input) => {
   inputOutputFields = ensureArray(inputOutputFields);
 
-  return ZapierPromise.all(
+  return Promise.all(
     inputOutputFields.map((field) =>
       _.isFunction(field) ? field(input.z, input.bundle) : field,
     ),
@@ -44,7 +43,7 @@ const executeInputOutputFields = (inputOutputFields, input) => {
 };
 
 const executeCallbackMethod = (z, bundle, method) => {
-  return new ZapierPromise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     const callback = (err, output) => {
       if (err) {
         reject(err);

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

@@ -65,8 +65,9 @@ const logResponse = (resp) => {
     infoMsg += ` after ${logs.data.request_duration_ms}ms`;
   }
 
-  resp._addContext(infoMsg);
-  resp._addContext(
+  const whatHappened = resp.request.input._zapier.whatHappened;
+  whatHappened.push(infoMsg);
+  whatHappened.push(
     `Received content "${String(logs.data.response_content).substr(0, 100)}"`,
   );
 

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

@@ -14,7 +14,9 @@ const addQueryParams = (req) => {
 
     normalizeEmptyParamFields(req);
 
-    let stringifiedParams = querystring.stringify(req.params);
+    let stringifiedParams = querystring.stringify(req.params, '&', '=', {
+      encodeURIComponent: req.encodeURIComponent,
+    });
 
     // it goes against spec, but for compatibility, some APIs want certain
     // characters (mostly $) unencoded

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

@@ -102,6 +102,29 @@ const finalRequest = (req) => {
   }
 };
 
+const throwForCurlies = (value, path) => {
+  path = path || [];
+  if (typeof value === 'string') {
+    if (/{{\s*(bundle|process)\.[^}]*}}/.test(value)) {
+      throw new Error(
+        'z.request() no longer supports {{bundle.*}} or {{process.*}} as of v17 ' +
+          "unless it's used in a shorthand request. " +
+          'Use JavaScript template literals instead. ' +
+          `Value in violation: "${value}" in attribute "${path.join('.')}".`,
+      );
+    }
+  } else if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      throwForCurlies(item, [...path, String(i)]);
+    }
+  } else if (_.isPlainObject(value)) {
+    for (const [k, v] of Object.entries(value)) {
+      throwForCurlies(v, [...path, k]);
+    }
+  }
+};
+
 const prepareRequest = function (req) {
   const input = req.input || {};
 
@@ -112,39 +135,53 @@ const prepareRequest = function (req) {
       params: false,
       body: false,
     },
-    replace: true, // always replace curlies
     // 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: () => {},
   });
 
   req = sugarBody(req);
 
   // apply app requestTemplate to request
   if (req.merge) {
-    const requestTemplate = (input._zapier.app || {}).requestTemplate;
+    const requestTemplate = (input._zapier?.app || {}).requestTemplate;
     req = requestMerge(requestTemplate, req);
   }
 
-  // replace {{curlies}} in the request
+  const replaceable = {
+    url: req.url,
+    headers: req.headers,
+    params: req.params,
+    body: req.body,
+  };
+
   if (req.replace) {
+    // replace {{curlies}} in the request
     const bank = createBundleBank(
       input._zapier.app,
       input._zapier.event,
       req.serializeValueForCurlies,
     );
-    req = recurseReplaceBank(req, bank);
+    req = {
+      ...req,
+      ...recurseReplaceBank(replaceable, bank),
+    };
+  } else {
+    // throw if there's {{curlies}} in the request
+    throwForCurlies(replaceable);
   }
 
   req = coerceBody(req);
 
   req._requestStart = new Date();
 
-  req._addContext(`Starting ${req.method} request to ${req.url}`);
+  const whatHappened = req.input._zapier.whatHappened;
+  if (whatHappened) {
+    whatHappened.push(`Starting ${req.method} request to ${req.url}`);
+  }
 
   return finalRequest(req);
 };

package/src/http-middlewares/before/sanatize-headers.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// Middleware to trim whitespace from header keys and values
+const sanitizeHeaders = (req) => {
+  req.headers = Object.fromEntries(
+    Object.entries(req.headers || {}).map(([key, value]) => [
+      key.trim(),
+      typeof value === 'string' ? value.trim() : value,
+    ]),
+  );
+  return req;
+};
+
+module.exports = sanitizeHeaders;

package/src/index.js

@@ -15,4 +15,5 @@ module.exports = {
   createAppHandler: createLambdaHandler,
   createAppTester,
   integrationTestHandler,
+  ...require('./typeHelpers'),
 };

package/src/middleware.js

@@ -3,7 +3,6 @@
 const _ = require('lodash');
 
 const envelope = require('./tools/envelope');
-const ZapierPromise = require('./tools/promise');
 
 /**
    Applies before and after middleware functions, returning
@@ -40,6 +39,17 @@ const ZapierPromise = require('./tools/promise');
    output. The default is false.
 */
 
+const enrichErrorMessages = (error, input) => {
+  if (error.doNotContextify) {
+    throw error;
+  }
+  if (input._zapier && input._zapier.whatHappened) {
+    const details = input._zapier.whatHappened.map((f) => `  ${f}`).join('\n');
+    error.message = `${error.message}\nWhat happened:\n${details}\n  ${error.message}`;
+  }
+  throw error;
+};
+
 const applyMiddleware = (befores, afters, app, options) => {
   options = _.defaults({}, options, {
     skipEnvelope: false,
@@ -55,47 +65,46 @@ const applyMiddleware = (befores, afters, app, options) => {
   };
 
   return (input) => {
-    const context = ZapierPromise.makeContext();
-    const resolve = (val) => ZapierPromise.resolve(val).bind(context);
-
-    const beforeMiddleware = (beforeInput) => {
-      return befores.reduce((collector, func) => {
-        return collector.then((newInput) => {
-          newInput._addContext = context.addContext;
-          const args = [newInput].concat(options.extraArgs);
-          const result = func.apply(undefined, args);
-          if (typeof result !== 'object') {
-            throw new Error('Middleware should return an object.');
-          }
-          return result;
-        });
-      }, resolve(beforeInput));
+    const beforeMiddleware = async (beforeInput) => {
+      let newInput = beforeInput;
+      for (const func of befores) {
+        const args = [newInput].concat(options.extraArgs);
+        const maybePromise = func.apply(undefined, args);
+        // legacy scripting runner returns a Promise for beforeRequest
+        if (typeof maybePromise !== 'object') {
+          throw new Error('Middleware should return an object.');
+        }
+        newInput = await Promise.resolve(maybePromise);
+      }
+      return newInput;
     };
 
-    const afterMiddleware = (output) => {
-      return afters.reduce((collector, func) => {
-        return collector.then((newOutput) => {
-          newOutput._addContext = context.addContext;
-          const args = [newOutput].concat(options.extraArgs);
-          const maybePromise = func.apply(undefined, args);
-          if (typeof maybePromise !== 'object') {
-            throw new Error('Middleware should return an object.');
-          }
-          return resolve(maybePromise).then(ensureEnvelope);
-        });
-      }, resolve(output));
+    const afterMiddleware = async (output) => {
+      for (const func of afters) {
+        const args = [output].concat(options.extraArgs);
+        const maybePromise = func.apply(undefined, args);
+        if (typeof maybePromise !== 'object') {
+          throw new Error('Middleware should return an object.');
+        }
+        output = await Promise.resolve(maybePromise);
+        output = ensureEnvelope(output);
+      }
+      return output;
     };
 
-    const promise = beforeMiddleware(input).then((newInput) => {
-      return resolve(app(newInput))
-        .then(ensureEnvelope)
-        .then((output) => {
-          output.input = newInput;
-          return afterMiddleware(output);
-        });
-    });
+    const promise = async (input) => {
+      const newInput = await beforeMiddleware(input);
+      try {
+        let output = await app(newInput);
+        output = await ensureEnvelope(output);
+        output.input = newInput;
+        return afterMiddleware(output);
+      } catch (error) {
+        return enrichErrorMessages(error, newInput);
+      }
+    };
 
-    return promise;
+    return promise(input);
   };
 };
 

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

@@ -14,6 +14,7 @@ const createInjectInputMiddleware = require('../http-middlewares/before/inject-i
 const disableSSLCertCheck = require('../http-middlewares/before/disable-ssl-cert-check');
 const oauth1SignRequest = require('../http-middlewares/before/oauth1-sign-request');
 const prepareRequest = require('../http-middlewares/before/prepare-request');
+const sanitizeHeaders = require('../http-middlewares/before/sanatize-headers');
 
 // after middles
 const { logResponse } = require('../http-middlewares/after/log-response');
@@ -45,7 +46,7 @@ const createAppRequestClient = (input, options) => {
       httpBefores.push(oauth1SignRequest);
     }
   }
-
+  httpBefores.push(sanitizeHeaders);
   httpBefores.push(addQueryParams);
 
   const verifySSL = _.get(input, '_zapier.event.verifySSL');

package/src/tools/create-app-tester.js

@@ -2,30 +2,13 @@
 
 const createLambdaHandler = require('./create-lambda-handler');
 const resolveMethodPath = require('./resolve-method-path');
-const ZapierPromise = require('./promise');
 const { isFunction } = require('lodash');
 const { genId } = require('./data');
 const { shouldPaginate } = require('./should-paginate');
 
-// Convert a app handler to promise for convenience.
-const promisifyHandler = (handler) => {
-  return (event) => {
-    return new ZapierPromise((resolve, reject) => {
-      handler(event, {}, (err, resp) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(resp);
-        }
-      });
-    });
-  };
-};
-
 // A shorthand compatible wrapper for testing.
 const createAppTester = (appRaw, { customStoreKey } = {}) => {
   const handler = createLambdaHandler(appRaw);
-  const createHandlerPromise = promisifyHandler(handler);
 
   const randomSeed = genId();
 
@@ -73,7 +56,7 @@ const createAppTester = (appRaw, { customStoreKey } = {}) => {
       event.detailedLogToStdout = true;
     }
 
-    return createHandlerPromise(event).then((resp) => {
+    return handler(event).then((resp) => {
       delete appRaw._testRequest; // clear adHocFunc so tests can't affect each other
       return resp.results;
     });

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

@@ -59,6 +59,9 @@ const createHttpPatch = (event) => {
 
         // Only include request or response data for specific content types
         // which we are able to read in logs and which are not typically too large
+        // Limitation: This doesn't capture the request content-type if it's set afterwards, like:
+        //   const req = https.request(options, callback);
+        //   req.setHeader('Content-Type', 'text/plain');
         const requestContentType = getContentType(options.headers || {});
         const responseContentType = getContentType(response.headers || {});
 

package/src/tools/create-input.js

@@ -35,6 +35,8 @@ const createInput = (app, event, logger, logBuffer, rpc) => {
       logger,
 
       logBuffer,
+
+      whatHappened: [],
     },
   };
 };