zapier-platform-core 17.5.0 → 17.7.0

package/index.js

@@ -2,4 +2,5 @@ const zapier = require('./src');
 zapier.version = require('./package.json').version;
 zapier.tools = require('./src/tools/exported');
 zapier.errors = require('./src/errors');
+zapier.console = require('./src/tools/console-singleton').consoleProxy;
 module.exports = zapier;

package/index.mjs

@@ -2,9 +2,11 @@ import zapier from './src/index.js';
 import packageJson from './package.json' with { type: 'json' };
 import _tools from './src/tools/exported.js';
 import _errors from './src/errors.js';
+import { consoleProxy } from './src/tools/console-singleton.js';
 zapier.version = packageJson.version;
 zapier.tools = _tools;
 zapier.errors = _errors;
+zapier.console = consoleProxy;
 // Allows `import { ... } from 'zapier-platform-core'`
 export const {
   createAppHandler,
@@ -16,6 +18,7 @@ export const {
   defineSearch,
   defineTrigger,
   integrationTestHandler,
+  console,
   tools,
   version,
   errors,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapier-platform-core",
-  "version": "17.5.0",
+  "version": "17.7.0",
   "description": "The core SDK for CLI apps in the Zapier Developer Platform.",
   "repository": "zapier/zapier-platform",
   "homepage": "https://platform.zapier.com/",
@@ -63,7 +63,7 @@
     "node-fetch": "2.7.0",
     "oauth-sign": "0.9.0",
     "semver": "7.7.1",
-    "zapier-platform-schema": "17.5.0"
+    "zapier-platform-schema": "17.7.0"
   },
   "devDependencies": {
     "@types/node-fetch": "^2.6.11",

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

@@ -10,7 +10,7 @@ const createJSONtool = require('../../tools/create-json-tool');
 const createStoreKeyTool = require('../../tools/create-storekey-tool');
 const createCallbackHigherOrderFunction = require('../../tools/create-callback-wrapper');
 const createLegacyScriptingRunner = require('../../tools/create-legacy-scripting-runner');
-const createLoggerConsole = require('../../tools/create-logger-console');
+const { initialize } = require('../../tools/console-singleton');
 const errors = require('../../errors');
 const hashing = require('../../tools/hashing');
 
@@ -19,9 +19,10 @@ const hashing = require('../../tools/hashing');
 */
 const injectZObject = (input) => {
   const bundle = _.get(input, '_zapier.event.bundle', {});
+
   const zRoot = {
     cache: createCache(input),
-    console: createLoggerConsole(input),
+    console: initialize(input),
     cursor: createStoreKeyTool(input),
     dehydrate: createDehydrator(input, 'method'),
     dehydrateFile: createDehydrator(input, 'file'),

package/src/checks/index.js

@@ -1,7 +1,7 @@
 module.exports = {
   createIsObject: require('./create-is-object'),
 
-  searchIsArray: require('./search-is-array'),
+  searchIsArrayOrEnvelope: require('./search-is-array-or-envelope'),
 
   triggerIsArray: require('./trigger-is-array'),
   triggerIsObject: require('./trigger-is-object'),

package/src/checks/search-is-array-or-envelope.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const _ = require('lodash');
+const { simpleTruncate } = require('../tools/data');
+
+const isSearch = require('./is-search');
+
+const hasCanPaginate = (searchKey, compiledApp) => {
+  const canPaginate =
+    compiledApp?.searches?.[searchKey]?.operation?.canPaginate;
+  return canPaginate;
+};
+
+/*
+  Searches should return an array of objects,
+  or a response envelope like { results: [...], paging_token: '...' } 
+  when canPaginate is true.
+*/
+const searchIsArrayOrEnvelope = {
+  name: 'searchIsArrayOrEnvelope',
+  shouldRun: isSearch,
+  run: (method, results, compiledApp) => {
+    const searchKey = method.split('.', 2)[1];
+    const truncatedResults = simpleTruncate(JSON.stringify(results), 50);
+
+    if (hasCanPaginate(searchKey, compiledApp)) {
+      // if paging is supported and results is an object (indicating pagination), it must have results and paging_token
+      if (_.isPlainObject(results)) {
+        if (!_.has(results, 'results') || !_.has(results, 'paging_token')) {
+          return [
+            `Paginated search results must be an object containing results and paging_token, got: ${truncatedResults}`,
+          ];
+        }
+        if (
+          !_.isString(results.paging_token) &&
+          !_.isNull(results.paging_token)
+        ) {
+          return [
+            `"paging_token" must be a string or null, got: ${typeof results.paging_token}`,
+          ];
+        }
+        // pass to array check below
+        results = results.results;
+      } else {
+        return [
+          `Paginated search results must be an object, got: ${typeof results}, (${truncatedResults})`,
+        ];
+      }
+    }
+
+    if (!_.isArray(results)) {
+      return [
+        `Search results must be an array, got: ${typeof results}, (${truncatedResults})`,
+      ];
+    }
+    return [];
+  },
+};
+
+module.exports = searchIsArrayOrEnvelope;

package/src/index.js

@@ -2,6 +2,7 @@
 
 const createLambdaHandler = require('./tools/create-lambda-handler');
 const createAppTester = require('./tools/create-app-tester');
+const { consoleProxy } = require('./tools/console-singleton');
 
 let _integrationTestHandler;
 const integrationTestHandler = (event, context, callback) => {
@@ -15,5 +16,6 @@ module.exports = {
   createAppHandler: createLambdaHandler,
   createAppTester,
   integrationTestHandler,
+  console: consoleProxy,
   ...require('./typeHelpers'),
 };

package/src/tools/console-singleton.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const createLoggerConsole = require('./create-logger-console');
+
+/**
+ * Shared console instance that can be used standalone or as z.console.
+ * Uses createLoggerConsole to create the single instance shared between both.
+ */
+
+// Shared console instance - will be initialized by middleware
+let loggerConsole = null;
+
+/**
+ * Initialize the console with the input context from middleware.
+ * This is called by the z-object middleware and uses createLoggerConsole.
+ * Creates a new logger console for each Lambda invocation to ensure proper isolation.
+ * Returns the shared console instance for z.console to use.
+ */
+const initialize = (input) => {
+  // Always create a new logger console for each invocation to ensure
+  // log context isolation between Lambda invocations
+  loggerConsole = createLoggerConsole(input);
+  return loggerConsole;
+};
+
+/**
+ * Reset the singleton for testing purposes
+ */
+const reset = () => {
+  loggerConsole = null;
+};
+
+/**
+ * Proxy that behaves like a console object.
+ * Forwards calls to loggerConsole if initialized, otherwise to global console.
+ */
+const consoleProxy = new Proxy(console, {
+  get(target, prop, receiver) {
+    // Use loggerConsole if initialized, otherwise fall back to global console
+    const actualConsole = loggerConsole || target;
+    return Reflect.get(actualConsole, prop, actualConsole);
+  },
+});
+
+module.exports = {
+  consoleProxy,
+  initialize,
+  reset,
+};

package/src/tools/create-logger.js

@@ -32,16 +32,68 @@ const LOG_STREAM_BYTES_LIMIT = 15 * 1024 * 1024;
 
 const DEFAULT_LOGGER_TIMEOUT = 200;
 
+// Will be initialized lazily
+const SAFE_AUTH_DATA_KEYS = new Set();
+
 const sleep = promisify(setTimeout);
 
-const isUrl = (url) => {
-  try {
-    // eslint-disable-next-line no-new
-    new URL(url);
-    return true;
-  } catch (e) {
+const initSafeAuthDataKeys = () => {
+  // An authData key in (safePrefixes x safeSuffixes) is considered safe to log
+  // uncensored
+  const safePrefixes = [
+    'account',
+    'bot_user',
+    'cloud',
+    'cloud_site',
+    'company',
+    'domain',
+    'email',
+    'environment',
+    'location',
+    'org',
+    'organization',
+    'project',
+    'region',
+    'scope',
+    'scopes',
+    'site',
+    'subdomain',
+    'team',
+    'token_type',
+    'user',
+    'workspace',
+  ];
+  const safeSuffixes = ['', '_id', '_name', 'id', 'name'];
+  for (const prefix of safePrefixes) {
+    for (const suffix of safeSuffixes) {
+      SAFE_AUTH_DATA_KEYS.add(prefix + suffix);
+    }
+  }
+};
+
+const isUrl = (value) => {
+  if (!value || typeof value !== 'string') {
     return false;
   }
+  const commonProtocols = [
+    'https://',
+    'http://',
+    'ftp://',
+    'ftps://',
+    'file://',
+  ];
+  for (const protocol of commonProtocols) {
+    if (value.startsWith(protocol)) {
+      try {
+        // eslint-disable-next-line no-new
+        new URL(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+  }
+  return false;
 };
 
 const MAX_LENGTH = 3500;
@@ -136,6 +188,13 @@ const attemptFindSecretsInStr = (s, isGettingNewSecret) => {
   return findSensitiveValues(parsedRespContent);
 };
 
+const isSafeAuthDataKey = (key) => {
+  if (SAFE_AUTH_DATA_KEYS.size === 0) {
+    initSafeAuthDataKeys();
+  }
+  return SAFE_AUTH_DATA_KEYS.has(key.toLowerCase());
+};
+
 const buildSensitiveValues = (event, data) => {
   const bundle = event.bundle || {};
   const authData = bundle.authData || {};
@@ -147,7 +206,9 @@ const buildSensitiveValues = (event, data) => {
     if (isSensitiveKey(key)) {
       return true;
     }
-
+    if (isSafeAuthDataKey(key)) {
+      return false;
+    }
     if (isUrl(value) && !isUrlWithSecrets(value)) {
       return false;
     }

package/types/console.test-d.ts

@@ -0,0 +1,24 @@
+import { expectType } from 'tsd';
+import { console } from '..';
+
+// Test that console is exported and has the right type
+expectType<Console>(console);
+
+// Test that console has expected methods with proper signatures
+expectType<{
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}>(console.log);
+expectType<{
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}>(console.error);
+expectType<{
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}>(console.warn);
+
+// Test that console can be used for logging
+console.log('test message');
+console.error('test error');
+console.warn('test warning');

package/types/custom.d.ts

@@ -10,13 +10,10 @@ import { Headers } from 'node-fetch';
 
 // The EXPORTED OBJECT
 export const version: string;
-export const tools: { 
-  env: { inject: (filename?: string) => void };
-};
+export const tools: { env: { inject: (filename?: string) => void } };
+export const console: Console;
 export const errors: ErrorsModule;
 
-
-
 // see: https://github.com/zapier/zapier-platform-cli/issues/339#issue-336888249
 export const createAppTester: (
   appRaw: object,

package/types/functions.d.ts

@@ -118,9 +118,17 @@ export type CreatePerformGet<
 > = (z: ZObject, bundle: Bundle<$InputData>) => $Return | Promise<$Return>;
 
 /**
- * Search for objects on a partner API.
+ * Helper type for search results that can optionally include pagination.
+ * Returns either:
+ * - an array of objects, matching the search query.
+ * - an object with a `results` array of objects and a `paging_token` string.
  *
- * Returns an 1-item array of objects, matching the search query.
+ * When `canPaginate` is true for the search, the object shape is required.
+ */
+type SearchResult<T> = T[] | { results: T[], paging_token: string };
+
+/**
+ * Search for objects on a partner API.
  *
  * @remarks
  * This type requires a one-item array. Multiple items *can* be
@@ -130,7 +138,7 @@ export type CreatePerformGet<
 export type SearchPerform<
   $InputData extends DefaultInputData = DefaultInputData,
   $Return extends {} = {},
-> = (z: ZObject, bundle: Bundle<$InputData>) => $Return[] | Promise<$Return[]>;
+> = (z: ZObject, bundle: Bundle<$InputData>) => SearchResult<$Return> | Promise<SearchResult<$Return>>;
 
 /**
  * Follow up a search's perform with additional data.

package/types/schemas.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: 17.4.0
+ * zapier-platform-schema version: 17.6.0
  *  schema-to-ts compiler version: 0.1.0
  */
 import type {
@@ -1193,6 +1193,9 @@ export interface BasicSearchOperation<
    */
   performGet?: Request | SearchPerformGet<InferInputData<$InputFields>>;
 
+  /** Does this search support pagination? */
+  canPaginate?: boolean;
+
   /** What should the form a user sees and configures look like? */
   inputFields?: $InputFields;
 

package/src/checks/search-is-array.js

@@ -1,23 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { simpleTruncate } = require('../tools/data');
-
-const isSearch = require('./is-search');
-
-/*
-  Searches should always return an array of objects.
-*/
-const searchIsArray = {
-  name: 'triggerIsArray',
-  shouldRun: isSearch,
-  run: (method, results) => {
-    if (!_.isArray(results)) {
-      const repr = simpleTruncate(JSON.stringify(results), 50);
-      return [`Results must be an array, got: ${typeof results}, (${repr})`];
-    }
-    return [];
-  },
-};
-
-module.exports = searchIsArray;