ts-openapi-codegen 2.1.0-beta.6 → 2.1.0-beta.8

package/dist/cli/analyzeUsage/rules/DiagnosticsRule.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticsRule = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const ts_morph_1 = require("ts-morph");
+class DiagnosticsRule {
+    async check(context, _contract, _stats) {
+        const findings = [];
+        for (const file of context.getConsumerSourceFiles()) {
+            const hasApiImport = file.getImportDeclarations().some(imp => {
+                const moduleName = imp.getModuleSpecifierValue();
+                return moduleName === '@lom-api' || moduleName.startsWith('@lom-api/');
+            });
+            if (!hasApiImport)
+                continue;
+            const diagnostics = context.project.getPreEmitDiagnostics().filter(diag => {
+                const sourceFile = diag.getSourceFile();
+                return sourceFile?.getFilePath() === file.getFilePath();
+            });
+            for (const diagnostic of diagnostics) {
+                const category = diagnostic.getCategory();
+                if (category !== ts_morph_1.ts.DiagnosticCategory.Error)
+                    continue;
+                if (diagnostic.getCode() === 2305 || diagnostic.getCode() === 2307) {
+                    // Covered by ImportRule to avoid duplicate findings for the same import issue.
+                    continue;
+                }
+                const line = diagnostic.getLineNumber() ?? 0;
+                const messageText = diagnostic.getMessageText();
+                if (typeof messageText === 'string') {
+                    findings.push({
+                        id: `TS_DIAGNOSTIC_${diagnostic.getCode()}`,
+                        category: 'TYPE_MISMATCH',
+                        severity: 'ERROR',
+                        message: String(diagnostic.getMessageText()),
+                        file: file.getFilePath(),
+                        line,
+                        context: { code: diagnostic.getCode() },
+                    });
+                }
+                else if (typeof messageText === 'object') {
+                    // For multiline messages, concatenate the text parts.
+                    const mainMessage = messageText.getMessageText();
+                    const details = messageText
+                        .getNext()
+                        ?.map(part => part.getMessageText())
+                        .join(' ') ?? '';
+                    findings.push({
+                        id: `TS_DIAGNOSTIC_${diagnostic.getCode()}`,
+                        category: 'TYPE_MISMATCH',
+                        severity: 'ERROR',
+                        message: `${mainMessage} ${details}`.trim(),
+                        file: file.getFilePath(),
+                        line,
+                        context: { code: diagnostic.getCode() },
+                    });
+                }
+            }
+        }
+        return findings;
+    }
+}
+exports.DiagnosticsRule = DiagnosticsRule;

package/dist/cli/analyzeUsage/rules/ImportRule.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+export declare class ImportRule implements Rule {
+    check(context: ProjectContext, contract: Contract, _stats: Stats): Promise<Finding[]>;
+}
+//# sourceMappingURL=ImportRule.d.ts.map

package/dist/cli/analyzeUsage/rules/ImportRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/ImportRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/D,qBAAa,UAAW,YAAW,IAAI;IAC7B,KAAK,CACP,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,QAAQ,EAElB,MAAM,EAAE,KAAK,GACd,OAAO,CAAC,OAAO,EAAE,CAAC;CA8CxB"}

