@zapier/zapier-sdk-cli 0.6.4 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.6.4",
+  "version": "0.8.0",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -42,9 +42,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.6.4",
+    "@zapier/zapier-sdk": "0.8.0",
     "@zapier/zapier-sdk-cli-login": "0.3.2",
-    "@zapier/zapier-sdk-mcp": "0.2.4"
+    "@zapier/zapier-sdk-mcp": "0.3.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/utils/cli-generator.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import chalk from "chalk";
+
+// We need to create a test for the formatItemsGeneric function that's defined in cli-generator.ts
+// Since it's not exported, we'll create a simple test that verifies the numbering logic
+
+interface TestItem {
+  name?: string;
+  key?: string;
+  id?: string;
+}
+
+describe("CLI Generator Pagination Numbering", () => {
+  let mockConsoleLog: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    mockConsoleLog.mockRestore();
+  });
+
+  // Since formatItemsGeneric is not exported, let's create a regression test
+  // that tests the key functionality we care about: continuous numbering
+  it("should prevent pagination numbering regression by testing chalk formatting", () => {
+    // Simulate what formatItemsGeneric does for pagination numbering
+    const simulateFormatting = (items: TestItem[], startingNumber: number) => {
+      const calls: string[] = [];
+      items.forEach((item, index) => {
+        const name = item.name || item.key || item.id || "Item";
+        const formatted = `${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`;
+        calls.push(formatted);
+      });
+      return calls;
+    };
+
+    // Test first page (items 1-3)
+    const page1Items = [
+      { name: "App 1", key: "app1" },
+      { name: "App 2", key: "app2" },
+      { name: "App 3", key: "app3" },
+    ];
+
+    const page2Items = [
+      { name: "App 4", key: "app4" },
+      { name: "App 5", key: "app5" },
+    ];
+
+    // Format first page starting from 0
+    const page1Output = simulateFormatting(page1Items, 0);
+
+    // Format second page starting from 3 (3 items shown already)
+    const page2Output = simulateFormatting(page2Items, 3);
+
+    // Check that page 1 contains 1., 2., 3.
+    expect(page1Output.some((line) => line.includes("1."))).toBe(true);
+    expect(page1Output.some((line) => line.includes("2."))).toBe(true);
+    expect(page1Output.some((line) => line.includes("3."))).toBe(true);
+
+    // Check that page 2 contains 4., 5. (continuing from page 1)
+    expect(page2Output.some((line) => line.includes("4."))).toBe(true);
+    expect(page2Output.some((line) => line.includes("5."))).toBe(true);
+
+    // Most importantly: page 2 should NOT restart at 1.
+    expect(page2Output.some((line) => line.includes("1."))).toBe(false);
+    expect(page2Output.some((line) => line.includes("2."))).toBe(false);
+    expect(page2Output.some((line) => line.includes("3."))).toBe(false);
+  });
+
+  it("should handle edge case of starting number 0", () => {
+    const simulateFormatting = (
+      items: TestItem[],
+      startingNumber: number = 0,
+    ) => {
+      const calls: string[] = [];
+      items.forEach((item, index) => {
+        const name = item.name || item.key || item.id || "Item";
+        const formatted = `${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`;
+        calls.push(formatted);
+      });
+      return calls;
+    };
+
+    const items = [{ name: "First Item" }, { name: "Second Item" }];
+
+    // Default startingNumber should be 0, resulting in 1. and 2.
+    const output = simulateFormatting(items, 0);
+
+    expect(output.some((line) => line.includes("1."))).toBe(true);
+    expect(output.some((line) => line.includes("2."))).toBe(true);
+  });
+});

package/src/utils/cli-generator.ts

