ts-openapi-codegen 2.1.0-beta.5 → 2.1.0-beta.7

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

@@ -0,0 +1,60 @@
+"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;IAC/B,KAAK,CACT,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,QAAQ,EAElB,MAAM,EAAE,KAAK,GACZ,OAAO,CAAC,OAAO,EAAE,CAAC;CAiDtB"}

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

@@ -0,0 +1,52 @@
+"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;IAC9B,KAAK,CACT,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,OAAO,EAAE,CAAC;CAuCtB"}

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

@@ -0,0 +1,38 @@
+"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;IAC/B,KAAK,CACT,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,OAAO,EAAE,CAAC;CAgDtB"}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/cli/analyzeUsage/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC9D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC;IAC3C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,QAAQ,EACJ,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,QAAQ,GACR,QAAQ,GACR,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED,MAAM,WAAW,KAAK;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1D;AAED,MAAM,WAAW,IAAI;IACjB,KAAK,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACxF"}

package/dist/cli/analyzeUsage/types.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../../src/cli/analyzeUsage/utils/report.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAE9D,qBAAa,QAAQ;IACnB;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IA8BzE;;OAEG;IACH,MAAM,CAAC,cAAc,CACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,cAAc,GACvB,IAAI;IAwBP;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAG,cAAc;CA0BtE"}

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

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

package/dist/cli/checkAndUpdateConfig/__tests__/checkConfig.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkConfig.test.d.ts.map

package/dist/cli/checkAndUpdateConfig/__tests__/checkConfig.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkConfig.test.d.ts","sourceRoot":"","sources":["../../../../src/cli/checkAndUpdateConfig/__tests__/checkConfig.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const Consts_1 = require("../../../common/Consts");
+const HttpClient_enum_1 = require("../../../core/types/enums/HttpClient.enum");
+const checkConfig_1 = require("../checkConfig");
+/** Config without schema-default fields so checkConfig does not open enquirer. */
+const flatConfig = {
+    input: './test/spec/v3.json',
+    output: './test/generated',
+    httpClient: HttpClient_enum_1.HttpClient.AXIOS,
+};
+async function writeConfig(dir, content) {
+    const configPath = (0, node_path_1.join)(dir, 'openapi.config.json');
+    await (0, promises_1.writeFile)(configPath, JSON.stringify(content, null, 2), 'utf8');
+    return configPath;
+}
+(0, node_test_1.describe)('@unit: checkConfig', () => {
+    (0, node_test_1.test)('returns failure when options fail schema validation', async () => {
+        const shutdownMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'shutdownLoggerAsync', async () => undefined);
+        const errorMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'error', () => undefined);
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: 123 });
+        node_assert_1.default.strictEqual(result.success, false);
+        node_assert_1.default.ok(result.error);
+        shutdownMock.mock.restore();
+        errorMock.mock.restore();
+    });
+    (0, node_test_1.test)('returns failure when config file is missing', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'check-config-'));
+        const configPath = (0, node_path_1.join)(dir, 'missing.json');
+        const shutdownMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'shutdownLoggerAsync', async () => undefined);
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: configPath });
+        node_assert_1.default.strictEqual(result.success, false);
+        node_assert_1.default.ok(result.error);
+        shutdownMock.mock.restore();
+    });
+    (0, node_test_1.test)('reports valid config without prompting when up to date', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'check-config-'));
+        const configPath = await writeConfig(dir, flatConfig);
+        const infoMock = node_test_1.mock.method(Consts_1.APP_LOGGER, 'info', () => undefined);
+        const result = await (0, checkConfig_1.checkConfig)({ openapiConfig: configPath });
+        node_assert_1.default.strictEqual(result.success, true);
+        node_assert_1.default.strictEqual(infoMock.mock.callCount(), 1);
+        infoMock.mock.restore();
+    });
+});

package/dist/cli/checkAndUpdateConfig/__tests__/updateConfig.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=updateConfig.test.d.ts.map

package/dist/cli/checkAndUpdateConfig/__tests__/updateConfig.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateConfig.test.d.ts","sourceRoot":"","sources":["../../../../src/cli/checkAndUpdateConfig/__tests__/updateConfig.test.ts"],"names":[],"mappings":""}