package/dist/cli/analyzeUsage/rules/ImportRule.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRule = void 0;
+const fuzzy_1 = require("../utils/fuzzy");
+class ImportRule {
+    async check(context, contract, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _stats) {
+        const findings = [];
+        const rootExports = new Set(contract.sourceFile.getExportedDeclarations().keys());
+        for (const file of context.getConsumerSourceFiles()) {
+            for (const imp of file.getImportDeclarations()) {
+                const moduleName = imp.getModuleSpecifierValue();
+                if (moduleName !== '@lom-api' && !moduleName.startsWith('@lom-api/')) {
+                    continue;
+                }
+                const importedSource = imp.getModuleSpecifierSourceFile();
+                if (!importedSource) {
+                    findings.push({
+                        id: 'INVALID_IMPORT_PATH',
+                        category: 'INVALID_IMPORT',
+                        severity: 'ERROR',
+                        message: `Import "${moduleName}" could not be resolved.`,
+                        file: file.getFilePath(),
+                        line: imp.getStartLineNumber(),
+                    });
+                    continue;
+                }
+                const allowedExports = moduleName === '@lom-api' ? rootExports : new Set(importedSource.getExportedDeclarations().keys());
+                for (const namedImport of imp.getNamedImports()) {
+                    const importedName = namedImport.getName();
+                    if (allowedExports.has(importedName))
+                        continue;
+                    const suggestion = (0, fuzzy_1.findBestMatch)(importedName, [...allowedExports]);
+                    findings.push({
+                        id: 'INVALID_IMPORT_NAME',
+                        category: suggestion ? 'RENAMED_SYMBOL' : 'MISSING_EXPORT',
+                        severity: 'ERROR',
+                        message: `Import "${importedName}" is not exported by "${moduleName}".${suggestion ? ` Did you mean "${suggestion}"?` : ''}`,
+                        file: file.getFilePath(),
+                        line: namedImport.getStartLineNumber(),
+                        context: { suggestion },
+                    });
+                }
+            }
+        }
+        return findings;
+    }
+}
+exports.ImportRule = ImportRule;

package/dist/cli/analyzeUsage/rules/ModelRule.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+export declare class ModelRule implements Rule {
+    check(context: ProjectContext, contract: Contract, stats: Stats): Promise<Finding[]>;
+}
+//# sourceMappingURL=ModelRule.d.ts.map

package/dist/cli/analyzeUsage/rules/ModelRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/ModelRule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/D,qBAAa,SAAU,YAAW,IAAI;IAC5B,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CA+B7F"}

package/dist/cli/analyzeUsage/rules/ModelRule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRule = void 0;
+const ts_morph_1 = require("ts-morph");
+class ModelRule {
+    async check(context, contract, stats) {
+        const findings = [];
+        const knownModels = new Set(contract.models);
+        for (const file of context.getConsumerSourceFiles()) {
+            for (const imp of file.getImportDeclarations()) {
+                const moduleName = imp.getModuleSpecifierValue();
+                if (moduleName !== '@lom-api' && !moduleName.startsWith('@lom-api/')) {
+                    continue;
+                }
+                for (const namedImport of imp.getNamedImports()) {
+                    const importedName = namedImport.getName();
+                    if (importedName.endsWith('Schema') || importedName.endsWith('Service') || importedName === 'createClient') {
+                        continue;
+                    }
+                    const localName = namedImport.getAliasNode()?.getText() || importedName;
+                    if (!knownModels.has(importedName))
+                        continue;
+                    const identifiers = file.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier).filter(id => id.getText() === localName);
+                    const usedOutsideImport = identifiers.some(id => id.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration) == null);
+                    if (usedOutsideImport) {
+                        stats.usedModels.add(importedName);
+                    }
+                }
+            }
+        }
+        return findings;
+    }
+}
+exports.ModelRule = ModelRule;

package/dist/cli/analyzeUsage/rules/SchemaRule.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+export declare class SchemaRule implements Rule {
+    check(context: ProjectContext, contract: Contract, stats: Stats): Promise<Finding[]>;
+}
+//# sourceMappingURL=SchemaRule.d.ts.map

package/dist/cli/analyzeUsage/rules/SchemaRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/SchemaRule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/D,qBAAa,UAAW,YAAW,IAAI;IAC7B,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CA4C7F"}

