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

package/README.md

@@ -31,6 +31,9 @@
 - Supports generator plugins (`plugins`) including built-in `x-typescript-type`
 - Supports binary request/response generation (`format: binary` -> `Blob`)
 - Supports opt-in generation cache and incremental writes (`--cache`, `--cachePath`, `--cacheStrategy`, `--cacheDebug`)
+- Generated services accept a `RequestExecutor` in the constructor (`request` / `requestRaw`, interceptors, `customExecutorPath` / `createExecutorAdapter`)
+- Optional output formatting via `prettierConfigPath` (explicit Prettier config file)
+- Optional batch ESLint `--fix` after generation when both `tsconfigPath` and `eslintConfigPath` are set
 
 ## Install
 

package/README.rus.md

@@ -31,6 +31,9 @@
 - Поддерживает плагины генератора (`plugins`), включая встроенный `x-typescript-type`
 - Поддерживает генерацию бинарных request/response (`format: binary` -> `Blob`)
 - Поддерживает opt-in кэш генерации и инкрементальную запись (`--cache`, `--cachePath`, `--cacheStrategy`, `--cacheDebug`)
+- Сгенерированные сервисы принимают `RequestExecutor` в конструкторе (`request` / `requestRaw`, interceptors, `customExecutorPath` / `createExecutorAdapter`)
+- Опциональное форматирование вывода через `prettierConfigPath` (явный путь к конфигу Prettier)
+- Опциональный пакетный ESLint `--fix` после генерации при указании `tsconfigPath` и `eslintConfigPath`
 
 ## Установка
 

package/dist/cli/analyzeDiff/__tests__/analyzeDiff.cli.test.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_test_1 = require("node:test");
 const LoggerMessages_1 = require("../../../common/LoggerMessages");
 const semanticDiffReportSchema_1 = require("../../../core/semanticDiff/semanticDiffReportSchema");
+const silenceLoggers_1 = require("../../../test/helpers/silenceLoggers");
 const analyzeDiff_1 = require("../analyzeDiff");
 const ciSummary_1 = require("../ciSummary");
 const repoRoot = node_path_1.default.join(__dirname, '..', '..', '..', '..');
