@zapier/zapier-sdk-cli 0.15.1 → 0.15.2

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

@@ -324,7 +324,7 @@ export class SchemaParameterResolver {
                 break;
             }
             // Process fields recursively, maintaining fieldset structure
-            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration);
+            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration, updatedContext);
             // If no new fields were processed, we're done
             if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
                 break;
@@ -343,7 +343,7 @@ export class SchemaParameterResolver {
      * 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) {
+    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context) {
         let newRequiredCount = 0;
         let newOptionalCount = 0;
         let optionalSkipped = false;
@@ -361,7 +361,7 @@ export class SchemaParameterResolver {
                 // 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);
+                const nestedStats = await this.processFieldItems(typedItem.fields, fieldsetTarget, processedFieldKeys, nestedPath, iteration, context);
                 newRequiredCount += nestedStats.newRequired;
                 newOptionalCount += nestedStats.newOptional;
                 if (nestedStats.optionalSkipped) {
@@ -381,7 +381,7 @@ export class SchemaParameterResolver {
                         // 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);
+                    await this.promptForField(typedItem, targetInputs, context);
                     processedFieldKeys.add(typedItem.key);
                 }
                 else {
@@ -415,7 +415,7 @@ export class SchemaParameterResolver {
                     if (shouldConfigureOptional.configure) {
                         console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
                         for (const field of optionalFields) {
-                            await this.promptForField(field, targetInputs);
+                            await this.promptForField(field, targetInputs, context);
                             const typedField = field;
                             processedFieldKeys.add(typedField.key);
                         }
@@ -458,36 +458,169 @@ export class SchemaParameterResolver {
         }, obj);
         parent[lastKey] = value;
     }
-    async promptForField(field, inputs) {
+    /**
+     * Extract and normalize field metadata from raw field object
+     */
+    extractFieldMetadata(field) {
         const fieldObj = field;
-        const fieldPrompt = {
-            type: fieldObj.type === "boolean" ? "confirm" : "input",
-            name: fieldObj.key,
-            message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`,
+        const valueType = fieldObj.value_type || "string";
+        return {
+            key: fieldObj.key,
+            title: fieldObj.title || fieldObj.label || fieldObj.key,
+            description: fieldObj.description || fieldObj.helpText,
+            isRequired: fieldObj.is_required || false,
+            defaultValue: fieldObj.default_value ?? fieldObj.default,
+            valueType,
+            hasDropdown: fieldObj.format === "SELECT",
+            isMultiSelect: Boolean(valueType === "array" ||
+                (fieldObj.items && fieldObj.items.type !== undefined)),
         };
-        if (fieldObj.helpText) {
-            fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
-        }
-        if (fieldObj.default !== undefined) {
-            fieldPrompt.default = fieldObj.default;
-        }
-        if (fieldObj.choices && fieldObj.choices.length > 0) {
-            fieldPrompt.type = "list";
-            fieldPrompt.choices = fieldObj.choices.map((choice) => {
-                const choiceObj = choice;
-                return {
-                    name: choiceObj.label || choiceObj.value,
-                    value: choiceObj.value,
-                };
+    }
+    /**
+     * Fetch a page of choices for a dropdown field
+     */
+    async fetchChoices(fieldMeta, inputs, context, cursor) {
+        try {
+            console.log(chalk.gray(cursor
+                ? `  Fetching more choices...`
+                : `  Fetching choices for ${fieldMeta.title}...`));
+            const page = await context.sdk.listInputFieldChoices({
+                appKey: context.resolvedParams.appKey,
+                actionKey: context.resolvedParams.actionKey,
+                actionType: context.resolvedParams.actionType,
+                authenticationId: context.resolvedParams.authenticationId,
+                inputFieldKey: fieldMeta.key,
+                inputs,
+                ...(cursor && { cursor }),
             });
+            const choices = page.data.map((choice) => ({
+                label: choice.label || choice.key || String(choice.value),
+                value: choice.value ?? choice.key,
+            }));
+            if (choices.length === 0 && !cursor) {
+                console.log(chalk.yellow(`  No choices available for ${fieldMeta.title}`));
+            }
+            return {
+                choices,
+                nextCursor: page.nextCursor,
+            };
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`  ⚠️  Failed to fetch choices for ${fieldMeta.title}:`), error);
+            return { choices: [] };
+        }
+    }
+    /**
+     * Prompt user with choices (handles both single and multi-select with pagination)
+     */
+    async promptWithChoices({ fieldMeta, choices: initialChoices, nextCursor: initialCursor, inputs, context, }) {
+        const choices = [...initialChoices];
+        let nextCursor = initialCursor;
+        const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
+        // Progressive loading loop
+        while (true) {
+            const promptChoices = choices.map((choice) => ({
+                name: choice.label,
+                value: choice.value,
+            }));
+            // Add "(Load more...)" option if there are more pages
+            if (nextCursor) {
+                promptChoices.push({
+                    name: chalk.dim("(Load more...)"),
+                    value: LOAD_MORE_SENTINEL,
+                });
+            }
+            // Add skip option for optional fields (single-select only)
+            if (!fieldMeta.isRequired && !fieldMeta.isMultiSelect) {
+                promptChoices.push({ name: "(Skip)", value: undefined });
+            }
+            const promptConfig = {
+                type: fieldMeta.isMultiSelect ? "checkbox" : "list",
+                name: fieldMeta.key,
+                message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
+                choices: promptChoices,
+                ...(fieldMeta.isMultiSelect && {
+                    validate: (input) => {
+                        if (fieldMeta.isRequired && (!input || input.length === 0)) {
+                            return "At least one selection is required";
+                        }
+                        return true;
+                    },
+                }),
+            };
+            const answer = await inquirer.prompt([promptConfig]);
+            let selectedValue = answer[fieldMeta.key];
+            // Check if user selected "Load more..."
+            const wantsMore = fieldMeta.isMultiSelect
+                ? Array.isArray(selectedValue) &&
+                    selectedValue.includes(LOAD_MORE_SENTINEL)
+                : selectedValue === LOAD_MORE_SENTINEL;
+            if (wantsMore && nextCursor && context) {
+                // Remove sentinel from multi-select
+                if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
+                    selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
+                }
+                // Fetch next page
+                const result = await this.fetchChoices(fieldMeta, inputs, context, nextCursor);
+                choices.push(...result.choices);
+                nextCursor = result.nextCursor;
+                // Re-prompt with updated choices
+                continue;
+            }
+            return selectedValue;
+        }
+    }
+    /**
+     * Prompt user for free-form input (text or boolean)
+     */
+    async promptFreeForm(fieldMeta) {
+        const promptConfig = {
+            name: fieldMeta.key,
+            message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
+        };
+        if (fieldMeta.valueType === "boolean") {
+            promptConfig.type = "confirm";
+            promptConfig.default =
+                fieldMeta.defaultValue !== undefined
+                    ? Boolean(fieldMeta.defaultValue)
+                    : undefined;
+        }
+        else {
+            promptConfig.type = "input";
+            promptConfig.default = fieldMeta.defaultValue;
+            promptConfig.validate = (input) => {
+                if (fieldMeta.isRequired && !input) {
+                    return "This field is required";
+                }
+                return true;
+            };
+        }
+        // Add help text if available
+        if (fieldMeta.description) {
+            promptConfig.prefix = chalk.gray(`ℹ  ${fieldMeta.description}\n`);
         }
         try {
-            const answer = await inquirer.prompt([fieldPrompt]);
-            if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
-                inputs[fieldObj.key] = answer[fieldObj.key];
+            const answer = await inquirer.prompt([promptConfig]);
+            return answer[fieldMeta.key];
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                throw new ZapierCliUserCancellationError();
             }
-            else if (fieldObj.is_required) {
-                throw new Error(`Required field ${fieldObj.key} cannot be empty`);
+            throw error;
+        }
+    }
+    /**
+     * Store field value in inputs object with validation
+     */
+    storeFieldValue(inputs, key, value, isRequired) {
+        try {
+            if (value !== undefined && value !== "") {
+                inputs[key] = value;
+            }
+            else if (isRequired) {
+                throw new Error(`Required field ${key} cannot be empty`);
             }
         }
         catch (error) {
@@ -498,6 +631,33 @@ export class SchemaParameterResolver {
             throw error;
         }
     }
+    async promptForField(field, inputs, context) {
+        const fieldMeta = this.extractFieldMetadata(field);
+        // Fetch choices if field has dropdown
+        let choices = [];
+        let nextCursor;
+        if (fieldMeta.hasDropdown && context) {
+            const result = await this.fetchChoices(fieldMeta, inputs, context);
+            choices = result.choices;
+            nextCursor = result.nextCursor;
+        }
+        // Prompt user based on field type
+        let selectedValue;
+        if (choices.length > 0) {
+            selectedValue = await this.promptWithChoices({
+                fieldMeta,
+                choices,
+                nextCursor,
+                inputs,
+                context,
+            });
+        }
+        else {
+            selectedValue = await this.promptFreeForm(fieldMeta);
+        }
+        // Store result
+        this.storeFieldValue(inputs, fieldMeta.key, selectedValue, fieldMeta.isRequired);
+    }
     isUserCancellation(error) {
         const errorObj = error;
         return (errorObj?.name === "ExitPromptError" ||