zapier-platform-cli 16.5.1 → 17.0.0

package/src/generators/templates/{typescript/src/index.ts → index.template.ts}

@@ -1,5 +1,4 @@
-import type { App } from 'zapier-platform-core';
-import { version as platformVersion } from 'zapier-platform-core';
+import { version as platformVersion, defineApp } from 'zapier-platform-core';
 
 import packageJson from '../package.json';
 
@@ -8,7 +7,7 @@ import MovieTrigger from './triggers/movie';
 import authentication from './authentication';
 import { addBearerHeader } from './middleware';
 
-export default {
+export default defineApp({
   version: packageJson.version,
   platformVersion,
 
@@ -22,4 +21,4 @@ export default {
   creates: {
     [MovieCreate.key]: MovieCreate,
   },
-} satisfies App;
+});

package/src/generators/templates/typescript/src/authentication.ts

@@ -1,6 +1,6 @@
 import type { Authentication } from 'zapier-platform-core';
 
-import { API_URL, SCOPES } from './constants';
+import { API_URL, SCOPES } from './constants.js';
 
 export default {
   type: 'oauth2',

package/src/generators/templates/typescript/src/creates/movie.ts

@@ -1,7 +1,17 @@
-import type { Create, PerformFunction } from 'zapier-platform-core';
-import { API_URL } from '../constants';
+import {
+  defineInputFields,
+  defineCreate,
+  type CreatePerform,
+  type InferInputData,
+} from 'zapier-platform-core';
+import { API_URL } from '../constants.js';
 
-const perform: PerformFunction = async (z, bundle) => {
+const inputFields = defineInputFields([
+  { key: 'title', required: true },
+  { key: 'year', type: 'integer' },
+]);
+
+const perform = (async (z, bundle) => {
   const response = await z.request({
     method: 'POST',
     url: `${API_URL}/movies`,
@@ -11,9 +21,9 @@ const perform: PerformFunction = async (z, bundle) => {
     },
   });
   return response.data;
-};
+}) satisfies CreatePerform<InferInputData<typeof inputFields>>;
 
-export default {
+export default defineCreate({
   key: 'movie',
   noun: 'Movie',
 
@@ -24,13 +34,10 @@ export default {
 
   operation: {
     perform,
-    inputFields: [
-      { key: 'title', required: true },
-      { key: 'year', type: 'integer' },
-    ],
+    inputFields,
     sample: {
       id: '1',
       title: 'example',
     },
   },
-} satisfies Create;
+});

package/src/generators/templates/typescript/src/test/creates.test.ts

@@ -10,7 +10,7 @@ describe('movie', () => {
   test('create a movie', async () => {
     const bundle = {
       inputData: { title: 'hello', year: 2020 },
-      authData: { access_token: 'a_token' }, 
+      authData: { access_token: 'a_token' },
     };
     const result = await appTester(App.creates.movie.operation.perform, bundle);
     expect(result).toMatchObject({

package/src/generators/templates/typescript/src/triggers/movie.ts

@@ -1,12 +1,15 @@
-import type { PerformFunction, Trigger } from 'zapier-platform-core';
-import { API_URL } from '../constants';
+import {
+  defineTrigger,
+  type PollingTriggerPerform,
+} from 'zapier-platform-core';
+import { API_URL } from '../constants.js';
 
-const perform: PerformFunction = async (z, bundle) => {
+const perform = (async (z, bundle) => {
   const response = await z.request(`${API_URL}/movies`);
   return response.data;
-};
+}) satisfies PollingTriggerPerform;
 
-export default {
+export default defineTrigger({
   key: 'movie',
   noun: 'Movie',
 
@@ -23,4 +26,4 @@ export default {
       title: 'example',
     },
   },
-} satisfies Trigger;
+});

package/src/oclif/commands/build.js

@@ -51,7 +51,7 @@ This command does the following:
 * Copies all code into the temporary folder
 * Adds an entry point: \`zapierwrapper.js\`
 * Generates and validates app definition.
-* Detects dependencies via browserify (optional, on by default)
+* Detects dependencies via esbuild (optional, on by default)
 * Zips up all needed \`.js\` files. If you want to include more files, add a "includeInBuild" property (array with strings of regexp paths) to your \`${CURRENT_APP_FILE}\`.
 * Moves the zip to \`${BUILD_PATH}\` and \`${SOURCE_PATH}\` and deletes the temp folder
 

package/src/oclif/commands/init.js

@@ -10,12 +10,12 @@ const { TEMPLATE_CHOICES, ProjectGenerator } = require('../../generators');
 class InitCommand extends BaseCommand {
   async perform() {
     const { path } = this.args;
-    const { template } = this.flags;
+    const { template, module } = this.flags;
 
     const env = yeoman.createEnv();
     env.registerStub(ProjectGenerator, 'zapier:integration');
 
-    await env.run('zapier:integration', { path, template });
+    await env.run('zapier:integration', { path, template, module });
 
     this.log();
     this.log(`A new integration has been created in directory "${path}".`);
@@ -30,6 +30,12 @@ InitCommand.flags = buildFlags({
       description: 'The template to start your integration with.',
       options: TEMPLATE_CHOICES,
     }),
+    module: Flags.string({
+      char: 'm',
+      description:
+        'Choose module type: CommonJS or ES Modules. Only enabled for Typescript and Minimal templates.',
+      options: ['commonjs', 'esm'],
+    }),
   },
 });
 InitCommand.args = {
@@ -42,6 +48,7 @@ InitCommand.args = {
 InitCommand.examples = [
   'zapier init myapp',
   'zapier init ./path/myapp --template oauth2',
+  'zapier init ./path/myapp --template minimal --module esm',
 ];
 InitCommand.description = `Initialize a new Zapier integration with a project template.
 

package/src/oclif/commands/invoke.js

@@ -13,7 +13,7 @@ const { DateTime, IANAZone } = require('luxon');
 
 const BaseCommand = require('../ZapierBaseCommand');
 const { buildFlags } = require('../buildFlags');
-const { localAppCommand, getLocalAppHandler } = require('../../utils/local');
+const { localAppCommand } = require('../../utils/local');
 const { startSpinner, endSpinner } = require('../../utils/display');
 const {
   getLinkedAppConfig,
@@ -510,10 +510,6 @@ class InvokeCommand extends BaseCommand {
     }
 
     if (!_.isEmpty(env)) {
-      // process.env changed, so we need to reload the modules that have loaded
-      // the old values of process.env
-      getLocalAppHandler({ reload: true });
-
       // Save envs so the user won't have to re-enter them if the command fails
       await appendEnv(env);
       console.warn('CLIENT_ID and CLIENT_SECRET saved to .env file.');

package/src/utils/build.js

@@ -2,10 +2,9 @@ const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 
-const browserify = require('browserify');
-const through = require('through2');
 const _ = require('lodash');
 const archiver = require('archiver');
+const esbuild = require('esbuild');
 const fs = require('fs');
 const fse = require('fs-extra');
 const klaw = require('klaw');
@@ -20,13 +19,7 @@ const {
 
 const constants = require('../constants');
 
-const {
-  writeFile,
-  readFile,
-  copyDir,
-  ensureDir,
-  removeDir,
-} = require('./files');
+const { writeFile, copyDir, ensureDir, removeDir } = require('./files');
 
 const {
   prettyJSONstringify,
@@ -42,67 +35,39 @@ const {
   validateApp,
 } = require('./api');
 
+const { copyZapierWrapper } = require('./zapierwrapper');
+
 const checkMissingAppInfo = require('./check-missing-app-info');
 
 const { runCommand, isWindows, findCorePackageDir } = require('./misc');
 const { respectGitIgnore } = require('./ignore');
+const { localAppCommand } = require('./local');
 
 const debug = require('debug')('zapier:build');
 
 const stripPath = (cwd, filePath) => filePath.split(cwd).pop();
 
 // given entry points in a directory, return a list of files that uses
-// could probably be done better with module-deps...
-// TODO: needs to include package.json files too i think
-//   https://github.com/serverless/serverless-optimizer-plugin?
-const requiredFiles = (cwd, entryPoints) => {
+const requiredFiles = async ({ cwd, entryPoints }) => {
   if (!_.endsWith(cwd, path.sep)) {
     cwd += path.sep;
   }
 
-  const argv = {
-    noParse: [undefined],
-    extensions: [],
-    ignoreTransform: [],
-    entries: entryPoints,
-    fullPaths: false,
-    builtins: false,
-    commondir: false,
-    bundleExternal: true,
-    basedir: cwd,
-    browserField: false,
-    detectGlobals: true,
-    insertGlobals: false,
-    insertGlobalVars: {
-      process: undefined,
-      global: undefined,
-      'Buffer.isBuffer': undefined,
-      Buffer: undefined,
-    },
-    ignoreMissing: true,
-    debug: false,
-    standalone: undefined,
-  };
-  const b = browserify(argv);
-
-  return new Promise((resolve, reject) => {
-    b.on('error', reject);
-
-    const paths = [];
-    b.pipeline.get('deps').push(
-      through
-        .obj((row, enc, next) => {
-          const filePath = row.file || row.id;
-          paths.push(stripPath(cwd, filePath));
-          next();
-        })
-        .on('end', () => {
-          paths.sort();
-          resolve(paths);
-        }),
-    );
-    b.bundle();
+  const result = await esbuild.build({
+    entryPoints,
+    outdir: './build',
+    bundle: true,
+    platform: 'node',
+    metafile: true,
+    logLevel: 'warning',
+    external: ['../test/userapp'],
+    format: 'esm',
+    write: false, // no need to write outfile
   });
+
+  return Object.keys(result.metafile.inputs).map((path) =>
+    stripPath(cwd, path),
+  );
 };
 
 const listFiles = (dir) => {
@@ -194,16 +159,21 @@ const writeZipFromPaths = (dir, zipPath, paths) => {
 };
 
 const makeZip = async (dir, zipPath, disableDependencyDetection) => {
-  const entryPoints = [
-    path.resolve(dir, 'zapierwrapper.js'),
-    path.resolve(dir, 'index.js'),
-  ];
+  const entryPoints = [path.resolve(dir, 'zapierwrapper.js')];
+
+  const indexPath = path.resolve(dir, 'index.js');
+  if (fs.existsSync(indexPath)) {
+    // Necessary for CommonJS integrations. The zapierwrapper they use require()
+    // the index.js file using a variable. esbuild can't detect it, so we need
+    // to add it here specifically.
+    entryPoints.push(indexPath);
+  }
 
   let paths;
 
   const [dumbPaths, smartPaths, appConfig] = await Promise.all([
     listFiles(dir),
-    requiredFiles(dir, entryPoints),
+    requiredFiles({ cwd: dir, entryPoints }),
     getLinkedAppConfig(dir).catch(() => ({})),
   ]);
 
@@ -234,24 +204,6 @@ const makeSourceZip = async (dir, zipPath) => {
   await writeZipFromPaths(dir, zipPath, finalPaths);
 };
 
-// Similar to utils.appCommand, but given a ready to go app
-// with a different location and ready to go zapierwrapper.js.
-const _appCommandZapierWrapper = (dir, event) => {
-  const app = require(`${dir}/zapierwrapper.js`);
-  event = Object.assign({}, event, {
-    calledFromCli: true,
-  });
-  return new Promise((resolve, reject) => {
-    app.handler(event, {}, (err, resp) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(resp);
-      }
-    });
-  });
-};
-
 const maybeNotifyAboutOutdated = () => {
   // find a package.json for the app and notify on the core dep
   // `build` won't run if package.json isn't there, so if we get to here we're good
@@ -417,35 +369,21 @@ const _buildFunc = async ({
 
   if (printProgress) {
     endSpinner();
-    startSpinner('Applying entry point file');
+    startSpinner('Applying entry point files');
   }
 
-  // TODO: should this routine for include exist elsewhere?
-  const zapierWrapperBuf = await readFile(
-    path.join(
-      tmpDir,
-      'node_modules',
-      constants.PLATFORM_PACKAGE,
-      'include',
-      'zapierwrapper.js',
-    ),
-  );
-  await writeFile(
-    path.join(tmpDir, 'zapierwrapper.js'),
-    zapierWrapperBuf.toString(),
-  );
+  await copyZapierWrapper(corePath, tmpDir);
 
   if (printProgress) {
     endSpinner();
     startSpinner('Building app definition.json');
   }
 
-  const rawDefinition = (
-    await _appCommandZapierWrapper(tmpDir, {
-      command: 'definition',
-    })
-  ).results;
-
+  const rawDefinition = await localAppCommand(
+    { command: 'definition' },
+    tmpDir,
+    false,
+  );
   const fileWriteError = await writeFile(
     path.join(tmpDir, 'definition.json'),
     prettyJSONstringify(rawDefinition),
@@ -472,11 +410,11 @@ const _buildFunc = async ({
     if (printProgress) {
       startSpinner('Validating project schema and style');
     }
-    const validateResponse = await _appCommandZapierWrapper(tmpDir, {
-      command: 'validate',
-    });
-
-    const validationErrors = validateResponse.results;
+    const validationErrors = await localAppCommand(
+      { command: 'validate' },
+      tmpDir,
+      false,
+    );
     if (validationErrors.length) {
       debug('\nErrors:\n', validationErrors, '\n');
       throw new Error(

package/src/utils/local.js

@@ -1,8 +1,8 @@
-const _ = require('lodash');
-const path = require('path');
+const path = require('node:path');
 
-const { findCorePackageDir } = require('./misc');
 const { BASE_ENDPOINT } = require('../constants');
+const { findCorePackageDir, runCommand } = require('./misc');
+const { copyZapierWrapper, deleteZapierWrapper } = require('./zapierwrapper');
 
 /**
  * Wraps Node's http.request() / https.request() so that all requests go via a relay URL.
@@ -218,34 +218,75 @@ function wrapFetchWithRelay(fetchFunc, relayUrl, relayHeaders) {
   };
 }
 
-const getLocalAppHandler = ({
-  reload = false,
-  baseEvent = {},
+const loadAppRawUsingImport = async (
+  appDir,
+  corePackageDir,
+  shouldDeleteWrapper,
+) => {
+  const wrapperPath = await copyZapierWrapper(corePackageDir, appDir);
+  let appRaw;
+  try {
+    // zapierwrapper.mjs is only available since zapier-platform-core v17.
+    // And only zapierwrapper.mjs exposes appRaw just for this use case.
+    appRaw = (await import(wrapperPath)).appRaw;
+  } catch (err) {
+    if (err.name === 'SyntaxError') {
+      // Run a separate process to print the line number of the SyntaxError.
+      // This workaround is needed because `err` doesn't provide the location
+      // info about the SyntaxError. However, if the error is thrown to
+      // Node.js's built-in error handler, it will print the location info.
+      // See: https://github.com/nodejs/node/issues/49441
+      await runCommand(process.execPath, ['zapierwrapper.js'], {
+        cwd: appDir,
+      });
+    }
+    throw err;
+  } finally {
+    if (shouldDeleteWrapper) {
+      await deleteZapierWrapper(appDir);
+    }
+  }
+
+  return appRaw;
+};
+
+const loadAppRawUsingRequire = (appDir) => {
+  let appRaw = require(appDir);
+  if (appRaw && appRaw.default) {
+    // Node.js 22+ supports using require() to import ESM.
+    // For Node.js < 20.17.0, require() will throw an error on ESM.
+    // https://nodejs.org/api/modules.html#loading-ecmascript-modules-using-require
+    appRaw = appRaw.default;
+  }
+  return appRaw;
+};
+
+const getLocalAppHandler = async ({
+  appDir = null,
   appId = null,
   deployKey = null,
   relayAuthenticationId = null,
   beforeRequest = null,
   afterResponse = null,
+  shouldDeleteWrapper = true,
 } = {}) => {
-  const entryPath = `${process.cwd()}/index`;
-  const rootPath = path.dirname(require.resolve(entryPath));
-  const corePackageDir = findCorePackageDir();
+  appDir = path.resolve(appDir || process.cwd());
 
-  if (reload) {
-    Object.keys(require.cache).forEach((cachePath) => {
-      if (cachePath.startsWith(rootPath)) {
-        delete require.cache[cachePath];
-      }
-    });
-  }
-  let appRaw, zapier;
+  const corePackageDir = findCorePackageDir();
+  let appRaw;
   try {
-    appRaw = require(entryPath);
-    zapier = require(corePackageDir);
+    appRaw = loadAppRawUsingRequire(appDir);
   } catch (err) {
-    // this err.stack doesn't give a nice traceback at all :-(
-    // maybe we could do require('syntax-error') in the future
-    return (event, ctx, callback) => callback(err);
+    if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ERR_REQUIRE_ESM') {
+      appRaw = await loadAppRawUsingImport(
+        appDir,
+        corePackageDir,
+        shouldDeleteWrapper,
+      );
+    } else {
+      // err.name === 'SyntaxError' or others
+      throw err;
+    }
   }
 
   if (beforeRequest) {
@@ -282,41 +323,65 @@ const getLocalAppHandler = ({
     global.fetch = wrapFetchWithRelay(global.fetch, relayUrl, relayHeaders);
   }
 
+  // Assumes the entry point of zapier-platform-core is index.js
+  const coreEntryPoint = path.join(corePackageDir, 'index.js');
+  const zapier = (await import(coreEntryPoint)).default;
+
   const handler = zapier.createAppHandler(appRaw);
-  return (event, ctx, callback) => {
-    event = _.merge(
-      {},
-      event,
-      {
+  if (handler.length === 3) {
+    // < v17: function handler(event, ctx, callback)
+    return (event, ctx, callback) => {
+      event = {
+        ...event,
         calledFromCli: true,
-      },
-      baseEvent,
-    );
-    handler(event, _, callback);
-  };
+      };
+      return handler(event, ctx, callback);
+    };
+  } else {
+    // >= v17: async function handler(event, ctx = {})
+    return async (event, ctx = {}) => {
+      event = {
+        ...event,
+        calledFromCli: true,
+      };
+      return await handler(event, ctx);
+    };
+  }
 };
 
 // Runs a local app command (./index.js) like {command: 'validate'};
-const localAppCommand = (event) => {
-  const handler = getLocalAppHandler({
+const localAppCommand = async (event, appDir, shouldDeleteWrapper = true) => {
+  const handler = await getLocalAppHandler({
     appId: event.appId,
     deployKey: event.deployKey,
     relayAuthenticationId: event.relayAuthenticationId,
     beforeRequest: event.beforeRequest,
     afterResponse: event.afterResponse,
+    appDir,
+    shouldDeleteWrapper,
   });
-  return new Promise((resolve, reject) => {
-    handler(event, {}, (err, resp) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(resp.results);
-      }
+  if (handler.length === 3) {
+    // < 17: function handler(event, ctx, callback)
+    return new Promise((resolve, reject) => {
+      event = {
+        ...event,
+        calledFromCli: true,
+      };
+      handler(event, {}, (err, response) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(response.results);
+        }
+      });
     });
-  });
+  } else {
+    // >= 17: async function handler(event, ctx = {})
+    const response = await handler(event);
+    return response.results;
+  }
 };
 
 module.exports = {
-  getLocalAppHandler,
   localAppCommand,
 };

package/src/utils/zapierwrapper.js

@@ -0,0 +1,55 @@
+// Utility functions that helps you copy and delete the Lambda function entry
+// point zapierwrapper.mjs or zapierwrapper.js to the integration directory.
+
+const { existsSync } = require('node:fs');
+const { readFile, writeFile, rm } = require('node:fs/promises');
+const { join } = require('node:path');
+
+// We have two different versions of zapierwrapper: the .mjs one for ESM and the
+// .js one for CommonJS. To copy the right one, we check the module type in the
+// integration's package.json.
+//
+// For esbuild to perform static analysis, zapierwrapper.mjs can only
+// import('packageName') where the packageName must be a static string literal.
+// It can't import(packageName) where packageName is a variable. So in
+// zapierwrapper.mjs, there's a placeholder {REPLACE_ME_PACKAGE_NAME} that
+// we'll replace with the actual package name.
+const copyZapierWrapper = async (corePackageDir, appDir) => {
+  const appPackageJson = require(join(appDir, 'package.json'));
+  let wrapperFilename;
+  if (appPackageJson.type === 'module') {
+    wrapperFilename = 'zapierwrapper.mjs';
+  } else {
+    wrapperFilename = 'zapierwrapper.js';
+  }
+  const wrapperPath = join(corePackageDir, 'include', wrapperFilename);
+
+  if (appPackageJson.type === 'module' && !existsSync(wrapperPath)) {
+    throw new Error(
+      "Couldn't find zapierwrapper.mjs in zapier-platform-core. Are you trying to run ESM? " +
+        'If so, you need to upgrade zapier-platform-core to at least v17.',
+    );
+  }
+
+  const wrapperText = (await readFile(wrapperPath, 'utf8')).replace(
+    '{REPLACE_ME_PACKAGE_NAME}',
+    appPackageJson.name,
+  );
+  const wrapperDest = join(appDir, 'zapierwrapper.js');
+  await writeFile(wrapperDest, wrapperText);
+  return wrapperDest;
+};
+
+const deleteZapierWrapper = async (appDir) => {
+  const wrapperPath = join(appDir, 'zapierwrapper.js');
+  try {
+    await rm(wrapperPath);
+  } catch (err) {
+    // ignore
+  }
+};
+
+module.exports = {
+  copyZapierWrapper,
+  deleteZapierWrapper,
+};

package/src/generators/templates/typescript/index.js

@@ -1 +0,0 @@
-module.exports = require('./dist').default;