package/dist/cli/analyzeUsage/rules/SchemaRule.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaRule = void 0;
+const ts_morph_1 = require("ts-morph");
+const fuzzy_1 = require("../utils/fuzzy");
+class SchemaRule {
+    async check(context, contract, stats) {
+        const findings = [];
+        const knownSchemas = new Set(contract.schemas);
+        for (const file of context.getConsumerSourceFiles()) {
+            const imports = file.getImportDeclarations();
+            for (const imp of imports) {
+                const moduleName = imp.getModuleSpecifierValue();
+                if (moduleName !== '@lom-api' && !moduleName.startsWith('@lom-api/')) {
+                    continue;
+                }
+                for (const namedImport of imp.getNamedImports()) {
+                    const importedName = namedImport.getName();
+                    if (!importedName.endsWith('Schema'))
+                        continue;
+                    const localName = namedImport.getAliasNode()?.getText() || importedName;
+                    if (!knownSchemas.has(importedName)) {
+                        const suggestion = (0, fuzzy_1.findBestMatch)(importedName, contract.schemas);
+                        findings.push({
+                            id: 'SCHEMA_NOT_FOUND',
+                            category: suggestion ? 'RENAMED_SYMBOL' : 'MISSING_EXPORT',
+                            severity: 'ERROR',
+                            message: `Schema "${importedName}" was not found in the API.${suggestion ? ` Did you mean "${suggestion}"?` : ''}`,
+                            file: file.getFilePath(),
+                            line: namedImport.getStartLineNumber(),
+                            context: { suggestion },
+                        });
+                        continue;
+                    }
+                    const identifiers = file.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier).filter(id => id.getText() === localName);
+                    const usedOutsideImport = identifiers.some(id => id.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration) == null);
+                    if (usedOutsideImport) {
+                        stats.usedSchemas.add(importedName);
+                    }
+                }
+            }
+        }
+        return findings;
+    }
+}
+exports.SchemaRule = SchemaRule;

package/dist/cli/analyzeUsage/rules/ServiceRule.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+export declare class ServiceRule implements Rule {
+    check(context: ProjectContext, contract: Contract, stats: Stats): Promise<Finding[]>;
+    private getExpectedParameterType;
+}
+//# sourceMappingURL=ServiceRule.d.ts.map

package/dist/cli/analyzeUsage/rules/ServiceRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/ServiceRule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/D,qBAAa,WAAY,YAAW,IAAI;IAC9B,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IA8E1F,OAAO,CAAC,wBAAwB;CASnC"}

package/dist/cli/analyzeUsage/rules/ServiceRule.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceRule = void 0;
+const ts_morph_1 = require("ts-morph");
+const fuzzy_1 = require("../utils/fuzzy");
+class ServiceRule {
+    async check(context, contract, stats) {
+        const findings = [];
+        const checker = context.getTypeChecker();
+        for (const file of context.getConsumerSourceFiles()) {
+            const calls = file.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+            for (const call of calls) {
+                const expression = call.getExpression();
+                if (!ts_morph_1.Node.isPropertyAccessExpression(expression))
+                    continue;
+                const serviceAccess = expression.getExpression();
+                if (!ts_morph_1.Node.isPropertyAccessExpression(serviceAccess))
+                    continue;
+                const serviceName = serviceAccess.getName();
+                const methodName = expression.getName();
+                if (!contract.services[serviceName])
+                    continue;
+                stats.usedMethods.add(`${serviceName}.${methodName}`);
+                const methodContract = contract.services[serviceName].find(m => m.name === methodName);
+                if (!methodContract) {
+                    const suggestion = (0, fuzzy_1.findBestMatch)(methodName, contract.services[serviceName].map(m => m.name));
+                    findings.push({
+                        id: 'SERVICE_METHOD_NOT_FOUND',
+                        category: suggestion ? 'RENAMED_SYMBOL' : 'MISSING_EXPORT',
+                        severity: 'ERROR',
+                        message: `Method "${serviceName}.${methodName}" was not found in the generated API.${suggestion ? ` Did you mean "${serviceName}.${suggestion}"?` : ''}`,
+                        file: file.getFilePath(),
+                        line: call.getStartLineNumber(),
+                        context: { suggestion },
+                    });
+                    continue;
+                }
+                const args = call.getArguments();
+                const serviceDecl = contract.sourceFile
+                    .getExportedDeclarations()
+                    .get(serviceName)
+                    ?.find(d => ts_morph_1.Node.isClassDeclaration(d));
+                const methodDecl = serviceDecl && ts_morph_1.Node.isClassDeclaration(serviceDecl) ? serviceDecl.getMethod(methodName) : undefined;
+                const requiredParams = methodDecl ? methodDecl.getParameters().filter(p => !p.isOptional()) : methodContract.params.filter(p => !p.isOptional);
+                if (args.length < requiredParams.length) {
+                    findings.push({
+                        id: 'SERVICE_ARGUMENTS_COUNT_MISMATCH',
+                        category: 'TYPE_MISMATCH',
+                        severity: 'ERROR',
+                        message: `Method ${serviceName}.${methodName} expects at least ${requiredParams.length} arguments, but got ${args.length}.`,
+                        file: file.getFilePath(),
+                        line: call.getStartLineNumber(),
+                    });
+                    continue;
+                }
+                for (let i = 0; i < Math.min(args.length, methodContract.params.length); i++) {
+                    const expectedType = this.getExpectedParameterType(contract, serviceName, methodName, i);
+                    if (!expectedType)
+                        continue;
+                    const providedType = checker.getTypeAtLocation(args[i]);
+                    if (!providedType.isAssignableTo(expectedType)) {
+                        findings.push({
+                            id: 'SERVICE_ARGUMENT_TYPE_MISMATCH',
+                            category: 'TYPE_MISMATCH',
+                            severity: 'ERROR',
+                            message: `Argument #${i + 1} type mismatch in ${serviceName}.${methodName}. Expected ${expectedType.getText()}, got ${providedType.getText()}.`,
+                            file: file.getFilePath(),
+                            line: args[i].getStartLineNumber(),
+                        });
+                    }
+                }
+            }
+        }
+        return findings;
+    }
+    getExpectedParameterType(contract, serviceName, methodName, paramIndex) {
+        const exportedDecl = contract.sourceFile
+            .getExportedDeclarations()
+            .get(serviceName)
+            ?.find(d => ts_morph_1.Node.isClassDeclaration(d));
+        const method = exportedDecl && ts_morph_1.Node.isClassDeclaration(exportedDecl) ? exportedDecl.getMethod(methodName) : undefined;
+        const param = method?.getParameters()[paramIndex];
+        return param?.getType();
+    }
+}
+exports.ServiceRule = ServiceRule;

