zapier-platform-core 15.18.0 → 15.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "15.18.0",
+  "version": "15.19.0",
   "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.19.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",

package/src/tools/create-dehydrator.js

@@ -9,19 +9,25 @@ const wrapHydrate = require('./wrap-hydrate');
 const createDehydrator = (input, type = 'method') => {
   const app = _.get(input, '_zapier.app');
 
-  return (func, inputData) => {
+  return (func, inputData, cacheExpiration) => {
     inputData = inputData || {};
     if (inputData.inputData) {
       throw new DehydrateError(
         'Oops! You passed a full `bundle` - really you should pass what you want under `inputData`!'
       );
     }
-    return wrapHydrate({
+    const payload = {
       type,
       method: resolveMethodPath(app, func),
       // inputData vs. bundle is a legacy oddity
       bundle: _.omit(inputData, 'environment'), // don't leak the environment
-    });
+    };
+
+    if (cacheExpiration) {
+      payload.cacheExpiration = cacheExpiration;
+    }
+
+    return wrapHydrate(payload);
   };
 };
 

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.custom.d.ts

@@ -37,13 +37,78 @@ export interface Bundle<InputData = { [x: string]: any }> {
   inputDataRaw: { [x: string]: string };
   meta: {
     isBulkRead: boolean;
+
+    /**
+     * If true, this poll is being used to populate a dynamic dropdown.
+     * You only need to return the fields you specified (such as id and
+     * name), though returning everything is fine too.
+     */
     isFillingDynamicDropdown: boolean;
+
+    /**
+     * If true, this run was initiated manually via the Zap Editor.
+     */
     isLoadingSample: boolean;
+
+    /**
+     * If true, the results of this poll will be used to initialize the
+     * deduplication list rather than trigger a zap. You should grab as
+     * many items as possible.
+     */
     isPopulatingDedupe: boolean;
+
+    /**
+     * (legacy property) If true, the poll was triggered by a user
+     * testing their account (via clicking “test” or during setup). We
+     * use this data to populate the auth label, but it’s mostly used to
+     * verify we made a successful authenticated request
+     *
+     * @deprecated
+     */
     isTestingAuth: boolean;
+
+    /**
+     * The number of items you should fetch. -1 indicates there’s no
+     * limit. Build this into your calls insofar as you are able.
+     */
     limit: number;
+
+    /**
+     * Used in paging to uniquely identify which page of results should
+     * be returned.
+     */
     page: number;
-    zap?: { id: string };
+
+    /**
+     * When a create is called as part of a search-or-create step,
+     * this will be the key of the search.
+     */
+    withSearch?: string;
+
+    /**
+     * The timezone the user has configured for their account or
+     * specific automation. Received as TZ identifier, such as
+     * “America/New_York”.
+     */
+    timezone: string | null;
+
+    /** @deprecated */
+    zap?: {
+      /** @deprecated */
+      id: string;
+      /** @deprecated */
+      user: {
+        /** @deprecated use meta.timezone instead. */
+        timezone: string;
+      };
+    };
+
+    /**
+     * Contains metadata about the input fields, optionally provided
+     * by the inputField.meta property. Useful for storing extra data
+     * in dynamically created input fields.
+     */
+    inputFields: { [fieldKey: string]: { [metaKey: string]: string | number | boolean } };
   };
   rawRequest?: Partial<{
     method: HttpMethod;
@@ -108,6 +173,8 @@ export interface HttpRequestOptions {
   middlewareData?: Record<string, any>;
 }
 
+type HttpRequestOptionsWithUrl = HttpRequestOptions & { url: string };
+
 interface BaseHttpResponse {
   status: number;
   headers: Headers;
@@ -133,7 +200,8 @@ export interface RawHttpResponse<T = any> extends BaseHttpResponse {
 
 type DehydrateFunc = <T>(
   func: (z: ZObject, bundle: Bundle<T>) => any,
-  inputData: T
+  inputData?: T,
+  cacheExpiration?: number
 ) => string;
 
 export interface ZObject {
@@ -143,16 +211,14 @@ export interface ZObject {
       url: string,
       options: HttpRequestOptions & { raw: true }
     ): Promise<RawHttpResponse<T>>;
-    <T = any>(
-      options: HttpRequestOptions & { raw: true; url: string }
-    ): Promise<RawHttpResponse<T>>;
+    <T = any>(options: HttpRequestOptionsWithUrl & { raw: true }): Promise<
+      RawHttpResponse<T>
+    >;
 
     <T = any>(url: string, options?: HttpRequestOptions): Promise<
       HttpResponse<T>
     >;
-    <T = any>(options: HttpRequestOptions & { url: string }): Promise<
-      HttpResponse<T>
-    >;
+    <T = any>(options: HttpRequestOptionsWithUrl): Promise<HttpResponse<T>>;
   };
 
   console: Console;
@@ -213,7 +279,7 @@ export interface ZObject {
 
   cache: {
     get: (key: string) => Promise<any>;
-    set: (key: string, value: any, ttl?: number) => Promise<boolean>;
+    set: (key: string, value: any, ttl?: number, scope?: string[], nx?: boolean) => Promise<boolean|null>;
     delete: (key: string) => Promise<boolean>;
   };
 }
@@ -230,10 +296,10 @@ export type PerformFunction<BI = Record<string, any>, R = any> = (
 ) => Promise<R>;
 
 export type BeforeRequestMiddleware = (
-  request: HttpRequestOptions,
+  request: HttpRequestOptionsWithUrl,
   z: ZObject,
   bundle: Bundle
-) => HttpRequestOptions | Promise<HttpRequestOptions>;
+) => HttpRequestOptionsWithUrl | Promise<HttpRequestOptionsWithUrl>;
 
 export type AfterResponseMiddleware = (
   response: HttpResponse,

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.19.0
  *  schema-to-ts compiler version: 0.1.0
  */
 
@@ -187,6 +187,22 @@ export type FieldChoices =
   | { [k: string]: unknown }
   | (string | FieldChoiceWithLabel)[];
 
+/**
+ * Allows for additional metadata to be stored on the field.
+ *
+ * [Docs: FieldMetaSchema](https://github.com/zapier/zapier-platform/blob/main/packages/schema/docs/build/schema.md#FieldMetaSchema)
+ */
+export interface FieldMeta {
+  /**
+   * Only string, integer or boolean values are allowed.
+   *
+   * This interface was referenced by `FieldMetaSchema`'s JSON-Schema
+   * definition
+   * via the `patternProperty` "[^\s]+".
+   */
+  [k: string]: string | number | boolean;
+}
+
 /**
  * Defines a field an app either needs as input, or gives as output.
  * In addition to the requirements below, the following keys are
@@ -323,6 +339,12 @@ export interface Field {
    * "https://{{input}}.yourdomain.com").
    */
   inputFormat?: string;
+
+  /**
+   * Allows for additional metadata to be stored on the field.
+   * Supports simple key-values only (no sub-objects or arrays).
+   */
+  meta?: FieldMeta;
 }
 
 /**