@zapier/zapier-sdk-cli 0.4.0 → 0.4.2

package/src/utils/cli-generator.ts

@@ -1,11 +1,17 @@
 import { Command } from "commander";
 import { z } from "zod";
-import { ZapierSdk, hasResolver, isPositional } from "@zapier/zapier-sdk";
+import {
+  ZapierSdk,
+  hasResolver,
+  isPositional,
+  formatErrorMessage,
+  ZapierError,
+} from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { createPager } from "./pager";
 import { formatItemsFromSchema } from "./schema-formatter";
 import chalk from "chalk";
 import util from "util";
+import inquirer from "inquirer";
 
 // ============================================================================
 // JSON Formatting
@@ -193,12 +199,10 @@ function createCommandConfig(
       // Check if this is a list command for pagination
       const isListCommand = cliCommandName.startsWith("list-");
       const hasPaginationParams = parameters.some(
-        (p) => p.name === "limit" || p.name === "offset",
+        (p) => p.name === "maxItems" || p.name === "pageSize",
       );
-      const hasUserSpecifiedLimit =
-        "limit" in options && options.limit !== undefined;
-      const shouldUsePaging =
-        isListCommand && hasPaginationParams && !hasUserSpecifiedLimit;
+      const hasUserSpecifiedMaxItems =
+        "maxItems" in options && options.maxItems !== undefined;
       const shouldUseJson = options.json;
 
       // Convert CLI args to SDK method parameters
@@ -216,42 +220,50 @@ function createCommandConfig(
         sdk,
       );
 
-      if (shouldUsePaging && !shouldUseJson) {
-        // Use interactive paging for list commands
-        await handlePaginatedList(sdkMethodName, resolvedParams, sdk, schema);
+      // Special handling for commands that write to files
+      const hasOutputFile = resolvedParams.output;
+      if (hasOutputFile) {
+        // Call the SDK method for file output commands
+        await (sdk as any)[sdkMethodName](resolvedParams);
+        console.log(
+          chalk.green(`✅ ${cliCommandName} completed successfully!`),
+        );
+        console.log(chalk.gray(`Output written to: ${resolvedParams.output}`));
+        return;
+      }
+
+      // Handle paginated list commands with async iteration
+      if (
+        isListCommand &&
+        hasPaginationParams &&
+        !shouldUseJson &&
+        !hasUserSpecifiedMaxItems
+      ) {
+        // Get the async iterator directly from the SDK method call
+        const sdkIterator = (sdk as any)[sdkMethodName](resolvedParams);
+        await handlePaginatedListWithAsyncIteration(
+          sdkMethodName,
+          sdkIterator,
+          schema,
+        );
       } else {
-        // Call the SDK method directly
-        const result: any = await (sdk as any)[sdkMethodName](resolvedParams);
-
-        // Special handling for commands that write to files
-        const hasOutputFile = resolvedParams.output;
-
-        // Output result (JSON or formatted)
-        if (!hasOutputFile && (shouldUseJson || !isListCommand)) {
-          // Use raw JSON if --json flag is specified, otherwise use pretty formatting
-          if (shouldUseJson) {
-            console.log(JSON.stringify(result, null, 2));
-          } else {
-            formatJsonOutput(result);
-          }
-        } else if (!hasOutputFile) {
-          // Format list results nicely (non-paginated)
+        // Call the SDK method and handle non-paginated results
+        const result = await (sdk as any)[sdkMethodName](resolvedParams);
+        const items = result?.data ? result.data : result;
+
+        if (shouldUseJson) {
+          console.log(JSON.stringify(items, null, 2));
+        } else if (isListCommand) {
           formatNonPaginatedResults(
-            result,
-            resolvedParams.limit,
-            hasUserSpecifiedLimit,
+            items,
+            resolvedParams.maxItems,
+            hasUserSpecifiedMaxItems,
             shouldUseJson,
             schema,
             sdkMethodName,
           );
-        } else if (hasOutputFile) {
-          // Show success message for file output instead of printing generated content
-          console.log(
-            chalk.green(`✅ ${cliCommandName} completed successfully!`),
-          );
-          console.log(
-            chalk.gray(`Output written to: ${resolvedParams.output}`),
-          );
+        } else {
+          formatJsonOutput(items);
         }
       }
     } catch (error) {
@@ -270,11 +282,15 @@ function createCommandConfig(
         } catch {
           console.error(chalk.red("Error:"), error.message);
         }
+      } else if (error instanceof ZapierError) {
+        // Handle SDK errors with clean, user-friendly messages using our formatter
+        const formattedMessage = formatErrorMessage(error);
+        console.error(chalk.red("❌ Error:"), formattedMessage);
       } else {
-        console.error(
-          chalk.red("Error:"),
-          error instanceof Error ? error.message : "Unknown error",
-        );
+        // Handle other errors
+        const errorMessage =
+          error instanceof Error ? error.message : "Unknown error";
+        console.error(chalk.red("❌ Error:"), errorMessage);
       }
       process.exit(1);
     }
@@ -323,6 +339,10 @@ function addCommand(
 
       if (param.type === "boolean") {
         command.option(flags.join(", "), param.description);
+      } else if (param.type === "array") {
+        // For arrays, use variadic syntax to collect multiple values
+        const flagSignature = flags.join(", ") + ` <values...>`;
+        command.option(flagSignature, param.description, param.default);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
         command.option(flagSignature, param.description, param.default);
@@ -406,69 +426,106 @@ function convertValue(value: any, type: CliParameter["type"]): any {
 // Pagination Handlers
 // ============================================================================
 
-async function handlePaginatedList(
+async function handlePaginatedListWithAsyncIteration(
   sdkMethodName: string,
-  baseParams: any,
-  sdk: ZapierSdk,
+  sdkResult: any,
   schema: z.ZodSchema,
 ): Promise<void> {
-  const limit = baseParams.limit || 20;
   const itemName = getItemNameFromMethod(sdkMethodName);
+  let totalShown = 0;
+  let pageCount = 0;
 
-  console.log(chalk.blue(`📋 Fetching ${itemName}...`));
+  console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
 
-  const pager = createPager({
-    pageSize: Math.min(limit, 20),
-    itemName,
-  });
+  try {
+    // Use async iteration to go through pages
+    for await (const page of sdkResult) {
+      const items = page.data || page;
+      pageCount++;
 
-  const displayFunction = (
-    items: any[],
-    totalShown: number,
-    totalAvailable?: number,
-  ) => {
-    // Only clear screen if we have items to show
-    if (items.length > 0) {
-      console.clear();
-    }
-    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+      if (!Array.isArray(items)) {
+        console.log(chalk.yellow(`No ${itemName} found.`));
+        return;
+      }
 
-    if (items.length === 0) {
-      console.log(chalk.yellow(`No ${itemName} found.`));
-      return;
-    }
+      if (items.length === 0 && pageCount === 1) {
+        console.log(chalk.yellow(`No ${itemName} found.`));
+        return;
+      }
 
-    // Use schema for formatting
-    if (schema) {
-      formatItemsFromSchema(schema as z.ZodType, items);
-    } else {
-      // Fallback to generic formatting
-      formatItemsGeneric(items);
+      if (items.length === 0) {
+        break; // No more items
+      }
+
+      // Clear screen for subsequent pages (not the first)
+      if (pageCount > 1) {
+        console.clear();
+        console.log(
+          chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`),
+        );
+      }
+
+      // Format and display items using schema
+      if (schema) {
+        formatItemsFromSchema(schema as z.ZodType, items);
+      } else {
+        formatItemsGeneric(items);
+      }
+
+      totalShown += items.length;
+      console.log(
+        chalk.green(
+          `\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`,
+        ),
+      );
+
+      // Only prompt if there's a nextCursor (more pages available)
+      if (page.nextCursor) {
+        const { continueReading } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "continueReading",
+            message: `Load next page?`,
+            default: true,
+          },
+        ]);
+
+        if (!continueReading) {
+          break;
+        }
+      } else {
+        // No more pages available, exit gracefully
+        break;
+      }
     }
 
-    const totalInfo = totalAvailable
-      ? ` of ${totalAvailable.toLocaleString()} total`
-      : "";
-    console.log(
-      chalk.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`),
-    );
-  };
+    console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
+  } catch (error) {
+    // If the result is not async iterable, fall back to showing the first page
+    const items = sdkResult?.data || sdkResult;
+    if (Array.isArray(items)) {
+      if (items.length === 0) {
+        console.log(chalk.yellow(`No ${itemName} found.`));
+        return;
+      }
 
-  await pager.paginate(
-    (params) =>
-      (sdk as any)[sdkMethodName]({
-        ...baseParams,
-        ...params,
-      }),
-    {},
-    displayFunction,
-  );
+      if (schema) {
+        formatItemsFromSchema(schema as z.ZodType, items);
+      } else {
+        formatItemsGeneric(items);
+      }
+
+      console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
+    } else {
+      throw error;
+    }
+  }
 }
 
 function formatNonPaginatedResults(
   result: any[],
-  requestedLimit?: number,
-  userSpecifiedLimit?: boolean,
+  requestedMaxItems?: number,
+  userSpecifiedMaxItems?: boolean,
   useRawJson?: boolean,
   schema?: z.ZodSchema,
   methodName?: string,
@@ -505,10 +562,10 @@ function formatNonPaginatedResults(
   }
 
   // Show appropriate status message
-  if (userSpecifiedLimit && requestedLimit) {
+  if (userSpecifiedMaxItems && requestedMaxItems) {
     console.log(
       chalk.gray(
-        `\n📄 Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`,
+        `\n📄 Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`,
       ),
     );
   } else {
@@ -519,7 +576,7 @@ function formatNonPaginatedResults(
 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)}`);