process-openapi-specs.cjs

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

/**
 * Process OpenAPI specs by filtering out write APIs, deprecated APIs, and ignored services
 * Usage: node process-openapi-specs.cjs [input-folder] [output-folder]
 * 
 * Features:
 * - Filters out write operations (POST, PUT, PATCH, DELETE)
 * - Filters out deprecated APIs
 * - Removes host field from specs
 * - Removes externalDocs field from specs
 * - Removes x-docs field from specs
 * - Removes realm field from x-version
 * - Ignores specified services (buildinfo, challenge, differ, eventlog, matchmaking, sessionbrowser, ugc)
 * - Prettifies JSON output
 */

// Default paths
const DEFAULT_INPUT_FOLDER = '../justice-codegen-sdk-spec/spec/stage_main';
const DEFAULT_OUTPUT_FOLDER = './openapi-specs';

// const FILTERED_METHODS = ['post', 'put', 'patch', 'delete'];
const FILTERED_METHODS = [];

// Services to be ignored during processing (by filename without extension)
const IGNORED_SERVICES = [
    'buildinfo',
    'challenge',
    'differ', 
    'eventlog',
    'matchmaking',
    'sessionbrowser',
    'ugc'
];

function parseArguments() {
    const args = process.argv.slice(2);
    const inputFolder = args[0] || DEFAULT_INPUT_FOLDER;
    const outputFolder = args[1] || DEFAULT_OUTPUT_FOLDER;
    
    return { inputFolder, outputFolder };
}

function ensureDirectoryExists(dirPath) {
    if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
        console.log(`Created directory: ${dirPath}`);
    }
}

function isJsonFile(filename) {
    return path.extname(filename).toLowerCase() === '.json';
}

function shouldIgnoreFile(filename) {
    const baseName = path.basename(filename, '.json').toLowerCase();
    return IGNORED_SERVICES.includes(baseName);
}

function filterPaths(paths) {
    const filteredPaths = {};
    
    for (const [pathKey, pathValue] of Object.entries(paths)) {
        const filteredMethods = {};
        let hasValidMethods = false;
        
        for (const [method, methodValue] of Object.entries(pathValue)) {
            // Skip write methods
            if (FILTERED_METHODS.includes(method.toLowerCase())) {
                console.log(`  Filtered out ${method.toUpperCase()} ${pathKey}`);
                continue;
            }
            
            // Skip deprecated APIs
            if (methodValue && methodValue.deprecated === true) {
                console.log(`  Filtered out ${method.toUpperCase()} ${pathKey} (deprecated)`);
                continue;
            }
            
            // Keep this method
            filteredMethods[method] = methodValue;
            hasValidMethods = true;
        }
        
        // Only include the path if it has valid methods
        if (hasValidMethods) {
            filteredPaths[pathKey] = filteredMethods;
        }
    }
    
    return filteredPaths;
}

function processOpenApiSpec(inputPath, outputPath) {
    try {
        console.log(`Processing: ${inputPath}`);
        
        // Read and parse JSON
        const rawData = fs.readFileSync(inputPath, 'utf8');
        const spec = JSON.parse(rawData);
        
        // Track original counts
        const originalPathCount = spec.paths ? Object.keys(spec.paths).length : 0;
        let originalMethodCount = 0;
        
        if (spec.paths) {
            for (const pathMethods of Object.values(spec.paths)) {
                originalMethodCount += Object.keys(pathMethods).length;
            }
        }
        
        // Filter paths
        if (spec.paths) {
            spec.paths = filterPaths(spec.paths);
        }
        
        // Remove host field if it exists
        if (spec.host) {
            delete spec.host;
            console.log('  Removed top-level host field');
        }
        
        // Remove externalDocs field if it exists
        if (spec.externalDocs) {
            delete spec.externalDocs;
            console.log('  Removed externalDocs field');
        }
        
        // Remove x-docs field if it exists
        if (spec['x-docs']) {
            delete spec['x-docs'];
            console.log('  Removed x-docs field');
        }
        
        // Remove realm field from x-version if it exists
        if (spec['x-version'] && spec['x-version'].realm) {
            delete spec['x-version'].realm;
            console.log('  Removed realm field from x-version');
        }
        
        // Calculate filtered counts
        const filteredPathCount = spec.paths ? Object.keys(spec.paths).length : 0;
        let filteredMethodCount = 0;
        
        if (spec.paths) {
            for (const pathMethods of Object.values(spec.paths)) {
                filteredMethodCount += Object.keys(pathMethods).length;
            }
        }
        
        // Prettify and write JSON
        const prettyJson = JSON.stringify(spec, null, 2);
        fs.writeFileSync(outputPath, prettyJson, 'utf8');
        
        console.log(`  ✓ Processed: ${path.basename(inputPath)}`);
        console.log(`    Paths: ${originalPathCount} → ${filteredPathCount}`);
        console.log(`    Methods: ${originalMethodCount} → ${filteredMethodCount}`);
        console.log(`    Output: ${outputPath}`);
        console.log('');
        
        return {
            originalPaths: originalPathCount,
            filteredPaths: filteredPathCount,
            originalMethods: originalMethodCount,
            filteredMethods: filteredMethodCount
        };
        
    } catch (error) {
        console.error(`Error processing ${inputPath}:`, error.message);
        return null;
    }
}

