schemantic 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,657 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CLI interface for schemantic
+ * Provides command-line interface for generating TypeScript types and API clients
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = exports.SchemanticCli = void 0;
+const commander_1 = require("commander");
+const core_1 = require("../types/core");
+const schemantic_1 = require("../core/schemantic");
+const plugins_1 = require("../plugins");
+const builtin_1 = require("../plugins/builtin");
+const readline = __importStar(require("readline"));
+/**
+ * Main CLI class
+ */
+class SchemanticCli {
+    constructor() {
+        this.program = new commander_1.Command();
+        this.setupProgram();
+    }
+    /**
+     * Setup the CLI program
+     */
+    setupProgram() {
+        this.program
+            .name("schemantic")
+            .description("Generate TypeScript types and API clients from OpenAPI schemas")
+            .version("1.0.0")
+            .option("-i, --interactive", "Run in interactive mode")
+            .option("-v, --verbose", "Verbose output")
+            .option("-q, --quiet", "Quiet output")
+            .option("--no-color", "Disable colored output");
+        // Add commands
+        this.addGenerateCommand();
+        this.addValidateCommand();
+        this.addPluginCommand();
+        this.addInitCommand();
+        this.addHelpCommand();
+    }
+    /**
+     * Add generate command
+     */
+    addGenerateCommand() {
+        this.program
+            .command("generate [source]")
+            .alias("gen")
+            .description("Generate TypeScript types and API client from OpenAPI schema")
+            .option("-u, --url <url>", "OpenAPI schema URL")
+            .option("-f, --file <file>", "OpenAPI schema file path")
+            .option("-o, --output <dir>", "Output directory", "./src/generated")
+            .option("--types", "Generate types only")
+            .option("--client", "Generate API client only")
+            .option("--hooks", "Generate React hooks")
+            .option("--strict", "Use strict TypeScript types", true)
+            .option("--naming <convention>", "Naming convention (camelCase|snake_case|PascalCase)", "camelCase")
+            .option("--prefix <prefix>", "Type name prefix", "API")
+            .option("--suffix <suffix>", "Type name suffix", "")
+            .option("--exclude-paths <paths>", "Exclude paths (comma-separated)")
+            .option("--include-paths <paths>", "Include paths (comma-separated)")
+            .option("--exclude-schemas <schemas>", "Exclude schemas (comma-separated)")
+            .option("--include-schemas <schemas>", "Include schemas (comma-separated)")
+            .option("--plugins <plugins>", "Enable plugins (comma-separated)")
+            .option("-c, --config <file>", "Configuration file path")
+            .option("--watch", "Watch for changes and regenerate")
+            .action(async (source, options) => {
+            await this.handleGenerateCommand(source, options);
+        });
+    }
+    /**
+     * Add validate command
+     */
+    addValidateCommand() {
+        this.program
+            .command("validate [source]")
+            .alias("check")
+            .description("Validate OpenAPI schema")
+            .option("-u, --url <url>", "OpenAPI schema URL")
+            .option("-f, --file <file>", "OpenAPI schema file path")
+            .option("--fix", "Attempt to fix common issues")
+            .action(async (source, options) => {
+            await this.handleValidateCommand(source, options);
+        });
+    }
+    /**
+     * Add plugin command
+     */
+    addPluginCommand() {
+        const pluginCommand = this.program
+            .command("plugin")
+            .alias("plugins")
+            .description("Manage plugins");
+        pluginCommand
+            .command("list")
+            .alias("ls")
+            .description("List available plugins")
+            .action(async () => {
+            await this.handlePluginListCommand();
+        });
+        pluginCommand
+            .command("load <path>")
+            .description("Load plugin from file or package")
+            .action(async (path) => {
+            await this.handlePluginLoadCommand(path);
+        });
+    }
+    /**
+     * Add init command
+     */
+    addInitCommand() {
+        this.program
+            .command("init [directory]")
+            .description("Initialize a new schemantic configuration")
+            .option("-t, --template <template>", "Configuration template", "default")
+            .option("--yes", "Skip interactive prompts")
+            .action(async (directory, options) => {
+            await this.handleInitCommand(directory, options);
+        });
+    }
+    /**
+     * Add help command
+     */
+    addHelpCommand() {
+        this.program
+            .command("help [command]")
+            .description("Display help for a specific command")
+            .action((command) => {
+            this.handleHelpCommand(command);
+        });
+    }
+    /**
+     * Handle generate command
+     */
+    async handleGenerateCommand(source, options = {}) {
+        try {
+            // Check for interactive mode
+            const globalOptions = this.program.opts();
+            if (globalOptions.interactive) {
+                await this.runInteractiveMode();
+                return;
+            }
+            // Load configuration
+            const config = await this.loadConfiguration(source, options);
+            // Create Schemantic instance
+            const schemanticInstance = new schemantic_1.Schemantic(config);
+            // Load plugins
+            await this.loadPlugins(config, schemanticInstance);
+            // Generate types and client
+            const result = await schemanticInstance.generate();
+            // Output results
+            this.outputResults(result, options);
+        }
+        catch (error) {
+            this.handleError(error, options);
+        }
+    }
+    /**
+     * Handle validate command
+     */
+    async handleValidateCommand(source, options = {}) {
+        try {
+            // Load configuration
+            const config = await this.loadConfiguration(source, options);
+            // Create Schemantic instance
+            const schemanticInstance = new schemantic_1.Schemantic(config);
+            // Validate schema
+            const result = await schemanticInstance.validate();
+            // Output validation results
+            this.outputValidationResults(result, options);
+        }
+        catch (error) {
+            this.handleError(error, options);
+        }
+    }
+    /**
+     * Handle init command
+     */
+    async handleInitCommand(directory, options = {}) {
+        try {
+            const targetDir = directory || process.cwd();
+            if (options.yes) {
+                await this.createDefaultConfig(targetDir);
+            }
+            else {
+                await this.runInitInteractive(targetDir, options);
+            }
+        }
+        catch (error) {
+            this.handleError(error, options);
+        }
+    }
+    /**
+     * Handle plugin list command
+     */
+    async handlePluginListCommand() {
+        try {
+            const builtinPlugins = (0, builtin_1.getBuiltinPlugins)();
+            console.log("Built-in plugins:");
+            for (const plugin of builtinPlugins) {
+                console.log(`  ${plugin.name} (${plugin.version}) - ${plugin.description}`);
+            }
+        }
+        catch (error) {
+            this.handleError(error, {});
+        }
+    }
+    /**
+     * Handle plugin load command
+     */
+    async handlePluginLoadCommand(path) {
+        try {
+            const loader = new plugins_1.PluginLoader();
+            const plugin = await loader.loadPluginFromFile(path);
+            console.log(`Loaded plugin: ${plugin.name} (${plugin.version})`);
+            console.log(`Description: ${plugin.description}`);
+        }
+        catch (error) {
+            this.handleError(error, {});
+        }
+    }
+    /**
+     * Handle help command
+     */
+    handleHelpCommand(command) {
+        if (command) {
+            // Show help for specific command
+            const subCommand = this.program.commands.find((cmd) => cmd.name() === command);
+            if (subCommand) {
+                subCommand.help();
+            }
+            else {
+                console.log(`Unknown command: ${command}`);
+                console.log("Available commands:");
+                this.program.commands.forEach((cmd) => {
+                    console.log(`  ${cmd.name()} - ${cmd.description()}`);
+                });
+            }
+        }
+        else {
+            // Show general help with examples
+            console.log("📚 Schemantic CLI Examples:");
+            console.log("\n� Basic Usage:");
+            console.log("  # Generate from FastAPI server");
+            console.log("  npx schemantic generate --url http://localhost:8000/openapi.json");
+            console.log("\n  # Generate from local file");
+            console.log("  npx schemantic generate --file ./openapi-schema.json");
+            console.log("\n  # Custom output directory");
+            console.log("  npx schemantic generate --url http://localhost:8000/openapi.json --output ./src/api");
+            console.log("\n⚛️ React Integration:");
+            console.log("  # Generate with React hooks");
+            console.log("  npx schemantic generate --url http://localhost:8000/openapi.json --hooks");
+            console.log("\n🎛️ Interactive Mode:");
+            console.log("  npx schemantic generate --interactive");
+            console.log("\n⚙️ Configuration:");
+            console.log("  # Initialize configuration");
+            console.log("  npx schemantic init");
+            console.log("\n  # Use configuration file");
+            console.log("  npx schemantic generate --config ./Schemantic.config.json");
+            console.log("\n✅ Validation:");
+            console.log("  # Validate schema");
+            console.log("  npx schemantic validate --url http://localhost:8000/openapi.json");
+            console.log("\n� Advanced:");
+            console.log("  # Custom naming and filtering");
+            console.log("  npx schemantic generate --url http://localhost:8000/openapi.json \\");
+            console.log("    --naming PascalCase --prefix MyAPI --exclude-paths '/health,/docs'");
+            console.log("\n📖 For complete documentation:");
+            console.log("  https://github.com/Cstannahill/schemantic#readme");
+            console.log("\n💡 Get help for specific commands:");
+            console.log("  npx schemantic help generate");
+            console.log("  npx schemantic generate --help");
+        }
+    }
+    /**
+     * Load configuration from options
+     */
+    async loadConfiguration(source, options = {}) {
+        let config = { ...core_1.DEFAULT_CONFIG };
+        // Load from config file if specified
+        if (options.config) {
+            const configFile = await this.loadConfigFile(options.config);
+            config = { ...config, ...configFile };
+        }
+        // Handle source parameter (URL or file path)
+        if (source) {
+            if (source.startsWith("http://") || source.startsWith("https://")) {
+                config.schemaUrl = source;
+            }
+            else {
+                config.schemaFile = source;
+            }
+        }
+        // Override with command line options
+        if (options.url) {
+            config.schemaUrl = options.url;
+        }
+        if (options.file) {
+            config.schemaFile = options.file;
+        }
+        if (options.output) {
+            config.outputDir = options.output;
+        }
+        if (options.types) {
+            config.generateTypes = true;
+        }
+        if (options.client) {
+            config.generateApiClient = true;
+        }
+        if (options.hooks) {
+            config.generateHooks = true;
+        }
+        if (options.strict !== undefined) {
+            config.useStrictTypes = options.strict;
+        }
+        if (options.naming) {
+            config.namingConvention = options.naming;
+        }
+        if (options.prefix) {
+            config.typePrefix = options.prefix;
+        }
+        if (options.suffix) {
+            config.typeSuffix = options.suffix;
+        }
+        if (options.excludePaths) {
+            config.excludePaths = options.excludePaths.split(",");
+        }
+        if (options.includePaths) {
+            config.includePaths = options.includePaths.split(",");
+        }
+        if (options.excludeSchemas) {
+            config.excludeSchemas = options.excludeSchemas.split(",");
+        }
+        if (options.includeSchemas) {
+            config.includeSchemas = options.includeSchemas.split(",");
+        }
+        if (options.plugins) {
+            config.plugins = options.plugins.split(",").map((name) => ({
+                name: name.trim(),
+                enabled: true,
+            }));
+        }
+        // Validate required fields
+        if (!config.schemaUrl && !config.schemaFile && !config.schemaData) {
+            throw new Error("Either source parameter, --url, --file, or schema data must be provided");
+        }
+        if (!config.outputDir) {
+            throw new Error("Output directory must be specified");
+        }
+        return config;
+    }
+    /**
+     * Load configuration file
+     */
+    async loadConfigFile(filePath) {
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            const content = await fs.readFile(filePath, "utf-8");
+            if (filePath.endsWith(".json")) {
+                return JSON.parse(content);
+            }
+            else if (filePath.endsWith(".js") || filePath.endsWith(".ts")) {
+                const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
+                return module.default || module;
+            }
+            else {
+                throw new Error(`Unsupported configuration file format: ${filePath}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load configuration file ${filePath}: ${error}`);
+        }
+    }
+    /**
+     * Load plugins
+     */
+    async loadPlugins(config, Schemantic) {
+        const pluginManager = Schemantic.getPluginManager();
+        // Load built-in plugins
+        const builtinPlugins = (0, builtin_1.getBuiltinPlugins)();
+        for (const plugin of builtinPlugins) {
+            pluginManager.registerPlugin(plugin);
+        }
+        // Load configured plugins
+        if (config.plugins) {
+            for (const pluginConfig of config.plugins) {
+                if (pluginConfig.enabled) {
+                    pluginManager.enablePlugin(pluginConfig.name);
+                }
+            }
+        }
+    }
+    /**
+     * Output generation results
+     */
+    outputResults(result, options) {
+        if (options.quiet) {
+            return;
+        }
+        if (result.success) {
+            console.log("✅ Generation completed successfully!");
+            console.log(`📁 Generated ${result.generatedFiles.length} files`);
+            console.log(`📊 Statistics: ${result.statistics.totalTypes} types, ${result.statistics.totalEndpoints} endpoints`);
+            console.log(`⏱️  Generation time: ${result.statistics.generationTime}ms`);
+        }
+        else {
+            console.log("❌ Generation failed!");
+            console.log(`🚨 Errors: ${result.errors.length}`);
+            for (const error of result.errors) {
+                console.log(`  - ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Output validation results
+     */
+    outputValidationResults(result, options) {
+        if (options.quiet) {
+            return;
+        }
+        if (result.isValid) {
+            console.log("✅ Schema validation passed!");
+        }
+        else {
+            console.log("❌ Schema validation failed!");
+            console.log(`🚨 Errors: ${result.errors.length}`);
+            for (const error of result.errors) {
+                console.log(`  - ${error.message}${error.source ? ` (${error.source})` : ""}`);
+            }
+        }
+        if (result.warnings.length > 0) {
+            console.log(`⚠️  Warnings: ${result.warnings.length}`);
+            for (const warning of result.warnings) {
+                console.log(`  - ${warning.message}${warning.source ? ` (${warning.source})` : ""}`);
+            }
+        }
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error, options) {
+        if (options.quiet) {
+            process.exit(1);
+        }
+        console.error("❌ Error:", error);
+        process.exit(1);
+    }
+    /**
+     * Run interactive mode
+     */
+    async runInteractiveMode() {
+        console.log("🚀 Schemantic Interactive Mode\n");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        try {
+            const config = { ...core_1.DEFAULT_CONFIG };
+            // Get schema source
+            const schemaSource = await this.askQuestion(rl, "Enter OpenAPI schema URL or file path: ");
+            if (schemaSource.startsWith("http")) {
+                config.schemaUrl = schemaSource;
+            }
+            else {
+                config.schemaFile = schemaSource;
+            }
+            // Get output directory
+            const outputDir = await this.askQuestion(rl, "Output directory (default: ./src/generated): ");
+            config.outputDir = outputDir || "./src/generated";
+            // Get type prefix
+            const prefix = await this.askQuestion(rl, "Type prefix (default: API): ");
+            config.typePrefix = prefix || "API";
+            // Get generation options
+            const generateTypes = await this.askYesNo(rl, "Generate types? (Y/n): ");
+            config.generateTypes = generateTypes !== false;
+            const generateClient = await this.askYesNo(rl, "Generate API client? (Y/n): ");
+            config.generateApiClient = generateClient !== false;
+            const generateHooks = await this.askYesNo(rl, "Generate React hooks? (y/N): ");
+            config.generateHooks = generateHooks === true;
+            const strictTypes = await this.askYesNo(rl, "Use strict TypeScript types? (Y/n): ");
+            config.useStrictTypes = strictTypes !== false;
+            // Create Schemantic instance and generate
+            const schemanticInstance = new schemantic_1.Schemantic(config);
+            await this.loadPlugins(config, schemanticInstance);
+            console.log("\n⚙️ Generating types and API client...");
+            const result = await schemanticInstance.generate();
+            this.outputResults(result, {});
+        }
+        finally {
+            rl.close();
+        }
+    }
+    /**
+     * Run init interactive mode
+     */
+    async runInitInteractive(directory, _options) {
+        console.log("🚀 Schemantic Configuration Initialization\n");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        try {
+            const config = { ...core_1.DEFAULT_CONFIG };
+            // Get schema source
+            const schemaSource = await this.askQuestion(rl, "Enter default OpenAPI schema URL or file path: ");
+            if (schemaSource.startsWith("http")) {
+                config.schemaUrl = schemaSource;
+            }
+            else {
+                config.schemaFile = schemaSource;
+            }
+            // Get output directory
+            const outputDir = await this.askQuestion(rl, "Default output directory (default: ./src/generated): ");
+            config.outputDir = outputDir || "./src/generated";
+            // Get type prefix
+            const prefix = await this.askQuestion(rl, "Type prefix (default: API): ");
+            config.typePrefix = prefix || "API";
+            // Get naming convention
+            const naming = await this.askChoice(rl, "Naming convention (camelCase/snake_case/PascalCase): ", ["camelCase", "snake_case", "PascalCase"], "camelCase");
+            config.namingConvention = naming;
+            // Get generation options
+            const generateTypes = await this.askYesNo(rl, "Generate types by default? (Y/n): ");
+            config.generateTypes = generateTypes !== false;
+            const generateClient = await this.askYesNo(rl, "Generate API client by default? (Y/n): ");
+            config.generateApiClient = generateClient !== false;
+            const generateHooks = await this.askYesNo(rl, "Generate React hooks by default? (y/N): ");
+            config.generateHooks = generateHooks === true;
+            const strictTypes = await this.askYesNo(rl, "Use strict TypeScript types by default? (Y/n): ");
+            config.useStrictTypes = strictTypes !== false;
+            // Save configuration
+            await this.saveConfig(directory, config);
+            console.log("\n✅ Configuration saved to Schemantic.config.json");
+        }
+        finally {
+            rl.close();
+        }
+    }
+    /**
+     * Create default configuration
+     */
+    async createDefaultConfig(directory) {
+        const config = {
+            ...core_1.DEFAULT_CONFIG,
+            outputDir: "./src/generated",
+            typePrefix: "API",
+            generateTypes: true,
+            generateApiClient: true,
+            generateHooks: false,
+            useStrictTypes: true,
+            namingConvention: "camelCase",
+            typeSuffix: "",
+            generateBarrelExports: true,
+            useOptionalChaining: true,
+            useNullishCoalescing: true,
+            preserveComments: true,
+            generateIndexFile: true,
+        };
+        await this.saveConfig(directory, config);
+        console.log("✅ Default configuration created");
+    }
+    /**
+     * Save configuration to file
+     */
+    async saveConfig(directory, config) {
+        const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+        const path = await Promise.resolve().then(() => __importStar(require("path")));
+        const configPath = path.join(directory, "Schemantic.config.json");
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    /**
+     * Ask a question and return the answer
+     */
+    askQuestion(rl, question) {
+        return new Promise((resolve) => {
+            rl.question(question, resolve);
+        });
+    }
+    /**
+     * Ask a yes/no question and return boolean
+     */
+    askYesNo(rl, question) {
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                const normalized = answer.toLowerCase().trim();
+                if (normalized === "" || normalized === "y" || normalized === "yes") {
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            });
+        });
+    }
+    /**
+     * Ask a choice question and return selected option
+     */
+    askChoice(rl, question, choices, defaultChoice) {
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                const normalized = answer.toLowerCase().trim();
+                if (normalized === "") {
+                    resolve(defaultChoice);
+                }
+                else {
+                    const choice = choices.find((c) => c.toLowerCase() === normalized);
+                    resolve(choice || defaultChoice);
+                }
+            });
+        });
+    }
+    /**
+     * Run the CLI
+     */
+    run() {
+        this.program.parse();
+    }
+}
+exports.SchemanticCli = SchemanticCli;
+// Export CLI class and create instance
+exports.cli = new SchemanticCli();
+// Run CLI if this file is executed directly
+if (require.main === module) {
+    exports.cli.run();
+}
+//# sourceMappingURL=index.js.map