zapier-platform-core 14.0.1 → 14.1.1

package/index.d.ts

@@ -16,7 +16,8 @@ export const createAppTester: (
   options?: { customStoreKey?: string }
 ) => <T, B extends Bundle>(
   func: (z: ZObject, bundle: B) => T | Promise<T>,
-  bundle?: Partial<B> // partial so we don't have to make a full bundle in tests
+  bundle?: Partial<B>, // partial so we don't have to make a full bundle in tests
+  clearZcacheBeforeUse?: boolean
 ) => Promise<T>; // appTester always returns a promise
 
 // internal only
@@ -193,4 +194,10 @@ export interface ZObject {
     RefreshAuthError: typeof RefreshAuthError;
     ThrottledError: typeof ThrottledError;
   };
+
+  cache: {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any, ttl?: number) => Promise<boolean>;
+    delete: (key: string) => Promise<boolean>;
+  };
 }

package/package.json

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

package/src/app-middlewares/before/z-object.js

@@ -3,6 +3,7 @@
 const _ = require('lodash');
 
 const createAppRequestClient = require('../../tools/create-app-request-client');
+const createCache = require('../../tools/create-cache');
 const createDehydrator = require('../../tools/create-dehydrator');
 const createFileStasher = require('../../tools/create-file-stasher');
 const createJSONtool = require('../../tools/create-json-tool');
@@ -19,6 +20,7 @@ const hashing = require('../../tools/hashing');
 const injectZObject = (input) => {
   const bundle = _.get(input, '_zapier.event.bundle', {});
   const zRoot = {
+    cache: createCache(input),
     console: createLoggerConsole(input),
     cursor: createStoreKeyTool(input),
     dehydrate: createDehydrator(input, 'method'),

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

@@ -29,7 +29,7 @@ const createAppTester = (appRaw, { customStoreKey } = {}) => {
 
   const randomSeed = genId();
 
-  return (methodOrFunc, bundle) => {
+  const appTester = (methodOrFunc, bundle, clearZcacheBeforeUse = false) => {
     bundle = bundle || {};
 
     let method = resolveMethodPath(appRaw, methodOrFunc, false);
@@ -53,12 +53,17 @@ const createAppTester = (appRaw, { customStoreKey } = {}) => {
         : `testKey-${method}-${randomSeed}`
       : null;
 
+    if (clearZcacheBeforeUse) {
+      appTester.zcacheTestObj = {};
+    }
+
     const event = {
       command: 'execute',
       method,
       bundle,
       storeKey,
       callback_url: 'https://auth-json-server.zapier-staging.com/echo',
+      zcacheTestObj: appTester.zcacheTestObj,
     };
 
     if (process.env.LOG_TO_STDOUT) {
@@ -73,6 +78,10 @@ const createAppTester = (appRaw, { customStoreKey } = {}) => {
       return resp.results;
     });
   };
+
+  appTester.zcacheTestObj = {};
+
+  return appTester;
 };
 
 module.exports = createAppTester;

package/src/tools/create-cache.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const _ = require('lodash');
+
+const JSON = require('./create-json-tool')();
+const ensureJSONEncodable = require('./ensure-json-encodable');
+
+const createCache = (input) => {
+  const rpc = _.get(input, '_zapier.rpc');
+  const runValidationChecks = (rpc, key, value = null, ttl = null) => {
+    if (!rpc) {
+      throw new Error('rpc is not available');
+    }
+
+    if (!_.isString(key)) {
+      throw new TypeError('key must be a string');
+    }
+
+    if (ttl != null && !_.isInteger(ttl)) {
+      throw new TypeError('ttl must be an integer');
+    }
+
+    ensureJSONEncodable(value);
+  };
+
+  return {
+    get: async (key) => {
+      runValidationChecks(rpc, key);
+
+      const result = await rpc('zcache_get', key);
+      return result ? JSON.parse(result) : null;
+    },
+    set: async (key, value, ttl = null) => {
+      runValidationChecks(rpc, key, value, ttl);
+
+      return await rpc('zcache_set', key, JSON.stringify(value), ttl);
+    },
+    delete: async (key) => {
+      runValidationChecks(rpc, key);
+
+      return await rpc('zcache_delete', key);
+    },
+  };
+};
+
+module.exports = createCache;

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

@@ -8,11 +8,40 @@ const { genId } = require('./data');
 
 const FALLBACK_RPC = process.env.ZAPIER_BASE_ENDPOINT + '/platform/rpc/cli';
 
+const rpcCacheMock = (zcacheTestObj, method, key, value = null, ttl = null) => {
+  if (method === 'zcache_get') {
+    const result = key in zcacheTestObj ? zcacheTestObj[key] : null;
+    return result;
+  }
+
+  if (method === 'zcache_set') {
+    zcacheTestObj[key] = value;
+    return true;
+  }
+
+  if (method === 'zcache_delete') {
+    if (key in zcacheTestObj) {
+      delete zcacheTestObj[key];
+      return true;
+    }
+
+    return false;
+  }
+
+  throw new Error(`Unexpected method '${method}'`);
+};
+
 const createRpcClient = (event) => {
   return function (method) {
     const params = _.toArray(arguments);
     params.shift();
 
+    const zcacheMethods = ['zcache_get', 'zcache_set', 'zcache_delete'];
+    if (zcacheMethods.includes(method) && _.isPlainObject(event.zcacheTestObj)) {
+      const [key, value = null] = params;
+      return rpcCacheMock(event.zcacheTestObj, method, key, value);
+    }
+
     const id = genId();
     const body = JSON.stringify({
       id,

package/src/tools/ensure-json-encodable.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const _ = require('lodash');
+
+const ensureJSONEncodable = (obj, path = null, visited = null) => {
+  if (obj === null || _.isBoolean(obj) || _.isNumber(obj) || _.isString(obj)) {
+    return;
+  }
+
+  path = path || [];
+
+  if (!_.isPlainObject(obj) && !_.isArray(obj)) {
+    const typeName = typeof obj;
+    const pathStr = path.join('.');
+    throw new TypeError(
+      `Type '${typeName}' is not JSON-encodable (path: '${pathStr}')`
+    );
+  }
+
+  visited = visited || new Set();
+
+  if (visited.has(obj)) {
+    const pathStr = path.join('.');
+    throw new TypeError(
+      `Circular structure is not JSON-encodable (path: '${pathStr}')`
+    );
+  }
+
+  visited.add(obj);
+
+  for (const key in obj) {
+    ensureJSONEncodable(obj[key], path.concat(key), visited);
+  }
+};
+
+module.exports = ensureJSONEncodable;