function main() {
    const { inputFolder, outputFolder } = parseArguments();
    
    console.log('OpenAPI Spec Processor');
    console.log('=====================');
    console.log(`Input folder: ${path.resolve(inputFolder)}`);
    console.log(`Output folder: ${path.resolve(outputFolder)}`);
    console.log('');
    
    // Check if input folder exists
    if (!fs.existsSync(inputFolder)) {
        console.error(`Error: Input folder does not exist: ${inputFolder}`);
        process.exit(1);
    }
    
    // Ensure output directory exists
    ensureDirectoryExists(outputFolder);
    
    // Get all JSON files in input folder
    const files = fs.readdirSync(inputFolder);
    const allJsonFiles = files.filter(isJsonFile);
    const jsonFiles = allJsonFiles.filter(file => !shouldIgnoreFile(file));
    const ignoredFiles = allJsonFiles.filter(shouldIgnoreFile);
    
    if (allJsonFiles.length === 0) {
        console.log('No JSON files found in input folder.');
        return;
    }
    
    console.log(`Found ${allJsonFiles.length} JSON file(s), processing ${jsonFiles.length}:`);
    jsonFiles.forEach(file => console.log(`  - ${file}`));
    
    if (ignoredFiles.length > 0) {
        console.log(`\nIgnored ${ignoredFiles.length} file(s):`);
        ignoredFiles.forEach(file => console.log(`  - ${file} (ignored service)`));
    }
    console.log('');
    
    // Process each JSON file
    const results = [];
    let totalOriginalPaths = 0;
    let totalFilteredPaths = 0;
    let totalOriginalMethods = 0;
    let totalFilteredMethods = 0;
    
    for (const file of jsonFiles) {
        const inputPath = path.join(inputFolder, file);
        const outputPath = path.join(outputFolder, file);
        
        const result = processOpenApiSpec(inputPath, outputPath);
        if (result) {
            results.push({ file, ...result });
            totalOriginalPaths += result.originalPaths;
            totalFilteredPaths += result.filteredPaths;
            totalOriginalMethods += result.originalMethods;
            totalFilteredMethods += result.filteredMethods;
        }
    }
    
    // Summary
    console.log('Processing Summary');
    console.log('==================');
    console.log(`Files found: ${allJsonFiles.length}`);
    console.log(`Files ignored: ${ignoredFiles.length} (${IGNORED_SERVICES.join(', ')})`);
    console.log(`Files processed: ${results.length}/${jsonFiles.length}`);
    console.log(`Total paths: ${totalOriginalPaths} → ${totalFilteredPaths} (${totalOriginalPaths - totalFilteredPaths} removed)`);
    console.log(`Total methods: ${totalOriginalMethods} → ${totalFilteredMethods} (${totalOriginalMethods - totalFilteredMethods} removed)`);
    console.log('');
    console.log('Filtering criteria:');
    console.log(`  - Ignored services: ${IGNORED_SERVICES.join(', ')}`);
    console.log(`  - Removed filtered methods: ${FILTERED_METHODS.join(', ').toUpperCase()}`);
    console.log('  - Removed deprecated APIs');
    console.log('');
    console.log('✓ Processing complete!');
}

if (require.main === module) {
    main();
}

module.exports = {
    processOpenApiSpec,
    filterPaths,
    shouldIgnoreFile,
    FILTERED_METHODS,
    IGNORED_SERVICES
};