typescript-runtime-schemas/dist/cli/commands/list.js

A TypeScript schema generation tool that extracts Zod schemas from TypeScript source files with runtime validation support. Generate validation schemas directly from your existing TypeScript types with support for computed types and constraint-based valid

"use strict";
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.listCommand = void 0;
const commander_1 = require("commander");
const schema_extractor_1 = require("../../core/schema-extractor");
const config_1 = require("../config");
const utils_1 = require("../utils");
exports.listCommand = new commander_1.Command('list')
    .description('List types that extend SupportsRuntimeValidation')
    .argument('<input>', 'Input file or directory')
    .option('--glob <pattern>', 'File pattern to match')
    .option('--exclude <pattern>', 'File pattern to exclude')
    .option('--config <file>', 'Configuration file path')
    .option('--show-stats', 'Show detailed statistics')
    .action(async (input, options) => {
    const progress = new utils_1.ProgressIndicator();
    try {
        progress.start('Loading configuration...');
        // Load configuration
        const config = options.config
            ? await Promise.resolve().then(() => __importStar(require('../config'))).then((m) => m.loadConfig(options.config))
            : await (0, config_1.findAndLoadConfig)();
        const mergedOptions = (0, config_1.mergeConfig)(config, {
            ...options,
            input,
        });
        progress.stop('Configuration loaded');
        progress.start('Analyzing types...');
        // Get validation types
        const validationTypes = await schema_extractor_1.SchemaExtractor.getValidationTypes(input, {
            glob: mergedOptions.glob,
            exclude: mergedOptions.exclude,
        });
        progress.stop('Analysis completed');
        // Display results
        if (validationTypes.length === 0) {
            (0, utils_1.logInfo)('No types found that extend SupportsRuntimeValidation');
            return;
        }
        (0, utils_1.logInfo)(`\n🎯 Found ${validationTypes.length} types that extend SupportsRuntimeValidation:\n`);
        validationTypes.forEach((typeName, index) => {
            (0, utils_1.logInfo)(`${(index + 1).toString().padStart(3)}. ${typeName}`);
        });
        // Show detailed statistics if requested
        if (options.showStats) {
            progress.start('Gathering detailed statistics...');
            try {
                // Create a temporary extractor to get statistics
                const { project, sourceFiles } = await Promise.resolve().then(() => __importStar(require('../../core/utils/source-loader'))).then((m) => m.SourceLoader.createProject(input, {
                    glob: mergedOptions.glob,
                    exclude: mergedOptions.exclude,
                }));
                const extractor = new schema_extractor_1.SchemaExtractor(project, sourceFiles);
                const stats = await extractor.getTypeStatistics();
                progress.stop('Statistics gathered');
                (0, utils_1.logInfo)(`\n📊 Detailed Statistics:`);
                (0, utils_1.logInfo)(`   Total types found: ${stats.totalTypes}`);
                (0, utils_1.logInfo)(`   Types with validation: ${stats.typesWithSupportsRuntimeValidation}`);
                (0, utils_1.logInfo)(`   Coverage: ${((stats.typesWithSupportsRuntimeValidation / stats.totalTypes) * 100).toFixed(1)}%`);
                (0, utils_1.logInfo)(`\n📁 Types by file:`);
                Object.entries(stats.typesByFile).forEach(([file, count]) => {
                    const validationCount = stats.validationTypesByFile[file] || 0;
                    (0, utils_1.logInfo)(`   ${file}: ${count} total (${validationCount} with validation)`);
                });
            }
            catch (statsError) {
                progress.stop();
                console.warn('Warning: Could not gather detailed statistics:', statsError);
            }
        }
    }
    catch (error) {
        progress.stop();
        (0, utils_1.handleError)(error, 'Failed to list validation types');
    }
});
//# sourceMappingURL=list.js.map