graphql-lint-clint-platform/dist/clintAnalyzer-new.js

GraphQL unused fields linter for Clint platform - Custom patterns and actions.graphql support

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ClintUsageAnalyzer = void 0;
const fs_1 = __importDefault(require("fs"));
const glob_1 = require("glob");
class ClintUsageAnalyzer {
    async analyzeUsageInPath(targetPath, actions, results, includePatterns, excludePatterns) {
        // Encontrar arquivos para analisar
        const files = await this.findFilesToAnalyze(targetPath, includePatterns, excludePatterns);
        // Para cada action, verificar se está sendo usada
        for (const action of actions) {
            const usageResult = {
                ...action,
                used: false,
                usageLocations: []
            };
            // Procurar uso da action nos arquivos
            for (const file of files) {
                const usages = await this.findUsageInFile(file, action.pattern);
                if (usages.length > 0) {
                    usageResult.used = true;
                    usageResult.usageLocations.push(...usages);
                }
            }
            results.push(usageResult);
        }
    }
    async findFilesToAnalyze(targetPath, includePatterns, excludePatterns) {
        const stats = fs_1.default.statSync(targetPath);
        if (stats.isFile()) {
            return [targetPath];
        }
        // Buscar arquivos TypeScript/JavaScript 
        const tsFiles = await (0, glob_1.glob)("**/*.{ts,tsx,js,jsx}", {
            cwd: targetPath,
            ignore: excludePatterns,
            absolute: true
        });
        return tsFiles;
    }
    async findUsageInFile(filePath, pattern) {
        try {
            const content = fs_1.default.readFileSync(filePath, 'utf-8');
            const lines = content.split('\n');
            const usages = [];
            for (let i = 0; i < lines.length; i++) {
                const line = lines[i];
                const lineNumber = i + 1;
                // Procurar pelo padrão clint.entity.method
                if (line.includes(pattern)) {
                    usages.push({
                        file: filePath,
                        line: lineNumber,
                        code: line.trim()
                    });
                }
            }
            return usages;
        }
        catch (error) {
            console.warn(`⚠️  Erro ao analisar arquivo ${filePath}:`, error);
            return [];
        }
    }
    /**
     * Analisa uso de actions customizadas da Clint no código
     * Detecta padrões como: clint.owner.getName, clint.user.createAccount
     */
    analyzeClintUsage(sourceCode, filePath) {
        const usages = [];
        const lines = sourceCode.split('\n');
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];
            const lineNumber = i + 1;
            // Detectar padrões clint.*.* 
            const clintMatches = line.matchAll(/clint\.([a-zA-Z_]+)\.([a-zA-Z_]+)/g);
            for (const match of clintMatches) {
                const fullPattern = match[0]; // clint.owner.getName
                const column = match.index || 0;
                usages.push({
                    pattern: fullPattern,
                    line: lineNumber,
                    column: column
                });
            }
        }
        return usages;
    }
    /**
     * Mapeia uso de padrões Clint para actions do Hasura
     */
    mapClintUsageToActions(clintUsages) {
        return clintUsages.map(usage => ({
            actionName: this.clintPatternToAction(usage.pattern),
            line: usage.line,
            column: usage.column
        }));
    }
    /**
     * Converte padrão Clint para nome de action do Hasura
     * Exemplo: clint.owner.getName -> owner_get_name
     */
    clintPatternToAction(pattern) {
        const match = pattern.match(/^clint\.([^.]+)\.([^.]+)$/);
        if (!match) {
            return pattern.replace('clint.', '');
        }
        const [, entity, method] = match;
        // Converter camelCase para snake_case
        const actionPart = method.replace(/([A-Z])/g, '_$1').toLowerCase();
        return `${entity}_${actionPart}`;
    }
}
exports.ClintUsageAnalyzer = ClintUsageAnalyzer;
//# sourceMappingURL=clintAnalyzer-new.js.map