@zapier/zapier-sdk-cli 0.2.1 → 0.4.0

package/dist/utils/parameter-resolver.js

@@ -1,300 +0,0 @@
-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 which parameters are "functionally required" vs truly optional
-        // For run-action: appKey, actionType, actionKey are schema-required
-        // authenticationId and inputs are schema-optional but functionally needed
-        const functionallyRequired = missingResolvable.filter((param) => {
-            // Schema-required parameters are always functionally required
-            if (param.isRequired)
-                return true;
-            // For run-action, inputs and authenticationId are functionally required
-            // even though schema-optional
-            if (param.name === "inputs" || param.name === "authenticationId") {
-                return true;
-            }
-            return false;
-        });
-        const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param));
-        if (parseResult.success && functionallyRequired.length === 0) {
-            return parseResult.data;
-        }
-        if (functionallyRequired.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 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);
-            const orderedRequiredParams = requiredResolutionOrder
-                .map((paramName) => functionallyRequired.find((p) => p.name === paramName))
-                .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);
-                    }
-                    console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
-                    throw error;
-                }
-            }
-        }
-        // 3. 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);
-                        }
-                        console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
-                        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 {
-                console.log(chalk.gray(`Fetching options for ${param.name}...`));
-                const items = await resolver.fetch(context.sdk, context.resolvedParams);
-                if (!items || items.length === 0) {
-                    throw new Error(`No options available for ${param.name}`);
-                }
-                const promptConfig = resolver.prompt(items, context.resolvedParams);
-                const answers = await inquirer.prompt([promptConfig]);
-                return answers[param.name];
-            }
-            catch (error) {
-                console.error(chalk.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
-                throw error;
-            }
-        }
-        else if (resolver.type === "fields") {
-            // Fields resolver - fetch field definitions and prompt for each input
-            try {
-                console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
-                const fields = await resolver.fetch(context.sdk, context.resolvedParams);
-                if (!fields || fields.length === 0) {
-                    console.log(chalk.yellow(`No input fields required for this action.`));
-                    return {};
-                }
-                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.blue(`\n📝 Please provide values for the following input fields:`));
-                    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.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
-                    let shouldConfigureOptional;
-                    try {
-                        shouldConfigureOptional = await inquirer.prompt([
-                            {
-                                type: "confirm",
-                                name: "configure",
-                                message: "Would you like to configure 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 optionalFields) {
-                            await this.promptForField(field, inputs);
-                        }
-                    }
-                }
-                return inputs;
-            }
-            catch (error) {
-                console.error(chalk.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
-                throw error;
-            }
-        }
-        throw new Error(`Unknown resolver type for ${param.name}`);
-    }
-    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/utils/schema-formatter.d.ts

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

package/dist/utils/schema-formatter.js

@@ -1,71 +0,0 @@
-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.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/utils/serializeAsync.d.ts

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

package/dist/utils/serializeAsync.js

@@ -1,16 +0,0 @@
-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/utils/spinner.d.ts

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

package/dist/utils/spinner.js

@@ -1,13 +0,0 @@
-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;
-    }
-};