@@ -29,6 +30,14 @@ async function runAnalyzeDiffCli(options) {
     };
 }
 (0, node_test_1.describe)('@unit: analyzeDiff cli', () => {
+    let restoreAppLogger;
+    (0, node_test_1.beforeEach)(() => {
+        restoreAppLogger = (0, silenceLoggers_1.installSilenceAppLogger)();
+    });
+    (0, node_test_1.afterEach)(() => {
+        restoreAppLogger?.();
+        restoreAppLogger = undefined;
+    });
     (0, node_test_1.test)('returns exit code 0 and skips when --input has no base source', async (t) => {
         const tempDir = createTempDir(t, 'openapi-cli-analyze-skip-');
         const reportPath = node_path_1.default.join(tempDir, 'report.json');

package/dist/cli/analyzeDiff/__tests__/analyzeDiffRenameAndInvalidRegex.test.js

@@ -7,6 +7,7 @@ const node_assert_1 = __importDefault(require("node:assert"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_test_1 = require("node:test");
+const silenceLoggers_1 = require("../../../test/helpers/silenceLoggers");
 const analyzeDiff_1 = require("../analyzeDiff");
 const writeSpec = (dir, filename, payload) => {
     const filePath = node_path_1.default.join(dir, filename);
@@ -23,6 +24,14 @@ const createTempDir = (t, prefix) => {
     return tempDir;
 };
 (0, node_test_1.describe)('@unit: analyzeDiff RENAME and invalid-regex handling', () => {
+    let restoreAppLogger;
+    (0, node_test_1.beforeEach)(() => {
+        restoreAppLogger = (0, silenceLoggers_1.installSilenceAppLogger)();
+    });
+    (0, node_test_1.afterEach)(() => {
+        restoreAppLogger?.();
+        restoreAppLogger = undefined;
+    });
     (0, node_test_1.test)('detects semantic remove/add entries for property rename-like change', async (t) => {
         const tmpDir = createTempDir(t, 'openapi-diff-rename-');
         const reportPath = node_path_1.default.join(tmpDir, 'report.json');

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.js

@@ -7,6 +7,7 @@ const node_assert_1 = __importDefault(require("node:assert"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_test_1 = require("node:test");
+const silenceLoggers_1 = require("../../../test/helpers/silenceLoggers");
 const analyzeDiff_1 = require("../analyzeDiff");
 const writeSpec = (dir, filename, payload) => {
     const filePath = node_path_1.default.join(dir, filename);
@@ -23,6 +24,14 @@ const createTempDir = (t, prefix) => {
     return tempDir;
 };
 (0, node_test_1.describe)('@unit: analyzeDiff TYPE_COERCION miracles', () => {
+    let restoreAppLogger;
+    (0, node_test_1.beforeEach)(() => {
+        restoreAppLogger = (0, silenceLoggers_1.installSilenceAppLogger)();
+    });
+    (0, node_test_1.afterEach)(() => {
+        restoreAppLogger?.();
+        restoreAppLogger = undefined;
+    });
     (0, node_test_1.test)('detects semantic type change for scalar property transition', async (t) => {
         const tmpDir = createTempDir(t, 'openapi-diff-test-');
         const reportPath = node_path_1.default.join(tmpDir, 'report.json');

package/dist/cli/analyzeDiff/ignoreRules.d.ts

@@ -1,10 +1,4 @@
 import type { DiffEntry, IgnoreRule } from './types';
-/**
- * Проверяет, активно ли правило игнорирования по полю `until`.
- * @param rule правило игнорирования
- * @returns true если правило активно или не содержит валидной даты
- */
-export declare const isRuleActive: (rule: IgnoreRule) => boolean;
 /**
  * Проверяет, соответствует ли запись diff правилу игнорирования.
  * Совмещает полное совпадение пути, префикс и регулярные выражения.

package/dist/cli/analyzeDiff/ignoreRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ignoreRules.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreRules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,UAAU,KAAG,OAK/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,EAAE,MAAM,UAAU,KAAG,OAkBtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,EAAE,EAAE,OAAO,UAAU,EAAE,KAAG;IAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAapH,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACjC,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,KAC/D,UAAU,EAOZ,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oBAAoB,MAAM,KAAG,UAAU,EAGtE,CAAC"}
+{"version":3,"file":"ignoreRules.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/ignoreRules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAcrD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,EAAE,MAAM,UAAU,KAAG,OAkBtE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,SAAS,EAAE,EAAE,OAAO,UAAU,EAAE,KAAG;IAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAapH,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,KAAG,UAAU,EAOnH,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oBAAoB,MAAM,KAAG,UAAU,EAGtE,CAAC"}

package/dist/cli/analyzeDiff/ignoreRules.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadIgnoreRules = exports.getIgnoreRulesFromConfig = exports.applyIgnoreRules = exports.matchesIgnoreRule = exports.isRuleActive = void 0;
+exports.loadIgnoreRules = exports.getIgnoreRulesFromConfig = exports.applyIgnoreRules = exports.matchesIgnoreRule = void 0;
 const Consts_1 = require("../../common/Consts");
 const LoggerMessages_1 = require("../../common/LoggerMessages");
 const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
@@ -17,7 +17,6 @@ const isRuleActive = (rule) => {
         return true;
     return Date.now() <= timestamp;
 };
-exports.isRuleActive = isRuleActive;
 /**
  * Проверяет, соответствует ли запись diff правилу игнорирования.
  * Совмещает полное совпадение пути, префикс и регулярные выражения.
@@ -26,7 +25,7 @@ exports.isRuleActive = isRuleActive;
  * @returns true если правило применимо к записи
  */
 const matchesIgnoreRule = (entry, rule) => {
-    if (!(0, exports.isRuleActive)(rule))
+    if (!isRuleActive(rule))
         return false;
     if (rule.path) {
         if (entry.path === rule.path)

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

@@ -0,0 +1,4 @@
+import { OptionValues } from 'commander';
+import { CLICommandResult } from '../types';
+export declare const analyzeUsage: (options: OptionValues) => Promise<CLICommandResult>;
+//# sourceMappingURL=analyzeUsage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeUsage.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeUsage/analyzeUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAO5C,eAAO,MAAM,YAAY,GAAU,SAAS,YAAY,KAAG,OAAO,CAAC,gBAAgB,CAwDlF,CAAC"}

package/dist/cli/analyzeUsage/analyzeUsage.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeUsage = void 0;
+const path_1 = __importDefault(require("path"));
+const Analyzer_1 = require("./core/Analyzer");
+const ProjectContext_1 = require("./core/ProjectContext");
+const Scanner_1 = require("./core/Scanner");
+const report_1 = require("./utils/report");
+const analyzeUsage = async (options) => {
+    try {
+        // Валидация входных данных
+        if (!options.sourcePath || !options.projectPath) {
+            console.error('❌ Error: --sourcePath (-s) and --projectPath (-p) are required.');
+            return { success: false, error: '--sourcePath (-s) and --projectPath (-p) are required.' };
+        }
+        const projectPath = path_1.default.resolve(options.projectPath);
+        const sourcePath = path_1.default.resolve(options.sourcePath);
+        const tsconfigPath = options.tsconfigPath ? path_1.default.resolve(options.tsconfigPath) : undefined;
+        console.log('🏗️  Initializing project context...');
+        const context = new ProjectContext_1.ProjectContext(projectPath, tsconfigPath);
+        // Добавляем файл генерации в проект для работы TypeChecker
+        const generatedFile = context.project.addSourceFileAtPath(sourcePath);
+        console.log('🔍 Scanning API contract...');
+        const scanner = new Scanner_1.Scanner(generatedFile);
+        const contract = scanner.scan();
+        // Инициализация объекта статистики для подсчета Coverage
+        const stats = {
+            usedMethods: new Set(),
+            usedSchemas: new Set(),
+            usedModels: new Set(),
+        };
+        console.log('🧪 Running semantic analysis...');
+        const analyzer = new Analyzer_1.Analyzer(context, contract);
+        const findings = await analyzer.run(stats);
+        // 1. Расчет покрытия API (через Reporter)
+        const coverage = report_1.Reporter.calculateCoverage(stats, contract);
+        // 2. Вывод результатов в консоль (таблица и сводка)
+        report_1.Reporter.renderConsole(findings, coverage);
+        // 3. Сохранение детального JSON-отчета
+        report_1.Reporter.saveJsonReport(options.output, findings, coverage);
+        // 4. Логика выхода для CI пайплайнов
+        if (options.check) {
+            const hasErrors = findings.some(f => f.severity === 'ERROR');
+            if (hasErrors) {
+                console.error('\n🛑 CI check failed: critical API contract mismatches were found.');
+                return { success: false, error: 'CI check failed: critical API contract mismatches were found.' };
+            }
+        }
+        console.log('\n✅ Done!');
+        return { success: true };
+    }
+    catch (error) {
+        console.error(`\n💥 Fatal error: ${error.message}`);
+        return { success: false, error: error?.message ?? String(error) };
+    }
+};
+exports.analyzeUsage = analyzeUsage;

package/dist/cli/analyzeUsage/core/Analyzer.d.ts

@@ -0,0 +1,9 @@
+import type { Contract, Finding, Stats } from '../types';
+import type { ProjectContext } from './ProjectContext';
+export declare class Analyzer {
+    private _context;
+    private _contract;
+    constructor(context: ProjectContext, contract: Contract);
+    run(stats: Stats): Promise<Finding[]>;
+}
+//# sourceMappingURL=Analyzer.d.ts.map

package/dist/cli/analyzeUsage/core/Analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyzer.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/core/Analyzer.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,qBAAa,QAAQ;IACjB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,SAAS,CAAW;gBAEhB,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ;IAKjD,GAAG,CAAC,KAAK,EAAE,KAAK;CAazB"}

package/dist/cli/analyzeUsage/core/Analyzer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Analyzer = void 0;
+const ClientRule_1 = require("../rules/ClientRule");
+const CoverageRule_1 = require("../rules/CoverageRule");
+const DiagnosticsRule_1 = require("../rules/DiagnosticsRule");
+const ImportRule_1 = require("../rules/ImportRule");
+const ModelRule_1 = require("../rules/ModelRule");
+const SchemaRule_1 = require("../rules/SchemaRule");
+const ServiceRule_1 = require("../rules/ServiceRule");
+class Analyzer {
+    _context;
+    _contract;
+    constructor(context, contract) {
+        this._context = context;
+        this._contract = contract;
+    }
+    async run(stats) {
+        const findings = [];
+        // Порядок важен: сначала собираем статистику, потом анализируем покрытие
+        const rules = [new ImportRule_1.ImportRule(), new ClientRule_1.ClientRule(), new ServiceRule_1.ServiceRule(), new SchemaRule_1.SchemaRule(), new ModelRule_1.ModelRule(), new DiagnosticsRule_1.DiagnosticsRule(), new CoverageRule_1.CoverageRule()];
+        for (const rule of rules) {
+            const results = await rule.check(this._context, this._contract, stats);
+            findings.push(...results);
+        }
+        return findings;
+    }
+}
+exports.Analyzer = Analyzer;

package/dist/cli/analyzeUsage/core/ProjectContext.d.ts

@@ -0,0 +1,10 @@
+import { Project } from 'ts-morph';
+export declare class ProjectContext {
+    readonly project: Project;
+    readonly projectPath: string;
+    constructor(projectPath: string, tsConfigPath?: string);
+    getTypeChecker(): import("ts-morph").TypeChecker;
+    getSourceFiles(): import("ts-morph").SourceFile[];
+    getConsumerSourceFiles(): import("ts-morph").SourceFile[];
+}
+//# sourceMappingURL=ProjectContext.d.ts.map

package/dist/cli/analyzeUsage/core/ProjectContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectContext.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/core/ProjectContext.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC,qBAAa,cAAc;IACvB,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,WAAW,EAAE,MAAM,CAAC;gBAExB,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM;IAwC/C,cAAc;IAId,cAAc;IAId,sBAAsB;CAIhC"}

package/dist/cli/analyzeUsage/core/ProjectContext.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectContext = void 0;
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+class ProjectContext {
+    project;
+    projectPath;
+    constructor(projectPath, tsConfigPath) {
+        this.projectPath = projectPath;
+        const options = {
+            // Очень важно для CLI:
+            skipAddingFilesFromTsConfig: false,
+        };
+        if (tsConfigPath) {
+            options.tsConfigFilePath = tsConfigPath;
+        }
+        else {
+            options.compilerOptions = {
+                allowJs: true,
+                jsx: 4, // React 17+ (react-jsx)
+                target: 99, // ESNext
+                moduleResolution: 2, // Node
+                esModuleInterop: true,
+                // БЕЗ ЭТОГО НЕ БУДЕТ ВИДЕТЬ ТИПЫ БИБЛИОТЕК:
+                skipLibCheck: true,
+                typeRoots: [path_1.default.resolve(projectPath, 'node_modules/@types')],
+                lib: ['lib.esnext.d.ts', 'lib.dom.d.ts'],
+            };
+        }
+        this.project = new ts_morph_1.Project(options);
+        // Если мы не используем tsconfig, нужно принудительно добавить файлы
+        if (!tsConfigPath) {
+            console.log('📂 Adding project files manually...');
+            this.project.addSourceFilesAtPaths([path_1.default.join(projectPath, 'src/**/*.{ts,tsx}'), '!**/node_modules/**']);
+        }
+        // ПРОВЕРКА: Проверяем, видит ли проект файлы
+        const fileCount = this.project.getSourceFiles().length;
+        console.log(`count: ${fileCount} files loaded into context.`);
+        if (fileCount === 0) {
+            throw new Error(`Project at path ${projectPath} is empty or no files were found.`);
+        }
+    }
+    getTypeChecker() {
+        return this.project.getTypeChecker();
+    }
+    getSourceFiles() {
+        return this.project.getSourceFiles();
+    }
+    getConsumerSourceFiles() {
+        const srcRoot = path_1.default.resolve(this.projectPath, 'src') + path_1.default.sep;
+        return this.project.getSourceFiles().filter(file => file.getFilePath().startsWith(srcRoot));
+    }
+}
+exports.ProjectContext = ProjectContext;

package/dist/cli/analyzeUsage/core/Scanner.d.ts

@@ -0,0 +1,15 @@
+import { SourceFile } from 'ts-morph';
+import type { Contract } from '../types';
+export declare class Scanner {
+    private generatedFile;
+    constructor(generatedFile: SourceFile);
+    scan(): Contract;
+    private extractMethodsFromDeclaration;
+    /**
+     * Разбирает метод и возвращает его метаданные.
+     * Возвращает null, если узел не является функцией (нет call-сигнатур).
+     */
+    private parseMethod;
+    private extractSchemas;
+}
+//# sourceMappingURL=Scanner.d.ts.map

package/dist/cli/analyzeUsage/core/Scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scanner.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/core/Scanner.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,UAAU,EAAc,MAAM,UAAU,CAAC;AAExD,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,UAAU,CAAC;AAEzD,qBAAa,OAAO;IACJ,OAAO,CAAC,aAAa;gBAAb,aAAa,EAAE,UAAU;IAEtC,IAAI,IAAI,QAAQ;IA4CvB,OAAO,CAAC,6BAA6B;IA0CrC;;;OAGG;IACH,OAAO,CAAC,WAAW;IAsBnB,OAAO,CAAC,cAAc;CAGzB"}

package/dist/cli/analyzeUsage/core/Scanner.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+const ts_morph_1 = require("ts-morph");
+class Scanner {
+    generatedFile;
+    constructor(generatedFile) {
+        this.generatedFile = generatedFile;
+    }
+    scan() {
+        const exports = this.generatedFile.getExportedDeclarations();
+        console.log(`DEBUG SCANNER: File exports:`, Array.from(exports.keys()));
+        // 1. Сервисы: экспорты с суффиксом "Service"
+        const services = {};
+        exports.forEach((declarations, name) => {
+            if (name.endsWith('Service')) {
+                // Объединяем методы из всех деклараций с одним именем (может быть несколько)
+                const methods = [];
+                declarations.forEach(decl => {
+                    methods.push(...this.extractMethodsFromDeclaration(decl));
+                });
+                // Если уже были методы от предыдущих итераций (для этого имени), объединяем
+                services[name] = [...(services[name] || []), ...methods];
+            }
+        });
+        // 2. Модели: типы и интерфейсы контракта (исключая сервисы и схемы)
+        const models = [];
+        exports.forEach((declarations, name) => {
+            if (name.endsWith('Service') || name.endsWith('Schema'))
+                return;
+            if (name === 'createClient')
+                return;
+            if (declarations.some(decl => ts_morph_1.Node.isTypeAliasDeclaration(decl) || ts_morph_1.Node.isInterfaceDeclaration(decl) || ts_morph_1.Node.isClassDeclaration(decl))) {
+                models.push(name);
+            }
+        });
+        // 3. Схемы: все экспорты с суффиксом Schema
+        const schemas = this.extractSchemas(exports);
+        console.log(`DEBUG SCANNER: Services found: ${Object.keys(services).length}`);
+        console.log(`DEBUG SCANNER: Models found (types/interfaces/classes): ${models.length}`);
+        console.log(`DEBUG SCANNER: Schemas found: ${schemas.length}`);
+        return {
+            services,
+            schemas,
+            models,
+            sourceFile: this.generatedFile,
+        };
+    }
+    extractMethodsFromDeclaration(decl) {
+        const methods = [];
+        // Сценарий А: Сервис объявлен как переменная с объектным литералом
+        if (ts_morph_1.Node.isVariableDeclaration(decl)) {
+            const init = decl.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (init) {
+                init.getProperties().forEach(prop => {
+                    // Обрабатываем обычные свойства
+                    if (ts_morph_1.Node.isPropertyAssignment(prop)) {
+                        const initializer = prop.getInitializer();
+                        if (initializer) {
+                            const method = this.parseMethod(prop.getName(), initializer);
+                            if (method)
+                                methods.push(method);
+                        }
+                    }
+                    // Обрабатываем короткую запись свойств (shorthand)
+                    else if (ts_morph_1.Node.isShorthandPropertyAssignment(prop)) {
+                        const method = this.parseMethod(prop.getName(), prop // у shorthand-свойства сам узел является функцией? Нужно взять значение
+                        );
+                        // Однако у ShorthandPropertyAssignment значение — это ссылка на переменную,
+                        // поэтому для получения типа нужно использовать nameNode или сам prop.
+                        // В ts-morph getType() на ShorthandPropertyAssignment даст тип функции, если она там.
+                        // Передадим весь prop как узел, parseMethod его использует.
+                        if (method)
+                            methods.push(method);
+                    }
+                });
+            }
+        }
+        // Сценарий Б: Сервис объявлен как класс
+        else if (ts_morph_1.Node.isClassDeclaration(decl)) {
+            decl.getMethods().forEach(method => {
+                const parsed = this.parseMethod(method.getName(), method);
+                if (parsed)
+                    methods.push(parsed);
+            });
+        }
+        return methods;
+    }
+    /**
+     * Разбирает метод и возвращает его метаданные.
+     * Возвращает null, если узел не является функцией (нет call-сигнатур).
+     */
+    parseMethod(name, node) {
+        const type = node.getType();
+        const signatures = type.getCallSignatures();
+        // Если сигнатур нет, это не метод (например, свойство-константа) — пропускаем
+        if (signatures.length === 0)
+            return null;
+        // У сгенерированного API обычно одна сигнатура
+        const sig = signatures[0];
+        return {
+            name,
+            params: sig?.getParameters().map(p => ({
+                name: p.getName(),
+                isOptional: p.isOptional(),
+                type: p.getTypeAtLocation(node).getText(),
+            })) || [],
+            returnType: sig?.getReturnType().getText() || 'void',
+        };
+    }
+    extractSchemas(exports) {
+        return [...exports.keys()].filter(name => name.endsWith('Schema'));
+    }
+}
+exports.Scanner = Scanner;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClientRule.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/rules/ClientRule.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,UAAW,YAAW,IAAI;IAC7B,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CA0E7F"}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRule = void 0;
+const ts_morph_1 = require("ts-morph");
+class ClientRule {
+    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]);
+                    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"}