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

package/dist/core/utils/applyDiffReportToClient.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDiffReportToClient = void 0;
+const jsonPath_1 = require("../../common/utils/jsonPath");
+const encode_1 = require("./encode");
+const escapeName_1 = require("./escapeName");
+const getClassName_1 = require("./getClassName");
+const getComment_1 = require("./getComment");
+const getModelNameWithPrefix_1 = require("./getModelNameWithPrefix");
+const getOpenApiVersion_1 = require("./getOpenApiVersion");
+const getOperationName_1 = require("./getOperationName");
+const getOperationPath_1 = require("./getOperationPath");
+const getServiceClassName_1 = require("./getServiceClassName");
+const serviceHelpers_1 = require("./serviceHelpers");
+const getSchemaDefinitions = (openApi, version) => {
+    if (version === getOpenApiVersion_1.OpenApiVersion.V3) {
+        const components = openApi?.components;
+        const schemas = components?.schemas;
+        return schemas ?? {};
+    }
+    const definitions = openApi?.definitions;
+    return definitions ?? {};
+};
+const buildSchemaNameMap = (openApi, version, prefix) => {
+    const definitions = getSchemaDefinitions(openApi, version);
+    const map = new Map();
+    Object.entries(definitions).forEach(([schemaName, schemaDef]) => {
+        const encodedName = (0, encode_1.encode)(schemaName);
+        const modelName = (0, getModelNameWithPrefix_1.getModelNameWithPrefix)(encodedName, schemaDef, prefix);
+        map.set(schemaName, modelName);
+    });
+    return map;
+};
+const getSchemaNameFromSegments = (segments, version) => {
+    if (version === getOpenApiVersion_1.OpenApiVersion.V3) {
+        return segments[0] === 'components' && segments[1] === 'schemas' ? segments[2] ?? null : null;
+    }
+    return segments[0] === 'definitions' ? segments[1] ?? null : null;
+};
+const describeSchemaType = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.$ref === 'string') {
+            return `ref:${record.$ref}`;
+        }
+        if (typeof record.type === 'string') {
+            return record.type;
+        }
+        if (Array.isArray(record.oneOf)) {
+            return 'oneOf';
+        }
+        if (Array.isArray(record.anyOf)) {
+            return 'anyOf';
+        }
+        if (Array.isArray(record.allOf)) {
+            return 'allOf';
+        }
+    }
+    return undefined;
+};
+const normalizeScalarType = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === 'int' || normalized === 'integer')
+        return 'number';
+    if (normalized === 'float' || normalized === 'double')
+        return 'number';
+    if (normalized === 'string')
+        return 'string';
+    if (normalized === 'number')
+        return 'number';
+    if (normalized === 'boolean')
+        return 'boolean';
+    return undefined;
+};
+const mergeOperationDiff = (existing, entry) => {
+    if (!existing) {
+        return {
+            action: entry.action,
+            path: entry.path,
+            severity: entry.severity,
+            from: entry.from,
+            to: entry.to,
+        };
+    }
+    const severityOrder = ['info', 'warning', 'breaking'];
+    const existingScore = severityOrder.indexOf(existing.severity);
+    const incomingScore = severityOrder.indexOf(entry.severity);
+    const severity = incomingScore > existingScore ? entry.severity : existing.severity;
+    return {
+        ...existing,
+        severity,
+    };
+};
+const buildOperationKey = (method, path) => `${method.toUpperCase()} ${(0, getOperationPath_1.getOperationPath)(path)}`;
+const findOperationMatches = (entries) => {
+    const operationDiffs = new Map();
+    const removedOperations = [];
+    entries.forEach(entry => {
+        const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+        if (segments[0] !== 'paths' || segments.length < 3) {
+            return;
+        }
+        const rawPath = segments[1];
+        const method = segments[2];
+        const key = buildOperationKey(method, rawPath);
+        if (entry.action === 'removed' && segments.length === 3) {
+            removedOperations.push({
+                key,
+                path: rawPath,
+                method,
+                entry,
+            });
+            return;
+        }
+        operationDiffs.set(key, mergeOperationDiff(operationDiffs.get(key), entry));
+    });
+    return { operationDiffs, removedOperations };
+};
+const createGhostOperation = (match, serviceName) => {
+    const from = (match.entry.from ?? {});
+    const operationId = typeof from.operationId === 'string' ? from.operationId : '';
+    const summary = typeof from.summary === 'string' ? from.summary : '';
+    const description = typeof from.description === 'string' ? from.description : '';
+    const operationNameFallback = `${match.method}${serviceName}`;
+    const operationName = (0, getOperationName_1.getOperationName)(operationId || operationNameFallback);
+    return {
+        service: serviceName,
+        name: operationName,
+        summary: (0, getComment_1.getComment)(summary),
+        description: (0, getComment_1.getComment)(description),
+        deprecated: true,
+        method: match.method.toUpperCase(),
+        path: (0, getOperationPath_1.getOperationPath)(match.path),
+        parameters: [],
+        parametersPath: [],
+        parametersQuery: [],
+        parametersForm: [],
+        parametersHeader: [],
+        parametersCookie: [],
+        parametersBody: null,
+        imports: [],
+        errors: [],
+        results: [],
+        responseHeader: null,
+        responseType: null,
+        diff: {
+            action: 'removed',
+            path: match.entry.path,
+            severity: match.entry.severity,
+            from: match.entry.from,
+            to: match.entry.to,
+        },
+        isGhost: true,
+    };
+};
+const resolveServiceFromMatch = (services, match) => {
+    const from = (match.entry.from ?? {});
+    const tagsValue = from.tags;
+    const tag = Array.isArray(tagsValue) ? String(tagsValue[0] ?? '') : '';
+    const preferredName = tag ? (0, getServiceClassName_1.getServiceClassName)(tag) : (0, getServiceClassName_1.getServiceClassName)('Default');
+    const preferredOrigin = tag ? (0, getClassName_1.getClassName)(tag) : (0, getClassName_1.getClassName)('Default');
+    const existingByName = services.get(preferredName);
+    if (existingByName) {
+        return existingByName;
+    }
+    const existingByOrigin = Array.from(services.values()).find(service => service.originName === preferredOrigin);
+    if (existingByOrigin) {
+        return existingByOrigin;
+    }
+    return (0, serviceHelpers_1.ensureService)(services, preferredName, preferredOrigin);
+};
+const applyOperationDiffs = (client, entries) => {
+    const { operationDiffs, removedOperations } = findOperationMatches(entries);
+    const servicesMap = new Map(client.services.map(service => [service.name, service]));
+    for (const service of servicesMap.values()) {
+        for (const operation of service.operations) {
+            const key = buildOperationKey(operation.method, operation.path);
+            const diff = operationDiffs.get(key);
+            if (diff) {
+                operation.diff = diff;
+            }
+        }
+    }
+    for (const match of removedOperations) {
+        const service = resolveServiceFromMatch(servicesMap, match);
+        const ghostOperation = createGhostOperation(match, service.name);
+        const existingOperation = service.operations.find(op => buildOperationKey(op.method, op.path) === match.key);
+        if (!existingOperation) {
+            service.operations.push(ghostOperation);
+        }
+    }
+    client.services = Array.from(servicesMap.values());
+};
+const applyModelDiffs = (client, entries, openApi, openApiVersion, prefix) => {
+    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix);
+    const modelsByName = new Map(client.models.map(model => [model.name, model]));
+    const ghostPropertyKeys = new Set();
+    entries.forEach(entry => {
+        const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+        const schemaName = getSchemaNameFromSegments(segments, openApiVersion);
+        if (!schemaName)
+            return;
+        const modelName = schemaNameMap.get(schemaName);
+        if (!modelName)
+            return;
+        const model = modelsByName.get(modelName);
+        if (!model)
+            return;
+        const propertiesIndex = segments.indexOf('properties');
+        if (propertiesIndex === -1 || propertiesIndex + 1 >= segments.length) {
+            return;
+        }
+        const rawPropertyName = segments[propertiesIndex + 1];
+        const propertyName = (0, escapeName_1.escapeName)(rawPropertyName);
+        if (entry.action === 'removed' && propertiesIndex + 1 === segments.length - 1) {
+            const key = `${modelName}:${propertyName}`;
+            if (ghostPropertyKeys.has(key))
+                return;
+            const exists = model.properties.some(prop => prop.name === propertyName);
+            if (!exists) {
+                const ghost = {
+                    name: propertyName,
+                    alias: '',
+                    path: model.path,
+                    export: 'generic',
+                    type: 'unknown',
+                    base: 'unknown',
+                    template: null,
+                    link: null,
+                    description: null,
+                    isDefinition: false,
+                    isReadOnly: false,
+                    isRequired: false,
+                    isNullable: false,
+                    imports: [],
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                    diff: {
+                        action: 'removed',
+                        path: entry.path,
+                        severity: entry.severity,
+                        from: entry.from,
+                        to: entry.to,
+                    },
+                    isGhost: true,
+                };
+                if (!model.ghostProperties) {
+                    model.ghostProperties = [];
+                }
+                model.ghostProperties.push(ghost);
+                ghostPropertyKeys.add(key);
+            }
+            return;
+        }
+        if (entry.action === 'changed' && segments[segments.length - 1] === 'type') {
+            const property = model.properties.find(prop => prop.name === propertyName);
+            if (!property)
+                return;
+            const previousType = describeSchemaType(entry.from);
+            const currentTypeRaw = typeof entry.to === 'string' ? entry.to : describeSchemaType(entry.to);
+            const currentType = normalizeScalarType(currentTypeRaw);
+            const previousScalar = normalizeScalarType(previousType);
+            property.diff = {
+                action: entry.action,
+                path: entry.path,
+                severity: entry.severity,
+                from: entry.from,
+                to: entry.to,
+                previousType,
+            };
+            if (previousScalar && currentType && previousScalar !== currentType) {
+                property.needsCoercion = true;
+                property.coercionFrom = previousScalar;
+                property.coercionTo = currentType;
+                model.hasCoercion = true;
+            }
+        }
+    });
+};
+const applyMiracleTypeCoercions = (client, confirmedMiracles, entries) => {
+    if (!confirmedMiracles.length)
+        return;
+    const modelsByName = new Map(client.models.map(model => [model.name, model]));
+    for (const miracle of confirmedMiracles) {
+        if (miracle.type !== 'TYPE_COERCION')
+            continue;
+        if (!miracle.modelName)
+            continue;
+        const model = modelsByName.get(miracle.modelName);
+        if (!model)
+            continue;
+        const rawProperty = miracle.newProperty ?? miracle.oldProperty;
+        if (!rawProperty)
+            continue;
+        const propertyName = (0, escapeName_1.escapeName)(rawProperty);
+        const property = model.properties.find(prop => prop.name === propertyName);
+        if (!property)
+            continue;
+        property.needsCoercion = true;
+        model.hasCoercion = true;
+        if (!miracle.newPath)
+            continue;
+        const typePath = `${miracle.newPath}.type`;
+        const typeEntry = entries.find(entry => entry.action === 'changed' && entry.path === typePath);
+        if (!typeEntry)
+            continue;
+        const previousType = describeSchemaType(typeEntry.from);
+        const currentTypeRaw = typeof typeEntry.to === 'string' ? typeEntry.to : describeSchemaType(typeEntry.to);
+        const currentType = normalizeScalarType(currentTypeRaw);
+        const previousScalar = normalizeScalarType(previousType);
+        if (previousScalar && currentType && previousScalar !== currentType) {
+            property.coercionFrom = previousScalar;
+            property.coercionTo = currentType;
+            if (!property.diff) {
+                property.diff = {
+                    action: typeEntry.action,
+                    path: typeEntry.path,
+                    severity: typeEntry.severity,
+                    from: typeEntry.from,
+                    to: typeEntry.to,
+                    previousType,
+                };
+            }
+        }
+    }
+};
+const applyDiffReportToClient = ({ client, openApi, openApiVersion, diffReport, prefix }) => {
+    const entries = diffReport?.diff?.all ?? [];
+    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix);
+    const confirmedMiracles = (diffReport?.miracles ?? [])
+        .filter(miracle => miracle.status === 'confirmed' || miracle.confidence === 1)
+        .map(miracle => {
+        const oldSegments = (0, jsonPath_1.parseJsonPath)(miracle.oldPath);
+        const newSegments = (0, jsonPath_1.parseJsonPath)(miracle.newPath);
+        const oldSchema = getSchemaNameFromSegments(oldSegments, openApiVersion);
+        const newSchema = getSchemaNameFromSegments(newSegments, openApiVersion);
+        const schemaName = oldSchema || newSchema;
+        const modelName = schemaName ? schemaNameMap.get(schemaName) : undefined;
+        const oldPropIndex = oldSegments.indexOf('properties');
+        const newPropIndex = newSegments.indexOf('properties');
+        const oldProperty = oldPropIndex !== -1 ? oldSegments[oldPropIndex + 1] : undefined;
+        const newProperty = newPropIndex !== -1 ? newSegments[newPropIndex + 1] : undefined;
+        return {
+            ...miracle,
+            modelName,
+            oldProperty,
+            newProperty,
+        };
+    });
+    if (confirmedMiracles.length > 0) {
+        client.miracles = confirmedMiracles;
+    }
+    applyMiracleTypeCoercions(client, confirmedMiracles, entries);
+    if (entries.length === 0) {
+        return client;
+    }
+    applyModelDiffs(client, entries, openApi, openApiVersion, prefix);
+    applyOperationDiffs(client, entries);
+    return client;
+};
+exports.applyDiffReportToClient = applyDiffReportToClient;

