@zapier/zapier-sdk-cli 0.0.1

package/dist/utils/parameter-resolver.js

@@ -0,0 +1,413 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaParameterResolver = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const zod_1 = require("zod");
+// ============================================================================
+// Schema Parameter Resolver
+// ============================================================================
+class SchemaParameterResolver {
+    async resolveParameters(schema, providedParams, sdk) {
+        // 1. Try to parse with current parameters
+        const parseResult = schema.safeParse(providedParams);
+        // Even if parsing succeeds, check if we should resolve optional but important parameters
+        const allResolvable = this.findAllResolvableParameters(schema);
+        const shouldResolveAnyway = allResolvable.filter((param) => {
+            const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
+            // Resolve any parameters with resolvers even if optional, unless explicitly provided
+            return !hasValue && param.resolverMeta?.resolver;
+        });
+        if (parseResult.success && shouldResolveAnyway.length === 0) {
+            return parseResult.data;
+        }
+        // 2. Analyze what's missing and can be resolved
+        let missingResolvable;
+        if (!parseResult.success) {
+            missingResolvable = this.findResolvableParameters(schema, parseResult.error, providedParams);
+        }
+        else {
+            // Schema parsing succeeded, but we want to resolve optional important parameters
+            missingResolvable = shouldResolveAnyway;
+        }
+        if (missingResolvable.length === 0) {
+            // No resolvable parameters, throw original error
+            throw parseResult.error;
+        }
+        // 3. Resolve missing parameters interactively
+        const resolvedParams = { ...providedParams };
+        const context = {
+            sdk,
+            currentParams: providedParams,
+            resolvedParams,
+        };
+        // Sort by dependency order (parameters that depend on others go last)
+        const sortedMissing = this.sortByDependencies(missingResolvable);
+        for (const missing of sortedMissing) {
+            try {
+                const value = await this.resolveParameter(missing, context);
+                this.setNestedValue(resolvedParams, missing.path, value);
+                // Update context with newly resolved value
+                context.resolvedParams = resolvedParams;
+            }
+            catch (error) {
+                if (this.isUserCancellation(error)) {
+                    console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                    process.exit(0);
+                }
+                console.error(chalk_1.default.red(`Failed to resolve ${missing.name}:`), error);
+                throw error;
+            }
+        }
+        // 4. Validate final parameters
+        const finalResult = schema.safeParse(resolvedParams);
+        if (!finalResult.success) {
+            console.error(chalk_1.default.red("❌ Parameter validation failed after resolution:"));
+            throw finalResult.error;
+        }
+        return finalResult.data;
+    }
+    findAllResolvableParameters(schema) {
+        const resolvable = [];
+        this.analyzeSchema(schema, [], resolvable);
+        return resolvable;
+    }
+    findResolvableParameters(schema, error, providedParams) {
+        const resolvable = this.findAllResolvableParameters(schema);
+        // Filter to only include parameters that are actually missing/invalid
+        const errorPaths = new Set(error.issues.map((issue) => issue.path.join(".")));
+        return resolvable.filter((param) => {
+            const paramPath = param.path.join(".");
+            const isErrorPath = errorPaths.has(paramPath);
+            const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
+            // Include if there's an error for this path or if it's required and missing
+            // Also include optional parameters that have resolvers and aren't provided
+            const shouldResolve = isErrorPath ||
+                (param.isRequired && !hasValue) ||
+                (!param.isRequired && !hasValue && param.resolverMeta?.resolver);
+            return shouldResolve;
+        });
+    }
+    analyzeSchema(schema, currentPath, resolvable) {
+        // Handle different Zod types
+        if (schema instanceof zod_1.z.ZodObject) {
+            const shape = schema.shape;
+            Object.entries(shape).forEach(([key, fieldSchema]) => {
+                const fieldPath = [...currentPath, key];
+                this.analyzeSchemaField(key, fieldSchema, fieldPath, resolvable);
+            });
+        }
+        else if (schema instanceof zod_1.z.ZodOptional) {
+            this.analyzeSchema(schema.unwrap(), currentPath, resolvable);
+        }
+        else if (schema instanceof zod_1.z.ZodDefault) {
+            this.analyzeSchema(schema.removeDefault(), currentPath, resolvable);
+        }
+    }
+    analyzeSchemaField(name, schema, path, resolvable) {
+        const resolverMeta = schema._def.resolverMeta;
+        if (resolverMeta?.resolver) {
+            resolvable.push({
+                name,
+                path,
+                schema,
+                description: schema.description,
+                resolverMeta,
+                isRequired: !schema.isOptional(),
+            });
+        }
+        // Recursively analyze nested objects
+        if (schema instanceof zod_1.z.ZodObject) {
+            this.analyzeSchema(schema, path, resolvable);
+        }
+        else if (schema instanceof zod_1.z.ZodOptional) {
+            this.analyzeSchemaField(name, schema.unwrap(), path, resolvable);
+        }
+        else if (schema instanceof zod_1.z.ZodDefault) {
+            this.analyzeSchemaField(name, schema.removeDefault(), path, resolvable);
+        }
+    }
+    sortByDependencies(parameters) {
+        // Simple topological sort based on 'depends' field
+        const sorted = [];
+        const remaining = [...parameters];
+        while (remaining.length > 0) {
+            const canResolve = remaining.filter((param) => {
+                const depends = param.resolverMeta?.resolver?.depends || [];
+                return depends.every((dep) => sorted.some((resolved) => resolved.name === dep));
+            });
+            if (canResolve.length === 0) {
+                // No more resolvable parameters, add remaining ones (circular dependency or no dependencies)
+                sorted.push(...remaining);
+                break;
+            }
+            sorted.push(...canResolve);
+            canResolve.forEach((param) => {
+                const index = remaining.indexOf(param);
+                remaining.splice(index, 1);
+            });
+        }
+        return sorted;
+    }
+    async resolveParameter(paramInfo, context) {
+        const resolver = paramInfo.resolverMeta?.resolver;
+        if (!resolver) {
+            return await this.promptStaticInput(paramInfo);
+        }
+        if (resolver.type === "static") {
+            return await this.promptStaticInput(paramInfo, resolver);
+        }
+        if (resolver.type === "dynamic") {
+            return await this.resolveDynamicParameter(paramInfo, resolver, context);
+        }
+        if (resolver.type === "fields") {
+            return await this.resolveFieldsParameter(paramInfo, resolver, context);
+        }
+        throw new Error(`Unknown resolver type: ${resolver.type}`);
+    }
+    async promptStaticInput(paramInfo, resolver) {
+        const promptConfig = {
+            type: resolver?.inputType === "editor"
+                ? "input"
+                : resolver?.inputType || "input",
+            name: "value",
+            message: `Enter ${paramInfo.description || paramInfo.name}${paramInfo.isRequired ? "" : " (optional)"}:`,
+        };
+        // Only use placeholder as default for required parameters
+        if (resolver?.placeholder && paramInfo.isRequired) {
+            promptConfig.default = resolver.placeholder;
+        }
+        // Add validation for required parameters
+        if (paramInfo.isRequired) {
+            promptConfig.validate = (input) => {
+                if (!input || (typeof input === "string" && input.trim() === "")) {
+                    return "This field is required. Please enter a value.";
+                }
+                return true;
+            };
+        }
+        // For editor-like prompts, provide helpful instructions
+        if (resolver?.inputType === "editor") {
+            promptConfig.message += " (JSON format)";
+        }
+        try {
+            const result = await inquirer_1.default.prompt([promptConfig]);
+            // For optional parameters, treat empty input as undefined
+            if (!paramInfo.isRequired &&
+                (!result.value || result.value.trim() === "")) {
+                return undefined;
+            }
+            // Try to parse JSON if it looks like JSON
+            if (typeof result.value === "string" &&
+                result.value.trim().startsWith("{")) {
+                try {
+                    return JSON.parse(result.value);
+                }
+                catch {
+                    console.warn(chalk_1.default.yellow("Warning: Could not parse as JSON, using as string"));
+                    return result.value;
+                }
+            }
+            return result.value;
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    async resolveDynamicParameter(paramInfo, resolver, context) {
+        console.log(chalk_1.default.gray(`Fetching options for ${paramInfo.name}...`));
+        try {
+            // Use the new fetch function approach
+            const options = await resolver.fetch(context.sdk, context.resolvedParams);
+            if (options.length === 0) {
+                console.log(chalk_1.default.yellow(`No options available for ${paramInfo.name}`));
+                return await this.promptStaticInput(paramInfo);
+            }
+            // Generate prompt configuration
+            const promptConfig = resolver.prompt(options, context.resolvedParams);
+            // Execute the prompt
+            let result;
+            try {
+                result = await inquirer_1.default.prompt([promptConfig]);
+            }
+            catch (error) {
+                if (this.isUserCancellation(error)) {
+                    console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                    process.exit(0);
+                }
+                throw error;
+            }
+            let value = result[promptConfig.name || "value"];
+            // Handle JSON parsing if the value looks like JSON
+            if (typeof value === "string" && value.trim().startsWith("{")) {
+                try {
+                    value = JSON.parse(value);
+                }
+                catch {
+                    console.warn(chalk_1.default.yellow("Warning: Could not parse as JSON, using as string"));
+                }
+            }
+            return value;
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                process.exit(0);
+            }
+            if (error instanceof Error && error.message.includes("401")) {
+                console.log(chalk_1.default.yellow(`⚠️  Invalid auth token, falling back to manual input for ${paramInfo.name}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`Failed to fetch options for ${paramInfo.name}:`), error);
+                console.log(chalk_1.default.yellow("Falling back to manual input..."));
+            }
+            return await this.promptStaticInput(paramInfo);
+        }
+    }
+    async resolveFieldsParameter(paramInfo, resolver, context) {
+        console.log(chalk_1.default.gray(`Fetching field definitions for ${paramInfo.name}...`));
+        try {
+            // Fetch field definitions using the resolver's fetch function
+            const fields = await resolver.fetch(context.sdk, context.resolvedParams);
+            if (fields.length === 0) {
+                console.log(chalk_1.default.yellow(`No input fields required for this action`));
+                return {};
+            }
+            console.log(chalk_1.default.blue(`\nConfiguring inputs for ${context.resolvedParams.app} ${context.resolvedParams.type} ${context.resolvedParams.action}:`));
+            const inputs = {};
+            // Separate required and optional fields
+            const requiredFields = fields.filter((field) => field.required);
+            const optionalFields = fields.filter((field) => !field.required);
+            // First, prompt for all required fields
+            if (requiredFields.length > 0) {
+                console.log(chalk_1.default.cyan(`\nRequired fields (${requiredFields.length}):`));
+                for (const field of requiredFields) {
+                    await this.promptForField(field, inputs);
+                }
+            }
+            // Then ask if user wants to configure optional fields
+            if (optionalFields.length > 0) {
+                console.log(chalk_1.default.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
+                let shouldConfigureOptional;
+                try {
+                    shouldConfigureOptional = await inquirer_1.default.prompt([
+                        {
+                            type: "confirm",
+                            name: "configure",
+                            message: "Would you like to configure optional fields?",
+                            default: false,
+                        },
+                    ]);
+                }
+                catch (error) {
+                    if (this.isUserCancellation(error)) {
+                        console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                        process.exit(0);
+                    }
+                    throw error;
+                }
+                if (shouldConfigureOptional.configure) {
+                    console.log(chalk_1.default.cyan(`\nOptional fields:`));
+                    for (const field of optionalFields) {
+                        await this.promptForField(field, inputs);
+                    }
+                }
+            }
+            return inputs;
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                process.exit(0);
+            }
+            console.error(chalk_1.default.red(`Failed to fetch field definitions for ${paramInfo.name}:`), error);
+            console.log(chalk_1.default.yellow("Falling back to manual JSON input..."));
+            return await this.promptStaticInput(paramInfo);
+        }
+    }
+    async promptForField(field, inputs) {
+        const fieldPrompt = {
+            type: "input",
+            name: field.key,
+            message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+        };
+        // Add description/help text if available
+        if (field.help_text || field.description) {
+            fieldPrompt.message += `\n  ${chalk_1.default.dim(field.help_text || field.description)}`;
+        }
+        // Set default value
+        if (field.default !== undefined) {
+            fieldPrompt.default = field.default;
+        }
+        // Add validation for required fields
+        if (field.required) {
+            fieldPrompt.validate = (input) => {
+                if (!input || (typeof input === "string" && input.trim() === "")) {
+                    return "This field is required. Please enter a value.";
+                }
+                return true;
+            };
+        }
+        let result;
+        try {
+            result = await inquirer_1.default.prompt([fieldPrompt]);
+        }
+        catch (error) {
+            if (this.isUserCancellation(error)) {
+                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                process.exit(0);
+            }
+            throw error;
+        }
+        // Only include non-empty values
+        if (result[field.key] !== undefined && result[field.key] !== "") {
+            let value = result[field.key];
+            // Try to parse as appropriate type
+            if (field.type === "integer" && typeof value === "string") {
+                const parsed = parseInt(value, 10);
+                if (!isNaN(parsed))
+                    value = parsed;
+            }
+            else if (field.type === "number" && typeof value === "string") {
+                const parsed = parseFloat(value);
+                if (!isNaN(parsed))
+                    value = parsed;
+            }
+            else if (field.type === "boolean" && typeof value === "string") {
+                value = value.toLowerCase() === "true" || value === "1";
+            }
+            inputs[field.key] = value;
+        }
+    }
+    getNestedValue(obj, path) {
+        return path.reduce((current, key) => current?.[key], obj);
+    }
+    setNestedValue(obj, path, value) {
+        const lastKey = path[path.length - 1];
+        const parentPath = path.slice(0, -1);
+        const parent = parentPath.reduce((current, key) => {
+            if (!current[key]) {
+                current[key] = {};
+            }
+            return current[key];
+        }, obj);
+        parent[lastKey] = value;
+    }
+    isUserCancellation(error) {
+        // Check for various ways user cancellation can be detected
+        return (error &&
+            (error.name === "ExitPromptError" ||
+                error.message?.includes("User force closed the prompt") ||
+                error.message?.includes("SIGINT") ||
+                error.code === "SIGINT" ||
+                error.signal === "SIGINT"));
+    }
+}
+exports.SchemaParameterResolver = SchemaParameterResolver;

package/dist/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/utils/schema-formatter.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatItemsFromSchema = formatItemsFromSchema;
+const chalk_1 = __importDefault(require("chalk"));
+const output_schemas_1 = require("../../../actions-sdk/dist/output-schemas");
+// ============================================================================
+// Generic Schema-Driven Formatter
+// ============================================================================
+function formatItemsFromSchema(inputSchema, items) {
+    // Get the output schema and its format metadata
+    const outputSchema = (0, output_schemas_1.getOutputSchema)(inputSchema);
+    if (!outputSchema) {
+        // Fallback to generic formatting if no output schema
+        formatItemsGeneric(items);
+        return;
+    }
+    const formatMeta = (0, output_schemas_1.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_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(formatted.title)}`;
+    if (formatted.subtitle) {
+        titleLine += ` ${chalk_1.default.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_1.default.dim(value);
+        case "accent":
+            return chalk_1.default.magenta(value);
+        case "warning":
+            return chalk_1.default.red(value);
+        case "success":
+            return chalk_1.default.green(value);
+        case "normal":
+        default:
+            return chalk_1.default.blue(value);
+    }
+}
+function formatItemsGeneric(items) {
+    // Fallback formatting for items without schema metadata
+    items.forEach((item, index) => {
+        const name = item.name || item.key || item.id || "Item";
+        console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(name)}`);
+        if (item.description) {
+            console.log(`   ${chalk_1.default.dim(item.description)}`);
+        }
+        console.log();
+    });
+}

package/dist/utils/schema-generator.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import { ActionsSDK } from '@zapier/actions-sdk';
+export declare function generateCLICommands(program: Command, sdk: ActionsSDK): void;
+export declare function enhanceCommandHelp(program: Command): void;