@zapier/zapier-sdk-cli 0.9.0 → 0.11.0

package/dist/src/utils/parameter-resolver.js

@@ -1,17 +1,59 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
-import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
+// ============================================================================
+// 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, resolvers, resolved = new Set()) {
+    const resolver = resolvers[paramName];
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    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, resolvers) {
+    const resolved = new Set();
+    const order = [];
+    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;
+}
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
 export class SchemaParameterResolver {
-    async resolveParameters(schema, providedParams, sdk) {
+    async resolveParameters(schema, providedParams, sdk, functionName) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
         // Get all schema parameters to check which ones have resolvers
         const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => hasResolver(param.name));
+        const resolvableParams = allParams.filter((param) => this.hasResolver(param.name, sdk, functionName));
         // Get all missing parameters that have resolvers
         const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
@@ -61,10 +103,13 @@ export class SchemaParameterResolver {
             sdk,
             currentParams: providedParams,
             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
             const orderedRequiredParams = requiredResolutionOrder
@@ -84,7 +129,7 @@ export class SchemaParameterResolver {
                 .filter((param) => param !== undefined);
             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
                     context.resolvedParams = resolvedParams;
@@ -105,13 +150,13 @@ 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))
                 .filter((param) => param !== undefined);
             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
                     context.resolvedParams = resolvedParams;
@@ -139,13 +184,13 @@ 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))
                     .filter((param) => param !== undefined);
                 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
                         context.resolvedParams = resolvedParams;
@@ -208,8 +253,8 @@ export class SchemaParameterResolver {
             isRequired,
         };
     }
-    async resolveParameter(param, context) {
-        const resolver = getResolver(param.name);
+    async resolveParameter(param, context, functionName) {
+        const resolver = this.getResolver(param.name, context.sdk, functionName);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
@@ -258,7 +303,7 @@ export class SchemaParameterResolver {
         const inputs = {};
         let processedFieldKeys = new Set();
         let iteration = 0;
-        const maxIterations = 5; // Prevent infinite loops
+        const maxIterations = 10; // Prevent infinite loops
         while (iteration < maxIterations) {
             iteration++;
             // Update context with current inputs so they're passed to listInputFields
@@ -270,44 +315,118 @@ export class SchemaParameterResolver {
                 },
             };
             console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
-            const fields = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
-            if (!fields || fields.length === 0) {
+            const rootFieldItems = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            if (!rootFieldItems || rootFieldItems.length === 0) {
                 if (iteration === 1) {
                     console.log(chalk.yellow(`No input fields required for this action.`));
                 }
                 break;
             }
-            // Find new fields that we haven't processed yet
-            const newFields = fields.filter((field) => !(field.key &&
-                processedFieldKeys.has(field.key)));
-            if (newFields.length === 0) {
-                // No new fields, we're done
+            // Process fields recursively, maintaining fieldset structure
+            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration);
+            // If no new fields were processed, we're done
+            if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
+                break;
+            }
+            // If we only processed optional fields and skipped them, no need to re-fetch
+            if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
                 break;
             }
-            // Separate new required and optional fields
-            const newRequiredFields = newFields.filter((field) => field.required);
-            const newOptionalFields = newFields.filter((field) => !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);
+        }
+        if (iteration >= maxIterations) {
+            console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
+        }
+        return inputs;
+    }
+    /**
+     * Recursively processes fieldsets and their fields, maintaining natural structure
+     * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
+     */
+    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1) {
+        let newRequiredCount = 0;
+        let newOptionalCount = 0;
+        let optionalSkipped = false;
+        for (const item of items) {
+            const typedItem = item;
+            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.cyan(`\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`));
+                // 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][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++;
                 }
             }
-            // 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.`));
+            // Skip info fields - they're for display only
+        }
+        // Handle optional fields after processing all required fields
+        if (newOptionalCount > 0) {
+            const optionalFields = items.filter((item) => {
+                const typedItem = item;
+                return (typedItem.type === "input_field" &&
+                    typedItem.key &&
+                    !typedItem.is_required &&
+                    !processedFieldKeys.has(typedItem.key));
+            });
+            if (optionalFields.length > 0) {
+                const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
+                console.log(chalk.gray(`\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;
+                            processedFieldKeys.add(typedField.key);
+                        }
+                    }
+                    else {
+                        optionalSkipped = true;
+                        // Mark these fields as processed even if skipped to avoid re-asking
+                        optionalFields.forEach((field) => {
+                            const typedField = field;
+                            processedFieldKeys.add(typedField.key);
+                        });
+                    }
                 }
                 catch (error) {
                     if (this.isUserCancellation(error)) {
@@ -316,28 +435,13 @@ 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.key);
-                    }
-                }
-                else {
-                    // Mark these fields as processed even if skipped to avoid re-asking
-                    newOptionalFields.forEach((field) => processedFieldKeys.add(field.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,
+        };
     }
     getNestedValue(obj, path) {
         return path.reduce((current, key) => current?.[key], obj);
@@ -358,7 +462,7 @@ export class SchemaParameterResolver {
         const fieldPrompt = {
             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) {
             fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
@@ -381,7 +485,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`);
             }
         }
@@ -399,4 +503,36 @@ export class SchemaParameterResolver {
             errorObj?.message?.includes("User force closed") ||
             errorObj?.isTTYError === true);
     }
