zapier-platform-core 15.14.1 → 15.14.2

package/package.json

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

package/src/app-middlewares/after/checks.js

@@ -32,7 +32,7 @@ const checkOutput = (output) => {
       })
       .map((check) => {
         return check
-          .run(event.method, output.results, compiledApp)
+          .run(event.method, output.results, compiledApp, event.bundle)
           .map((err) => ({ name: check.name, error: err }));
       });
     const checkResults = _.flatten(rawResults);

package/src/checks/index.js

@@ -9,4 +9,5 @@ module.exports = {
   triggerHasId: require('./trigger-has-id'),
   firehoseSubscriptionIsArray: require('./firehose_is_array'),
   firehoseSubscriptionKeyIsString: require('./firehose_is_string'),
+  performBufferReturnType: require('./perform-buffer-return-type'),
 };

package/src/checks/is-create.js

@@ -1,6 +1,10 @@
 module.exports = (method) => {
+  // `method` will never start with "resources." in production.
+  // Seems only for testing.
   return (
-    (method.startsWith('creates.') && method.endsWith('.operation.perform')) ||
+    (method.startsWith('creates.') &&
+      (method.endsWith('.operation.perform') ||
+        method.endsWith('.operation.performBuffer'))) ||
     (method.startsWith('resources.') &&
       method.endsWith('.create.operation.perform'))
   );

package/src/checks/is-trigger.js

@@ -1,6 +1,7 @@
 module.exports = (method) => {
   return (
-    // `method` will never start with "resources.". Seems like legacy code.
+    // `method` will never start with "resources." in production.
+    // Seems only for testing.
     (method.startsWith('triggers.') && method.endsWith('.operation.perform')) ||
     (method.startsWith('resources.') &&
       method.endsWith('.list.operation.perform'))

package/src/checks/perform-buffer-return-type.js

@@ -0,0 +1,65 @@
+const _ = require('lodash');
+
+const performBufferEchoesIds = {
+  name: 'performBufferReturnType',
+
+  shouldRun: (method, bundle) => {
+    return (
+      Array.isArray(bundle.buffer) &&
+      method.endsWith('.operation.performBuffer') &&
+      method.startsWith('creates.')
+    );
+  },
+
+  run: (method, results, compiledApp, bundle) => {
+    if (!_.isPlainObject(results)) {
+      // create-is-object should have caught this
+      return [];
+    }
+
+    const inputIds = bundle.buffer
+      .map((b) => {
+        return b && b.meta ? b.meta.id : null;
+      })
+      .filter((id) => id);
+
+    const outputIds = Object.keys(results);
+    const missingIds = inputIds.filter((id) => !outputIds.includes(id));
+
+    if (missingIds.length > 0) {
+      const LIMIT = 3;
+      let missingIdsStr = missingIds.slice(0, LIMIT).join(', ');
+      const remainingCount = missingIds.length - LIMIT;
+      if (remainingCount > 0) {
+        // Don't want to flood the user with too many IDs
+        missingIdsStr += `, and ${remainingCount} more`;
+      }
+      return [`Result object is missing these IDs as keys: ${missingIdsStr}`];
+    }
+
+    const errors = [];
+    for (const id of inputIds) {
+      const item = results[id];
+
+      if (!_.isPlainObject(item)) {
+        errors.push(`Result object member with ID '${id}' must be an object`);
+      } else if (
+        !_.isPlainObject(item.outputData) &&
+        typeof item.error !== 'string'
+      ) {
+        errors.push(
+          `Result object member with ID '${id}' must have 'outputData' object or 'error' string`
+        );
+      }
+
+      if (errors.length >= 4) {
+        // No need to flood the user with too many errors
+        break;
+      }
+    }
+
+    return errors;
+  },
+};
+
+module.exports = performBufferEchoesIds;

package/src/tools/create-logger.js

@@ -166,7 +166,8 @@ const buildSensitiveValues = (event, data) => {
   const isGettingNewSecret =
     event.method &&
     (event.method.endsWith('refreshAccessToken') ||
-      event.method.endsWith('sessionConfig.perform'));
+      event.method.endsWith('sessionConfig.perform') ||
+      event.method.endsWith('oauth1Config.getAccessToken'));
 
   for (const prop of ['response_content', 'request_data']) {
     if (data[prop]) {

package/types/zapier.custom.d.ts

@@ -135,13 +135,12 @@ type DehydrateFunc = <T>(
 export interface ZObject {
   request: {
     // most specific overloads go first
-    (
-      url: string,
-      options: HttpRequestOptions & { raw: true }
-    ): Promise<RawHttpResponse>;
-    (
-      options: HttpRequestOptions & { raw: true; url: string }
-    ): Promise<RawHttpResponse>;
+    (url: string, options: HttpRequestOptions & { raw: true }): Promise<
+      RawHttpResponse
+    >;
+    (options: HttpRequestOptions & { raw: true; url: string }): Promise<
+      RawHttpResponse
+    >;
 
     (url: string, options?: HttpRequestOptions): Promise<HttpResponse>;
     (options: HttpRequestOptions & { url: string }): Promise<HttpResponse>;
@@ -231,3 +230,40 @@ export type AfterResponseMiddleware = (
   z: ZObject,
   bundle?: Bundle
 ) => HttpResponse | Promise<HttpResponse>;
+
+export interface BufferedItem<InputData = { [x: string]: any }> {
+  inputData: InputData;
+  meta: {
+    id: string;
+    [x: string]: any;
+  };
+}
+
+export interface BufferedBundle<InputData = { [x: string]: any }> {
+  authData: { [x: string]: string };
+  buffer: BufferedItem<InputData>[];
+  groupedBy: { [x: string]: string };
+}
+
+interface PerformBufferSuccessItem {
+  outputData: { [x: string]: any };
+  error?: string;
+}
+
+interface PerformBufferErrorItem {
+  outputData?: { [x: string]: any };
+  error: string;
+}
+
+export type PerformBufferResultItem =
+  | PerformBufferSuccessItem
+  | PerformBufferErrorItem;
+
+export interface PerformBufferResult {
+  [id: string]: PerformBufferResultItem;
+}
+
+export const performBuffer: (
+  z: ZObject,
+  bundle: BufferedBundle
+) => Promise<PerformBufferResult>;

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.14.0
+ * zapier-platform-schema version: 15.14.1
  *  schema-to-ts compiler version: 0.1.0
  */
 
@@ -1316,6 +1316,34 @@ export interface Search {
   operation: BasicActionOperation;
 }
 
+/**
+ * Currently an **internal-only** feature. Zapier uses this
+ * configuration for creating objects in bulk.
+ *
+ * [Docs: BufferConfigSchema](https://github.com/zapier/zapier-platform/blob/main/packages/schema/docs/build/schema.md#BufferConfigSchema)
+ */
+export interface BufferConfig {
+  /**
+   * The list of keys of input fields to group bulk-create with. The
+   * actual user data provided for the fields will be used during
+   * execution. Note that a required input field should be referenced
+   * to get user data always.
+   *
+   * @minItems 1
+   */
+  groupedBy: unknown[];
+
+  /**
+   * The maximum number of items to call `performBuffer` with.
+   * **Note** that it is capped by the platform to prevent exceeding
+   * the [AWS Lambda's request/response payload size quota of 6
+   * MB](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution).
+   * Also, the execution is time-bound; we recommend reducing it upon
+   * consistent timeout.
+   */
+  limit: number;
+}
+
 /**
  * Represents the fundamental mechanics of a create.
  *
@@ -1332,9 +1360,11 @@ export interface BasicCreateActionOperation {
 
   /**
    * How will Zapier get the data? This can be a function like `(z) =>
-   * [{id: 123}]` or a request like `{url: 'http...'}`.
+   * [{id: 123}]` or a request like `{url: 'http...'}`. Exactly one of
+   * `perform` or `performBuffer` must be defined. If you choose to
+   * define `buffer` and `performBuffer`, you must omit `perform`.
    */
-  perform: Request | Function;
+  perform?: Request | Function;
 
   /**
    * Internal pointer to a function from the original source or the
@@ -1385,6 +1415,21 @@ export interface BasicCreateActionOperation {
    * concurrency)?
    */
   shouldLock?: boolean;
+
+  /**
+   * Currently an **internal-only** feature. Zapier uses this
+   * configuration for creating objects in bulk with `performBuffer`.
+   */
+  buffer?: BufferConfig;
+
+  /**
+   * Internal pointer to a function from the original source or the
+   * source code itself. Encodes arity and if `arguments` is used in
+   * the body. Note - just write normal functions and the system will
+   * encode the pointers for you. Or, provide {source: "return 1 + 2"}
+   * and the system will wrap in a function for you.
+   */
+  performBuffer?: Function;
 }
 
 /**