ts-openapi-codegen 2.0.0 → 2.1.0-beta.10

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRule = void 0;
+const ts_morph_1 = require("ts-morph");
+/** Правило проверки использования createClient и ClientOptions в потребителях API. */
+class ClientRule {
+    /**
+     * Проверяет вызовы createClient и соответствие ClientOptions.
+     * @param context контекст проекта
+     * @param contract контракт сгенерированного API
+     * @param stats накопительная статистика использования
+     * @returns список найденных проблем
+     */
+    async check(context, contract, stats) {
+        const findings = [];
+        const checker = context.getTypeChecker();
+        const clientOptionsDecl = contract.sourceFile.getExportedDeclarations().get('ClientOptions')?.[0];
+        const expectedType = clientOptionsDecl?.getType();
+        if (!expectedType) {
+            findings.push({
+                id: 'CLIENT_OPTIONS_TYPE_NOT_FOUND',
+                category: 'CONFIG',
+                severity: 'WARNING',
+                message: 'ClientOptions type was not found in the contract. createClient argument validation is limited.',
+                file: contract.sourceFile.getFilePath(),
+                line: 0,
+            });
+        }
+        for (const file of context.getConsumerSourceFiles()) {
+            const imports = file.getImportDeclarations();
+            const createClientNames = new Set();
+            for (const imp of imports) {
+                const moduleName = imp.getModuleSpecifierValue();
+                if (moduleName !== '@lom-api' && !moduleName.startsWith('@lom-api/')) {
+                    continue;
+                }
+                for (const namedImport of imp.getNamedImports()) {
+                    if (namedImport.getName() === 'createClient') {
+                        createClientNames.add(namedImport.getAliasNode()?.getText() || 'createClient');
+                    }
+                }
+            }
+            if (createClientNames.size === 0)
+                continue;
+            const calls = file.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+            for (const call of calls) {
+                const expression = call.getExpression();
+                if (!ts_morph_1.Node.isIdentifier(expression))
+                    continue;
+                if (!createClientNames.has(expression.getText()))
+                    continue;
+                stats.usedMethods.add('createClient');
+                const args = call.getArguments();
+                if (args.length === 0)
+                    continue;
+                if (expectedType) {
+                    const providedType = checker.getTypeAtLocation(args[0]);
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    if (!providedType.isAssignableTo(expectedType)) {
+                        findings.push({
+                            id: 'CLIENT_OPTIONS_MISMATCH',
+                            category: 'TYPE_MISMATCH',
+                            severity: 'ERROR',
+                            message: 'createClient configuration object does not match ClientOptions from the generated API.',
+                            file: file.getFilePath(),
+                            line: args[0].getStartLineNumber(),
+                        });
+                    }
+                }
+            }
+        }
+        if (!stats.usedMethods.has('createClient')) {
+            findings.push({
+                id: 'CLIENT_NOT_FOUND',
+                category: 'USAGE',
+                severity: 'WARNING',
+                message: 'No createClient call from @lom-api was found in src.',
+                file: 'Global',
+                line: 0,
+            });
+        }
+        return findings;
+    }
+}
+exports.ClientRule = ClientRule;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CoverageRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/CoverageRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/D,qBAAa,YAAa,YAAW,IAAI;IACrC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAoI;IAElK,KAAK,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CAmD9F"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoverageRule = void 0;
+class CoverageRule {
+    ignoredUnusedModels = new Set(['ApiError', 'RequestConfig', 'RequestExecutor', 'TOpenAPIConfig', 'OpenAPI', 'createExecutorAdapter', 'ClientOptions']);
+    async check(_context, contract, stats) {
+        const findings = [];
+        // Проверка неиспользуемых схем
+        contract.schemas.forEach(schema => {
+            if (!stats.usedSchemas.has(schema)) {
+                findings.push({
+                    id: 'UNUSED_SCHEMA',
+                    category: 'UNUSED',
+                    severity: 'WARNING',
+                    message: `Schema "${schema}" is exported by the API but not used in the project.`,
+                    file: 'API Contract',
+                    line: 0,
+                });
+            }
+        });
+        // Проверка неиспользуемых моделей
+        contract.models.forEach(model => {
+            if (this.ignoredUnusedModels.has(model))
+                return;
+            if (!stats.usedModels.has(model)) {
+                findings.push({
+                    id: 'UNUSED_MODEL',
+                    category: 'UNUSED',
+                    severity: 'WARNING',
+                    message: `Model "${model}" is exported by the API but not used in the project.`,
+                    file: 'API Contract',
+                    line: 0,
+                });
+            }
+        });
+        // Проверка неиспользуемых методов
+        Object.entries(contract.services).forEach(([serviceName, methods]) => {
+            methods.forEach(method => {
+                const methodKey = `${serviceName}.${method.name}`;
+                if (!stats.usedMethods.has(methodKey)) {
+                    findings.push({
+                        id: 'UNUSED_METHOD',
+                        category: 'UNUSED',
+                        severity: 'WARNING',
+                        message: `Method "${methodKey}" is exported by the API but not used in the project.`,
+                        file: 'API Contract',
+                        line: 0,
+                    });
+                }
+            });
+        });
+        return findings;
+    }
+}
+exports.CoverageRule = CoverageRule;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticsRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/DiagnosticsRule.ts"],"names":[],"mappings":"AAGA,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,eAAgB,YAAW,IAAI;IAClC,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CA0D/F"}

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,15 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+/** Правило проверки вызовов методов сгенерированных сервисов в потребителях API. */
+export declare class ServiceRule implements Rule {
+    /**
+     * Проверяет вызовы методов сервисов и соответствие их сигнатурам.
+     * @param context контекст проекта
+     * @param contract контракт сгенерированного API
+     * @param stats накопительная статистика использования
+     * @returns список найденных проблем
+     */
+    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,oFAAoF;AACpF,qBAAa,WAAY,YAAW,IAAI;IACpC;;;;;;OAMG;IACG,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAgF1F,OAAO,CAAC,wBAAwB;CASnC"}

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

@@ -0,0 +1,96 @@
+"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");
+/** Правило проверки вызовов методов сгенерированных сервисов в потребителях API. */
+class ServiceRule {
+    /**
+     * Проверяет вызовы методов сервисов и соответствие их сигнатурам.
+     * @param context контекст проекта
+     * @param contract контракт сгенерированного API
+     * @param stats накопительная статистика использования
+     * @returns список найденных проблем
+     */
+    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]);
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    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"}