+    hasResolver(paramName, sdk, functionName) {
+        // 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;
+    }
+    getResolver(paramName, sdk, functionName) {
+        // 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;
+    }
+    getLocalResolvers(sdk, functionName) {
+        if (!functionName || typeof sdk.getRegistry !== "function") {
+            return {};
+        }
+        const registry = sdk.getRegistry();
+        const functionInfo = registry.functions.find((f) => f.name === functionName);
+        return functionInfo?.resolvers || {};
+    }
 }

package/dist/src/utils/schema-formatter.d.ts

@@ -1,2 +1,6 @@
 import type { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[], startingNumber?: number): void;
+export declare function formatJsonOutput(data: unknown): void;
+export declare function formatItemsFromSchema(functionInfo: {
+    inputSchema: z.ZodType;
+    outputSchema?: z.ZodType;
+}, items: unknown[], startingNumber?: number): void;

package/dist/src/utils/schema-formatter.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import util from "util";
 function getFormatMetadata(schema) {
     return schema?._def
         ?.formatMeta;
@@ -7,11 +8,22 @@ function getOutputSchema(schema) {
     return schema?._def?.outputSchema;
 }
 // ============================================================================
+// JSON Formatting
+// ============================================================================
+export function formatJsonOutput(data) {
+    // Don't print anything for undefined results (commands that just perform actions)
+    if (data === undefined) {
+        return;
+    }
+    // Use util.inspect for colored output
+    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
+}
+// ============================================================================
 // Generic Schema-Driven Formatter
 // ============================================================================
-export function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
-    // Get the output schema and its format metadata
-    const outputSchema = getOutputSchema(inputSchema);
+export function formatItemsFromSchema(functionInfo, items, startingNumber = 0) {
+    // Get the output schema from function info or fall back to input schema output schema
+    const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
     if (!outputSchema) {
         // Fallback to generic formatting if no output schema
         formatItemsGeneric(items, startingNumber);
@@ -25,18 +37,31 @@ export function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
     }
     // Format each item using the schema metadata
     items.forEach((item, index) => {
-        formatSingleItem(item, startingNumber + index, formatMeta);
+        const formatted = formatMeta.format(item);
+        formatSingleItem(formatted, startingNumber + index);
     });
 }
-function formatSingleItem(item, itemNumber, formatMeta) {
-    // Get the formatted item from the format function
-    const formatted = formatMeta.format(item);
-    // Build the main title line
+function formatSingleItem(formatted, itemNumber) {
+    // Build the main title line with optional subtitle
     let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
-    if (formatted.subtitle) {
-        titleLine += ` ${chalk.gray(formatted.subtitle)}`;
+    // Generate subtitle from id or key
+    if (formatted.id) {
+        titleLine += ` ${chalk.gray(`(ID: ${formatted.id})`)}`;
+    }
+    else if (formatted.key) {
+        titleLine += ` ${chalk.gray(`(${formatted.key})`)}`;
     }
     console.log(titleLine);
+    // Show description if available
+    if (formatted.description) {
+        console.log(`   ${chalk.dim(formatted.description)}`);
+    }
+    // If data is provided, use JSON formatting instead of details
+    if (formatted.data !== undefined) {
+        formatJsonOutput(formatted.data);
+        console.log(); // Empty line between items
+        return;
+    }
     // Format detail lines
     for (const detail of formatted.details) {
         const styledText = applyStyle(detail.text, detail.style);
@@ -59,15 +84,20 @@ function applyStyle(value, style) {
             return chalk.blue(value);
     }
 }
+function convertGenericItemToFormattedItem(item) {
+    const itemObj = item;
+    return {
+        title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
+        id: itemObj.id,
+        key: itemObj.key,
+        description: itemObj.description,
+        details: [],
+    };
+}
 function formatItemsGeneric(items, startingNumber = 0) {
-    // Fallback formatting for items without schema metadata
+    // Convert generic items to FormattedItem and use formatSingleItem
     items.forEach((item, index) => {
-        const itemObj = item;
-        const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
-        console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(name)}`);
-        if (itemObj.description) {
-            console.log(`   ${chalk.dim(itemObj.description)}`);
-        }
-        console.log();
+        const formatted = convertGenericItemToFormattedItem(item);
+        formatSingleItem(formatted, startingNumber + index);
     });
 }