@zapier/zapier-sdk-cli 0.3.1 → 0.4.1

package/dist/utils/cli-generator.js

@@ -1,388 +0,0 @@
-import { z } from "zod";
-import { hasResolver, isPositional } from "@zapier/zapier-sdk";
-import { SchemaParameterResolver } from "./parameter-resolver.js";
-import { createPager } from "./pager.js";
-import { formatItemsFromSchema } from "./schema-formatter.js";
-import chalk from "chalk";
-import util from "util";
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-function formatJsonOutput(data) {
-    // Show success message for action results
-    if (data &&
-        typeof data === "object" &&
-        !Array.isArray(data) &&
-        (data.success !== undefined || data.id || data.status)) {
-        console.log(chalk.green("✅ Action completed successfully!\n"));
-    }
-    // Use util.inspect for colored output
-    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
-}
-// ============================================================================
-// Schema Analysis
-// ============================================================================
-function analyzeZodSchema(schema) {
-    const parameters = [];
-    if (schema instanceof z.ZodObject) {
-        const shape = schema.shape;
-        for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema);
-            if (param) {
-                parameters.push(param);
-            }
-        }
-    }
-    return parameters;
-}
-function analyzeZodField(name, schema) {
-    let baseSchema = schema;
-    let required = true;
-    let defaultValue = undefined;
-    // Unwrap optional and default wrappers
-    if (baseSchema instanceof z.ZodOptional) {
-        required = false;
-        baseSchema = baseSchema._def.innerType;
-    }
-    if (baseSchema instanceof z.ZodDefault) {
-        required = false;
-        defaultValue = baseSchema._def.defaultValue();
-        baseSchema = baseSchema._def.innerType;
-    }
-    // Determine parameter type
-    let paramType = "string";
-    let choices;
-    if (baseSchema instanceof z.ZodString) {
-        paramType = "string";
-    }
-    else if (baseSchema instanceof z.ZodNumber) {
-        paramType = "number";
-    }
-    else if (baseSchema instanceof z.ZodBoolean) {
-        paramType = "boolean";
-    }
-    else if (baseSchema instanceof z.ZodArray) {
-        paramType = "array";
-    }
-    else if (baseSchema instanceof z.ZodEnum) {
-        paramType = "string";
-        choices = baseSchema._def.values;
-    }
-    else if (baseSchema instanceof z.ZodRecord) {
-        // Handle Record<string, any> as JSON string input
-        paramType = "string";
-    }
-    // Extract resolver metadata
-    return {
-        name,
-        type: paramType,
-        required,
-        description: schema.description,
-        default: defaultValue,
-        choices,
-        hasResolver: hasResolver(name),
-        isPositional: isPositional(schema),
-    };
-}
-// ============================================================================
-// CLI Structure Derivation - Purely Generic
-// ============================================================================
-/**
- * Convert camelCase to kebab-case
- * e.g., listApps -> list-apps, generateTypes -> generate-types
- */
-function toKebabCase(str) {
-    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
-/**
- * Convert SDK method name directly to CLI command
- * e.g., listApps -> list-apps, getApp -> get-app, generateTypes -> generate-types
- */
-function methodNameToCliCommand(methodName) {
-    return toKebabCase(methodName);
-}
-// ============================================================================
-// CLI Command Generation - Completely Generic
-// ============================================================================
-export function generateCliCommands(program, sdk) {
-    // Check if SDK has registry
-    if (!sdk.__registry) {
-        console.error("SDK registry not available");
-        return;
-    }
-    // Generate one flat command for each function in the registry
-    sdk.__registry.forEach((fnInfo) => {
-        if (!fnInfo.inputSchema) {
-            console.warn(`Schema not found for ${fnInfo.name}`);
-            return;
-        }
-        // Convert methodName to kebab-case CLI command
-        const cliCommandName = methodNameToCliCommand(fnInfo.name);
-        const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
-        addCommand(program, cliCommandName, config);
-    });
-}
-function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
-    const parameters = analyzeZodSchema(schema);
-    const description = schema.description || `${cliCommandName} command`;
-    const handler = async (...args) => {
-        try {
-            // The last argument is always the command object with parsed options
-            const commandObj = args[args.length - 1];
-            const options = commandObj.opts();
-            // Check if this is a list command for pagination
-            const isListCommand = cliCommandName.startsWith("list-");
-            const hasPaginationParams = parameters.some((p) => p.name === "limit" || p.name === "offset");
-            const hasUserSpecifiedLimit = "limit" in options && options.limit !== undefined;
-            const shouldUsePaging = isListCommand && hasPaginationParams && !hasUserSpecifiedLimit;
-            const shouldUseJson = options.json;
-            // Convert CLI args to SDK method parameters
-            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
-            // Resolve missing parameters interactively using schema metadata
-            const resolver = new SchemaParameterResolver();
-            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
-            if (shouldUsePaging && !shouldUseJson) {
-                // Use interactive paging for list commands
-                await handlePaginatedList(sdkMethodName, resolvedParams, sdk, schema);
-            }
-            else {
-                // Call the SDK method directly
-                const result = await sdk[sdkMethodName](resolvedParams);
-                // Special handling for commands that write to files
-                const hasOutputFile = resolvedParams.output;
-                // Output result (JSON or formatted)
-                if (!hasOutputFile && (shouldUseJson || !isListCommand)) {
-                    // Use raw JSON if --json flag is specified, otherwise use pretty formatting
-                    if (shouldUseJson) {
-                        console.log(JSON.stringify(result, null, 2));
-                    }
-                    else {
-                        formatJsonOutput(result);
-                    }
-                }
-                else if (!hasOutputFile) {
-                    // Format list results nicely (non-paginated)
-                    formatNonPaginatedResults(result, resolvedParams.limit, hasUserSpecifiedLimit, shouldUseJson, schema, sdkMethodName);
-                }
-                else if (hasOutputFile) {
-                    // Show success message for file output instead of printing generated content
-                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
-                    console.log(chalk.gray(`Output written to: ${resolvedParams.output}`));
-                }
-            }
-        }
-        catch (error) {
-            // Handle Zod validation errors more gracefully
-            if (error instanceof Error && error.message.includes('"code"')) {
-                try {
-                    const validationErrors = JSON.parse(error.message);
-                    console.error(chalk.red("❌ Validation Error:"));
-                    validationErrors.forEach((err) => {
-                        const field = err.path?.join(".") || "unknown";
-                        console.error(chalk.yellow(`  • ${field}: ${err.message}`));
-                    });
-                    console.error("\n" + chalk.dim(`Use --help to see available options`));
-                }
-                catch {
-                    console.error(chalk.red("Error:"), error.message);
-                }
-            }
-            else {
-                console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-            }
-            process.exit(1);
-        }
-    };
-    return {
-        description,
-        parameters,
-        handler,
-    };
-}
-function addCommand(program, commandName, config) {
-    const command = program.command(commandName).description(config.description);
-    // Add parameters to command
-    config.parameters.forEach((param) => {
-        // Convert camelCase to kebab-case for CLI display
-        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
-        if (param.hasResolver && param.required) {
-            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
-            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
-        }
-        else if (param.required) {
-            // Required parameters without resolvers become required positional arguments
-            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
-        }
-        else if (param.isPositional) {
-            // Optional parameters marked as positional become optional positional arguments
-            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
-        }
-        else {
-            // Optional parameters become flags (whether they have resolvers or not)
-            const flags = [`--${kebabName}`];
-            if (param.type === "boolean") {
-                command.option(flags.join(", "), param.description);
-            }
-            else {
-                const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
-            }
-        }
-    });
-    // Add formatting options for all commands
-    command.option("--json", "Output raw JSON instead of formatted results");
-    command.action(config.handler);
-}
-// ============================================================================
-// Parameter Conversion
-// ============================================================================
-function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
-    const sdkParams = {};
-    // Handle positional arguments (required parameters or optional positional parameters)
-    let argIndex = 0;
-    parameters.forEach((param) => {
-        if ((param.required || param.isPositional) &&
-            argIndex < positionalArgs.length) {
-            // Use the original camelCase parameter name for the SDK
-            sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
-            argIndex++;
-        }
-    });
-    // Handle option flags
-    Object.entries(options).forEach(([key, value]) => {
-        // Convert kebab-case back to camelCase
-        const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-        const param = parameters.find((p) => p.name === camelKey);
-        if (param && value !== undefined) {
-            sdkParams[camelKey] = convertValue(value, param.type);
-        }
-    });
-    return sdkParams;
-}
-function convertValue(value, type) {
-    switch (type) {
-        case "number":
-            return Number(value);
-        case "boolean":
-            return Boolean(value);
-        case "array":
-            return Array.isArray(value) ? value : [value];
-        case "string":
-        default:
-            // Handle JSON string for objects
-            if (typeof value === "string" &&
-                (value.startsWith("{") || value.startsWith("["))) {
-                try {
-                    return JSON.parse(value);
-                }
-                catch {
-                    return value;
-                }
-            }
-            return value;
-    }
-}
-// ============================================================================
-// Pagination Handlers
-// ============================================================================
-async function handlePaginatedList(sdkMethodName, baseParams, sdk, schema) {
-    const limit = baseParams.limit || 20;
-    const itemName = getItemNameFromMethod(sdkMethodName);
-    console.log(chalk.blue(`📋 Fetching ${itemName}...`));
-    const pager = createPager({
-        pageSize: Math.min(limit, 20),
-        itemName,
-    });
-    const displayFunction = (items, totalShown, totalAvailable) => {
-        // Only clear screen if we have items to show
-        if (items.length > 0) {
-            console.clear();
-        }
-        console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
-        if (items.length === 0) {
-            console.log(chalk.yellow(`No ${itemName} found.`));
-            return;
-        }
-        // Use schema for formatting
-        if (schema) {
-            formatItemsFromSchema(schema, items);
-        }
-        else {
-            // Fallback to generic formatting
-            formatItemsGeneric(items);
-        }
-        const totalInfo = totalAvailable
-            ? ` of ${totalAvailable.toLocaleString()} total`
-            : "";
-        console.log(chalk.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`));
-    };
-    await pager.paginate((params) => sdk[sdkMethodName]({
-        ...baseParams,
-        ...params,
-    }), {}, displayFunction);
-}
-function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, useRawJson, schema, methodName) {
-    if (!Array.isArray(result)) {
-        if (useRawJson) {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        else {
-            formatJsonOutput(result);
-        }
-        return;
-    }
-    if (useRawJson) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
-    if (result.length === 0) {
-        console.log(chalk.yellow(`No ${itemName} found.`));
-        return;
-    }
-    console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
-    // Use schema for formatting
-    if (schema) {
-        formatItemsFromSchema(schema, result);
-    }
-    else {
-        // Fallback to generic formatting
-        formatItemsGeneric(result);
-    }
-    // Show appropriate status message
-    if (userSpecifiedLimit && requestedLimit) {
-        console.log(chalk.gray(`\n📄 Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`));
-    }
-    else {
-        console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
-    }
-}
-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();
-    });
-}
-// Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(methodName) {
-    // Extract from method name: listApps -> apps, listActions -> actions
-    const listMatch = methodName.match(/^list(.+)$/);
-    if (listMatch) {
-        return listMatch[1].toLowerCase();
-    }
-    // Fallback to generic
-    return "items";
-}
-function getListTitleFromMethod(methodName) {
-    const itemName = getItemNameFromMethod(methodName);
-    if (itemName === "items")
-        return "Available Items";
-    // Capitalize first letter: apps -> Apps
-    const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-    return `Available ${capitalized}`;
-}

package/dist/utils/constants.d.ts

@@ -1,5 +0,0 @@
-export declare const ZAPIER_BASE = "https://zapier.com";
-export declare const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
-export declare const LOGIN_PORTS: number[];
-export declare const LOGIN_TIMEOUT_MS = 300000;
-export declare const AUTH_MODE_HEADER = "X-Auth";

package/dist/utils/constants.js

@@ -1,6 +0,0 @@
-export const ZAPIER_BASE = "https://zapier.com";
-// OAuth client ID for zapier-sdk CLI
-export const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
-export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
-export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes
-export const AUTH_MODE_HEADER = "X-Auth";

package/dist/utils/getCallablePromise.d.ts

@@ -1,6 +0,0 @@
-declare const getCallablePromise: <T>() => {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason: unknown) => void;
-};
-export default getCallablePromise;

package/dist/utils/getCallablePromise.js

@@ -1,14 +0,0 @@
-const getCallablePromise = () => {
-    let resolve = () => { };
-    let reject = () => { };
-    const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-    return {
-        promise,
-        resolve,
-        reject,
-    };
-};
-export default getCallablePromise;

package/dist/utils/log.d.ts

@@ -1,7 +0,0 @@
-declare const log: {
-    info: (message: string, ...args: any[]) => void;
-    error: (message: string, ...args: any[]) => void;
-    success: (message: string, ...args: any[]) => void;
-    warn: (message: string, ...args: any[]) => void;
-};
-export default log;

package/dist/utils/log.js

@@ -1,16 +0,0 @@
-import chalk from "chalk";
-const log = {
-    info: (message, ...args) => {
-        console.log(chalk.blue("ℹ"), message, ...args);
-    },
-    error: (message, ...args) => {
-        console.error(chalk.red("✖"), message, ...args);
-    },
-    success: (message, ...args) => {
-        console.log(chalk.green("✓"), message, ...args);
-    },
-    warn: (message, ...args) => {
-        console.log(chalk.yellow("⚠"), message, ...args);
-    },
-};
-export default log;

package/dist/utils/pager.d.ts

@@ -1,48 +0,0 @@
-export interface PagerOptions {
-    pageSize?: number;
-    showPrompt?: boolean;
-    itemName?: string;
-}
-export interface PaginatedResult<T> {
-    items: T[];
-    hasMore: boolean;
-    totalShown: number;
-}
-/**
- * Generic pager that handles pagination for any data source
- * Supports interactive "load more" functionality
- */
-export declare class Pager<T> {
-    private pageSize;
-    private showPrompt;
-    private itemName;
-    private allItems;
-    private currentOffset;
-    constructor(options?: PagerOptions);
-    /**
-     * Fetch and display paginated results with interactive loading
-     */
-    paginate<TParams>(fetchFunction: (params: TParams & {
-        limit: number;
-        offset?: number;
-    }) => Promise<T[]>, baseParams: TParams, displayFunction: (items: T[], totalShown: number, totalAvailable?: number) => void): Promise<PaginatedResult<T>>;
-    /**
-     * Reset the pager state
-     */
-    reset(): void;
-}
-/**
- * Convenience function to create a pager for a specific use case
- */
-export declare function createPager<T>(options?: PagerOptions): Pager<T>;
-/**
- * Simple pagination without interactivity - just fetches all results up to a limit
- */
-export declare function fetchAllPages<T, TParams>(fetchFunction: (params: TParams & {
-    limit: number;
-    offset?: number;
-}) => Promise<T[]>, baseParams: TParams, maxResults?: number): Promise<T[]>;
-/**
- * Display helper for showing pagination status
- */
-export declare function showPaginationStatus(currentCount: number, requestedLimit: number, itemName?: string): void;

package/dist/utils/pager.js

@@ -1,137 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-/**
- * Generic pager that handles pagination for any data source
- * Supports interactive "load more" functionality
- */
-export class Pager {
-    constructor(options = {}) {
-        this.allItems = [];
-        this.currentOffset = 0;
-        this.pageSize = options.pageSize || 20;
-        this.showPrompt = options.showPrompt !== false;
-        this.itemName = options.itemName || "items";
-    }
-    /**
-     * Fetch and display paginated results with interactive loading
-     */
-    async paginate(fetchFunction, baseParams, displayFunction) {
-        let hasMore = true;
-        let totalAvailable;
-        while (hasMore) {
-            // Fetch next page
-            const params = {
-                ...baseParams,
-                limit: this.pageSize,
-                offset: this.currentOffset,
-            };
-            try {
-                const items = await fetchFunction(params);
-                if (items.length === 0) {
-                    // Still call display function to show "No items found" message
-                    displayFunction(this.allItems, this.allItems.length, totalAvailable);
-                    hasMore = false;
-                    break;
-                }
-                // Check for pagination metadata to get total count
-                const pagination = items.__pagination;
-                if (pagination && pagination.count) {
-                    totalAvailable = pagination.count;
-                    hasMore = pagination.hasNext;
-                }
-                else {
-                    // Fallback: check if we got fewer items than requested
-                    hasMore = items.length >= this.pageSize;
-                }
-                // Add to our collection
-                this.allItems.push(...items);
-                this.currentOffset += items.length;
-                // Display current batch
-                displayFunction(this.allItems, this.allItems.length, totalAvailable);
-                // If prompting is disabled, continue automatically
-                if (!this.showPrompt) {
-                    continue;
-                }
-                // If we have total count info, show more detailed prompt
-                const totalInfo = totalAvailable
-                    ? ` of ${totalAvailable.toLocaleString()}`
-                    : "";
-                const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
-                // Ask user if they want to load more
-                const { loadMore } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "loadMore",
-                        message,
-                        default: true,
-                    },
-                ]);
-                if (!loadMore) {
-                    hasMore = false;
-                }
-            }
-            catch (error) {
-                // Re-throw the error to be handled by the caller
-                throw error;
-            }
-        }
-        return {
-            items: this.allItems,
-            hasMore: this.currentOffset > 0 && hasMore,
-            totalShown: this.allItems.length,
-        };
-    }
-    /**
-     * Reset the pager state
-     */
-    reset() {
-        this.allItems = [];
-        this.currentOffset = 0;
-    }
-}
-/**
- * Convenience function to create a pager for a specific use case
- */
-export function createPager(options = {}) {
-    return new Pager(options);
-}
-/**
- * Simple pagination without interactivity - just fetches all results up to a limit
- */
-export async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
-    const pageSize = Math.min(maxResults, 50); // Reasonable page size
-    const allItems = [];
-    let offset = 0;
-    while (allItems.length < maxResults) {
-        const remainingItems = maxResults - allItems.length;
-        const currentPageSize = Math.min(pageSize, remainingItems);
-        const params = {
-            ...baseParams,
-            limit: currentPageSize,
-            offset,
-        };
-        const items = await fetchFunction(params);
-        if (items.length === 0) {
-            break; // No more data
-        }
-        allItems.push(...items);
-        offset += items.length;
-        // If we got fewer items than requested, we've reached the end
-        if (items.length < currentPageSize) {
-            break;
-        }
-    }
-    return allItems;
-}
-/**
- * Display helper for showing pagination status
- */
-export function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
-    if (currentCount >= requestedLimit) {
-        console.log(chalk.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
-        console.log(chalk.gray(`Use --limit to increase the limit, or add paging with --page`));
-    }
-    else {
-        console.log(chalk.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
-    }
-}

package/dist/utils/parameter-resolver.d.ts

@@ -1,13 +0,0 @@
-import { z } from "zod";
-import { ZapierSdk } from "@zapier/zapier-sdk";
-export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ZapierSdk): Promise<any>;
-    private extractParametersFromSchema;
-    private analyzeFieldSchema;
-    private createResolvableParameter;
-    private resolveParameter;
-    private getNestedValue;
-    private setNestedValue;
-    private promptForField;
-    private isUserCancellation;
-}