package/dist/core/utils/getMappedType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMappedType.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getMappedType.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD"}
+{"version":3,"file":"getMappedType.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getMappedType.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD"}

package/dist/core/utils/getMappedType.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMappedType = getMappedType;
 exports.hasMappedType = hasMappedType;
 const TYPE_MAPPINGS = new Map([
+    ['Blob', 'Blob'],
     ['File', 'File'],
     ['file', 'File'],
+    ['binary', 'Blob'],
     ['any', 'any'],
     ['object', 'any'],
     ['array', 'any[]'],

package/dist/core/utils/getOpenApiSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOpenApiSpec.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getOpenApiSpec.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAqC5F"}
+{"version":3,"file":"getOpenApiSpec.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getOpenApiSpec.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAyB5F"}

package/dist/core/utils/getOpenApiSpec.js

@@ -17,20 +17,7 @@ async function getOpenApiSpec(context, input) {
         throw new Error(`OpenAPI spec not found: ${absoluteInput}`);
     }
     const parser = new swagger_parser_1.default();
-    const previousCwd = process.cwd();
-    const inputDir = (0, pathHelpers_1.dirNameHelper)(absoluteInput);
-    if (previousCwd !== inputDir) {
-        process.chdir(inputDir);
-    }
-    let resolved;
-    try {
-        resolved = await parser.resolve(absoluteInput);
-    }
-    finally {
-        if (process.cwd() !== previousCwd) {
-            process.chdir(previousCwd);
-        }
-    }
+    const resolved = await parser.resolve(absoluteInput);
     context.addRefs(resolved);
     // Получить основную схему
     const raw = resolved.get(absoluteInput);

package/dist/core/utils/getOperationResponseCode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOperationResponseCode.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getOperationResponseCode.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAejF"}
+{"version":3,"file":"getOperationResponseCode.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getOperationResponseCode.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAmBjF"}

package/dist/core/utils/getOperationResponseCode.js

@@ -2,16 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOperationResponseCode = getOperationResponseCode;
 function getOperationResponseCode(value) {
-    // You can specify a "default" response, this is treated as HTTP code 200
+    // "default" is not an explicit HTTP status code and should not be coerced.
     if (value === 'default') {
-        return 200;
+        return null;
     }
-    // Check if we can parse the code and return of successful.
-    if (/[0-9]+/g.test(value)) {
-        const code = parseInt(value);
-        if (Number.isInteger(code)) {
-            return Math.abs(code);
-        }
+    const normalizedValue = value.trim();
+    // OpenAPI supports exact response codes (e.g. "200")
+    if (/^\d{3}$/.test(normalizedValue)) {
+        return Number(normalizedValue);
+    }
+    // OpenAPI supports response code ranges (e.g. "2XX")
+    if (/^[1-5]XX$/i.test(normalizedValue)) {
+        return Number(normalizedValue[0]) * 100;
     }
     return null;
 }

package/dist/core/utils/loadDiffReport.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '../../common/Logger';
+import type { DiffInfo } from '../types/shared/DiffInfo.model';
+import type { MiracleEntry } from '../types/shared/Miracle.model';
+export interface DiffReportEntry extends DiffInfo {
+    action: DiffInfo['action'];
+}
+export interface DiffReport {
+    version?: string;
+    timestamp?: string;
+    metadata?: {
+        base?: string;
+        target?: string;
+        baseHash?: string;
+        targetHash?: string;
+    };
+    stats?: {
+        totalChanges?: number;
+        added?: number;
+        removed?: number;
+        changed?: number;
+        ignored?: number;
+    };
+    diff?: {
+        breaking?: DiffReportEntry[];
+        warnings?: DiffReportEntry[];
+        info?: DiffReportEntry[];
+        all?: DiffReportEntry[];
+    };
+    miracles?: MiracleEntry[];
+}
+type LoadDiffReportParams = {
+    useHistory?: boolean;
+    diffReport?: string;
+    inputPath?: string;
+    logger: Logger;
+};
+export declare const loadDiffReport: ({ useHistory, diffReport, inputPath, logger }: LoadDiffReportParams) => DiffReport | null;
+export {};
+//# sourceMappingURL=loadDiffReport.d.ts.map

package/dist/core/utils/loadDiffReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDiffReport.d.ts","sourceRoot":"","sources":["../../../src/core/utils/loadDiffReport.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,MAAM,WAAW,eAAgB,SAAQ,QAAQ;IAC7C,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,KAAK,CAAC,EAAE;QACJ,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,IAAI,CAAC,EAAE;QACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;QAC7B,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;QAC7B,IAAI,CAAC,EAAE,eAAe,EAAE,CAAC;QACzB,GAAG,CAAC,EAAE,eAAe,EAAE,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;CAC7B;AAED,KAAK,oBAAoB,GAAG;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB,CAAC;AAaF,eAAO,MAAM,cAAc,GAAI,+CAA+C,oBAAoB,KAAG,UAAU,GAAG,IA8BjH,CAAC"}

package/dist/core/utils/loadDiffReport.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDiffReport = void 0;
+const fs_1 = __importDefault(require("fs"));
+const Consts_1 = require("../../common/Consts");
+const isFreshEnough = (reportPath, inputPath) => {
+    if (!inputPath)
+        return true;
+    try {
+        const reportStat = fs_1.default.statSync(reportPath);
+        const inputStat = fs_1.default.statSync(inputPath);
+        return reportStat.mtimeMs >= inputStat.mtimeMs;
+    }
+    catch {
+        return true;
+    }
+};
+const loadDiffReport = ({ useHistory, diffReport, inputPath, logger }) => {
+    const shouldLoad = useHistory || !!diffReport;
+    if (!shouldLoad)
+        return null;
+    const reportPath = diffReport || Consts_1.DEFAULT_ANALYZE_DIFF_REPORT_PATH;
+    if (!fs_1.default.existsSync(reportPath)) {
+        logger.info(`[openapi-codegen] Diff report not found at "${reportPath}". Skipping history annotations.`);
+        return null;
+    }
+    if (!isFreshEnough(reportPath, inputPath)) {
+        logger.warn(`[openapi-codegen] Diff report "${reportPath}" is older than the input spec. Skipping history annotations.`);
+        return null;
+    }
+    try {
+        const raw = fs_1.default.readFileSync(reportPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const hasDiffEntries = !!parsed?.diff?.all?.length;
+        const hasMiracles = !!parsed?.miracles?.length;
+        if (!hasDiffEntries && !hasMiracles) {
+            logger.info(`[openapi-codegen] Diff report "${reportPath}" has no entries. Skipping history annotations.`);
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(`[openapi-codegen] Failed to read diff report "${reportPath}": ${message}`);
+        return null;
+    }
+};
+exports.loadDiffReport = loadDiffReport;

package/dist/core/utils/prepareDtoModels.d.ts

@@ -0,0 +1,3 @@
+import type { Client } from '../types/shared/Client.model';
+export declare const prepareDtoModels: (client: Client) => Client;
+//# sourceMappingURL=prepareDtoModels.d.ts.map

package/dist/core/utils/prepareDtoModels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareDtoModels.d.ts","sourceRoot":"","sources":["../../../src/core/utils/prepareDtoModels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAyL3D,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,KAAG,MAqCjD,CAAC"}