@zapier/zapier-sdk-cli 0.0.2 → 0.1.0

package/dist/utils/schema-generator.js

@@ -1,389 +0,0 @@
-"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("@zapier/actions-sdk/dist/schemas");
-const parameter_resolver_1 = require("./parameter-resolver");
-const pager_1 = require("./pager");
-const chalk_1 = __importDefault(require("chalk"));
-// ============================================================================
-// 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)) {
-                    console.log(JSON.stringify(result, null, 2));
-                }
-                else if (!hasOutputFile) {
-                    // Format list results nicely (non-paginated)
-                    formatNonPaginatedResults(namespace, result, resolvedParams.limit, hasUserSpecifiedLimit);
-                }
-                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);
-    // Check if this is a list command that should have pagination options
-    const isListCommand = name === 'list';
-    const hasPaginationParams = config.parameters.some(p => p.name === 'limit' || p.name === 'offset');
-    // 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 list commands
-    if (isListCommand) {
-        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) => {
-        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;
-        }
-        formatItems(namespace, 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) {
-    if (!Array.isArray(result)) {
-        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`));
-    formatItems(namespace, 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 formatItems(namespace, items) {
-    switch (namespace) {
-        case 'apps':
-            items.forEach((app, index) => {
-                console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(app.name || app.key)} ${chalk_1.default.gray(`(${app.key})`)}`);
-                if (app.description) {
-                    console.log(`   ${chalk_1.default.dim(app.description)}`);
-                }
-                if (app.category) {
-                    console.log(`   ${chalk_1.default.magenta(`Category: ${app.category}`)}`);
-                }
-                console.log();
-            });
-            break;
-        case 'actions':
-            items.forEach((action, index) => {
-                console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(action.name || action.key)} ${chalk_1.default.gray(`(${action.key})`)}`);
-                console.log(`   ${chalk_1.default.magenta(`Type: ${action.type}`)}`);
-                if (action.appKey) {
-                    console.log(`   ${chalk_1.default.blue(`App: ${action.appKey}`)}`);
-                }
-                if (action.description) {
-                    console.log(`   ${chalk_1.default.dim(action.description)}`);
-                }
-                console.log();
-            });
-            break;
-        case 'auths':
-            items.forEach((auth, index) => {
-                const title = auth.title || auth.label || `Authentication ${auth.id}`;
-                console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(title)} ${chalk_1.default.gray(`(ID: ${auth.id})`)}`);
-                if (auth.identifier) {
-                    console.log(`    ${chalk_1.default.magenta(`Identifier: ${auth.identifier}`)}`);
-                }
-                if (auth.label && auth.title && auth.label !== auth.title) {
-                    console.log(`    ${chalk_1.default.blue(`Label: ${auth.label}`)}`);
-                }
-                console.log(`    ${chalk_1.default.dim(`Account: ${auth.account_id} | Private: ${auth.is_private} | Shared: ${auth.shared_with_all}`)}`);
-                if (auth.marked_stale_at) {
-                    console.log(`    ${chalk_1.default.red(`⚠️  Marked stale: ${new Date(auth.marked_stale_at).toLocaleDateString()}`)}`);
-                }
-                console.log();
-            });
-            break;
-        default:
-            // Generic formatting for unknown types
-            items.forEach((item, index) => {
-                console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(item.name || item.key || item.id || 'Item')}`);
-                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 apps list --category=productivity --limit=10');
-        console.log('  zapier actions run slack search user_by_email --inputs=\'{"email":"user@example.com"}\'');
-        console.log('  zapier generate my-app --output=./generated/');
-        console.log('');
-    });
-}