zapier-platform-cli 15.18.1 → 15.19.0

package/scaffold/test.template.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import zapier from 'zapier-platform-core';
+
+import App from '../../index';
+
+const appTester = zapier.createAppTester(App);
+// read the `.env` file into the environment, if available
+zapier.tools.env.inject();
+
+describe('<%= ACTION_PLURAL %>.<%= KEY %>', () => {
+  it('should run', async () => {
+    const bundle = { inputData: {} };
+
+    const results = await appTester(App.<%= ACTION_PLURAL %>['<%= KEY %>'].<%= MAYBE_RESOURCE %>operation.perform, bundle);
+    expect(results).toBeDefined();
+    // TODO: add more assertions
+  });
+});

package/scaffold/trigger.template.ts

@@ -0,0 +1,58 @@
+import type { PerformFunction, Trigger } from 'zapier-platform-core';
+
+// triggers on a new <%= LOWER_NOUN %> with a certain tag
+const perform: PerformFunction = async (z, bundle) => {
+  const response = await z.request({
+    url: 'https://jsonplaceholder.typicode.com/posts',
+    params: {
+      tag: bundle.inputData.tagName,
+    },
+  });
+  // this should return an array of objects
+  return response.data;
+};
+
+export default {
+  // see here for a full list of available properties:
+  // https://github.com/zapier/zapier-platform/blob/main/packages/schema/docs/build/schema.md#triggerschema
+  key: '<%= KEY %>' as const,
+  noun: '<%= NOUN %>',
+
+  display: {
+    label: 'New <%= NOUN %>',
+    description: 'Triggers when a new <%= LOWER_NOUN %> is created.',
+  },
+
+  operation: {
+    type: 'polling',
+    perform,
+
+    <%= INCLUDE_INTRO_COMMENTS ? [
+      '// `inputFields` defines the fields a user could provide',
+      '// Zapier will pass them in as `bundle.inputData` later. They\'re optional.'
+    ].join('\n    ') : '' %>
+    inputFields: [],
+
+    <%= INCLUDE_INTRO_COMMENTS ? [
+      '// In cases where Zapier needs to show an example record to the user, but we are unable to get a live example',
+      '// from the API, Zapier will fallback to this hard-coded sample. It should reflect the data structure of',
+      '// returned records, and have obvious placeholder values that we can show to any user.'
+    ].join('\n    ') : '' %>
+    sample: {
+      id: 1,
+      name: 'Test',
+    },
+
+    <%= INCLUDE_INTRO_COMMENTS ? [
+      '// If fields are custom to each user (like spreadsheet columns), `outputFields` can create human labels',
+      '// For a more complete example of using dynamic fields see',
+      '// https://github.com/zapier/zapier-platform/tree/main/packages/cli#customdynamic-fields',
+      '// Alternatively, a static field definition can be provided, to specify labels for the fields'
+    ].join('\n    ') : '' %>
+    outputFields: [
+      // these are placeholders to match the example `perform` above
+      // {key: 'id', label: 'Person ID'},
+      // {key: 'name', label: 'Person Name'}
+    ],
+  },
+} satisfies Trigger;

package/src/oclif/commands/scaffold.js

@@ -1,4 +1,8 @@
+/* eslint-disable camelcase */
+// @ts-check
+
 const path = require('path');
+const fs = require('fs');
 
 const { flags } = require('@oclif/command');
 
