@zapier/zapier-sdk-cli 0.4.1 → 0.4.2

package/src/utils/parameter-resolver.ts

@@ -52,16 +52,29 @@ export class SchemaParameterResolver {
       return !hasValue;
     });
 
-    // Determine which parameters are "functionally required" vs truly optional
-    // For run-action: appKey, actionType, actionKey are schema-required
-    // authenticationId and inputs are schema-optional but functionally needed
+    // Determine parameter resolution categories:
+    // - functionally required: must be provided (inputs)
+    // - always prompt: should be prompted for but can be skipped (authenticationId)
+    // - truly optional: only ask if user wants to be prompted
     const functionallyRequired = missingResolvable.filter((param) => {
       // Schema-required parameters are always functionally required
       if (param.isRequired) return true;
 
-      // For run-action, inputs and authenticationId are functionally required
-      // even though schema-optional
-      if (param.name === "inputs" || param.name === "authenticationId") {
+      // Only inputs is functionally required for run-action
+      if (param.name === "inputs") {
+        return true;
+      }
+
+      return false;
+    });
+
+    // Parameters that should always be prompted for directly, but can be skipped
+    const alwaysPrompt = missingResolvable.filter((param) => {
+      if (functionallyRequired.includes(param)) return false;
+
+      // authenticationId should always be prompted for (since it's usually needed)
+      // but can be skipped with "Continue without authentication"
+      if (param.name === "authenticationId") {
         return true;
       }
 
@@ -69,14 +82,19 @@ export class SchemaParameterResolver {
     });
 
     const trulyOptional = missingResolvable.filter(
-      (param) => !functionallyRequired.includes(param),
+      (param) =>
+        !functionallyRequired.includes(param) && !alwaysPrompt.includes(param),
     );
 
-    if (parseResult.success && functionallyRequired.length === 0) {
+    if (
+      parseResult.success &&
+      functionallyRequired.length === 0 &&
+      alwaysPrompt.length === 0
+    ) {
       return parseResult.data;
     }
 
-    if (functionallyRequired.length === 0) {
+    if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
       // No functionally required parameters missing, but check if we can parse
       if (!parseResult.success) {
         throw parseResult.error;
@@ -84,7 +102,7 @@ export class SchemaParameterResolver {
       return parseResult.data;
     }
 
-    // 2. Resolve functionally required parameters first
+    // 2. Resolve functionally required parameters and their dependencies first
     const resolvedParams = { ...providedParams };
     const context: ResolverContext = {
       sdk,
@@ -97,10 +115,22 @@ export class SchemaParameterResolver {
       const requiredResolutionOrder =
         getResolutionOrderForParams(requiredParamNames);
 
+      // Find all parameters that need to be resolved (including dependencies)
+      // from the available resolvable parameters
       const orderedRequiredParams = requiredResolutionOrder
-        .map((paramName) =>
-          functionallyRequired.find((p) => p.name === paramName),
-        )
+        .map((paramName) => {
+          // First try to find in functionally required
+          let param = functionallyRequired.find((p) => p.name === paramName);
+          // If not found, try always prompt (for dependencies like authenticationId)
+          if (!param) {
+            param = alwaysPrompt.find((p) => p.name === paramName);
+          }
+          // If not found, try truly optional (for other dependencies)
+          if (!param) {
+            param = trulyOptional.find((p) => p.name === paramName);
+          }
+          return param;
+        })
         .filter((param): param is ResolvableParameter => param !== undefined);
 
       for (const param of orderedRequiredParams) {
@@ -115,13 +145,54 @@ export class SchemaParameterResolver {
             console.log(chalk.yellow("\n\nOperation cancelled by user"));
             process.exit(0);
           }
-          console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+          throw error;
+        }
+      }
+
+      // Remove resolved dependencies from other categories to avoid double-prompting
+      const resolvedParamNames = new Set(
+        orderedRequiredParams.map((p) => p.name),
+      );
+      alwaysPrompt.splice(
+        0,
+        alwaysPrompt.length,
+        ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)),
+      );
+      trulyOptional.splice(
+        0,
+        trulyOptional.length,
+        ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)),
+      );
+    }
+
+    // 3. Resolve parameters that should always be prompted for (but can be skipped)
+    if (alwaysPrompt.length > 0) {
+      const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
+      const alwaysPromptResolutionOrder =
+        getResolutionOrderForParams(alwaysPromptNames);
+
+      const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
+        .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
+        .filter((param): param is ResolvableParameter => param !== undefined);
+
+      for (const param of orderedAlwaysPromptParams) {
+        try {
+          const value = await this.resolveParameter(param, context);
+          this.setNestedValue(resolvedParams, param.path, value);
+
+          // Update context with newly resolved value
+          context.resolvedParams = resolvedParams;
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
           throw error;
         }
       }
     }
 
-    // 3. Ask user if they want to resolve truly optional parameters
+    // 4. Ask user if they want to resolve truly optional parameters
     if (trulyOptional.length > 0) {
       const optionalNames = trulyOptional.map((p) => p.name).join(", ");
       const shouldResolveOptional = await inquirer.prompt([
@@ -155,7 +226,6 @@ export class SchemaParameterResolver {
               console.log(chalk.yellow("\n\nOperation cancelled by user"));
               process.exit(0);
             }
-            console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
             throw error;
           }
         }
@@ -258,102 +328,164 @@ export class SchemaParameterResolver {
     } else if (resolver.type === "dynamic") {
       // Dynamic resolver - fetch options and prompt for selection
       try {
-        console.log(chalk.gray(`Fetching options for ${param.name}...`));
-        const items = await resolver.fetch(context.sdk, context.resolvedParams);
-
-        if (!items || items.length === 0) {
-          throw new Error(`No options available for ${param.name}`);
+        // Only show "Fetching..." for required parameters that typically have many options
+        if (param.isRequired && param.name !== "authenticationId") {
+          console.log(chalk.gray(`Fetching options for ${param.name}...`));
         }
+        const items = await resolver.fetch(context.sdk, context.resolvedParams);
 
-        const promptConfig = resolver.prompt(items, context.resolvedParams);
+        // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
+        const safeItems = items || [];
+        const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
         const answers = await inquirer.prompt([promptConfig as any]);
         return answers[param.name];
       } catch (error) {
-        console.error(
-          chalk.red(`Failed to fetch options for ${param.name}:`),
-          error instanceof Error ? error.message : error,
-        );
+        // Let the main CLI error handler display user-friendly errors
         throw error;
       }
     } else if ((resolver as any).type === "fields") {
-      // Fields resolver - fetch field definitions and prompt for each input
-      try {
-        console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
-        const fields = await (resolver as any).fetch(
-          context.sdk,
-          context.resolvedParams,
-        );
+      // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
+      return await this.resolveFieldsRecursively(
+        resolver as any,
+        context,
+        param,
+      );
+    }
+
+    throw new Error(`Unknown resolver type for ${param.name}`);
+  }
+
+  private async resolveFieldsRecursively(
+    resolver: any,
+    context: ResolverContext,
+    param: ResolvableParameter,
+  ): Promise<Record<string, any>> {
+    const inputs: Record<string, any> = {};
+    let processedFieldKeys = new Set<string>();
+    let iteration = 0;
+    const maxIterations = 5; // Prevent infinite loops
+
+    while (iteration < maxIterations) {
+      iteration++;
+
+      // Update context with current inputs so they're passed to listInputFields
+      const updatedContext = {
+        ...context,
+        resolvedParams: {
+          ...context.resolvedParams,
+          inputs,
+        },
+      };
+
+      console.log(
+        chalk.gray(
+          `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`,
+        ),
+      );
+
+      const fields = await resolver.fetch(
+        updatedContext.sdk,
+        updatedContext.resolvedParams,
+      );
 
-        if (!fields || fields.length === 0) {
+      if (!fields || fields.length === 0) {
+        if (iteration === 1) {
           console.log(
             chalk.yellow(`No input fields required for this action.`),
           );
-          return {};
         }
+        break;
+      }
 
-        const inputs: Record<string, any> = {};
+      // Find new fields that we haven't processed yet
+      const newFields = fields.filter(
+        (field: any) => !processedFieldKeys.has(field.key),
+      );
 
-        // Separate required and optional fields
-        const requiredFields = fields.filter((field: any) => field.required);
-        const optionalFields = fields.filter((field: any) => !field.required);
+      if (newFields.length === 0) {
+        // No new fields, we're done
+        break;
+      }
 
-        // First, prompt for all required fields
-        if (requiredFields.length > 0) {
-          console.log(
-            chalk.blue(
-              `\n📝 Please provide values for the following input fields:`,
-            ),
-          );
-          for (const field of requiredFields) {
-            await this.promptForField(field, inputs);
-          }
+      // Separate new required and optional fields
+      const newRequiredFields = newFields.filter(
+        (field: any) => field.required,
+      );
+      const newOptionalFields = newFields.filter(
+        (field: any) => !field.required,
+      );
+
+      // Prompt for new required fields
+      if (newRequiredFields.length > 0) {
+        console.log(
+          chalk.blue(
+            `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
+          ),
+        );
+        for (const field of newRequiredFields) {
+          await this.promptForField(field, inputs);
+          processedFieldKeys.add(field.key);
         }
+      }
 
-        // Then ask if user wants to configure optional fields
-        if (optionalFields.length > 0) {
-          console.log(
-            chalk.gray(
-              `\nThere are ${optionalFields.length} optional field(s) available.`,
-            ),
-          );
+      // Ask about optional fields
+      let shouldConfigureOptional = { configure: false };
+      if (newOptionalFields.length > 0) {
+        console.log(
+          chalk.gray(
+            `\nThere are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`,
+          ),
+        );
 
-          let shouldConfigureOptional;
-          try {
-            shouldConfigureOptional = await inquirer.prompt([
-              {
-                type: "confirm",
-                name: "configure",
-                message: "Would you like to configure optional fields?",
-                default: false,
-              },
-            ]);
-          } catch (error) {
-            if (this.isUserCancellation(error)) {
-              console.log(chalk.yellow("\n\nOperation cancelled by user"));
-              process.exit(0);
-            }
-            throw error;
+        try {
+          shouldConfigureOptional = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "configure",
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              default: false,
+            },
+          ]);
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
           }
+          throw error;
+        }
 
-          if (shouldConfigureOptional.configure) {
-            console.log(chalk.cyan(`\nOptional fields:`));
-            for (const field of optionalFields) {
-              await this.promptForField(field, inputs);
-            }
+        if (shouldConfigureOptional.configure) {
+          console.log(chalk.cyan(`\nOptional fields:`));
+          for (const field of newOptionalFields) {
+            await this.promptForField(field, inputs);
+            processedFieldKeys.add(field.key);
           }
+        } else {
+          // Mark these fields as processed even if skipped to avoid re-asking
+          newOptionalFields.forEach((field: any) =>
+            processedFieldKeys.add(field.key),
+          );
         }
+      }
 
-        return inputs;
-      } catch (error) {
-        console.error(
-          chalk.red(`Failed to fetch fields for ${param.name}:`),
-          error instanceof Error ? error.message : error,
-        );
-        throw error;
+      // If we only processed optional fields and skipped them, no need to re-fetch
+      if (
+        newRequiredFields.length === 0 &&
+        (!newOptionalFields.length || !shouldConfigureOptional.configure)
+      ) {
+        break;
       }
     }
 
-    throw new Error(`Unknown resolver type for ${param.name}`);
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk.yellow(
+          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
+        ),
+      );
+    }
+
+    return inputs;
   }
 
   private getNestedValue(obj: any, path: string[]): any {

package/src/utils/schema-formatter.ts

@@ -96,7 +96,7 @@ function applyStyle(value: string, style: string): string {
 function formatItemsGeneric(items: any[]): void {
   // Fallback formatting for items without schema metadata
   items.forEach((item, index) => {
-    const name = item.name || item.key || item.id || "Item";
+    const name = item.title || item.name || item.key || item.id || "Item";
     console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
     if (item.description) {
       console.log(`   ${chalk.dim(item.description)}`);

package/tsconfig.json

@@ -11,11 +11,9 @@
     "forceConsistentCasingInFileNames": true,
     "declaration": true,
     "outDir": "./dist",
-    "baseUrl": ".",
-    "paths": {
-      "@zapier/zapier-sdk": ["../zapier-sdk/dist/index.mjs"]
-    }
+    "composite": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+  "exclude": ["node_modules", "dist", "**/*.test.ts"],
+  "references": [{ "path": "../zapier-sdk" }]
 }

package/src/commands/whoami.ts

@@ -1,25 +0,0 @@
-import { Command } from "commander";
-import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
-import { spinPromise } from "../utils/spinner";
-
-export function createWhoamiCommand(): Command {
-  return new Command("whoami")
-    .description("Show current login status and user information")
-    .action(async () => {
-      try {
-        const user = await spinPromise(
-          getLoggedInUser(),
-          "Checking login status...",
-        );
-
-        console.log(
-          `✅ Logged in as ${user.email} (Account ID: ${user.accountId})`,
-        );
-      } catch {
-        console.log(
-          "❌ Not logged in. Use 'zapier-sdk login' to authenticate.",
-        );
-        process.exit(1);
-      }
-    });
-}

package/src/utils/pager.ts

@@ -1,202 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-
-export interface PagerOptions {
-  pageSize?: number;
-  showPrompt?: boolean;
-  itemName?: string;
-}
-
-export interface PaginatedResult<T> {
-  items: T[];
-  hasMore: boolean;
-  totalShown: number;
-}
-
-/**
- * Generic pager that handles pagination for any data source
- * Supports interactive "load more" functionality
- */
-export class Pager<T> {
-  private pageSize: number;
-  private showPrompt: boolean;
-  private itemName: string;
-  private allItems: T[] = [];
-  private currentOffset = 0;
-
-  constructor(options: PagerOptions = {}) {
-    this.pageSize = options.pageSize || 20;
-    this.showPrompt = options.showPrompt !== false;
-    this.itemName = options.itemName || "items";
-  }
-
-  /**
-   * Fetch and display paginated results with interactive loading
-   */
-  async paginate<TParams>(
-    fetchFunction: (
-      params: TParams & { limit: number; offset?: number },
-    ) => Promise<T[]>,
-    baseParams: TParams,
-    displayFunction: (
-      items: T[],
-      totalShown: number,
-      totalAvailable?: number,
-    ) => void,
-  ): Promise<PaginatedResult<T>> {
-    let hasMore = true;
-    let totalAvailable: number | undefined;
-
-    while (hasMore) {
-      // Fetch next page
-      const params = {
-        ...baseParams,
-        limit: this.pageSize,
-        offset: this.currentOffset,
-      };
-
-      try {
-        const items = await fetchFunction(params);
-
-        if (items.length === 0) {
-          // Still call display function to show "No items found" message
-          displayFunction(this.allItems, this.allItems.length, totalAvailable);
-          hasMore = false;
-          break;
-        }
-
-        // Check for pagination metadata to get total count
-        const pagination = (items as any).__pagination;
-        if (pagination && pagination.count) {
-          totalAvailable = pagination.count;
-          hasMore = pagination.hasNext;
-        } else {
-          // Fallback: check if we got fewer items than requested
-          hasMore = items.length >= this.pageSize;
-        }
-
-        // Add to our collection
-        this.allItems.push(...items);
-        this.currentOffset += items.length;
-
-        // Display current batch
-        displayFunction(this.allItems, this.allItems.length, totalAvailable);
-
-        // If prompting is disabled, continue automatically
-        if (!this.showPrompt) {
-          continue;
-        }
-
-        // If we have total count info, show more detailed prompt
-        const totalInfo = totalAvailable
-          ? ` of ${totalAvailable.toLocaleString()}`
-          : "";
-        const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
-
-        // Ask user if they want to load more
-        const { loadMore } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "loadMore",
-            message,
-            default: true,
-          },
-        ]);
-
-        if (!loadMore) {
-          hasMore = false;
-        }
-      } catch (error) {
-        // Re-throw the error to be handled by the caller
-        throw error;
-      }
-    }
-
-    return {
-      items: this.allItems,
-      hasMore: this.currentOffset > 0 && hasMore,
-      totalShown: this.allItems.length,
-    };
-  }
-
-  /**
-   * Reset the pager state
-   */
-  reset(): void {
-    this.allItems = [];
-    this.currentOffset = 0;
-  }
-}
-
-/**
- * Convenience function to create a pager for a specific use case
- */
-export function createPager<T>(options: PagerOptions = {}): Pager<T> {
-  return new Pager<T>(options);
-}
-
-/**
- * Simple pagination without interactivity - just fetches all results up to a limit
- */
-export async function fetchAllPages<T, TParams>(
-  fetchFunction: (
-    params: TParams & { limit: number; offset?: number },
-  ) => Promise<T[]>,
-  baseParams: TParams,
-  maxResults: number = 100,
-): Promise<T[]> {
-  const pageSize = Math.min(maxResults, 50); // Reasonable page size
-  const allItems: T[] = [];
-  let offset = 0;
-
-  while (allItems.length < maxResults) {
-    const remainingItems = maxResults - allItems.length;
-    const currentPageSize = Math.min(pageSize, remainingItems);
-
-    const params = {
-      ...baseParams,
-      limit: currentPageSize,
-      offset,
-    };
-
-    const items = await fetchFunction(params);
-
-    if (items.length === 0) {
-      break; // No more data
-    }
-
-    allItems.push(...items);
-    offset += items.length;
-
-    // If we got fewer items than requested, we've reached the end
-    if (items.length < currentPageSize) {
-      break;
-    }
-  }
-
-  return allItems;
-}
-
-/**
- * Display helper for showing pagination status
- */
-export function showPaginationStatus(
-  currentCount: number,
-  requestedLimit: number,
-  itemName: string = "items",
-): void {
-  if (currentCount >= requestedLimit) {
-    console.log(
-      chalk.yellow(
-        `\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`,
-      ),
-    );
-    console.log(
-      chalk.gray(
-        `Use --limit to increase the limit, or add paging with --page`,
-      ),
-    );
-  } else {
-    console.log(chalk.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
-  }
-}