@@ -69,6 +69,18 @@ interface CliParameter {
 function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
   const parameters: CliParameter[] = [];
 
+  // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
+  if (
+    (schema as unknown as { _def?: { typeName?: string } })._def &&
+    (schema as unknown as { _def: { typeName: string } })._def.typeName ===
+      "ZodEffects"
+  ) {
+    // Get the underlying schema
+    const innerSchema = (schema as unknown as { _def: { schema: z.ZodSchema } })
+      ._def.schema;
+    return analyzeZodSchema(innerSchema);
+  }
+
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
 
@@ -91,16 +103,31 @@ function analyzeZodField(
   let required = true;
   let defaultValue: unknown = undefined;
 
-  // Unwrap optional and default wrappers
-  if (baseSchema instanceof z.ZodOptional) {
-    required = false;
-    baseSchema = baseSchema._def.innerType;
-  }
-
-  if (baseSchema instanceof z.ZodDefault) {
-    required = false;
-    defaultValue = baseSchema._def.defaultValue();
-    baseSchema = baseSchema._def.innerType;
+  // Unwrap optional, default, and nullable wrappers - keep unwrapping until we get to the base type
+  while (true) {
+    if (baseSchema instanceof z.ZodOptional) {
+      required = false;
+      baseSchema = baseSchema._def.innerType;
+    } else if (baseSchema instanceof z.ZodDefault) {
+      required = false;
+      defaultValue = baseSchema._def.defaultValue();
+      baseSchema = baseSchema._def.innerType;
+    } else if (
+      (
+        baseSchema as unknown as {
+          _def?: { typeName?: string; innerType?: z.ZodSchema };
+        }
+      )._def &&
+      (baseSchema as unknown as { _def: { typeName: string } })._def
+        .typeName === "ZodNullable"
+    ) {
+      // nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
+      baseSchema = (
+        baseSchema as unknown as { _def: { innerType: z.ZodSchema } }
+      )._def.innerType;
+    } else {
+      break; // No more wrappers to unwrap
+    }
   }
 
   // Determine parameter type
@@ -307,12 +334,12 @@ function createCommandConfig(
         !shouldUseJson &&
         !hasUserSpecifiedMaxItems
       ) {
-        // Get the async iterator directly from the SDK method call
+        // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
         const sdkObj = sdk as unknown as Record<
           string,
-          (params: unknown) => Promise<unknown>
+          (params: unknown) => Promise<unknown> & AsyncIterable<unknown>
         >;
-        const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
+        const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
           sdkMethodName,
           sdkIterator,
@@ -577,9 +604,9 @@ async function handlePaginatedListWithAsyncIteration(
 
       // Format and display items using schema
       if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items);
+        formatItemsFromSchema(schema as z.ZodType, items, totalShown);
       } else {
-        formatItemsGeneric(items);
+        formatItemsGeneric(items, totalShown);
       }
 
       totalShown += items.length;
@@ -620,9 +647,9 @@ async function handlePaginatedListWithAsyncIteration(
       }
 
       if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items);
+        formatItemsFromSchema(schema as z.ZodType, items, 0);
       } else {
-        formatItemsGeneric(items);
+        formatItemsGeneric(items, 0);
       }
 
       console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
@@ -683,12 +710,17 @@ function formatNonPaginatedResults(
   }
 }
 
-function formatItemsGeneric(items: unknown[]): void {
+function formatItemsGeneric(
+  items: unknown[],
+  startingNumber: number = 0,
+): void {
   // Fallback formatting for items without schema metadata
   items.forEach((item, index) => {
     const itemObj = item as Record<string, unknown>;
     const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
-    console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(String(name))}`);
+    console.log(
+      `${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`,
+    );
     if (itemObj?.description) {
       console.log(`   ${chalk.dim(String(itemObj.description))}`);
     }

package/src/utils/schema-formatter.ts

@@ -32,38 +32,39 @@ function getOutputSchema(schema: unknown): unknown {
 export function formatItemsFromSchema(
   inputSchema: z.ZodType,
   items: unknown[],
+  startingNumber: number = 0,
 ): void {
   // Get the output schema and its format metadata
   const outputSchema = getOutputSchema(inputSchema);
   if (!outputSchema) {
     // Fallback to generic formatting if no output schema
-    formatItemsGeneric(items);
+    formatItemsGeneric(items, startingNumber);
     return;
   }
 
   const formatMeta = getFormatMetadata(outputSchema);
   if (!formatMeta) {
     // Fallback to generic formatting if no format metadata
-    formatItemsGeneric(items);
+    formatItemsGeneric(items, startingNumber);
     return;
   }
 
   // Format each item using the schema metadata
   items.forEach((item, index) => {
-    formatSingleItem(item, index, formatMeta);
+    formatSingleItem(item, startingNumber + index, formatMeta);
   });
 }
 
 function formatSingleItem(
   item: unknown,
-  index: number,
+  itemNumber: number,
   formatMeta: FormatMetadata,
 ): void {
   // Get the formatted item from the format function
   const formatted = formatMeta.format(item);
 
   // Build the main title line
-  let titleLine = `${chalk.gray(`${index + 1}.`)} ${chalk.cyan(formatted.title)}`;
+  let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
   if (formatted.subtitle) {
     titleLine += ` ${chalk.gray(formatted.subtitle)}`;
   }
@@ -94,7 +95,10 @@ function applyStyle(value: string, style: string): string {
   }
 }
 
-function formatItemsGeneric(items: unknown[]): void {
+function formatItemsGeneric(
+  items: unknown[],
+  startingNumber: number = 0,
+): void {
   // Fallback formatting for items without schema metadata
   items.forEach((item, index) => {
     const itemObj = item as {
@@ -106,7 +110,9 @@ function formatItemsGeneric(items: unknown[]): void {
     };
     const name =
       itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
-    console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
+    console.log(
+      `${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(name)}`,
+    );
     if (itemObj.description) {
       console.log(`   ${chalk.dim(itemObj.description)}`);
     }