@@ -6,8 +10,7 @@ const BaseCommand = require('../ZapierBaseCommand');
 const { buildFlags } = require('../buildFlags');
 
 const {
-  createTemplateContext,
-  getRelativeRequirePath,
+  createScaffoldingContext,
   plural,
   updateEntryFile,
   isValidEntryFileUpdate,
@@ -18,126 +21,89 @@ const { isValidAppInstall } = require('../../utils/misc');
 const { writeFile } = require('../../utils/files');
 const { ISSUES_URL } = require('../../constants');
 
-const getNewFileDirectory = (action, test = false) =>
-  path.join(test ? 'test/' : '', plural(action));
-
-const getLocalFilePath = (directory, actionKey) =>
-  path.join(directory, actionKey);
-/**
- * both the string to `require` and later, the filepath to write to
- */
-const getFullActionFilePath = (directory, actionKey) =>
-  path.join(process.cwd(), getLocalFilePath(directory, actionKey));
-
-const getFullActionFilePathWithExtension = (directory, actionKey, isTest) =>
-  `${getFullActionFilePath(directory, actionKey)}${isTest ? '.test' : ''}.js`;
-
 class ScaffoldCommand extends BaseCommand {
   async perform() {
     const { actionType, noun } = this.args;
-
-    // TODO: interactive portion here?
+    const indexFileLocal = this.flags.entry ?? this.defaultIndexFileLocal();
     const {
-      dest: newActionDir = getNewFileDirectory(actionType),
-      testDest: newTestActionDir = getNewFileDirectory(actionType, true),
-      entry = 'index.js',
+      dest: actionDirLocal = this.defaultActionDirLocal(indexFileLocal),
+      'test-dest': testDirLocal = this.defaultTestDirLocal(indexFileLocal),
       force,
     } = this.flags;
 
-    // this is possible, just extra work that's out of scope
-    // const tsParser = j.withParser('ts')
-    // tsParser(codeStr)
-    // will have to change logic probably though
-    if (entry.endsWith('ts')) {
-      this.error(
-        `Typescript isn't supported for scaffolding yet. Instead, try copying the example code at https://github.com/zapier/zapier-platform/blob/b8224ec9855be91c66c924b731199a068b1e913a/example-apps/typescript/src/resources/recipe.ts`
-      );
-    }
+    const language = indexFileLocal.endsWith('.ts') ? 'ts' : 'js';
 
-    const shouldIncludeComments = !this.flags['no-help']; // when called from other commands (namely `init`) this will be false
-    const templateContext = createTemplateContext(
+    const context = createScaffoldingContext({
       actionType,
       noun,
-      shouldIncludeComments
-    );
-
-    const actionKey = templateContext.KEY;
+      language,
+      indexFileLocal,
+      actionDirLocal,
+      testDirLocal,
+      includeIntroComments: !this.flags['no-help'],
+      preventOverwrite: !force,
+    });
 
-    const preventOverwrite = !force;
     // TODO: read from config file?
 
-    this.startSpinner(
-      `Creating new file: ${getLocalFilePath(newActionDir, actionKey)}.js`
-    );
-    await writeTemplateFile(
-      actionType,
-      templateContext,
-      getFullActionFilePathWithExtension(newActionDir, actionKey),
-      preventOverwrite
-    );
+    this.startSpinner(`Creating new file: ${context.actionFileLocal}`);
+
+    await writeTemplateFile({
+      destinationPath: context.actionFileResolved,
+      templateType: context.actionType,
+      language: context.language,
+      preventOverwrite: context.preventOverwrite,
+      templateContext: context.templateContext,
+    });
     this.stopSpinner();
 
-    this.startSpinner(
-      `Creating new test file: ${getLocalFilePath(
-        newTestActionDir,
-        actionKey
-      )}.js`
-    );
-    await writeTemplateFile(
-      'test',
-      templateContext,
-      getFullActionFilePathWithExtension(newTestActionDir, actionKey, true),
-      preventOverwrite
-    );
+    this.startSpinner(`Creating new test file: ${context.testFileLocal}`);
+    await writeTemplateFile({
+      destinationPath: context.testFileResolved,
+      templateType: 'test',
+      language: context.language,
+      preventOverwrite: context.preventOverwrite,
+      templateContext: context.templateContext,
+    });
     this.stopSpinner();
 
     // * rewire the index.js to point to the new file
-    this.startSpinner(`Rewriting your ${entry}`);
+    this.startSpinner(`Rewriting your ${context.indexFileLocal}`);
 
-    const entryFilePath = path.join(process.cwd(), entry);
-
-    const originalContents = await updateEntryFile(
-      entryFilePath,
-      templateContext.VARIABLE,
-      getFullActionFilePath(newActionDir, actionKey),
-      actionType,
-      templateContext.KEY
-    );
+    const originalContents = await updateEntryFile({
+      language: context.language,
+      indexFileResolved: context.indexFileResolved,
+      actionRelativeImportPath: context.actionRelativeImportPath,
+      actionImportName: context.templateContext.VARIABLE,
+      actionType: context.actionType,
+    });
 
     if (isValidAppInstall().valid) {
       const success = isValidEntryFileUpdate(
-        entryFilePath,
-        actionType,
-        templateContext.KEY
+        context.language,
+        context.indexFileResolved,
+        context.actionType,
+        context.templateContext.KEY
       );
 
       this.stopSpinner({ success });
 
       if (!success) {
-        const entryName = splitFileFromPath(entryFilePath)[1];
+        const entryName = splitFileFromPath(context.indexFileResolved)[1];
 
         this.startSpinner(
           `Unable to successfully rewrite your ${entryName}. Rolling back...`
         );
-        await writeFile(entryFilePath, originalContents);
+        await writeFile(context.indexFileResolved, originalContents);
         this.stopSpinner();
 
         this.error(
           [
-            `\nPlease add the following lines to ${entryFilePath}:`,
-            ` * \`const ${
-              templateContext.VARIABLE
-            } = require('./${getRelativeRequirePath(
-              entryFilePath,
-              getFullActionFilePath(newActionDir, actionKey)
-            )}');\` at the top-level`,
-            ` * \`[${templateContext.VARIABLE}.key]: ${
-              templateContext.VARIABLE
-            }\` in the "${plural(
-              actionType
-            )}" object in your exported integration definition.`,
+            `\nPlease add the following lines to ${context.indexFileResolved}:`,
+            ` * \`const ${context.templateContext.VARIABLE} = require('./${context.actionRelativeImportPath}');\` at the top-level`,
+            ` * \`[${context.templateContext.VARIABLE}.key]: ${context.templateContext.VARIABLE}\` in the "${context.actionTypePlural}" object in your exported integration definition.`,
             '',
-            `Also, please file an issue at ${ISSUES_URL} with the contents of your ${entryFilePath}.`,
+            `Also, please file an issue at ${ISSUES_URL} with the contents of your ${context.indexFileResolved}.`,
           ].join('\n')
         );
       }
@@ -146,8 +112,51 @@ class ScaffoldCommand extends BaseCommand {
     this.stopSpinner();
 
     if (!this.flags.invokedFromAnotherCommand) {
-      this.log(`\nAll done! Your new ${actionType} is ready to use.`);
+      this.log(`\nAll done! Your new ${context.actionType} is ready to use.`);
+    }
+  }
+
+  /**
+   * If `--entry` is not provided, this will determine the path to the
+   * root index file. Notably, we'll look for tsconfig.json and
+   * src/index.ts first, because even TS apps have a root level plain
+   * index.js that we should ignore.
+   *
+   * @returns {string}
+   */
+  defaultIndexFileLocal() {
+    const tsConfigPath = path.join(process.cwd(), 'tsconfig.json');
+    const srcIndexTsPath = path.join(process.cwd(), 'src', 'index.ts');
+    if (fs.existsSync(tsConfigPath) && fs.existsSync(srcIndexTsPath)) {
+      this.log('Automatically detected TypeScript project');
+      return 'src/index.ts';
     }
+
+    return 'index.js';
+  }
+
+  /**
+   * If `--dest` is not provided, this will determine the directory for
+   * the new action file to be created in.
+   *
+   * @param {string} indexFileLocal - The path to the index file
+   * @returns {string}
+   */
+  defaultActionDirLocal(indexFileLocal) {
+    const parent = path.dirname(indexFileLocal);
+    return path.join(parent, plural(this.args.actionType));
+  }
+
+  /**
+   * If `--test-dest` is not provided, this will determine the directory
+   * for the new test file to be created in.
+   *
+   * @param {string} indexFileLocal - The path to the index file
+   * @returns {string}
+   */
+  defaultTestDirLocal(indexFileLocal) {
+    const parent = path.dirname(indexFileLocal);
+    return path.join(parent, 'test', plural(this.args.actionType));
   }
 }
 
@@ -179,13 +188,12 @@ ScaffoldCommand.flags = buildFlags({
     entry: flags.string({
       char: 'e',
       description:
-        "Supply the path to your integration's root (`index.js`). Only needed if your `index.js` is in a subfolder, like `src`.",
-      default: 'index.js',
+        "Supply the path to your integration's entry point (`index.js` or `src/index.ts`). This will try to automatically detect the correct file if not provided.",
     }),
     force: flags.boolean({
       char: 'f',
       description:
-        'Should we overwrite an exisiting trigger/search/create file?',
+        'Should we overwrite an existing trigger/search/create file?',
       default: false,
     }),
     'no-help': flags.boolean({

package/src/utils/ast.js

@@ -1,6 +1,9 @@
-// tools for modifiyng an AST
+// @ts-check
+
+// tools for modifying an AST
 
 const j = require('jscodeshift');
+const ts = j.withParser('ts');
 
 // simple helper functions used for searching for nodes
 // can't use j.identifier(name) because it has extra properties and we have to have no extras to find nodes
@@ -21,7 +24,7 @@ const typeHelpers = {
 /**
  * adds a `const verName = require(path)` to the root of a codeStr
  */
-const createRootRequire = (codeStr, varName, path) => {
+const importActionInJsApp = (codeStr, varName, path) => {
   if (codeStr.match(new RegExp(`${varName} ?= ?require`))) {
     // duplicate identifier, no need to re-add
     // this would fail if they used this variable name for something else; we'd keep going and double-declare that variable
@@ -61,7 +64,7 @@ const createRootRequire = (codeStr, varName, path) => {
   return root.toSource();
 };
 
-const addKeyToPropertyOnApp = (codeStr, property, varName) => {
+const registerActionInJsApp = (codeStr, property, varName) => {
   // to play with this, use https://astexplorer.net/#/gist/cb4986b3f1c6eb975339608109a48e7d/0fbf2fabbcf27d0b6ebd8910f979bd5d97dd9404
 
   const root = j(codeStr);
@@ -136,4 +139,102 @@ const addKeyToPropertyOnApp = (codeStr, property, varName) => {
   return root.toSource();
 };
 
-module.exports = { createRootRequire, addKeyToPropertyOnApp };
+/**
+ * Adds an import statement to the top of an index.ts file to import a
+ * new action, such as `import some_trigger from './triggers/some_trigger';`
+ *
+ * @param {string} codeStr - The code of the index.ts file to modify.
+ * @param {string} identifierName - The name of imported action used as a variable in the code.
+ * @param {string} actionRelativeImportPath - The relative path to import the action from
+ * @returns {string}
+ */
+const importActionInTsApp = (
+  codeStr,
+  identifierName,
+  actionRelativeImportPath
+) => {
+  const root = ts(codeStr);
+
+  const imports = root.find(ts.ImportDeclaration);
+
+  const newImportStatement = j.importDeclaration(
+    [j.importDefaultSpecifier(j.identifier(identifierName))],
+    j.literal(actionRelativeImportPath)
+  );
+
+  if (imports.length) {
+    imports.at(-1).insertAfter(newImportStatement);
+  } else {
+    const body = root.find(ts.Program).get().node.body;
+    body.unshift(newImportStatement);
+    // Add newline after import?
+  }
+
+  return root.toSource({ quote: 'single' });
+};
+
+/**
+ *
+ * @param {string} codeStr
+ * @param {'creates' | 'searches' | 'triggers'} actionTypePlural - The type of action to register within the app
+ * @param {string} identifierName - Name of the action imported to be registered
+ * @returns {string}
+ */
+const registerActionInTsApp = (codeStr, actionTypePlural, identifierName) => {
+  const root = ts(codeStr);
+
+  // the `[thing.key]: thing` entry we'd like to insert.
+  const newProperty = ts.property.from({
+    kind: 'init',
+    key: j.memberExpression(j.identifier(identifierName), j.identifier('key')),
+    value: j.identifier(identifierName),
+    computed: true,
+  });
+
+  // Find the top level app Object; the one with the `platformVersion`
+  // key. This is where we'll insert our new property.
+  const appObjectCandidates = root
+    .find(ts.ObjectExpression)
+    .filter((path) =>
+      path.value.properties.some(
+        (prop) => prop.key && prop.key.name === 'platformVersion'
+      )
+    );
+  if (appObjectCandidates.length !== 1) {
+    throw new Error('Unable to find the app definition to modify');
+  }
+  const appObj = appObjectCandidates.get().node;
+
+  // Now we have an app object to modify.
+
+  // Check if this object already has the actionType group inside it.
+  const existingProp = appObj.properties.find(
+    (props) => props.key.name === actionTypePlural
+  );
+  if (existingProp) {
+    const value = existingProp.value;
+    if (value.type !== 'ObjectExpression') {
+      throw new Error(
+        `Tried to edit the ${actionTypePlural} key, but the value wasn't an object`
+      );
+    }
+    value.properties.push(newProperty);
+  } else {
+    appObj.properties.push(
+      j.property(
+        'init',
+        j.identifier(actionTypePlural),
+        j.objectExpression([newProperty])
+      )
+    );
+  }
+
+  return root.toSource({ quote: 'single' });
+};
+
+module.exports = {
+  importActionInJsApp,
+  registerActionInJsApp,
+  importActionInTsApp,
+  registerActionInTsApp,
+};