zapier-platform-core 15.9.1 → 15.11.0

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "zapier-platform-core",
-  "version": "15.9.1",
+  "version": "15.11.0",
   "description": "The core SDK for CLI apps in the Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
   "author": "Zapier Engineering <contact@zapier.com>",
   "license": "SEE LICENSE IN LICENSE",
   "main": "index.js",
-  "typings": "index.d.ts",
+  "types": "types/index.d.ts",
   "files": [
     "/include/",
-    "/index.d.ts",
     "/index.js",
-    "/src/"
+    "/src/",
+    "/types/"
   ],
   "scripts": {
     "preversion": "git pull && yarn test",
     "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",
     "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",
+    "test": "yarn main-tests && yarn solo-test && yarn type-tests",
     "test:debug": "mocha inspect -t 10s --recursive test",
     "debug": "mocha -t 10s --inspect-brk --recursive test",
     "test:w": "mocha -t 10s --recursive test --watch",
@@ -52,7 +53,7 @@
     "node-fetch": "2.6.7",
     "oauth-sign": "0.9.0",
     "semver": "7.5.2",
-    "zapier-platform-schema": "15.9.1"
+    "zapier-platform-schema": "15.11.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",
@@ -61,7 +62,8 @@
     "dicer": "^0.3.1",
     "fs-extra": "^11.1.1",
     "mock-fs": "^5.2.0",
-    "nock": "^13.5.4"
+    "nock": "^13.5.4",
+    "tsd": "^0.31.1"
   },
   "optionalDependencies": {
     "@types/node": "^20.3.1"

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

@@ -1,5 +1,8 @@
 const zlib = require('zlib');
 const _ = require('lodash');
+
+const { ALLOWED_HTTP_DATA_CONTENT_TYPES, getContentType } = require('./http');
+
 const constants = require('../constants');
 
 const createHttpPatch = (event) => {
@@ -54,19 +57,34 @@ const createHttpPatch = (event) => {
       const newCallback = function (response) {
         const chunks = [];
 
+        // 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
+        const requestContentType = getContentType(options.headers || {});
+        const responseContentType = getContentType(response.headers || {});
+
+        const shouldIncludeRequestData =
+          ALLOWED_HTTP_DATA_CONTENT_TYPES.has(requestContentType);
+        const shouldIncludeResponseData =
+          ALLOWED_HTTP_DATA_CONTENT_TYPES.has(responseContentType);
+
         const sendToLogger = (responseBody) => {
           // Prepare data for GL
           const logData = {
             log_type: 'http',
-            request_type: 'devplatform-outbound',
+            // Using a custom request_type to differentiate from z.request() since `request_via_client` is not logged in GL
+            request_type: 'patched-devplatform-outbound',
             request_url: requestUrl,
             request_method: options.method || 'GET',
             request_headers: options.headers,
-            request_data: options.body || '',
+            request_data: shouldIncludeRequestData
+              ? options.body || ''
+              : '<unsupported format>',
             request_via_client: false,
             response_status_code: response.statusCode,
             response_headers: response.headers,
-            response_content: responseBody,
+            response_content: shouldIncludeResponseData
+              ? responseBody
+              : '<unsupported format>',
           };
 
           object.zapierLogger(

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

@@ -19,42 +19,84 @@ const environmentTools = require('./environment');
 const schemaTools = require('./schema');
 const ZapierPromise = require('./promise');
 
-const RequestSchema = require('zapier-platform-schema/lib/schemas/RequestSchema');
-const FunctionSchema = require('zapier-platform-schema/lib/schemas/FunctionSchema');
-
-const isRequestOrFunction = (obj) => {
+const isDefinedPrimitive = (value) => {
   return (
-    RequestSchema.validate(obj).valid || FunctionSchema.validate(obj).valid
+    value === null ||
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'boolean'
   );
 };
 
-const extendAppRaw = (base, extension) => {
-  const keysToOverride = [
-    'test',
-    'perform',
-    'performList',
-    'performSubscribe',
-    'performUnsubscribe',
-  ];
-  const concatArrayAndOverrideKeys = (objValue, srcValue, key) => {
-    if (Array.isArray(objValue) && Array.isArray(srcValue)) {
-      return objValue.concat(srcValue);
+const shouldFullyReplace = (path) => {
+  // covers inputFields, outputFields, sample, throttle, etc
+  const isOperation = path[path.length - 2] === 'operation';
+  return isOperation;
+};
+
+const extendAppRaw = (base, extension, path) => {
+  if (extension === undefined) {
+    return base;
+  } else if (isDefinedPrimitive(extension)) {
+    return extension;
+  } else if (Array.isArray(extension)) {
+    return [...extension];
+  } else if (_.isPlainObject(extension)) {
+    path = path || [];
+    if (shouldFullyReplace(path)) {
+      return extension;
+    } else {
+      const baseObject = _.isPlainObject(base) ? base : {};
+      const result = { ...baseObject };
+      for (const [key, value] of Object.entries(extension)) {
+        const newPath = [...path, key];
+        result[key] = extendAppRaw(baseObject[key], value, newPath);
+      }
+      return result;
     }
+  }
+  throw new TypeError('Unexpected extension type');
+};
 
-    if (
-      // Do full replacement when it comes to keysToOverride
-      keysToOverride.indexOf(key) !== -1 &&
-      _.isPlainObject(srcValue) &&
-      _.isPlainObject(objValue) &&
-      isRequestOrFunction(srcValue) &&
-      isRequestOrFunction(objValue)
-    ) {
-      return srcValue;
+const mayMoveCreatesToResourcesInExtension = (base, extension) => {
+  // The backend sends an extension for creates.KEY.operation.perform as a
+  // special case for legacy-scripting-runner.
+  // For details, see the MR description at
+  // https://gitlab.com/zapier/zapier/-/merge_requests/57964
+  //
+  // We need to make sure that 'creates.{key}Create' in extension won't collide
+  // with 'resources.{key}.create' in base. Otherwise, the checks in
+  // compileApp() will throw an error. So here we move 'creates.{key}Create' to
+  // 'resources.{key}.create' in extension if base has 'resources.{key}.create'.
+  //
+  // There's a regression test: Search for 'resource key collision' in
+  // integration-test.js.
+  if (
+    !_.isPlainObject(base.resources) ||
+    !_.isPlainObject(extension.creates) ||
+    _.isEmpty(base.resources) ||
+    _.isEmpty(extension.creates)
+  ) {
+    return extension;
+  }
+
+  const creates = extension.creates;
+  extension.creates = {};
+  extension.resources = extension.resources || {};
+
+  for (const [key, resource] of Object.entries(base.resources)) {
+    const standaloneCreate = creates[key + 'Create'];
+    if (resource.create && standaloneCreate) {
+      delete standaloneCreate.key;
+      delete standaloneCreate.noun;
+      extension.resources[key] = {
+        ...extension.resources[key],
+        create: standaloneCreate,
+      };
     }
+  }
 
-    return undefined;
-  };
-  return _.mergeWith(base, extension, concatArrayAndOverrideKeys);
+  return extension;
 };
 
 const getAppRawOverride = (rpc, appRawOverride) => {
@@ -69,6 +111,10 @@ const getAppRawOverride = (rpc, appRawOverride) => {
       appRawOverride = appRawOverride[0];
 
       if (typeof appRawOverride !== 'string') {
+        appRawExtension = mayMoveCreatesToResourcesInExtension(
+          appRawOverride,
+          appRawExtension
+        );
         appRawOverride = extendAppRaw(appRawOverride, appRawExtension);
         resolve(appRawOverride);
         return;
@@ -116,17 +162,25 @@ const getAppRawOverride = (rpc, appRawOverride) => {
 // so allow for that, and an event.appRawOverride for "buildless" apps.
 const loadApp = (event, rpc, appRawOrPath) => {
   return new ZapierPromise((resolve, reject) => {
+    const appRaw = _.isString(appRawOrPath)
+      ? require(appRawOrPath)
+      : appRawOrPath;
+
     if (event && event.appRawOverride) {
+      if (
+        Array.isArray(event.appRawOverride) &&
+        event.appRawOverride.length > 1 &&
+        !event.appRawOverride[0]
+      ) {
+        event.appRawOverride[0] = appRaw;
+      }
+
       return getAppRawOverride(rpc, event.appRawOverride)
         .then((appRawOverride) => resolve(appRawOverride))
         .catch((err) => reject(err));
     }
 
-    if (_.isString(appRawOrPath)) {
-      return resolve(require(appRawOrPath));
-    }
-
-    return resolve(appRawOrPath);
+    return resolve(appRaw);
   });
 };
 

package/src/tools/http.js

@@ -4,6 +4,23 @@ const fetch = require('node-fetch');
 const FORM_TYPE = 'application/x-www-form-urlencoded';
 const JSON_TYPE = 'application/json';
 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 YAML_TYPE = 'application/yaml';
+const XML_TYPE = 'application/xml';
+const JSONAPI_TYPE = 'application/vnd.api+json';
+
+const ALLOWED_HTTP_DATA_CONTENT_TYPES = new Set([
+  FORM_TYPE,
+  JSON_TYPE,
+  JSON_TYPE_UTF8,
+  HTML_TYPE,
+  TEXT_TYPE,
+  YAML_TYPE,
+  XML_TYPE,
+  JSONAPI_TYPE,
+]);
 
 const getContentType = (headers) => {
   const headerKeys = Object.keys(headers);
@@ -101,6 +118,13 @@ module.exports = {
   FORM_TYPE,
   JSON_TYPE,
   JSON_TYPE_UTF8,
+  BINARY_TYPE,
+  HTML_TYPE,
+  TEXT_TYPE,
+  YAML_TYPE,
+  XML_TYPE,
+  JSONAPI_TYPE,
+  ALLOWED_HTTP_DATA_CONTENT_TYPES,
   getContentType,
   parseDictHeader,
   unheader,

package/src/tools/wrap-hydrate.js

@@ -4,9 +4,11 @@ const crypto = require('crypto');
 
 const { DehydrateError } = require('../errors');
 
-// Max URL length for Node is 8KB (https://stackoverflow.com/a/56954244/)
-// 8 * 1024 * (3 / 4) = 6144 max, minus some room for additional overhead
-const MAX_PAYLOAD_SIZE = 6000;
+// https://nodejs.org/docs/latest-v16.x/api/http.html#httpmaxheadersize
+// Base64 encoding adds approx 4/3 to the original size
+// To account for encoding, we use the inverse to calc the max original size (3/4)
+// 16kb limit * 1024 * (3 / 4) = 12.228 kb max, minus some room for additional overhead
+const MAX_PAYLOAD_SIZE = 12000;
 
 const wrapHydrate = (payload) => {
   payload = JSON.stringify(payload);

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './zapier.generated';
+export * from './zapier.custom';

package/types/index.test-d.ts

@@ -0,0 +1,152 @@
+import type {
+  AfterResponseMiddleware,
+  BeforeRequestMiddleware,
+  Bundle,
+  PerformFunction,
+  ZObject,
+} from './zapier.custom';
+import type {
+  App,
+  Authentication,
+  AuthenticationOAuth2Config,
+  BasicActionOperation,
+  BasicCreateActionOperation,
+  BasicDisplay,
+  BasicHookOperation,
+  BasicPollingOperation,
+  Create,
+  Search,
+  Trigger,
+} from './zapier.generated';
+
+import { expectType } from 'tsd';
+
+const basicDisplay: BasicDisplay = {
+  label: 'some-label',
+  description: 'some-description',
+  directions: 'some-directions',
+  hidden: false,
+};
+expectType<BasicDisplay>(basicDisplay);
+
+const oauth2Config: AuthenticationOAuth2Config = {
+  authorizeUrl: 'https://example.com/authorize',
+  getAccessToken: 'https://example.com/token',
+  refreshAccessToken: async (z: ZObject, b: Bundle) => 'some-refresh-token',
+};
+expectType<AuthenticationOAuth2Config>(oauth2Config);
+
+const authentication: Authentication = {
+  type: 'oauth2',
+  test: async (z: ZObject, b: Bundle) => ({ data: true }),
+  oauth2Config,
+};
+expectType<Authentication>(authentication);
+
+const createOperation: BasicCreateActionOperation = {
+  inputFields: [{ key: 'some-input-key-1', type: 'string', required: true }],
+  perform: async (z: ZObject, b: Bundle) => ({ data: true }),
+  sample: { id: 'some-id', name: 'some-name' },
+};
+expectType<BasicCreateActionOperation>(createOperation);
+
+const create: Create = {
+  key: 'some_create_key_v1',
+  noun: 'Some Noun',
+  display: {
+    label: 'some create label',
+    description: 'some trigger description',
+  },
+  operation: createOperation,
+};
+expectType<Create>(create);
+
+const pollingOperation: BasicPollingOperation = {
+  type: 'polling',
+  inputFields: [{ key: 'some-input-key-1', type: 'number', required: true }],
+  perform: async (z: ZObject, b: Bundle) => ({ data: true }),
+};
+
+const pollingTrigger: Trigger = {
+  key: 'some_polling_trigger_key_v1',
+  noun: 'Some Noun',
+  display: {
+    label: 'some polling trigger label',
+    description: 'some polling trigger description',
+  },
+  operation: pollingOperation,
+};
+expectType<Trigger>(pollingTrigger);
+
+const hookOperation: BasicHookOperation = {
+  type: 'hook',
+  inputFields: [{ key: 'some-input-key-1', type: 'boolean', required: false }],
+  perform: async (z: ZObject, b: Bundle) => ({ data: true }),
+  performList: async (z: ZObject, b: Bundle) => [{ data: true }],
+  performSubscribe: async (z: ZObject, b: Bundle) => ({ data: true }),
+  performUnsubscribe: async (z: ZObject, b: Bundle) => ({ data: true }),
+};
+expectType<BasicHookOperation>(hookOperation);
+
+const hookTrigger: Trigger = {
+  key: 'some_hook_trigger_key_v1',
+  noun: 'Some Noun',
+  display: {
+    label: 'some hook label',
+    description: 'some hook description',
+  },
+  operation: hookOperation,
+};
+expectType<Trigger>(hookTrigger);
+
+const searchOperation: BasicActionOperation = {
+  inputFields: [{ key: 'some-input-key-1', type: 'file', required: true }],
+  perform: async (z: ZObject, b: Bundle) => [{ data: true }],
+};
+expectType<BasicActionOperation>(searchOperation);
+
+const search: Search = {
+  key: 'some_search_key_v1',
+  noun: 'Some Noun',
+  display: {
+    label: 'some search label',
+    description: 'some search description',
+  },
+  operation: searchOperation,
+};
+expectType<Search>(search);
+
+const addBearerHeader: BeforeRequestMiddleware = (request, z, bundle) => {
+  if (bundle?.authData?.access_token && !request.headers!.Authorization) {
+    request.headers!.Authorization = `Bearer ${bundle.authData.access_token}`;
+  }
+  return request;
+};
+expectType<BeforeRequestMiddleware>(addBearerHeader);
+
+const checkPermissionsError: AfterResponseMiddleware = (response, z) => {
+  if (response.status === 403) {
+    throw new z.errors.Error(
+      response.json?.['o:errorDetails']?.[0].detail,
+      response.status.toString()
+    );
+  }
+  return response;
+};
+expectType<AfterResponseMiddleware>(checkPermissionsError);
+
+const app: App = {
+  platformVersion: '0.0.1',
+  version: '0.0.1',
+
+  beforeRequest: [addBearerHeader],
+  afterResponse: [checkPermissionsError],
+
+  creates: { [create.key]: create },
+  triggers: {
+    [pollingTrigger.key]: pollingTrigger,
+    [hookTrigger.key]: hookTrigger,
+  },
+  searches: { [search.key]: search },
+};
+expectType<App>(app);

package/{index.d.ts → types/zapier.custom.d.ts}

@@ -22,10 +22,6 @@ export const createAppTester: (
   clearZcacheBeforeUse?: boolean
 ) => Promise<T>; // appTester always returns a promise
 
-// internal only
-// export const integrationTestHandler: () => any;
-// export const createAppHandler: (appRaw: object) => any
-
 type HttpMethod =
   | 'GET'
   | 'POST'
@@ -118,9 +114,9 @@ export interface HttpResponse extends BaseHttpResponse {
 
 export interface RawHttpResponse extends BaseHttpResponse {
   body: NodeJS.ReadableStream;
-	buffer(): Promise<Buffer>;
-	json(): Promise<object>;
-	text(): Promise<string>;
+  buffer(): Promise<Buffer>;
+  json(): Promise<object>;
+  text(): Promise<string>;
 }
 
 type DehydrateFunc = <T>(
@@ -204,3 +200,26 @@ export interface ZObject {
     delete: (key: string) => Promise<boolean>;
   };
 }
+
+/**
+ * A function that performs the action.
+ *
+ * @template BI The shape of data in the `bundle.inputData` object.
+ * @template R The return type of the function.
+ */
+export type PerformFunction<BI = Record<string, any>, R = any> = (
+  z: ZObject,
+  bundle: Bundle<BI>
+) => Promise<R>;
+
+export type BeforeRequestMiddleware = (
+  request: HttpRequestOptions,
+  z?: ZObject,
+  bundle?: Bundle
+) => HttpRequestOptions;
+
+export type AfterResponseMiddleware = (
+  response: HttpResponse,
+  z: ZObject,
+  bundle?: Bundle
+) => HttpResponse;