package/dist/cli/analyzeUsage/types.d.ts

@@ -0,0 +1,52 @@
+import type { SourceFile } from 'ts-morph';
+import type { ProjectContext } from './core/ProjectContext';
+export interface MethodMetadata {
+    name: string;
+    params: {
+        name: string;
+        type: string;
+        isOptional: boolean;
+    }[];
+    returnType: string;
+}
+export interface Contract {
+    services: Record<string, MethodMetadata[]>;
+    schemas: string[];
+    models: string[];
+    sourceFile: SourceFile;
+}
+export interface Finding {
+    id: string;
+    severity: 'ERROR' | 'WARNING';
+    category: 'INVALID_IMPORT' | 'MISSING_EXPORT' | 'RENAMED_SYMBOL' | 'TYPE_MISMATCH' | 'UNUSED' | 'CONFIG' | 'USAGE';
+    message: string;
+    file: string;
+    line: number;
+    context?: any;
+}
+export interface Stats {
+    usedMethods: Set<string>;
+    usedSchemas: Set<string>;
+    usedModels: Set<string>;
+}
+export interface CoverageReport {
+    methods: {
+        total: number;
+        used: number;
+        percent: string;
+    };
+    schemas: {
+        total: number;
+        used: number;
+        percent: string;
+    };
+    models: {
+        total: number;
+        used: number;
+        percent: string;
+    };
+}
+export interface Rule {
+    check(context: ProjectContext, contract: Contract, stats: Stats): Promise<Finding[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cli/analyzeUsage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeUsage/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC9D,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,QAAQ;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;IAC3C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;CAC1B;AAED,MAAM,WAAW,OAAO;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,eAAe,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnH,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,GAAG,CAAC;CACjB;AAED,MAAM,WAAW,KAAK;IAClB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC3B,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,IAAI;IACjB,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACxF"}

package/dist/cli/analyzeUsage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/analyzeUsage/utils/fuzzy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ищет наиболее подходящую замену из списка доступных опций.
+ */
+export declare function findBestMatch(target: string, options: string[], threshold?: number): string | null;
+//# sourceMappingURL=fuzzy.d.ts.map

package/dist/cli/analyzeUsage/utils/fuzzy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/utils/fuzzy.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,SAAI,GAAG,MAAM,GAAG,IAAI,CAa7F"}

package/dist/cli/analyzeUsage/utils/fuzzy.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBestMatch = findBestMatch;
+/**
+ * Вычисляет расстояние Левенштейна между двумя строками.
+ */
+function getLevenshteinDistance(a, b) {
+    const matrix = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = 0; i <= a.length; i++)
+        matrix[i][0] = i;
+    for (let j = 0; j <= b.length; j++)
+        matrix[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // удаление
+            matrix[i][j - 1] + 1, // вставка
+            matrix[i - 1][j - 1] + cost // замена
+            );
+        }
+    }
+    return matrix[a.length][b.length];
+}
+/**
+ * Ищет наиболее подходящую замену из списка доступных опций.
+ */
+function findBestMatch(target, options, threshold = 3) {
+    let bestMatch = null;
+    let minDistance = Infinity;
+    for (const option of options) {
+        const distance = getLevenshteinDistance(target, option);
+        if (distance < minDistance && distance <= threshold) {
+            minDistance = distance;
+            bestMatch = option;
+        }
+    }
+    return bestMatch;
+}

