@zapier/zapier-sdk-cli 0.8.4 → 0.10.0

package/src/utils/cli-generator.ts

@@ -2,45 +2,16 @@ import type { Command } from "commander";
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
 import {
-  hasResolver,
   isPositional,
   formatErrorMessage,
   ZapierError,
+  type FunctionRegistryEntry,
 } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { formatItemsFromSchema } from "./schema-formatter";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
-import util from "util";
 import inquirer from "inquirer";
 
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-
-function formatJsonOutput(data: unknown): void {
-  // Don't print anything for undefined results (commands that just perform actions)
-  if (data === undefined) {
-    return;
-  }
-
-  // Show success message for action results
-  if (
-    data &&
-    typeof data === "object" &&
-    !Array.isArray(data) &&
-    ((data as Record<string, unknown>).success !== undefined ||
-      (data as Record<string, unknown>).id ||
-      (data as Record<string, unknown>).status)
-  ) {
-    console.log(chalk.green("✅ Action completed successfully!\n"));
-  }
-
-  // Use util.inspect for colored output
-  console.log(
-    util.inspect(data, { colors: true, depth: null, breakLength: 80 }),
-  );
-}
-
 // ============================================================================
 // Types
 // ============================================================================
@@ -66,7 +37,10 @@ interface CliParameter {
 // Schema Analysis
 // ============================================================================
 
-function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
+function analyzeZodSchema(
+  schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
+): CliParameter[] {
   const parameters: CliParameter[] = [];
 
   // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
@@ -78,14 +52,18 @@ function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
     // Get the underlying schema
     const innerSchema = (schema as unknown as { _def: { schema: z.ZodSchema } })
       ._def.schema;
-    return analyzeZodSchema(innerSchema);
+    return analyzeZodSchema(innerSchema, functionInfo);
   }
 
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
 
     for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(key, fieldSchema as z.ZodSchema);
+      const param = analyzeZodField(
+        key,
+        fieldSchema as z.ZodSchema,
+        functionInfo,
+      );
       if (param) {
         parameters.push(param);
       }
@@ -98,6 +76,7 @@ function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
 function analyzeZodField(
   name: string,
   schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
@@ -150,6 +129,14 @@ function analyzeZodField(
     paramType = "string";
   }
 
+  // Check if this parameter has a resolver
+  let paramHasResolver = false;
+
+  // Check function-specific resolvers first
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
+
   // Extract resolver metadata
   return {
     name,
@@ -158,7 +145,7 @@ function analyzeZodField(
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema),
   };
 }
@@ -206,12 +193,7 @@ export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
     // Convert methodName to kebab-case CLI command
     const cliCommandName = methodNameToCliCommand(fnInfo.name);
 
-    const config = createCommandConfig(
-      cliCommandName,
-      fnInfo.name,
-      fnInfo.inputSchema as z.ZodSchema,
-      sdk,
-    );
+    const config = createCommandConfig(cliCommandName, fnInfo, sdk);
 
     addCommand(program, cliCommandName, config);
   });
