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

package/dist/core/OpenApiClient.d.ts

@@ -1,13 +1,41 @@
 import { TRawOptions } from '../common/TRawOptions';
 import { WriteClient } from './WriteClient';
+/**
+ * Оркестратор генерации OpenAPI-клиента: парсинг спецификации, применение diff-отчёта и запись артефактов.
+ */
 export declare class OpenApiClient {
+    private static readonly CACHE_FINGERPRINT_VERSION;
+    private static readonly DEFAULT_CACHE_FILENAME;
     private _writeClient;
+    /** ESLint paths from top-level rawOptions (not per items[] entry). */
+    private eslintFixOptions;
+    /** Экземпляр WriteClient для записи сгенерированных файлов. */
     get writeClient(): WriteClient;
     private normalizeOptions;
     private addDefaultValues;
-    private cleanOutputDirectories;
+    private getOutputRoots;
+    private cleanupStaleOutputs;
+    private removeStaleFilesInDirectory;
     private generateCodeForItems;
+    private getUniqueResolvedOutputs;
+    private resolveOutputRoot;
+    private resolveCachePathForOutput;
+    private warnOnSharedOutputsWithoutCache;
     private generateSingle;
+    private getCacheKey;
+    private getCacheFingerprint;
+    private filesExist;
+    /**
+     * Runs batch ESLint fix after combineAndWrite / combineAndWrightSimple when both paths are set.
+     * Warns and skips when only one path is provided; always clears the WriteClient lint registry.
+     */
+    private runBatchEslintFixIfEnabled;
+    private loadDiffReportIfNeeded;
+    private applyDiffReportIfNeeded;
+    /**
+     * Запускает генерацию клиента по опциям CLI или конфигурации.
+     * @param rawOptions сырые опции генерации
+     */
     generate(rawOptions: TRawOptions): Promise<void>;
 }
 //# sourceMappingURL=OpenApiClient.d.ts.map