package/dist/cli/analyzeUsage/utils/report.d.ts

@@ -0,0 +1,16 @@
+import type { CoverageReport, Finding, Stats } from '../types';
+export declare class Reporter {
+    /**
+     * Выводит сводную таблицу и результаты в консоль
+     */
+    static renderConsole(findings: Finding[], coverage: CoverageReport): void;
+    /**
+     * Сохраняет отчет в формате JSON для CI/CD инструментов
+     */
+    static saveJsonReport(filePath: string, findings: Finding[], coverage: CoverageReport): void;
+    /**
+     * Вычисляет процент покрытия на основе статистики
+     */
+    static calculateCoverage(stats: Stats, contract: any): CoverageReport;
+}
+//# sourceMappingURL=report.d.ts.map

package/dist/cli/analyzeUsage/utils/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/utils/report.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/D,qBAAa,QAAQ;IACjB;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAwBzE;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAwB5F;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAG,cAAc;CAyBxE"}

package/dist/cli/analyzeUsage/utils/report.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reporter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class Reporter {
+    /**
+     * Выводит сводную таблицу и результаты в консоль
+     */
+    static renderConsole(findings, coverage) {
+        console.log('\n📊 API Coverage:');
+        console.log(`   Methods: ${coverage.methods.used}/${coverage.methods.total} (${coverage.methods.percent})`);
+        console.log(`   Schemas: ${coverage.schemas.used}/${coverage.schemas.total} (${coverage.schemas.percent})`);
+        console.log(`   Models:  ${coverage.models.used}/${coverage.models.total} (${coverage.models.percent})`);
+        if (findings.length === 0) {
+            console.log('\n✅ No mismatches found. Project is in sync.');
+            return;
+        }
+        console.log('\n⚠️  Findings:');
+        // Форматируем данные для console.table
+        const tableData = findings.map(f => ({
+            Status: f.severity === 'ERROR' ? '🔴 ERROR' : '🟡 WARN',
+            Category: f.category,
+            Location: `${path_1.default.basename(f.file)}:${f.line}`,
+            Message: f.message,
+        }));
+        console.table(tableData);
+    }
+    /**
+     * Сохраняет отчет в формате JSON для CI/CD инструментов
+     */
+    static saveJsonReport(filePath, findings, coverage) {
+        const report = {
+            timestamp: new Date().toISOString(),
+            summary: {
+                totalIssues: findings.length,
+                errors: findings.filter(f => f.severity === 'ERROR').length,
+                warnings: findings.filter(f => f.severity === 'WARNING').length,
+            },
+            categories: findings.reduce((acc, finding) => {
+                acc[finding.category] = (acc[finding.category] || 0) + 1;
+                return acc;
+            }, {}),
+            coverage,
+            findings,
+        };
+        try {
+            fs_1.default.writeFileSync(filePath, JSON.stringify(report, null, 2));
+            console.log(`\n💾 Report saved: ${path_1.default.resolve(filePath)}`);
+        }
+        catch (error) {
+            console.error(`\n❌ Failed to save JSON report: ${error.message}`);
+        }
+    }
+    /**
+     * Вычисляет процент покрытия на основе статистики
+     */
+    static calculateCoverage(stats, contract) {
+        const totalMethods = Object.values(contract.services).flat().length;
+        const totalSchemas = contract.schemas.length;
+        const totalModels = contract.models.length;
+        const getPercent = (used, total) => (total > 0 ? ((used / total) * 100).toFixed(2) + '%' : '0%');
+        return {
+            methods: {
+                total: totalMethods,
+                used: stats.usedMethods.size,
+                percent: getPercent(stats.usedMethods.size, totalMethods),
+            },
+            schemas: {
+                total: totalSchemas,
+                used: stats.usedSchemas.size,
+                percent: getPercent(stats.usedSchemas.size, totalSchemas),
+            },
+            models: {
+                total: totalModels,
+                used: stats.usedModels.size,
+                percent: getPercent(stats.usedModels.size, totalModels),
+            },
+        };
+    }
+}
+exports.Reporter = Reporter;

