@zapier/zapier-sdk-cli 0.4.1 → 0.4.2

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

@@ -0,0 +1,387 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { z } from "zod";
+import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
+// ============================================================================
+// Schema Parameter Resolver
+// ============================================================================
+export class SchemaParameterResolver {
+    async resolveParameters(schema, providedParams, sdk) {
+        // 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));
+        // Get all missing parameters that have resolvers
+        const missingResolvable = resolvableParams.filter((param) => {
+            const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
+            return !hasValue;
+        });
+        // Determine parameter resolution categories:
+        // - functionally required: must be provided (inputs)
+        // - always prompt: should be prompted for but can be skipped (authenticationId)
+        // - truly optional: only ask if user wants to be prompted
+        const functionallyRequired = missingResolvable.filter((param) => {
+            // Schema-required parameters are always functionally required
+            if (param.isRequired)
+                return true;
+            // Only inputs is functionally required for run-action
+            if (param.name === "inputs") {
+                return true;
+            }
+            return false;
+        });
+        // Parameters that should always be prompted for directly, but can be skipped
+        const alwaysPrompt = missingResolvable.filter((param) => {
+            if (functionallyRequired.includes(param))
+                return false;
+            // authenticationId should always be prompted for (since it's usually needed)
+            // but can be skipped with "Continue without authentication"
+            if (param.name === "authenticationId") {
+                return true;
+            }
+            return false;
+        });
+        const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param) && !alwaysPrompt.includes(param));
+        if (parseResult.success &&
+            functionallyRequired.length === 0 &&
+            alwaysPrompt.length === 0) {
+            return parseResult.data;
+        }
+        if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+            // No functionally required parameters missing, but check if we can parse
+            if (!parseResult.success) {
+                throw parseResult.error;
+            }
+            return parseResult.data;
+        }
+        // 2. Resolve functionally required parameters and their dependencies first
+        const resolvedParams = { ...providedParams };
+        const context = {
+            sdk,
+            currentParams: providedParams,
+            resolvedParams,
+        };
+        if (functionallyRequired.length > 0) {
+            const requiredParamNames = functionallyRequired.map((p) => p.name);
+            const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
+            // Find all parameters that need to be resolved (including dependencies)
+            // from the available resolvable parameters
+            const orderedRequiredParams = requiredResolutionOrder
+                .map((paramName) => {
+                // First try to find in functionally required
+                let param = functionallyRequired.find((p) => p.name === paramName);
+                // If not found, try always prompt (for dependencies like authenticationId)
+                if (!param) {
+                    param = alwaysPrompt.find((p) => p.name === paramName);
+                }
+                // If not found, try truly optional (for other dependencies)
+                if (!param) {
+                    param = trulyOptional.find((p) => p.name === paramName);
+                }
+                return param;
+            })
+                .filter((param) => param !== undefined);
+            for (const param of orderedRequiredParams) {
+                try {
+                    const value = await this.resolveParameter(param, context);
+                    this.setNestedValue(resolvedParams, param.path, value);
+                    // Update context with newly resolved value
+                    context.resolvedParams = resolvedParams;
+                }
+                catch (error) {
+                    if (this.isUserCancellation(error)) {
+                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                        process.exit(0);
+                    }
+                    throw error;
+                }
+            }
+            // Remove resolved dependencies from other categories to avoid double-prompting
+            const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
+            alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
+            trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
+        }
+        // 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 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);
+                    this.setNestedValue(resolvedParams, param.path, value);
+                    // Update context with newly resolved value
+                    context.resolvedParams = resolvedParams;
+                }
+                catch (error) {
+                    if (this.isUserCancellation(error)) {
+                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                        process.exit(0);
+                    }
+                    throw error;
+                }
+            }
+        }
+        // 4. Ask user if they want to resolve truly optional parameters
+        if (trulyOptional.length > 0) {
+            const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+            const shouldResolveOptional = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "resolveOptional",
+                    message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
+                    default: false,
+                },
+            ]);
+            if (shouldResolveOptional.resolveOptional) {
+                // Resolve optional parameters using their resolvers
+                const optionalParamNames = trulyOptional.map((p) => p.name);
+                const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
+                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);
+                        this.setNestedValue(resolvedParams, param.path, value);
+                        // Update context with newly resolved value
+                        context.resolvedParams = resolvedParams;
+                    }
+                    catch (error) {
+                        if (this.isUserCancellation(error)) {
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                            process.exit(0);
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        // 3. Validate final parameters
+        const finalResult = schema.safeParse(resolvedParams);
+        if (!finalResult.success) {
+            console.error(chalk.red("❌ Parameter validation failed after resolution:"));
+            throw finalResult.error;
+        }
+        return finalResult.data;
+    }
+    extractParametersFromSchema(schema) {
+        const parameters = [];
+        // Only handle ZodObject at the top level
+        if (schema instanceof z.ZodObject) {
+            const shape = schema.shape;
+            for (const [key, fieldSchema] of Object.entries(shape)) {
+                const param = this.analyzeFieldSchema(key, fieldSchema);
+                if (param) {
+                    parameters.push(param);
+                }
+            }
+        }
+        return parameters;
+    }
+    analyzeFieldSchema(fieldName, fieldSchema) {
+        let baseSchema = fieldSchema;
+        let isRequired = true;
+        // Check if field is optional or has default
+        if (baseSchema instanceof z.ZodOptional) {
+            isRequired = false;
+            baseSchema = baseSchema._def.innerType;
+        }
+        if (baseSchema instanceof z.ZodDefault) {
+            isRequired = false;
+            baseSchema = baseSchema._def.innerType;
+        }
+        return this.createResolvableParameter([fieldName], baseSchema, isRequired);
+    }
+    createResolvableParameter(path, schema, isRequired) {
+        if (path.length === 0)
+            return null;
+        const name = path[path.length - 1];
+        return {
+            name,
+            path,
+            schema,
+            description: schema.description,
+            isRequired,
+        };
+    }
+    async resolveParameter(param, context) {
+        const resolver = getResolver(param.name);
+        if (!resolver) {
+            throw new Error(`No resolver found for parameter: ${param.name}`);
+        }
+        console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
+        if (resolver.type === "static") {
+            // Static resolver - just prompt for input
+            const promptConfig = {
+                type: resolver.inputType === "password" ? "password" : "input",
+                name: param.name,
+                message: `Enter ${param.name}:`,
+                ...(resolver.placeholder && { default: resolver.placeholder }),
+            };
+            const answers = await inquirer.prompt([promptConfig]);
+            return answers[param.name];
+        }
+        else if (resolver.type === "dynamic") {
+            // Dynamic resolver - fetch options and prompt for selection
+            try {
+                // Only show "Fetching..." for required parameters that typically have many options
+                if (param.isRequired && param.name !== "authenticationId") {
+                    console.log(chalk.gray(`Fetching options for ${param.name}...`));
+                }
+                const items = await resolver.fetch(context.sdk, context.resolvedParams);
+                // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
+                const safeItems = items || [];
+                const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
+                const answers = await inquirer.prompt([promptConfig]);
+                return answers[param.name];
+            }
+            catch (error) {
+                // Let the main CLI error handler display user-friendly errors
+                throw error;
+            }
+        }
+        else if (resolver.type === "fields") {
+            // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
+            return await this.resolveFieldsRecursively(resolver, context, param);
+        }
+        throw new Error(`Unknown resolver type for ${param.name}`);
+    }
+    async resolveFieldsRecursively(resolver, context, param) {
+        const inputs = {};
+        let processedFieldKeys = new Set();
+        let iteration = 0;
+        const maxIterations = 5; // Prevent infinite loops
+        while (iteration < maxIterations) {
+            iteration++;
+            // Update context with current inputs so they're passed to listInputFields
+            const updatedContext = {
+                ...context,
+                resolvedParams: {
+                    ...context.resolvedParams,
+                    inputs,
+                },
+            };
+            console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
+            const fields = await resolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            if (!fields || fields.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) => !processedFieldKeys.has(field.key));
+            if (newFields.length === 0) {
+                // No new fields, we're done
+                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);
+                }
+            }
+            // 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.`));
+                try {
+                    shouldConfigureOptional = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "configure",
+                            message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+                            default: false,
+                        },
+                    ]);
+                }
+                catch (error) {
+                    if (this.isUserCancellation(error)) {
+                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                        process.exit(0);
+                    }
+                    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;
+    }
+    getNestedValue(obj, path) {
+        return path.reduce((current, key) => current?.[key], obj);
+    }
+    setNestedValue(obj, path, value) {
+        const lastKey = path[path.length - 1];
+        const parent = path.slice(0, -1).reduce((current, key) => {
+            if (!(key in current)) {
+                current[key] = {};
+            }
+            return current[key];
+        }, obj);
+        parent[lastKey] = value;
+    }
+    async promptForField(field, inputs) {
+        const fieldPrompt = {
+            type: field.type === "boolean" ? "confirm" : "input",
+            name: field.key,
+            message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+            ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
+            ...(field.default && { default: field.default }),
+        };
+        if (field.choices && field.choices.length > 0) {
+            fieldPrompt.type = "list";
+            fieldPrompt.choices = field.choices.map((choice) => ({
+                name: choice.label || choice.value,
+                value: choice.value,
+            }));
+        }
+        try {
+            const answer = await inquirer.prompt([fieldPrompt]);
+            if (answer[field.key] !== undefined && answer[field.key] !== "") {
+                inputs[field.key] = answer[field.key];
+            }
+            else if (field.required) {
+                throw new Error(`Required field ${field.key} cannot be empty`);
+            }
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    isUserCancellation(error) {
+        return (error?.name === "ExitPromptError" ||
+            error?.message?.includes("User force closed") ||
+            error?.isTTYError);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: any[]): void;

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

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+function getFormatMetadata(schema) {
+    return schema?._def?.formatMeta;
+}
+function getOutputSchema(schema) {
+    return schema?._def?.outputSchema;
+}
+// ============================================================================
+// Generic Schema-Driven Formatter
+// ============================================================================
+export function formatItemsFromSchema(inputSchema, items) {
+    // Get the output schema and its format metadata
+    const outputSchema = getOutputSchema(inputSchema);
+    if (!outputSchema) {
+        // Fallback to generic formatting if no output schema
+        formatItemsGeneric(items);
+        return;
+    }
+    const formatMeta = getFormatMetadata(outputSchema);
+    if (!formatMeta) {
+        // Fallback to generic formatting if no format metadata
+        formatItemsGeneric(items);
+        return;
+    }
+    // Format each item using the schema metadata
+    items.forEach((item, index) => {
+        formatSingleItem(item, index, formatMeta);
+    });
+}
+function formatSingleItem(item, index, formatMeta) {
+    // 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)}`;
+    if (formatted.subtitle) {
+        titleLine += ` ${chalk.gray(formatted.subtitle)}`;
+    }
+    console.log(titleLine);
+    // Format detail lines
+    for (const detail of formatted.details) {
+        const styledText = applyStyle(detail.text, detail.style);
+        console.log(`   ${styledText}`);
+    }
+    console.log(); // Empty line between items
+}
+function applyStyle(value, style) {
+    switch (style) {
+        case "dim":
+            return chalk.dim(value);
+        case "accent":
+            return chalk.magenta(value);
+        case "warning":
+            return chalk.red(value);
+        case "success":
+            return chalk.green(value);
+        case "normal":
+        default:
+            return chalk.blue(value);
+    }
+}
+function formatItemsGeneric(items) {
+    // Fallback formatting for items without schema metadata
+    items.forEach((item, index) => {
+        const name = item.title || item.name || item.key || item.id || "Item";
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
+        if (item.description) {
+            console.log(`   ${chalk.dim(item.description)}`);
+        }
+        console.log();
+    });
+}

package/dist/src/utils/serializeAsync.d.ts

@@ -0,0 +1,2 @@
+declare const serializeAsync: <R, A extends []>(fn: (...args: A) => Promise<R>) => ((...args: A) => Promise<R>);
+export default serializeAsync;

package/dist/src/utils/serializeAsync.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+const promises = {};
+const serializeAsync = (fn) => async (...args) => {
+    const hash = createHash("sha256")
+        .update(fn.toString(), "utf8")
+        .digest()
+        .toString("hex");
+    const promise = promises[hash];
+    if (!promise) {
+        promises[hash] = fn(...args).finally(() => {
+            delete promises[hash];
+        });
+    }
+    return promises[hash];
+};
+export default serializeAsync;

package/dist/src/utils/spinner.d.ts

@@ -0,0 +1 @@
+export declare const spinPromise: <T>(promise: Promise<T>, text: string) => Promise<T>;

package/dist/src/utils/spinner.js

@@ -0,0 +1,13 @@
+import ora from "ora";
+export const spinPromise = async (promise, text) => {
+    const spinner = ora(text).start();
+    try {
+        const result = await promise;
+        spinner.succeed();
+        return result;
+    }
+    catch (error) {
+        spinner.fail();
+        throw error;
+    }
+};