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

package/dist/cli/analyzeDiff/miracles.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeConfidence = exports.descriptionSimilarityBonus = exports.normalizeScalarType = exports.getTypeSignature = exports.normalizeName = void 0;
+const camelcase_1 = __importDefault(require("camelcase"));
+const leven_1 = __importDefault(require("leven"));
+/**
+ * Нормализует строковое имя (удаляет спецсимволы, приводит к camelCase и lower-case).
+ * @param value исходная строка
+ * @returns нормализованное имя
+ */
+const normalizeName = (value) => {
+    const clean = value.replace(/[^a-zA-Z0-9]+/g, ' ').trim();
+    if (!clean) {
+        return value.toLowerCase();
+    }
+    return (0, camelcase_1.default)(clean).toLowerCase();
+};
+exports.normalizeName = normalizeName;
+/**
+ * Получает сигнатуру типа из описания свойства схемы (учитывает $ref, type, oneOf/anyOf/allOf).
+ * @param payload объект описания свойства
+ * @returns строковая сигнатура типа или undefined
+ */
+const getTypeSignature = (payload) => {
+    if (typeof payload.$ref === 'string') {
+        return `ref:${payload.$ref}`;
+    }
+    if (typeof payload.type === 'string') {
+        return String(payload.type);
+    }
+    if (Array.isArray(payload.oneOf)) {
+        return 'oneOf';
+    }
+    if (Array.isArray(payload.anyOf)) {
+        return 'anyOf';
+    }
+    if (Array.isArray(payload.allOf)) {
+        return 'allOf';
+    }
+    return undefined;
+};
+exports.getTypeSignature = getTypeSignature;
+/**
+ * Приводит разные обозначения скалярных типов к общим (number/string/boolean).
+ * @param value строковая сигнатура типа
+ * @returns нормализованный скалярный тип или undefined
+ */
+const normalizeScalarType = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === 'int' || normalized === 'integer')
+        return 'number';
+    if (normalized === 'float' || normalized === 'double')
+        return 'number';
+    if (normalized === 'string')
+        return 'string';
+    if (normalized === 'number')
+        return 'number';
+    if (normalized === 'boolean')
+        return 'boolean';
+    return undefined;
+};
+exports.normalizeScalarType = normalizeScalarType;
+/**
+ * Вычисляет бонус к confidence на основе схожести описаний свойств.
+ * @param removed описание для удалённого свойства
+ * @param added описание для добавленного свойства
+ * @returns числовой бонус (0..0.05)
+ */
+const descriptionSimilarityBonus = (removed, added) => {
+    if (!removed || !added)
+        return 0;
+    const a = (0, exports.normalizeName)(removed);
+    const b = (0, exports.normalizeName)(added);
+    if (!a || !b)
+        return 0;
+    const distance = (0, leven_1.default)(a, b);
+    const ratio = distance / Math.max(a.length, b.length);
+    return ratio <= 0.4 ? 0.05 : 0;
+};
+exports.descriptionSimilarityBonus = descriptionSimilarityBonus;
+/**
+ * Комбинирует факторы в итоговую confidence (0..1) для RENAME эвристики.
+ * @param nameRatio нормализованное расстояние имён
+ * @param sameType флаг совпадения сигнатур типов
+ * @param onlyCandidate флаг единственного кандидата
+ * @param descBonus бонус от схожести описаний
+ * @returns итоговое confidence
+ */
+const computeConfidence = (nameRatio, sameType, onlyCandidate, descBonus) => {
+    let confidence = 1 - nameRatio;
+    if (sameType)
+        confidence += 0.1;
+    if (onlyCandidate)
+        confidence += 0.05;
+    confidence += descBonus;
+    if (confidence > 1)
+        confidence = 1;
+    if (confidence < 0)
+        confidence = 0;
+    return Number(confidence.toFixed(3));
+};
+exports.computeConfidence = computeConfidence;

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

@@ -0,0 +1,5 @@
+/**
+ * Reads plugin paths from openapi config for semantic diff hooks.
+ */
+export declare function resolvePluginPaths(openapiConfig?: string): string[];
+//# sourceMappingURL=pluginPaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pluginPaths.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/pluginPaths.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE"}

package/dist/cli/analyzeDiff/pluginPaths.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePluginPaths = resolvePluginPaths;
+const convertArrayToObject_1 = require("../../common/utils/convertArrayToObject");
+const loadConfigIfExists_1 = require("../../common/utils/loadConfigIfExists");
+/**
+ * Reads plugin paths from openapi config for semantic diff hooks.
+ */
+function resolvePluginPaths(openapiConfig) {
+    const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfig);
+    const config = (0, convertArrayToObject_1.convertArrayToObject)(configData);
+    return Array.isArray(config.plugins) ? config.plugins.filter((item) => typeof item === 'string' && !!item.trim()) : [];
+}

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

@@ -0,0 +1,6 @@
+import { Context } from '../../core/Context';
+/**
+ * Creates lightweight context for OpenAPI parsing in semantic diff mode.
+ */
+export declare function createSemanticDiffContext(input: string): Context;
+//# sourceMappingURL=semanticDiffContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticDiffContext.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/semanticDiffContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAK7C;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKhE"}

