zapier-platform-core 15.16.1 → 15.18.0

package/CHANGELOG.md

@@ -1,3 +1 @@
-Read docs: https://zapier.github.io/zapier-platform/.
-
-Changelog: https://github.com/zapier/zapier-platform/blob/main/CHANGELOG.md
+See [CHANGELOG.md](https://github.com/zapier/zapier-platform/blob/main/CHANGELOG.md).

package/README.md

@@ -1,9 +1,13 @@
-# Core for Zapier CLI Platform [![Travis](https://img.shields.io/travis/zapier/zapier-platform-core.svg)](https://travis-ci.org/zapier/zapier-platform-core)
+# Zapier Platform Core
 
-This is the code that powers our [Zapier Platform CLI](https://zapier.github.io/zapier-platform-cli). You'll want to head to that repo to see how it's used.
+This is the SDK used in Zapier integrations.
 
 ## Development
 
+See [CONTRIBUTING.md](https://github.com/zapier/zapier-platform/blob/main/CONTRIBUTING.md) and [ARCHITECTURE.md](https://github.com/zapier/zapier-platform/blob/main/packages/core/ARCHITECTURE.md) of this package in particular.
+
+Useful commands:
+
 * `npm install` for getting started
 * `npm test` for running unit tests
 * `npm run local-integration-test` for running integration tests locally
@@ -16,6 +20,8 @@ Make sure your AWS access key have permission to update and run Lambda functions
 * `npm run deploy-integration-test` builds and deploys a zip to a function named `integration-test-cli` on Lambda
 * `npm run lambda-integration-test` runs the integration test using the live Lambda function `integration-test-cli`
 
-## Publishing (after merging)
+## Publishing
+
+Only do this after merging your PR to `main`.
 
 * `npm version [patch|minor|major]` will pull, test, update schema version in dependencies for this package, update docs, increment version in package.json, and push tags, which then will tell Travis to publish to npm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "15.16.1",
+  "version": "15.18.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.16.1"
+    "zapier-platform-schema": "15.18.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",
@@ -61,7 +61,7 @@
     "aws-sdk": "^2.1397.0",
     "dicer": "^0.3.1",
     "fs-extra": "^11.1.1",
-    "mock-fs": "^5.2.0",
+    "mock-fs": "^5.3.0",
     "nock": "^13.5.4",
     "tsd": "^0.31.1"
   },

package/src/tools/create-cache.js

@@ -12,7 +12,8 @@ const createCache = (input) => {
     key,
     value = null,
     ttl = null,
-    scope = null
+    scope = null,
+    nx = null
   ) => {
     if (!rpc) {
       throw new Error('rpc is not available');
@@ -36,6 +37,10 @@ const createCache = (input) => {
       );
     }
 
+    if (nx !== null && !_.isBoolean(nx)) {
+      throw new TypeError('nx must be a boolean');
+    }
+
     ensureJSONEncodable(value);
   };
 
@@ -46,10 +51,10 @@ const createCache = (input) => {
       const result = await rpc('zcache_get', key, scope);
       return result ? JSON.parse(result) : null;
     },
-    set: async (key, value, ttl = null, scope = null) => {
-      runValidationChecks(rpc, key, value, ttl, scope);
+    set: async (key, value, ttl = null, scope = null, nx = null) => {
+      runValidationChecks(rpc, key, value, ttl, scope, nx);
 
-      return await rpc('zcache_set', key, JSON.stringify(value), ttl, scope);
+      return await rpc('zcache_set', key, JSON.stringify(value), ttl, scope, nx);
     },
     delete: async (key, scope = null) => {
       runValidationChecks(rpc, key, scope);

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

@@ -196,7 +196,8 @@ const createLambdaHandler = (appRawOrPath) => {
       ZapierPromise.patchGlobal();
     }
 
-    // If we're running out of memory, exit the process. Backend will try again.
+    // If we're running out of memory or file descriptors, force exit the process.
+    // The backend will try again via @retry(ProcessExitedException).
     checkMemory(event);
 
     environmentTools.cleanEnvironment();

package/src/tools/create-rpc-client.js

@@ -45,7 +45,7 @@ const rpcCursorMock = (cursorTestObj, method, key, value = null) => {
 };
 
 const createRpcClient = (event) => {
-  return function (method) {
+  return async function (method) {
     const params = _.toArray(arguments);
     params.shift();
 
@@ -97,25 +97,46 @@ const createRpcClient = (event) => {
       }
     }
 
-    return request(req)
-      .then((res) => {
+    // RPC can fail, so let's retry.
+    // Be careful what we throw here as this will be forwarded to the user.
+    const maxRetries = 3;
+    let attempt = 0;
+    let res;
+
+    while (attempt < maxRetries) {
+      // We will throw here, which will be caught by catch logic to either retry or bubble up.
+      try {
+        res = await request(req);
+
+        if (res.status > 500) {
+          throw new Error('Unable to reach the RPC server');
+        }
         if (res.content) {
+          // check if the ids match
           if (res.content.id !== id) {
             throw new Error(
               `Got id ${res.content.id} but expected ${id} when calling RPC`
             );
           }
-          return res.content;
+          if (res.content.error) {
+            throw new Error(res.content.error);
+          }
+          return res.content.result;
         } else {
           throw new Error(`Got a ${res.status} when calling RPC`);
         }
-      })
-      .then((content) => {
-        if (content.error) {
-          throw new Error(content.error);
+      } catch (err) {
+        attempt++;
+
+        if (attempt === maxRetries || (res && res.status < 500)) {
+          throw new Error(
+            `RPC request failed after ${attempt} attempts: ${err.message}`
+          );
         }
-        return content.result;
-      });
+        // sleep for 100ms before retrying
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
   };
 };
 

package/src/tools/memory-checker.js

@@ -8,22 +8,31 @@ let zrun = 0;
 const checkMemory = (event) => {
   event = event || {};
 
+  let memUsage;
+
+  try {
+    memUsage = process.memoryUsage();
+  } catch (err) {
+    if (err.code === 'EMFILE') {
+      console.error(
+        'Force killing process by Zapier for too many open file descriptors'
+      );
+
+      /* eslint no-process-exit: 0 */
+      process.exit(1);
+    } else {
+      throw err;
+    }
+  }
+
   zrun += 1;
   if (!constants.IS_TESTING && !event.calledFromCli) {
-    console.log(
-      'ZID:',
-      zid,
-      'pid',
-      'ZRUN:',
-      zrun,
-      'RSSMEM:',
-      process.memoryUsage()
-    );
+    console.log('ZID:', zid, 'pid', 'ZRUN:', zrun, 'RSSMEM:', memUsage);
   }
 
   if (
     zrun > constants.KILL_MIN_LIMIT &&
-    process.memoryUsage().rss > constants.KILL_MAX_LIMIT
+    memUsage.rss > constants.KILL_MAX_LIMIT
   ) {
     // should throw "Process exited before completing request"
     // and a @retry in our stack will attempt again - and this

package/types/index.test-d.ts

@@ -18,7 +18,7 @@ import type {
   Trigger,
 } from './zapier.generated';
 
-import { expectType } from 'tsd';
+import { expectType, expectDeprecated } from 'tsd';
 
 const basicDisplay: BasicDisplay = {
   label: 'some-label',
@@ -166,3 +166,37 @@ const app: App = {
   searches: { [search.key]: search },
 };
 expectType<App>(app);
+
+// Return types from z.request
+async (z: ZObject) => {
+  const resp = await z.request<{ id: number; name: string }>(
+    'https://example.com'
+  );
+  expectType<{ id: number; name: string }>(resp.data);
+  expectDeprecated(resp.json);
+};
+
+async (z: ZObject) => {
+  const resp = await z.request<{ id: number; name: string }>({
+    url: 'https://example.com',
+  });
+  expectType<{ id: number; name: string }>(resp.data);
+};
+
+// Return types from z.request (raw)
+async (z: ZObject) => {
+  const resp = await z.request<{ id: number; name: string }>(
+    'https://example.com',
+    { raw: true }
+  );
+  const result = await resp.json();
+  expectType<{ id: number; name: string }>(result);
+};
+async (z: ZObject) => {
+  const resp = await z.request<{ id: number; name: string }>({
+    raw: true,
+    url: 'https://example.com',
+  });
+  const result = await resp.json();
+  expectType<{ id: number; name: string }>(result);
+};

package/types/zapier.custom.d.ts

@@ -73,6 +73,9 @@ declare class RefreshAuthError extends Error {}
 declare class ThrottledError extends Error {
   constructor(message: string, delay?: number);
 }
+declare class ResponseError extends Error {
+  constructor(response: HttpResponse);
+}
 
 // copied http stuff from external typings
 export interface HttpRequestOptions {
@@ -114,16 +117,17 @@ interface BaseHttpResponse {
   request: HttpRequestOptions;
 }
 
-export interface HttpResponse extends BaseHttpResponse {
+export interface HttpResponse<T = any> extends BaseHttpResponse {
   content: string;
-  data?: any;
-  json?: any;
+  data: T;
+  /** @deprecated Since v10.0.0. Use `data` instead. */
+  json?: T;
 }
 
-export interface RawHttpResponse extends BaseHttpResponse {
+export interface RawHttpResponse<T = any> extends BaseHttpResponse {
   body: NodeJS.ReadableStream;
   buffer(): Promise<Buffer>;
-  json(): Promise<object>;
+  json(): Promise<T>;
   text(): Promise<string>;
 }
 
@@ -135,15 +139,20 @@ type DehydrateFunc = <T>(
 export interface ZObject {
   request: {
     // most specific overloads go first
-    (url: string, options: HttpRequestOptions & { raw: true }): Promise<
-      RawHttpResponse
+    <T = any>(
+      url: string,
+      options: HttpRequestOptions & { raw: true }
+    ): Promise<RawHttpResponse<T>>;
+    <T = any>(
+      options: HttpRequestOptions & { raw: true; url: string }
+    ): Promise<RawHttpResponse<T>>;
+
+    <T = any>(url: string, options?: HttpRequestOptions): Promise<
+      HttpResponse<T>
     >;
-    (options: HttpRequestOptions & { raw: true; url: string }): Promise<
-      RawHttpResponse
+    <T = any>(options: HttpRequestOptions & { url: string }): Promise<
+      HttpResponse<T>
     >;
-
-    (url: string, options?: HttpRequestOptions): Promise<HttpResponse>;
-    (options: HttpRequestOptions & { url: string }): Promise<HttpResponse>;
   };
 
   console: Console;
@@ -199,6 +208,7 @@ export interface ZObject {
     ExpiredAuthError: typeof ExpiredAuthError;
     RefreshAuthError: typeof RefreshAuthError;
     ThrottledError: typeof ThrottledError;
+    ResponseError: typeof ResponseError;
   };
 
   cache: {
@@ -221,14 +231,14 @@ export type PerformFunction<BI = Record<string, any>, R = any> = (
 
 export type BeforeRequestMiddleware = (
   request: HttpRequestOptions,
-  z?: ZObject,
-  bundle?: Bundle
+  z: ZObject,
+  bundle: Bundle
 ) => HttpRequestOptions | Promise<HttpRequestOptions>;
 
 export type AfterResponseMiddleware = (
   response: HttpResponse,
   z: ZObject,
-  bundle?: Bundle
+  bundle: Bundle
 ) => HttpResponse | Promise<HttpResponse>;
 
 export interface BufferedItem<InputData = { [x: string]: any }> {

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.16.0
+ * zapier-platform-schema version: 15.17.0
  *  schema-to-ts compiler version: 0.1.0
  */