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

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"}

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"}