@zapier/zapier-sdk-cli 0.9.0 → 0.11.0

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}`);
     }
@@ -380,7 +459,7 @@ export class SchemaParameterResolver {
     const inputs: Record<string, unknown> = {};
     let processedFieldKeys = new Set<string>();
     let iteration = 0;
-    const maxIterations = 5; // Prevent infinite loops
+    const maxIterations = 10; // Prevent infinite loops
 
     while (iteration < maxIterations) {
       iteration++;
@@ -400,12 +479,12 @@ export class SchemaParameterResolver {
         ),
       );
 
-      const fields = await typedResolver.fetch(
+      const rootFieldItems = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams,
       );
 
-      if (!fields || fields.length === 0) {
+      if (!rootFieldItems || rootFieldItems.length === 0) {
         if (iteration === 1) {
           console.log(
             chalk.yellow(`No input fields required for this action.`),
@@ -414,59 +493,180 @@ export class SchemaParameterResolver {
         break;
       }
 
-      // Find new fields that we haven't processed yet
-      const newFields = fields.filter(
-        (field: unknown) =>
-          !(
-            (field as { key: string }).key &&
-            processedFieldKeys.has((field as { key: string }).key)
-          ),
+      // Process fields recursively, maintaining fieldset structure
+      const fieldStats = await this.processFieldItems(
+        rootFieldItems,
+        inputs,
+        processedFieldKeys,
+        [],
+        iteration,
       );
 
-      if (newFields.length === 0) {
-        // No new fields, we're done
+      // If no new fields were processed, we're done
+      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
       }
 
-      // Separate new required and optional fields
-      const newRequiredFields = newFields.filter(
-        (field: unknown) => (field as { required: boolean }).required,
-      );
-      const newOptionalFields = newFields.filter(
-        (field: unknown) => !(field as { required: boolean }).required,
+      // If we only processed optional fields and skipped them, no need to re-fetch
+      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+        break;
+      }
+    }
+
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk.yellow(
+          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
+        ),
       );
+    }
 
-      // Prompt for new required fields
-      if (newRequiredFields.length > 0) {
+    return inputs;
+  }
+
+  /**
+   * Recursively processes fieldsets and their fields, maintaining natural structure
+   * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
+   */
+  private async processFieldItems(
+    items: unknown[],
+    targetInputs: Record<string, unknown>,
+    processedFieldKeys: Set<string>,
+    fieldsetPath: string[] = [],
+    iteration: number = 1,
+  ): Promise<{
+    newRequired: number;
+    newOptional: number;
+    optionalSkipped: boolean;
+  }> {
+    let newRequiredCount = 0;
+    let newOptionalCount = 0;
+    let optionalSkipped = false;
+
+    for (const item of items) {
+      const typedItem = item as {
+        type?: string;
+        key?: string;
+        title?: string;
+        fields?: unknown[];
+        is_required?: boolean;
+      };
+
+      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+        // Show fieldset context to user
+        const fieldsetTitle = typedItem.title || typedItem.key;
+        const pathDisplay =
+          fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
         console.log(
-          chalk.blue(
-            `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
+          chalk.cyan(
+            `\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`,
           ),
         );
-        for (const field of newRequiredFields) {
-          await this.promptForField(field, inputs);
-          processedFieldKeys.add((field as { key: string }).key);
+
+        // Create fieldset array in target inputs if it doesn't exist
+        if (!targetInputs[typedItem.key]) {
+          targetInputs[typedItem.key] = [{}];
+        }
+
+        // Process fields within this fieldset recursively
+        const fieldsetTarget = (
+          targetInputs[typedItem.key] as Record<string, unknown>[]
+        )[0];
+        const nestedPath = [...fieldsetPath, fieldsetTitle];
+
+        const nestedStats = await this.processFieldItems(
+          typedItem.fields,
+          fieldsetTarget,
+          processedFieldKeys,
+          nestedPath,
+          iteration,
+        );
+
+        newRequiredCount += nestedStats.newRequired;
+        newOptionalCount += nestedStats.newOptional;
+        if (nestedStats.optionalSkipped) {
+          optionalSkipped = true;
+        }
+      } else if (typedItem.type === "input_field" && typedItem.key) {
+        // Skip if already processed
+        if (processedFieldKeys.has(typedItem.key)) {
+          continue;
+        }
+
+        const isRequired = typedItem.is_required || false;
+
+        if (isRequired) {
+          // Process required field immediately
+          newRequiredCount++;
+          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
+            // Only show this message once at root level
+            console.log(
+              chalk.blue(
+                `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
+              ),
+            );
+          }
+
+          await this.promptForField(typedItem, targetInputs);
+          processedFieldKeys.add(typedItem.key);
+        } else {
+          // Collect optional fields for batch processing
+          newOptionalCount++;
         }
       }
+      // Skip info fields - they're for display only
+    }
+
+    // Handle optional fields after processing all required fields
+    if (newOptionalCount > 0) {
+      const optionalFields = items.filter((item: unknown) => {
+        const typedItem = item as {
+          type?: string;
+          key?: string;
+          is_required?: boolean;
+        };
+        return (
+          typedItem.type === "input_field" &&
+          typedItem.key &&
+          !typedItem.is_required &&
+          !processedFieldKeys.has(typedItem.key)
+        );
+      });
 
-      // Ask about optional fields
-      let shouldConfigureOptional = { configure: false };
-      if (newOptionalFields.length > 0) {
+      if (optionalFields.length > 0) {
+        const pathContext =
+          fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
         console.log(
           chalk.gray(
-            `\nThere are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`,
+            `\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`,
           ),
         );
 
         try {
-          shouldConfigureOptional = await inquirer.prompt([
+          const shouldConfigureOptional = await inquirer.prompt([
             {
               type: "confirm",
               name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
               default: false,
             },
           ]);
+
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, targetInputs);
+              const typedField = field as { key: string };
+              processedFieldKeys.add(typedField.key);
+            }
+          } else {
+            optionalSkipped = true;
+            // Mark these fields as processed even if skipped to avoid re-asking
+            optionalFields.forEach((field: unknown) => {
+              const typedField = field as { key: string };
+              processedFieldKeys.add(typedField.key);
+            });
+          }
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk.yellow("\n\nOperation cancelled by user"));
@@ -474,39 +674,14 @@ export class SchemaParameterResolver {
           }
           throw error;
         }
-
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk.cyan(`\nOptional fields:`));
-          for (const field of newOptionalFields) {
-            await this.promptForField(field, inputs);
-            processedFieldKeys.add((field as { key: string }).key);
-          }
-        } else {
-          // Mark these fields as processed even if skipped to avoid re-asking
-          newOptionalFields.forEach((field: unknown) =>
-            processedFieldKeys.add((field as { key: string }).key),
-          );
-        }
-      }
-
-      // If we only processed optional fields and skipped them, no need to re-fetch
-      if (
-        newRequiredFields.length === 0 &&
-        (!newOptionalFields.length || !shouldConfigureOptional.configure)
-      ) {
-        break;
       }
     }
 
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk.yellow(
-          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
-        ),
-      );
-    }
-
-    return inputs;
+    return {
+      newRequired: newRequiredCount,
+      newOptional: newOptionalCount,
+      optionalSkipped,
+    };
   }
 
   private getNestedValue(obj: unknown, path: string[]): unknown {
@@ -536,7 +711,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 +720,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 +749,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 +773,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 || {};
+  }
 }