@zapier/zapier-sdk-cli 0.0.1

package/dist/utils/cli-generator.js

@@ -0,0 +1,414 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCLICommands = generateCLICommands;
+exports.enhanceCommandHelp = enhanceCommandHelp;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../actions-sdk/dist/schemas");
+const parameter_resolver_1 = require("./parameter-resolver");
+const pager_1 = require("./pager");
+const schema_formatter_1 = require("./schema-formatter");
+const chalk_1 = __importDefault(require("chalk"));
+const util_1 = __importDefault(require("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_1.default.green("✅ Action completed successfully!\n"));
+    }
+    // Use util.inspect for colored output
+    console.log(util_1.default.inspect(data, { colors: true, depth: null, breakLength: 80 }));
+}
+// ============================================================================
+// Schema Analysis
+// ============================================================================
+function analyzeZodSchema(schema) {
+    const parameters = [];
+    if (schema instanceof zod_1.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 zod_1.z.ZodOptional) {
+        required = false;
+        baseSchema = baseSchema._def.innerType;
+    }
+    if (baseSchema instanceof zod_1.z.ZodDefault) {
+        required = false;
+        defaultValue = baseSchema._def.defaultValue();
+        baseSchema = baseSchema._def.innerType;
+    }
+    // Determine parameter type
+    let paramType = "string";
+    let choices;
+    if (baseSchema instanceof zod_1.z.ZodString) {
+        paramType = "string";
+    }
+    else if (baseSchema instanceof zod_1.z.ZodNumber) {
+        paramType = "number";
+    }
+    else if (baseSchema instanceof zod_1.z.ZodBoolean) {
+        paramType = "boolean";
+    }
+    else if (baseSchema instanceof zod_1.z.ZodArray) {
+        paramType = "array";
+    }
+    else if (baseSchema instanceof zod_1.z.ZodEnum) {
+        paramType = "string";
+        choices = baseSchema._def.values;
+    }
+    else if (baseSchema instanceof zod_1.z.ZodRecord) {
+        // Handle Record<string, any> as JSON string input
+        paramType = "string";
+    }
+    // Extract resolver metadata
+    const resolverMeta = schema._def.resolverMeta;
+    return {
+        name,
+        type: paramType,
+        required,
+        description: schema.description,
+        default: defaultValue,
+        choices,
+        resolverMeta,
+    };
+}
+// ============================================================================
+// CLI Command Generation
+// ============================================================================
+function generateCLICommands(program, sdk) {
+    // Check if SDKSchemas is available
+    if (!schemas_1.SDKSchemas) {
+        console.error("SDKSchemas not available");
+        return;
+    }
+    // Generate namespace commands (apps, actions, auths, fields)
+    Object.entries(schemas_1.SDKSchemas).forEach(([namespace, methods]) => {
+        if (namespace === "generate" || namespace === "bundle") {
+            // Handle root tools separately
+            return;
+        }
+        const namespaceCommand = program
+            .command(namespace)
+            .description(`${namespace} management commands`);
+        if (typeof methods === "object" && methods !== null) {
+            Object.entries(methods).forEach(([method, schema]) => {
+                const config = createCommandConfig(namespace, method, schema, sdk);
+                addSubCommand(namespaceCommand, method, config);
+            });
+        }
+    });
+    // Generate root tool commands
+    if (schemas_1.SDKSchemas.generate) {
+        const generateConfig = createCommandConfig("", "generate", schemas_1.SDKSchemas.generate, sdk);
+        addSubCommand(program, "generate", generateConfig);
+    }
+    if (schemas_1.SDKSchemas.bundle) {
+        const bundleConfig = createCommandConfig("", "bundle", schemas_1.SDKSchemas.bundle, sdk);
+        addSubCommand(program, "bundle", bundleConfig);
+    }
+}
+function createCommandConfig(namespace, method, schema, sdk) {
+    const parameters = analyzeZodSchema(schema);
+    const description = schema.description || `${namespace} ${method} command`;
+    const handler = async (...args) => {
+        try {
+            // The last argument is always the command object with parsed options
+            const command = args[args.length - 1];
+            const options = command.opts();
+            // Check if this is a list command with pagination support
+            const isListCommand = method === "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);
+            // NEW: Resolve missing parameters interactively using schema metadata
+            const resolver = new parameter_resolver_1.SchemaParameterResolver();
+            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
+            if (shouldUsePaging && !shouldUseJSON) {
+                // Use interactive paging for list commands
+                await handlePaginatedList(namespace, method, resolvedParams, sdk);
+            }
+            else {
+                // Call the appropriate SDK method with complete, validated parameters
+                let result;
+                if (namespace === "") {
+                    // Root tool (generate, bundle)
+                    result = await sdk[method](resolvedParams);
+                }
+                else {
+                    // Regular namespace method
+                    result = await sdk[namespace][method](resolvedParams);
+                }
+                // Special handling for generate and bundle commands - don't output to console if writing to file
+                const isRootCommandWithOutput = namespace === "" && (method === "generate" || method === "bundle");
+                const hasOutputFile = isRootCommandWithOutput && 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(namespace, result, resolvedParams.limit, hasUserSpecifiedLimit, shouldUseJSON);
+                }
+                else if (hasOutputFile) {
+                    // Show success message for file output instead of printing generated content
+                    console.log(chalk_1.default.green(`✅ ${method} completed successfully!`));
+                    console.log(chalk_1.default.gray(`Output written to: ${resolvedParams.output}`));
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    };
+    return {
+        description,
+        parameters,
+        handler,
+    };
+}
+function addSubCommand(parentCommand, name, config) {
+    const command = parentCommand.command(name).description(config.description);
+    // Add parameters to command
+    config.parameters.forEach((param) => {
+        if (param.resolverMeta?.resolver && param.required) {
+            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
+            command.argument(`[${param.name}]`, param.description || `${param.name} parameter`);
+        }
+        else if (param.required) {
+            // Required parameters without resolvers become required positional arguments
+            command.argument(`<${param.name}>`, param.description || `${param.name} parameter`);
+        }
+        else {
+            // Optional parameters become flags (whether they have resolvers or not)
+            const flags = [
+                `--${param.name.replace(/([A-Z])/g, "-$1").toLowerCase()}`,
+            ];
+            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 only, whether they have resolvers or not)
+    let argIndex = 0;
+    parameters.forEach((param) => {
+        if (param.required && argIndex < positionalArgs.length) {
+            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(namespace, method, baseParams, sdk) {
+    const limit = baseParams.limit || 20;
+    const itemName = getItemName(namespace);
+    console.log(chalk_1.default.blue(`📋 Fetching ${itemName}...`));
+    const pager = (0, pager_1.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_1.default.blue(`📋 ${getListTitle(namespace)}\n`));
+        if (items.length === 0) {
+            console.log(chalk_1.default.yellow(`No ${itemName} found.`));
+            return;
+        }
+        // Get the schema for this namespace/method to extract formatting info
+        const schema = schemas_1.SDKSchemas[namespace];
+        const listSchema = schema && typeof schema === "object" && "list" in schema
+            ? schema.list
+            : null;
+        if (listSchema) {
+            (0, schema_formatter_1.formatItemsFromSchema)(listSchema, items);
+        }
+        else {
+            // Fallback to generic formatting
+            formatItemsGeneric(items);
+        }
+        const totalInfo = totalAvailable
+            ? ` of ${totalAvailable.toLocaleString()} total`
+            : "";
+        console.log(chalk_1.default.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`));
+    };
+    await pager.paginate((params) => sdk[namespace][method]({
+        ...baseParams,
+        ...params,
+    }), {}, displayFunction);
+}
+function formatNonPaginatedResults(namespace, result, requestedLimit, userSpecifiedLimit, useRawJSON) {
+    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 = getItemName(namespace);
+    if (result.length === 0) {
+        console.log(chalk_1.default.yellow(`No ${itemName} found.`));
+        return;
+    }
+    console.log(chalk_1.default.green(`\n✅ Found ${result.length} ${itemName}:\n`));
+    // Get the schema for this namespace/method to extract formatting info
+    const schema = schemas_1.SDKSchemas[namespace];
+    const listSchema = schema && typeof schema === "object" && "list" in schema
+        ? schema.list
+        : null;
+    if (listSchema) {
+        (0, schema_formatter_1.formatItemsFromSchema)(listSchema, result);
+    }
+    else {
+        // Fallback to generic formatting
+        formatItemsGeneric(result);
+    }
+    // Show appropriate status message
+    if (userSpecifiedLimit && requestedLimit) {
+        console.log(chalk_1.default.gray(`\n📄 Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`));
+    }
+    else {
+        console.log(chalk_1.default.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_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(name)}`);
+        if (item.description) {
+            console.log(`   ${chalk_1.default.dim(item.description)}`);
+        }
+        console.log();
+    });
+}
+function getItemName(namespace) {
+    switch (namespace) {
+        case "apps":
+            return "apps";
+        case "actions":
+            return "actions";
+        case "auths":
+            return "authentications";
+        case "fields":
+            return "fields";
+        default:
+            return "items";
+    }
+}
+function getListTitle(namespace) {
+    switch (namespace) {
+        case "apps":
+            return "Available Apps";
+        case "actions":
+            return "Available Actions";
+        case "auths":
+            return "Available Authentications";
+        case "fields":
+            return "Available Fields";
+        default:
+            return "Available Items";
+    }
+}
+// ============================================================================
+// Help Text Enhancement
+// ============================================================================
+function enhanceCommandHelp(program) {
+    // Add custom help that shows schema-driven nature
+    program.on("--help", () => {
+        console.log("");
+        console.log("Commands are automatically generated from SDK schemas.");
+        console.log("Each command maps directly to an SDK method with the same parameters.");
+        console.log("");
+        console.log("Examples:");
+        console.log("  zapier-sdk apps list --category=productivity --limit=10");
+        console.log('  zapier-sdk actions run slack search user_by_email --inputs=\'{"email":"user@example.com"}\'');
+        console.log("  zapier-sdk generate my-app --output=./generated/");
+        console.log("  zsdk apps list --limit=5  # Using the shorter alias");
+        console.log("");
+    });
+}

package/dist/utils/pager.d.ts

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pager = void 0;
+exports.createPager = createPager;
+exports.fetchAllPages = fetchAllPages;
+exports.showPaginationStatus = showPaginationStatus;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Generic pager that handles pagination for any data source
+ * Supports interactive "load more" functionality
+ */
+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_1.default.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;
+    }
+}
+exports.Pager = Pager;
+/**
+ * Convenience function to create a pager for a specific use case
+ */
+function createPager(options = {}) {
+    return new Pager(options);
+}
+/**
+ * Simple pagination without interactivity - just fetches all results up to a limit
+ */
+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
+ */
+function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
+    if (currentCount >= requestedLimit) {
+        console.log(chalk_1.default.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
+        console.log(chalk_1.default.gray(`Use --limit to increase the limit, or add paging with --page`));
+    }
+    else {
+        console.log(chalk_1.default.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
+    }
+}

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { ActionsSDK } from "@zapier/actions-sdk";
+export declare class SchemaParameterResolver {
+    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ActionsSDK): Promise<any>;
+    private findAllResolvableParameters;
+    private findResolvableParameters;
+    private analyzeSchema;
+    private analyzeSchemaField;
+    private sortByDependencies;
+    private resolveParameter;
+    private promptStaticInput;
+    private resolveDynamicParameter;
+    private resolveFieldsParameter;
+    private promptForField;
+    private getNestedValue;
+    private setNestedValue;
+    private isUserCancellation;
+}