@@ -288,11 +270,11 @@ export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
 
 function createCommandConfig(
   cliCommandName: string,
-  sdkMethodName: string,
-  schema: z.ZodSchema,
+  functionInfo: FunctionRegistryEntry,
   sdk: ZapierSdk,
 ): CliCommandConfig {
-  const parameters = analyzeZodSchema(schema);
+  const schema = functionInfo.inputSchema as z.ZodSchema;
+  const parameters = analyzeZodSchema(schema, functionInfo);
   const description = schema.description || `${cliCommandName} command`;
 
   const handler = async (...args: unknown[]) => {
@@ -304,7 +286,7 @@ function createCommandConfig(
       const options = commandObj.opts();
 
       // Check if this is a list command for pagination
-      const isListCommand = cliCommandName.startsWith("list-");
+      const isListCommand = functionInfo.type === "list";
       const hasPaginationParams = parameters.some(
         (p) => p.name === "maxItems" || p.name === "pageSize",
       );
@@ -325,6 +307,7 @@ function createCommandConfig(
         schema,
         rawParams,
         sdk,
+        functionInfo.name,
       );
 
       // Handle paginated list commands with async iteration
@@ -339,11 +322,11 @@ function createCommandConfig(
           string,
           (params: unknown) => Promise<unknown> & AsyncIterable<unknown>
         >;
-        const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
+        const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
-          sdkMethodName,
+          functionInfo.name,
           sdkIterator,
-          schema,
+          functionInfo,
         );
       } else {
         // Special handling for commands that write to files
@@ -354,7 +337,7 @@ function createCommandConfig(
             string,
             (params: unknown) => Promise<unknown>
           >;
-          await sdkObj[sdkMethodName](resolvedParams);
+          await sdkObj[functionInfo.name](resolvedParams);
           console.log(
             chalk.green(`✅ ${cliCommandName} completed successfully!`),
           );
@@ -367,7 +350,7 @@ function createCommandConfig(
           string,
           (params: unknown) => Promise<unknown>
         >;
-        const result: unknown = await sdkObj[sdkMethodName](resolvedParams);
+        const result: unknown = await sdkObj[functionInfo.name](resolvedParams);
         const items = (result as { data?: unknown })?.data
           ? (result as { data: unknown }).data
           : result;
@@ -380,8 +363,7 @@ function createCommandConfig(
             (resolvedParams as { maxItems?: number }).maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson as boolean,
-            schema,
-            sdkMethodName,
+            functionInfo,
           );
         } else {
           formatJsonOutput(items);
@@ -436,6 +418,9 @@ function addCommand(
 ): void {
   const command = program.command(commandName).description(config.description);
 
+  // Track whether we've already used a positional array parameter
+  let hasPositionalArray = false;
+
   // Add parameters to command
   config.parameters.forEach((param) => {
     // Convert camelCase to kebab-case for CLI display
@@ -447,6 +432,25 @@ function addCommand(
         `[${kebabName}]`,
         param.description || `${kebabName} parameter`,
       );
+    } else if (
+      param.required &&
+      param.type === "array" &&
+      !hasPositionalArray
+    ) {
+      // First required array parameter becomes a variadic positional argument
+      hasPositionalArray = true;
+      command.argument(
+        `<${kebabName}...>`,
+        param.description || `${kebabName} parameter`,
+      );
+    } else if (param.required && param.type === "array") {
+      // Subsequent required array parameters become required flags
+      const flags = [`--${kebabName}`];
+      const flagSignature = flags.join(", ") + ` <values...>`;
+      command.requiredOption(
+        flagSignature,
+        param.description || `${kebabName} parameter (required)`,
+      );
     } else if (param.required) {
       // Required parameters without resolvers become required positional arguments
       command.argument(
@@ -532,6 +536,11 @@ function convertCliArgsToSdkParams(
 }
 
 function convertValue(value: unknown, type: CliParameter["type"]): unknown {
+  // Don't convert undefined values - let the resolver system handle them
+  if (value === undefined) {
+    return undefined;
+  }
+
   switch (type) {
     case "number":
       return Number(value);
@@ -563,13 +572,15 @@ function convertValue(value: unknown, type: CliParameter["type"]): unknown {
 async function handlePaginatedListWithAsyncIteration(
   sdkMethodName: string,
   sdkResult: unknown,
-  schema: z.ZodSchema,
+  functionInfo: FunctionRegistryEntry,
 ): Promise<void> {
-  const itemName = getItemNameFromMethod(sdkMethodName);
+  const itemName = getItemNameFromMethod(functionInfo);
   let totalShown = 0;
   let pageCount = 0;
 
-  console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+  console.log(
+    chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`),
+  );
 
   try {
     // Use async iteration to go through pages
@@ -598,13 +609,15 @@ async function handlePaginatedListWithAsyncIteration(
       if (pageCount > 1) {
         console.clear();
         console.log(
-          chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`),
+          chalk.blue(
+            `📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`,
+          ),
         );
       }
 
-      // Format and display items using schema
-      if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items, totalShown);
+      // Format and display items using function info
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, totalShown);
       } else {
         formatItemsGeneric(items, totalShown);
       }
@@ -646,8 +659,8 @@ async function handlePaginatedListWithAsyncIteration(
         return;
       }
 
-      if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items, 0);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, 0);
       } else {
         formatItemsGeneric(items, 0);
       }
@@ -664,8 +677,7 @@ function formatNonPaginatedResults(
   requestedMaxItems?: number,
   userSpecifiedMaxItems?: boolean,
   useRawJson?: boolean,
-  schema?: z.ZodSchema,
-  methodName?: string,
+  functionInfo?: FunctionRegistryEntry,
 ): void {
   if (!Array.isArray(result)) {
     if (useRawJson) {
@@ -681,7 +693,7 @@ function formatNonPaginatedResults(
     return;
   }
 
-  const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+  const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
 
   if (result.length === 0) {
     console.log(chalk.yellow(`No ${itemName} found.`));
@@ -690,9 +702,9 @@ function formatNonPaginatedResults(
 
   console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
 
-  // Use schema for formatting
-  if (schema) {
-    formatItemsFromSchema(schema as z.ZodType, result);
+  // Use function info for formatting
+  if (functionInfo) {
+    formatItemsFromSchema(functionInfo, result);
   } else {
     // Fallback to generic formatting
     formatItemsGeneric(result);
@@ -729,22 +741,21 @@ function formatItemsGeneric(
 }
 
 // Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(methodName: string): string {
-  // Extract from method name: listApps -> apps, listActions -> actions
-  const listMatch = methodName.match(/^list(.+)$/);
-  if (listMatch) {
-    return listMatch[1].toLowerCase();
+function getItemNameFromMethod(functionInfo: FunctionRegistryEntry): string {
+  if (functionInfo.itemType) {
+    return `${functionInfo.itemType} items`;
   }
 
-  // Fallback to generic
   return "items";
 }
 
-function getListTitleFromMethod(methodName: string): string {
-  const itemName = getItemNameFromMethod(methodName);
-  if (itemName === "items") return "Available Items";
+function getListTitleFromMethod(
+  methodName: string,
+  functionInfo: FunctionRegistryEntry,
+): string {
+  if (functionInfo.itemType) {
+    return `Available ${functionInfo.itemType} items`;
+  }
 
-  // Capitalize first letter: apps -> Apps
-  const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-  return `Available ${capitalized}`;
+  return `${methodName} items`;
 }

package/src/utils/parameter-resolver.ts

@@ -2,11 +2,6 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
-import {
-  getResolver,
-  hasResolver,
-  getResolutionOrderForParams,
-} from "@zapier/zapier-sdk";
 
 // ============================================================================
 // Types
@@ -24,6 +19,66 @@ interface ResolverContext {
   sdk: ZapierSdk;
   currentParams: Record<string, unknown>;
   resolvedParams: Record<string, unknown>;
+  functionName?: string;
+}
+
+// ============================================================================
+// Local Resolution Helper Functions
+// ============================================================================
+
+/**
+ * Resolve dependency chain for a parameter using local resolvers
+ * Returns parameters in the order they need to be resolved
+ */
+function getLocalResolutionOrder(
+  paramName: string,
+  resolvers: Record<string, any>,
+  resolved: Set<string> = new Set(),
+): string[] {
+  const resolver = resolvers[paramName];
+  if (!resolver || resolver.type === "static") {
+    return [paramName];
+  }
+
+  const order: string[] = [];
+
+  if ("depends" in resolver && resolver.depends) {
+    for (const dependency of resolver.depends) {
+      if (!resolved.has(dependency)) {
+        order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
+        resolved.add(dependency);
+      }
+    }
+  }
+
+  if (!resolved.has(paramName)) {
+    order.push(paramName);
+    resolved.add(paramName);
+  }
+
+  return order;
+}
+
+/**
+ * Get resolution order for multiple parameters using local resolvers
+ */
+function getLocalResolutionOrderForParams(
+  paramNames: string[],
+  resolvers: Record<string, any>,
+): string[] {
+  const resolved = new Set<string>();
+  const order: string[] = [];
+
+  for (const paramName of paramNames) {
+    const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
+    for (const param of paramOrder) {
+      if (!order.includes(param)) {
+        order.push(param);
+      }
+    }
+  }
+
+  return order;
 }
 
 // ============================================================================
@@ -35,6 +90,7 @@ export class SchemaParameterResolver {
     schema: z.ZodSchema,
     providedParams: unknown,
     sdk: ZapierSdk,
+    functionName?: string,
   ): Promise<unknown> {
     // 1. Try to parse with current parameters
     const parseResult = schema.safeParse(providedParams);
@@ -42,7 +98,7 @@ export class SchemaParameterResolver {
     // Get all schema parameters to check which ones have resolvers
     const allParams = this.extractParametersFromSchema(schema);
     const resolvableParams = allParams.filter((param) =>
-      hasResolver(param.name),
+      this.hasResolver(param.name, sdk, functionName),
     );
 
     // Get all missing parameters that have resolvers
@@ -108,12 +164,18 @@ export class SchemaParameterResolver {
       sdk,
       currentParams: providedParams as Record<string, unknown>,
       resolvedParams,
+      functionName,
     };
 
+    // Get local resolvers for this function
+    const localResolvers = this.getLocalResolvers(sdk, functionName);
+
     if (functionallyRequired.length > 0) {
       const requiredParamNames = functionallyRequired.map((p) => p.name);
-      const requiredResolutionOrder =
-        getResolutionOrderForParams(requiredParamNames);
+      const requiredResolutionOrder = getLocalResolutionOrderForParams(
+        requiredParamNames,
+        localResolvers,
+      );
 
       // Find all parameters that need to be resolved (including dependencies)
       // from the available resolvable parameters
@@ -135,7 +197,11 @@ export class SchemaParameterResolver {
 
       for (const param of orderedRequiredParams) {
         try {
-          const value = await this.resolveParameter(param, context);
+          const value = await this.resolveParameter(
+            param,
+            context,
+            functionName,
+          );
           this.setNestedValue(resolvedParams, param.path, value);
 
           // Update context with newly resolved value
@@ -168,8 +234,10 @@ export class SchemaParameterResolver {
     // 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 alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(
+        alwaysPromptNames,
+        localResolvers,
+      );
 
       const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
         .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
@@ -177,7 +245,11 @@ export class SchemaParameterResolver {
 
       for (const param of orderedAlwaysPromptParams) {
         try {
-          const value = await this.resolveParameter(param, context);
+          const value = await this.resolveParameter(
+            param,
+            context,
+            functionName,
+          );
           this.setNestedValue(resolvedParams, param.path, value);
 
           // Update context with newly resolved value
@@ -207,8 +279,10 @@ export class SchemaParameterResolver {
       if (shouldResolveOptional.resolveOptional) {
         // Resolve optional parameters using their resolvers
         const optionalParamNames = trulyOptional.map((p) => p.name);
-        const optionalResolutionOrder =
-          getResolutionOrderForParams(optionalParamNames);
+        const optionalResolutionOrder = getLocalResolutionOrderForParams(
+          optionalParamNames,
+          localResolvers,
+        );
 
         const orderedOptionalParams = optionalResolutionOrder
           .map((paramName) => trulyOptional.find((p) => p.name === paramName))
@@ -216,7 +290,11 @@ export class SchemaParameterResolver {
 
         for (const param of orderedOptionalParams) {
           try {
-            const value = await this.resolveParameter(param, context);
+            const value = await this.resolveParameter(
+              param,
+              context,
+              functionName,
+            );
             this.setNestedValue(resolvedParams, param.path, value);
 
             // Update context with newly resolved value
@@ -306,8 +384,9 @@ export class SchemaParameterResolver {
   private async resolveParameter(
     param: ResolvableParameter,
     context: ResolverContext,
+    functionName?: string,
   ): Promise<unknown> {
-    const resolver = getResolver(param.name);
+    const resolver = this.getResolver(param.name, context.sdk, functionName);
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
     }
@@ -430,10 +509,10 @@ export class SchemaParameterResolver {
 
       // Separate new required and optional fields
       const newRequiredFields = newFields.filter(
-        (field: unknown) => (field as { required: boolean }).required,
+        (field: unknown) => (field as { is_required: boolean }).is_required,
       );
       const newOptionalFields = newFields.filter(
-        (field: unknown) => !(field as { required: boolean }).required,
+        (field: unknown) => !(field as { is_required: boolean }).is_required,
       );
 
       // Prompt for new required fields
@@ -536,7 +615,7 @@ export class SchemaParameterResolver {
       type?: string;
       key: string;
       label?: string;
-      required?: boolean;
+      is_required?: boolean;
       helpText?: string;
       default?: unknown;
       choices?: Array<{ label?: string; value: unknown }>;
@@ -545,7 +624,7 @@ export class SchemaParameterResolver {
     const fieldPrompt: Record<string, unknown> = {
       type: fieldObj.type === "boolean" ? "confirm" : "input",
       name: fieldObj.key,
-      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`,
     };
 
     if (fieldObj.helpText) {
@@ -574,7 +653,7 @@ export class SchemaParameterResolver {
 
       if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
         inputs[fieldObj.key] = answer[fieldObj.key];
-      } else if (fieldObj.required) {
+      } else if (fieldObj.is_required) {
         throw new Error(`Required field ${fieldObj.key} cannot be empty`);
       }
     } catch (error) {
@@ -598,4 +677,59 @@ export class SchemaParameterResolver {
       errorObj?.isTTYError === true
     );
   }
+
+  private hasResolver(
+    paramName: string,
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): boolean {
+    // Check plugin-specific resolvers first
+    if (functionName && typeof sdk.getRegistry === "function") {
+      const registry = sdk.getRegistry();
+      const functionInfo = registry.functions.find(
+        (f) => f.name === functionName,
+      );
+      if (functionInfo && functionInfo.resolvers?.[paramName]) {
+        return true;
+      }
+    }
+
+    // No global registry fallback
+    return false;
+  }
+
+  private getResolver(
+    paramName: string,
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): any {
+    // Check plugin-specific resolvers first
+    if (functionName && typeof sdk.getRegistry === "function") {
+      const registry = sdk.getRegistry();
+      const functionInfo = registry.functions.find(
+        (f) => f.name === functionName,
+      );
+      if (functionInfo && functionInfo.resolvers?.[paramName]) {
+        return functionInfo.resolvers[paramName];
+      }
+    }
+
+    // No global registry fallback
+    return null;
+  }
+
+  private getLocalResolvers(
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): Record<string, any> {
+    if (!functionName || typeof sdk.getRegistry !== "function") {
+      return {};
+    }
+
+    const registry = sdk.getRegistry();
+    const functionInfo = registry.functions.find(
+      (f) => f.name === functionName,
+    );
+    return functionInfo?.resolvers || {};
+  }
 }