package/dist/cli/checkAndUpdateConfig/__tests__/checkConfig.test.js

@@ -11,52 +11,42 @@ const node_test_1 = require("node:test");
 const Consts_1 = require("../../../common/Consts");
 const HttpClient_enum_1 = require("../../../core/types/enums/HttpClient.enum");
 const checkConfig_1 = require("../checkConfig");
-class ProcessExitError extends Error {
-    exitCode;
-    constructor(exitCode) {
-        super(`process.exit(${exitCode})`);
-        this.exitCode = exitCode;
-        this.name = 'ProcessExitError';
-    }
-}
 /** Config without schema-default fields so checkConfig does not open enquirer. */
 const flatConfig = {
     input: './test/spec/v3.json',
     output: './test/generated',
     httpClient: HttpClient_enum_1.HttpClient.AXIOS,
 };
-const mockProcessExit = () => node_test_1.mock.method(process, 'exit', (code) => {
-    throw new ProcessExitError(Number(code ?? 0));
-});
 async function writeConfig(dir, content) {
     const configPath = (0, node_path_1.join)(dir, 'openapi.config.json');
     await (0, promises_1.writeFile)(configPath, JSON.stringify(content, null, 2), 'utf8');
     return configPath;
 }
 (0, node_test_1.describe)('@unit: checkConfig', () => {
-    (0, node_test_1.test)('exits when options fail schema validation', async () => {
-        const exitMock = mockProcessExit();
+    (0, node_test_1.test)('returns failure when options fail schema validation', async () => {
         const shutdownMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'shutdownLoggerAsync', async () => undefined);
         const errorMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'error', () => undefined);
-        await node_assert_1.default.rejects(() => (0, checkConfig_1.checkConfig)({ openapiConfig: 123 }), ProcessExitError);
-        exitMock.mock.restore();
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: 123 });
+        node_assert_1.default.strictEqual(result.success, false);
+        node_assert_1.default.ok(result.error);
         shutdownMock.mock.restore();
         errorMock.mock.restore();
     });
-    (0, node_test_1.test)('exits when config file is missing', async () => {
+    (0, node_test_1.test)('returns failure when config file is missing', async () => {
         const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'check-config-'));
         const configPath = (0, node_path_1.join)(dir, 'missing.json');
-        const exitMock = mockProcessExit();
         const shutdownMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'shutdownLoggerAsync', async () => undefined);
-        await node_assert_1.default.rejects(() => (0, checkConfig_1.checkConfig)({ openapiConfig: configPath }), ProcessExitError);
-        exitMock.mock.restore();
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: configPath });
+        node_assert_1.default.strictEqual(result.success, false);
+        node_assert_1.default.ok(result.error);
         shutdownMock.mock.restore();
     });
     (0, node_test_1.test)('reports valid config without prompting when up to date', async () => {
         const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'check-config-'));
         const configPath = await writeConfig(dir, flatConfig);
         const infoMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'info', () => undefined);
-        await (0, checkConfig_1.checkConfig)({ openapiConfig: configPath });
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: configPath });
+        node_assert_1.default.strictEqual(result.success, true);
         node_assert_1.default.strictEqual(infoMock.mock.callCount(), 1);
         infoMock.mock.restore();
     });