package/dist/cli/analyzeDiff/semanticDiffContext.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemanticDiffContext = createSemanticDiffContext;
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const Context_1 = require("../../core/Context");
+const getOutputPaths_1 = require("../../core/utils/getOutputPaths");
+const SEMANTIC_DIFF_TMP_OUTPUT = './test/generated/.semantic-diff-tmp';
+/**
+ * Creates lightweight context for OpenAPI parsing in semantic diff mode.
+ */
+function createSemanticDiffContext(input) {
+    return new Context_1.Context({
+        input: (0, pathHelpers_1.resolveHelper)(process.cwd(), input),
+        output: (0, getOutputPaths_1.getOutputPaths)({ output: SEMANTIC_DIFF_TMP_OUTPUT }),
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { JsonValue } from './types';
+/**
+ * Извлекает содержимое файла спецификации из Git по ref и парсит его.
+ * @param ref git-реф (например, HEAD~1)
+ * @param specPath путь к спецификации в репозитории
+ * @returns распарсенная спецификация из git
+ */
+export declare const readSpecFromGit: (ref: string, specPath: string) => Promise<JsonValue>;
+//# sourceMappingURL=specParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"specParser.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/specParser.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAiCzC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAU,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,SAAS,CAYtF,CAAC"}

package/dist/cli/analyzeDiff/specParser.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSpecFromGit = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Парсит содержимое спецификации, переданное как строка. При YAML создаёт временный файл для парсинга.
+ * @param content строковое содержимое спецификации
+ * @param sourcePath исходный путь/идентификатор (используется для расширения временного файла)
+ * @returns распарсенная спецификация
+ */
+const parseSpecContent = async (content, sourcePath) => {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        throw new Error(`Specification content is empty: ${sourcePath}`);
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return JSON.parse(trimmed);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const SwaggerParser = require('@apidevtools/swagger-parser');
+    const parser = new SwaggerParser();
+    const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'openapi-diff-'));
+    const ext = path_1.default.extname(sourcePath) || '.yaml';
+    const tmpFile = path_1.default.join(tmpDir, `spec${ext}`);
+    try {
+        fs_1.default.writeFileSync(tmpFile, content, 'utf-8');
+        return await parser.parse(tmpFile);
+    }
+    finally {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    }
+};
+/**
+ * Извлекает содержимое файла спецификации из Git по ref и парсит его.
+ * @param ref git-реф (например, HEAD~1)
+ * @param specPath путь к спецификации в репозитории
+ * @returns распарсенная спецификация из git
+ */
+const readSpecFromGit = async (ref, specPath) => {
+    const relativePath = path_1.default.isAbsolute(specPath) ? path_1.default.relative(process.cwd(), specPath) : specPath;
+    const normalizedPath = path_1.default.normalize(relativePath);
+    const gitCommand = `git show ${ref}:${normalizedPath}`;
+    let content;
+    try {
+        content = (0, child_process_1.execSync)(gitCommand, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        const hint = `Failed to read '${specPath}' from git ref '${ref}'. Ensure you run this command in a git repository and the path exists at the specified ref.`;
+        throw new Error(`${hint} (${String(err)})`);
+    }
+    return parseSpecContent(content, `${ref}:${normalizedPath}`);
+};
+exports.readSpecFromGit = readSpecFromGit;

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

@@ -0,0 +1,19 @@
+export type JsonValue = unknown;
+export type DiffAction = 'added' | 'removed' | 'changed';
+export type DiffSeverity = 'breaking' | 'warning' | 'info';
+export interface DiffEntry {
+    action: DiffAction;
+    path: string;
+    from?: JsonValue;
+    to?: JsonValue;
+    severity: DiffSeverity;
+    note?: string;
+    type?: string;
+}
+export type IgnoreRule = {
+    path?: string;
+    pattern?: string;
+    reason?: string;
+    until?: string;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeDiff/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAEhC,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAEzD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE3D,MAAM,WAAW,SAAS;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/cli/analyzeDiff/types.js

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

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,23 @@
+import { SourceFile } from 'ts-morph';
+import type { Contract } from '../types';
+/** Сканер экспортов сгенерированного API-файла для построения контракта. */
+export declare class Scanner {
+    private generatedFile;
+    /**
+     * @param generatedFile сгенерированный исходный файл API
+     */
+    constructor(generatedFile: SourceFile);
+    /**
+     * Сканирует экспорты файла и собирает контракт сервисов, моделей и схем.
+     * @returns контракт сгенерированного API
+     */
+    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,4EAA4E;AAC5E,qBAAa,OAAO;IAIJ,OAAO,CAAC,aAAa;IAHjC;;OAEG;gBACiB,aAAa,EAAE,UAAU;IAE7C;;;OAGG;IACI,IAAI,IAAI,QAAQ;IA4CvB,OAAO,CAAC,6BAA6B;IA0CrC;;;OAGG;IACH,OAAO,CAAC,WAAW;IAwBnB,OAAO,CAAC,cAAc;CAGzB"}

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+const ts_morph_1 = require("ts-morph");
+/** Сканер экспортов сгенерированного API-файла для построения контракта. */
+class Scanner {
+    generatedFile;
+    /**
+     * @param generatedFile сгенерированный исходный файл API
+     */
+    constructor(generatedFile) {
+        this.generatedFile = generatedFile;
+    }
+    /**
+     * Сканирует экспорты файла и собирает контракт сервисов, моделей и схем.
+     * @returns контракт сгенерированного API
+     */
+    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(),
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                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,14 @@
+import type { ProjectContext } from '../core/ProjectContext';
+import type { Contract, Finding, Rule, Stats } from '../types';
+/** Правило проверки использования createClient и ClientOptions в потребителях API. */
+export declare class ClientRule implements Rule {
+    /**
+     * Проверяет вызовы createClient и соответствие ClientOptions.
+     * @param context контекст проекта
+     * @param contract контракт сгенерированного API
+     * @param stats накопительная статистика использования
+     * @returns список найденных проблем
+     */
+    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,sFAAsF;AACtF,qBAAa,UAAW,YAAW,IAAI;IACnC;;;;;;OAMG;IACG,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CA4E7F"}