package/dist/core/OpenApiClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenApiClient.d.ts","sourceRoot":"","sources":["../../src/core/OpenApiClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,WAAW,EAAsB,MAAM,uBAAuB,CAAC;AAgBtF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,qBAAa,aAAa;IACtB,OAAO,CAAC,YAAY,CAA4B;IAEhD,IAAW,WAAW,gBAKrB;IAED,OAAO,CAAC,gBAAgB;IAuDxB,OAAO,CAAC,gBAAgB;YA4BV,sBAAsB;YAUtB,oBAAoB;YAmCpB,cAAc;IAwFtB,QAAQ,CAAC,UAAU,EAAE,WAAW;CAWzC"}
+{"version":3,"file":"OpenApiClient.d.ts","sourceRoot":"","sources":["../../src/core/OpenApiClient.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,WAAW,EAAsB,MAAM,uBAAuB,CAAC;AA2BtF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAK;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAiC;IAC/E,OAAO,CAAC,YAAY,CAA4B;IAChD,sEAAsE;IACtE,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,+DAA+D;IAC/D,IAAW,WAAW,gBAKrB;IAED,OAAO,CAAC,gBAAgB;IAkFxB,OAAO,CAAC,gBAAgB;IA2CxB,OAAO,CAAC,cAAc;YAaR,mBAAmB;YASnB,2BAA2B;YA+B3B,oBAAoB;IA8DlC,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,+BAA+B;YAiBzB,cAAc;IA0L5B,OAAO,CAAC,WAAW;YAaL,mBAAmB;YAiCnB,UAAU;IAUxB;;;OAGG;YACW,0BAA0B;YAwC1B,sBAAsB;IASpC,OAAO,CAAC,uBAAuB;IAe/B;;;OAGG;IACG,QAAQ,CAAC,UAAU,EAAE,WAAW;CAYzC"}

package/dist/core/OpenApiClient.js

@@ -1,24 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenApiClient = void 0;
+const fs_1 = require("fs");
 const Consts_1 = require("../common/Consts");
 const Logger_1 = require("../common/Logger");
 const LoggerMessages_1 = require("../common/LoggerMessages");
+const TEslintFixOptions_1 = require("../common/TEslintFixOptions");
+const eslintFix_1 = require("../common/utils/eslintFix");
 const fileSystemHelpers_1 = require("../common/utils/fileSystemHelpers");
 const pathHelpers_1 = require("../common/utils/pathHelpers");
 const Parser_1 = require("./api/v2/Parser");
 const Parser_2 = require("./api/v3/Parser");
 const Context_1 = require("./Context");
+const loadGovernanceConfig_1 = require("./governance/loadGovernanceConfig");
+const loadGeneratorPlugins_1 = require("./plugins/loadGeneratorPlugins");
+const validateOpenApiStrict_1 = require("./strict/validateOpenApiStrict");
 const EmptySchemaStrategy_enum_1 = require("./types/enums/EmptySchemaStrategy.enum");
+const ModelsMode_enum_1 = require("./types/enums/ModelsMode.enum");
 const ValidationLibrary_enum_1 = require("./types/enums/ValidationLibrary.enum");
+const applyDiffReportToClient_1 = require("./utils/applyDiffReportToClient");
+const GenerationCache_1 = require("./utils/GenerationCache");
 const getOpenApiSpec_1 = require("./utils/getOpenApiSpec");
 const getOpenApiVersion_1 = require("./utils/getOpenApiVersion");
 const getOutputPaths_1 = require("./utils/getOutputPaths");
+const loadDiffReport_1 = require("./utils/loadDiffReport");
 const postProcessClient_1 = require("./utils/postProcessClient");
+const prepareDtoModels_1 = require("./utils/prepareDtoModels");
 const registerHandlebarTemplates_1 = require("./utils/registerHandlebarTemplates");
+const resolveClassesModeTypes_1 = require("./utils/resolveClassesModeTypes");
 const WriteClient_1 = require("./WriteClient");
+/**
+ * Оркестратор генерации OpenAPI-клиента: парсинг спецификации, применение diff-отчёта и запись артефактов.
+ */
 class OpenApiClient {
+    static CACHE_FINGERPRINT_VERSION = 1;
+    static DEFAULT_CACHE_FILENAME = '.openapi-codegen-cache.json';
     _writeClient = null;
+    /** ESLint paths from top-level rawOptions (not per items[] entry). */
+    eslintFixOptions = {};
+    /** Экземпляр WriteClient для записи сгенерированных файлов. */
     get writeClient() {
         if (!this._writeClient) {
             throw new Error('WriteClient must be initialized');
@@ -26,12 +46,16 @@ class OpenApiClient {
         return this._writeClient;
     }
     normalizeOptions(rawOptions) {
+        const modelsMode = rawOptions.modelsMode ?? rawOptions.models?.mode;
+        const useHistory = rawOptions.useHistory ?? rawOptions.analyze?.useHistory;
+        const diffReport = rawOptions.diffReport ?? rawOptions.analyze?.reportPath;
         if (rawOptions.items && rawOptions.items.length > 0) {
             // Для items: Наследуем глобальный request, если не переопределён
             return rawOptions.items.map(item => ({
                 ...item,
                 httpClient: rawOptions.httpClient,
                 request: item.request ?? rawOptions.request, // ?? для fallback на глобальный
+                plugins: item.plugins ?? rawOptions.plugins,
                 customExecutorPath: rawOptions.customExecutorPath,
                 useOptions: rawOptions.useOptions,
                 useUnionTypes: rawOptions.useUnionTypes,
@@ -47,6 +71,17 @@ class OpenApiClient {
                 useSeparatedIndexes: rawOptions.useSeparatedIndexes,
                 validationLibrary: rawOptions.validationLibrary,
                 emptySchemaStrategy: rawOptions.emptySchemaStrategy,
+                useHistory: item.useHistory ?? useHistory,
+                diffReport: item.diffReport ?? diffReport,
+                modelsMode: item.modelsMode ?? modelsMode,
+                strictOpenapi: rawOptions.strictOpenapi,
+                reportFile: rawOptions.reportFile,
+                governanceConfig: rawOptions.governanceConfig,
+                cache: rawOptions.cache,
+                cachePath: rawOptions.cachePath,
+                cacheStrategy: rawOptions.cacheStrategy,
+                cacheDebug: rawOptions.cacheDebug,
+                prettierConfigPath: rawOptions.prettierConfigPath,
             }));
         }
         else {
@@ -65,6 +100,7 @@ class OpenApiClient {
                     includeSchemasFiles: rawOptions.includeSchemasFiles,
                     excludeCoreServiceFiles: rawOptions.excludeCoreServiceFiles,
                     request: rawOptions.request,
+                    plugins: rawOptions.plugins,
                     customExecutorPath: rawOptions.customExecutorPath,
                     interfacePrefix: rawOptions.interfacePrefix,
                     enumPrefix: rawOptions.enumPrefix,
@@ -76,6 +112,17 @@ class OpenApiClient {
                     useSeparatedIndexes: rawOptions.useSeparatedIndexes,
                     validationLibrary: rawOptions.validationLibrary,
                     emptySchemaStrategy: rawOptions.emptySchemaStrategy,
+                    useHistory,
+                    diffReport,
+                    modelsMode,
+                    strictOpenapi: rawOptions.strictOpenapi,
+                    reportFile: rawOptions.reportFile,
+                    governanceConfig: rawOptions.governanceConfig,
+                    cache: rawOptions.cache,
+                    cachePath: rawOptions.cachePath,
+                    cacheStrategy: rawOptions.cacheStrategy,
+                    cacheDebug: rawOptions.cacheDebug,
+                    prettierConfigPath: rawOptions.prettierConfigPath,
                 },
             ];
         }
@@ -94,6 +141,7 @@ class OpenApiClient {
             includeSchemasFiles: item.includeSchemasFiles ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.includeSchemasFiles,
             excludeCoreServiceFiles: item.excludeCoreServiceFiles ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.excludeCoreServiceFiles,
             request: item.request || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.request,
+            plugins: item.plugins || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.plugins,
             customExecutorPath: item.customExecutorPath || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.customExecutorPath,
             interfacePrefix: item.interfacePrefix || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.interfacePrefix,
             enumPrefix: item.enumPrefix || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.enumPrefix,
@@ -105,15 +153,65 @@ class OpenApiClient {
             useSeparatedIndexes: item.useSeparatedIndexes ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.useSeparatedIndexes,
             validationLibrary: item.validationLibrary ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.validationLibrary,
             emptySchemaStrategy: item.emptySchemaStrategy ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.emptySchemaStrategy,
+            useHistory: item.useHistory ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.useHistory,
+            diffReport: item.diffReport || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.diffReport,
+            modelsMode: item.modelsMode ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.modelsMode,
+            models: item.models || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.models,
+            analyze: item.analyze || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.analyze,
+            miracles: item.miracles || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.miracles,
+            strictOpenapi: item.strictOpenapi ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.strictOpenapi,
+            reportFile: item.reportFile || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.reportFile,
+            prettierConfigPath: item.prettierConfigPath ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.prettierConfigPath,
+            governanceConfig: item.governanceConfig || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.governanceConfig,
+            cache: item.cache ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.cache,
+            cachePath: item.cachePath || Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.cachePath,
+            cacheStrategy: item.cacheStrategy ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.cacheStrategy,
+            cacheDebug: item.cacheDebug ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.cacheDebug,
         };
     }
-    async cleanOutputDirectories(option) {
-        const outputDirs = [option.output, option.outputCore, option.outputSchemas, option.outputModels, option.outputServices];
-        for (const dir of outputDirs) {
-            if (dir) {
-                await fileSystemHelpers_1.fileSystemHelpers.rmdir(dir);
+    getOutputRoots(items) {
+        const roots = new Set();
+        for (const item of items) {
+            const outputDirs = [item.output, item.outputCore, item.outputSchemas, item.outputModels, item.outputServices];
+            for (const dir of outputDirs) {
+                if (dir) {
+                    roots.add((0, pathHelpers_1.resolveHelper)(process.cwd(), dir));
+                }
             }
         }
+        return Array.from(roots);
+    }
+    async cleanupStaleOutputs(items) {
+        const outputRoots = this.getOutputRoots(items);
+        const expectedFiles = this.writeClient.getExpectedOutputFiles();
+        for (const root of outputRoots) {
+            await this.removeStaleFilesInDirectory(root, expectedFiles);
+        }
+    }
+    async removeStaleFilesInDirectory(path, expectedFiles) {
+        const stats = await fs_1.promises.stat(path).catch(() => null);
+        if (!stats) {
+            return false;
+        }
+        if (stats.isFile()) {
+            if (!expectedFiles.has(path)) {
+                await fileSystemHelpers_1.fileSystemHelpers.rmdir(path);
+                return false;
+            }
+            return true;
+        }
+        const entries = await fs_1.promises.readdir(path);
+        let hasAnyFile = false;
+        for (const entry of entries) {
+            const childPath = (0, pathHelpers_1.resolveHelper)(path, entry);
+            const childHasFiles = await this.removeStaleFilesInDirectory(childPath, expectedFiles);
+            hasAnyFile = hasAnyFile || childHasFiles;
+        }
+        if (!hasAnyFile) {
+            await fileSystemHelpers_1.fileSystemHelpers.rmdir(path);
+            return false;
+        }
+        return true;
     }
     async generateCodeForItems(items) {
         if (items.length === 0) {
@@ -122,12 +220,27 @@ class OpenApiClient {
         this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.STARTED(items.length));
         try {
             const start = process.hrtime.bigint();
-            for (const option of items) {
-                await this.cleanOutputDirectories(option);
+            const cacheEnabled = items[0]?.cache === true;
+            const generationCaches = new Map();
+            if (!cacheEnabled) {
+                this.warnOnSharedOutputsWithoutCache(items);
+            }
+            else {
+                for (const outputRoot of this.getUniqueResolvedOutputs(items)) {
+                    const sampleItem = items.find(item => this.resolveOutputRoot(item.output) === outputRoot);
+                    if (!sampleItem) {
+                        continue;
+                    }
+                    const cachePath = this.resolveCachePathForOutput(sampleItem.output, sampleItem.cachePath);
+                    const generationCache = new GenerationCache_1.GenerationCache(cachePath);
+                    await generationCache.load();
+                    generationCaches.set(outputRoot, generationCache);
+                }
             }
             for (const option of items) {
                 const fileStart = process.hrtime.bigint();
-                await this.generateSingle(option);
+                const generationCache = cacheEnabled ? (generationCaches.get(this.resolveOutputRoot(option.output)) ?? null) : null;
+                await this.generateSingle(option, generationCache);
                 const fileEnd = process.hrtime.bigint();
                 const fileDurationInSeconds = Number(fileEnd - fileStart) / 1e9;
                 this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.DURATION_FOR_FILE(option.input, fileDurationInSeconds.toFixed(3)));
@@ -138,6 +251,15 @@ class OpenApiClient {
             else {
                 await this.writeClient.combineAndWrite();
             }
+            await this.cleanupStaleOutputs(items);
+            if (cacheEnabled) {
+                for (const generationCache of generationCaches.values()) {
+                    await generationCache.save();
+                }
+            }
+            const writeStats = this.writeClient.getWriteStats();
+            this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.WRITE_STATS(writeStats.written, writeStats.unchanged));
+            await this.runBatchEslintFixIfEnabled();
             this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.FINISHED);
             const end = process.hrtime.bigint();
             const durationInSeconds = Number(end - start) / 1e9;
@@ -145,11 +267,38 @@ class OpenApiClient {
         }
         catch (error) {
             this.writeClient.logger.error(LoggerMessages_1.LOGGER_MESSAGES.ERROR.GENERIC(error.message));
+            throw error;
         }
         this.writeClient.logger.shutdownLogger();
     }
-    async generateSingle(item) {
-        const { input, output, outputCore, outputServices, outputModels, outputSchemas, httpClient, useOptions, useUnionTypes, excludeCoreServiceFiles, request, customExecutorPath, interfacePrefix, enumPrefix, typePrefix, useCancelableRequest, sortByRequired, useSeparatedIndexes, validationLibrary = ValidationLibrary_enum_1.ValidationLibrary.NONE, emptySchemaStrategy = EmptySchemaStrategy_enum_1.EmptySchemaStrategy.KEEP, } = item;
+    getUniqueResolvedOutputs(items) {
+        return Array.from(new Set(items.map(item => this.resolveOutputRoot(item.output))));
+    }
+    resolveOutputRoot(output) {
+        return (0, pathHelpers_1.resolveHelper)(process.cwd(), output);
+    }
+    resolveCachePathForOutput(output, cachePath) {
+        if (cachePath.startsWith('/') || /^[A-Za-z]:[\\/]/.test(cachePath)) {
+            return cachePath;
+        }
+        return (0, pathHelpers_1.resolveHelper)(this.resolveOutputRoot(output), cachePath || OpenApiClient.DEFAULT_CACHE_FILENAME);
+    }
+    warnOnSharedOutputsWithoutCache(items) {
+        const countByOutput = new Map();
+        for (const item of items) {
+            const output = this.resolveOutputRoot(item.output);
+            countByOutput.set(output, (countByOutput.get(output) ?? 0) + 1);
+        }
+        const duplicatedOutputs = Array.from(countByOutput.entries())
+            .filter(([, count]) => count > 1)
+            .map(([output]) => output);
+        if (duplicatedOutputs.length === 0) {
+            return;
+        }
+        this.writeClient.logger.warn(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.CACHE_SHARED_OUTPUT_WARNING(duplicatedOutputs.map(output => `- ${output}`).join('\n')));
+    }
+    async generateSingle(item, generationCache) {
+        const { input, output, outputCore, outputServices, outputModels, outputSchemas, httpClient, useOptions, useUnionTypes, excludeCoreServiceFiles, request, plugins, customExecutorPath, interfacePrefix, enumPrefix, typePrefix, useCancelableRequest, sortByRequired, useSeparatedIndexes, validationLibrary = ValidationLibrary_enum_1.ValidationLibrary.NONE, emptySchemaStrategy = EmptySchemaStrategy_enum_1.EmptySchemaStrategy.KEEP, useHistory, diffReport, modelsMode = ModelsMode_enum_1.ModelsMode.INTERFACES, strictOpenapi, reportFile, prettierConfigPath, governanceConfig, } = item;
         const outputPaths = (0, getOutputPaths_1.getOutputPaths)({
             output,
             outputCore,
@@ -158,23 +307,87 @@ class OpenApiClient {
             outputSchemas,
         });
         const absoluteInput = (0, pathHelpers_1.resolveHelper)(process.cwd(), input);
-        const context = new Context_1.Context({ input: absoluteInput, output: outputPaths, prefix: { interface: interfacePrefix, enum: enumPrefix, type: typePrefix }, sortByRequired });
+        const cacheKey = this.getCacheKey(item, absoluteInput);
+        const cacheFingerprint = await this.getCacheFingerprint(item, absoluteInput);
+        const useEntityCache = item.cache && item.cacheStrategy === 'entity' && generationCache !== null;
+        if (useEntityCache) {
+            const cachedEntry = generationCache.get(cacheKey);
+            if (cachedEntry && cachedEntry.fingerprint === cacheFingerprint) {
+                const allFilesExist = await this.filesExist(cachedEntry.files);
+                if (allFilesExist) {
+                    for (const filePath of cachedEntry.files) {
+                        this.writeClient.registerOutputFile(filePath);
+                    }
+                    if (item.cacheDebug) {
+                        this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.CACHE_HIT(input));
+                    }
+                    return;
+                }
+            }
+            if (item.cacheDebug) {
+                this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.CACHE_MISS(input));
+            }
+        }
+        const knownFilesBefore = new Set(this.writeClient.getExpectedOutputFilesArray());
+        const generatorPlugins = await (0, loadGeneratorPlugins_1.loadGeneratorPlugins)(plugins);
+        const context = new Context_1.Context({
+            input: absoluteInput,
+            output: outputPaths,
+            prefix: { interface: interfacePrefix, enum: enumPrefix, type: typePrefix },
+            sortByRequired,
+            plugins: generatorPlugins,
+        });
         const openApi = await (0, getOpenApiSpec_1.getOpenApiSpec)(context, absoluteInput);
+        if (strictOpenapi) {
+            const parserValidationIssues = await (0, validateOpenApiStrict_1.validateWithSwaggerParser)(absoluteInput);
+            const governancePolicy = await (0, loadGovernanceConfig_1.loadGovernanceConfig)(governanceConfig);
+            const strictReport = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+                openApi,
+                context,
+                preIssues: parserValidationIssues,
+                governanceConfig: governancePolicy,
+            });
+            const reportPath = await (0, validateOpenApiStrict_1.writeOpenApiStrictReport)(strictReport, reportFile);
+            this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.GENERATION.STRICT_REPORT_CREATED(reportPath));
+            if (strictReport.summary.errors > 0) {
+                throw new Error(`Strict OpenAPI validation failed with ${strictReport.summary.errors} error(s). Report: ${reportPath}`);
+            }
+        }
         const openApiVersion = (0, getOpenApiVersion_1.getOpenApiVersion)(openApi);
         const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
             httpClient,
             useUnionTypes,
             useOptions,
             validationLibrary,
+            useBatchEslintFix: Boolean(this.eslintFixOptions.tsconfigPath && this.eslintFixOptions.eslintConfigPath),
+        });
+        const diffReportData = await this.loadDiffReportIfNeeded({
+            useHistory,
+            diffReport,
+            inputPath: absoluteInput,
         });
+        if (useHistory && !diffReportData) {
+            const reportPath = diffReport || Consts_1.DEFAULT_ANALYZE_DIFF_REPORT_PATH;
+            this.writeClient.logger.warn(LoggerMessages_1.LOGGER_MESSAGES.DIFF_REPORT.USE_HISTORY_NO_REPORT(reportPath));
+        }
         this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.OPENAPI.DEFINING_VERSION);
         switch (openApiVersion) {
             case getOpenApiVersion_1.OpenApiVersion.V2: {
                 const client = new Parser_1.Parser(context).parse(openApi);
-                const clientFinal = (0, postProcessClient_1.postProcessClient)(client);
+                const clientWithDiff = this.applyDiffReportIfNeeded({
+                    client,
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    openApi,
+                    openApiVersion,
+                    diffReport: diffReportData,
+                    context,
+                });
+                const clientFinal = (0, postProcessClient_1.postProcessClient)(clientWithDiff);
+                const clientPrepared = modelsMode === ModelsMode_enum_1.ModelsMode.CLASSES ? (0, resolveClassesModeTypes_1.resolveClassesModeTypes)((0, prepareDtoModels_1.prepareDtoModels)(clientFinal)) : clientFinal;
                 this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.OPENAPI.WRITING_V2);
                 await this.writeClient.writeClient({
-                    client: clientFinal,
+                    client: clientPrepared,
                     templates,
                     outputPaths,
                     httpClient,
@@ -187,15 +400,27 @@ class OpenApiClient {
                     useSeparatedIndexes,
                     validationLibrary,
                     emptySchemaStrategy,
+                    modelsMode,
+                    prettierConfigPath,
                 });
                 break;
             }
             case getOpenApiVersion_1.OpenApiVersion.V3: {
                 const client = new Parser_2.Parser(context).parse(openApi);
-                const clientFinal = (0, postProcessClient_1.postProcessClient)(client);
+                const clientWithDiff = this.applyDiffReportIfNeeded({
+                    client,
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    openApi,
+                    openApiVersion,
+                    diffReport: diffReportData,
+                    context,
+                });
+                const clientFinal = (0, postProcessClient_1.postProcessClient)(clientWithDiff);
+                const clientPrepared = modelsMode === ModelsMode_enum_1.ModelsMode.CLASSES ? (0, resolveClassesModeTypes_1.resolveClassesModeTypes)((0, prepareDtoModels_1.prepareDtoModels)(clientFinal)) : clientFinal;
                 this.writeClient.logger.info(LoggerMessages_1.LOGGER_MESSAGES.OPENAPI.WRITING_V3);
                 await this.writeClient.writeClient({
-                    client: clientFinal,
+                    client: clientPrepared,
                     templates,
                     outputPaths,
                     httpClient,
@@ -208,11 +433,135 @@ class OpenApiClient {
                     useSeparatedIndexes,
                     validationLibrary,
                     emptySchemaStrategy,
+                    modelsMode,
+                    prettierConfigPath,
                 });
                 break;
             }
         }
+        const generatedFiles = this.writeClient.getExpectedOutputFilesArray().filter(filePath => !knownFilesBefore.has(filePath));
+        if (item.cache && generationCache) {
+            generationCache.set({
+                key: cacheKey,
+                fingerprint: cacheFingerprint,
+                files: generatedFiles,
+                updatedAt: Date.now(),
+            });
+        }
+    }
+    getCacheKey(item, absoluteInput) {
+        return GenerationCache_1.GenerationCache.hash(JSON.stringify({
+            input: absoluteInput,
+            output: item.output,
+            outputCore: item.outputCore,
+            outputServices: item.outputServices,
+            outputModels: item.outputModels,
+            outputSchemas: item.outputSchemas,
+        }));
+    }
+    async getCacheFingerprint(item, absoluteInput) {
+        const specContent = await fileSystemHelpers_1.fileSystemHelpers.readFile(absoluteInput, 'utf8');
+        const fingerprint = {
+            cacheFingerprintVersion: OpenApiClient.CACHE_FINGERPRINT_VERSION,
+            generatorVersion: process.env.npm_package_version || 'dev',
+            specHash: GenerationCache_1.GenerationCache.hash(specContent),
+            options: {
+                httpClient: item.httpClient,
+                useOptions: item.useOptions,
+                useUnionTypes: item.useUnionTypes,
+                includeSchemasFiles: item.includeSchemasFiles,
+                excludeCoreServiceFiles: item.excludeCoreServiceFiles,
+                request: item.request,
+                plugins: item.plugins,
+                customExecutorPath: item.customExecutorPath,
+                interfacePrefix: item.interfacePrefix,
+                enumPrefix: item.enumPrefix,
+                typePrefix: item.typePrefix,
+                useCancelableRequest: item.useCancelableRequest,
+                sortByRequired: item.sortByRequired,
+                useSeparatedIndexes: item.useSeparatedIndexes,
+                validationLibrary: item.validationLibrary,
+                emptySchemaStrategy: item.emptySchemaStrategy,
+                useHistory: item.useHistory,
+                diffReport: item.diffReport,
+                modelsMode: item.modelsMode,
+                strictOpenapi: item.strictOpenapi,
+            },
+        };
+        return GenerationCache_1.GenerationCache.hash(JSON.stringify(fingerprint));
+    }
+    async filesExist(paths) {
+        for (const filePath of paths) {
+            const exists = await fileSystemHelpers_1.fileSystemHelpers.exists(filePath);
+            if (!exists) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Runs batch ESLint fix after combineAndWrite / combineAndWrightSimple when both paths are set.
+     * Warns and skips when only one path is provided; always clears the WriteClient lint registry.
+     */
+    async runBatchEslintFixIfEnabled() {
+        const opts = this.eslintFixOptions;
+        const hasTsconfig = !!opts.tsconfigPath;
+        const hasEslintConfig = !!opts.eslintConfigPath;
+        if (!hasTsconfig && !hasEslintConfig) {
+            this.writeClient.clearLintTargets();
+            return;
+        }
+        if (!hasTsconfig || !hasEslintConfig) {
+            this.writeClient.logger.warn(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_PATHS_MISSING);
+            this.writeClient.clearLintTargets();
+            return;
+        }
+        try {
+            const { files, includeGlobs } = this.writeClient.getLintTargets();
+            if (files.length === 0) {
+                return;
+            }
+            const fixStart = process.hrtime.bigint();
+            this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_BATCH_STARTED);
+            await (0, eslintFix_1.eslintFixBatch)({
+                files,
+                includeGlobs,
+                tsconfigPath: opts.tsconfigPath,
+                eslintConfigPath: opts.eslintConfigPath,
+            });
+            const fixEnd = process.hrtime.bigint();
+            const durationInSeconds = Number(fixEnd - fixStart) / 1e9;
+            this.writeClient.logger.forceInfo(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_BATCH_FINISHED(durationInSeconds.toFixed(3)));
+        }
+        finally {
+            this.writeClient.clearLintTargets();
+        }
+    }
+    async loadDiffReportIfNeeded(params) {
+        return (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: params.useHistory,
+            diffReport: params.diffReport,
+            inputPath: params.inputPath,
+            logger: this.writeClient.logger,
+        });
+    }
+    applyDiffReportIfNeeded(params) {
+        if (!params.diffReport) {
+            return params.client;
+        }
+        return (0, applyDiffReportToClient_1.applyDiffReportToClient)({
+            client: params.client,
+            openApi: params.openApi,
+            openApiVersion: params.openApiVersion,
+            diffReport: params.diffReport,
+            prefix: params.context.prefix,
+            context: params.context,
+        });
     }
+    /**
+     * Запускает генерацию клиента по опциям CLI или конфигурации.
+     * @param rawOptions сырые опции генерации
+     */
     async generate(rawOptions) {
         const logger = new Logger_1.Logger({
             level: rawOptions.logLevel ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.logLevel,
@@ -220,6 +569,7 @@ class OpenApiClient {
             logOutput: rawOptions.logTarget ?? Consts_1.COMMON_DEFAULT_OPTIONS_VALUES.logTarget,
         });
         this._writeClient = new WriteClient_1.WriteClient(logger);
+        this.eslintFixOptions = (0, TEslintFixOptions_1.extractEslintFixOptions)(rawOptions);
         const items = this.normalizeOptions(rawOptions).map(item => this.addDefaultValues(item));
         await this.generateCodeForItems(items);
     }