ts-openapi-codegen 2.0.0-beta.9 → 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/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/getRelativeModelPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The function calculates the relative path to the model.
+ * Removes the transition to the directory with a level above.
+ * @param folderPath Root folder.
+ * @param relativeModelPath Relative path to the model.
+ * @returns Correct relative model path.
+ */
+export declare function getRelativeModelPath(folderPath: string | undefined, relativeModelPath: string): string;
+//# sourceMappingURL=getRelativeModelPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getRelativeModelPath.d.ts","sourceRoot":"","sources":["../../../src/core/utils/getRelativeModelPath.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,iBAAiB,EAAE,MAAM,UA2B7F"}

package/dist/core/utils/getRelativeModelPath.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeModelPath = getRelativeModelPath;
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const getTypeName_1 = require("./getTypeName");
+const isInsideDirectory_1 = require("./isInsideDirectory");
+/**
+ * The function calculates the relative path to the model.
+ * Removes the transition to the directory with a level above.
+ * @param folderPath Root folder.
+ * @param relativeModelPath Relative path to the model.
+ * @returns Correct relative model path.
+ */
+function getRelativeModelPath(folderPath, relativeModelPath) {
+    if (!folderPath) {
+        return relativeModelPath;
+    }
+    const pathSep = '/';
+    let mappedPaths = '';
+    let modelPath = relativeModelPath;
+    // If absolute path (filesystem or URL-like), collapse to type name only
+    if (modelPath.startsWith('/')) {
+        return (0, getTypeName_1.getTypeName)(modelPath);
+    }
+    if (modelPath.startsWith('../')) {
+        const pathArray = modelPath.split(pathSep).filter(Boolean);
+        while (pathArray[0] === '..') {
+            pathArray.shift();
+        }
+        modelPath = pathArray.join(pathSep);
+    }
+    const resolvedPath = (0, pathHelpers_1.resolveHelper)(folderPath, modelPath);
+    if ((0, isInsideDirectory_1.isInsideDirectory)(resolvedPath, folderPath)) {
+        mappedPaths = modelPath;
+    }
+    return mappedPaths;
+}

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/modelHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modelHelpers.d.ts","sourceRoot":"","sources":["../../../src/core/utils/modelHelpers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAkBjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,eAAe,EAAE,MAAM,GAAG,KAAK,EAAE,CA+BrF"}
+{"version":3,"file":"modelHelpers.d.ts","sourceRoot":"","sources":["../../../src/core/utils/modelHelpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAkBjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,eAAe,EAAE,MAAM,GAAG,KAAK,EAAE,CA4ErF"}

package/dist/core/utils/modelHelpers.js

@@ -52,8 +52,36 @@ function setDuplicateModelAliases(models) {
  * @returns the same array of models (modified)
  */
 function resolveModelImports(models, outputModelsDir) {
+    const normalizeImportPath = (value) => (value.startsWith('./') ? value.slice(2) : value);
+    const applyAliasToModel = (model, imprt) => {
+        const modelPath = normalizeImportPath(model.path);
+        const importPath = normalizeImportPath(imprt.path);
+        if (modelPath === importPath && model.type === imprt.name && imprt.alias) {
+            model.alias = imprt.alias;
+            model.base = imprt.alias;
+            model.type = imprt.alias;
+        }
+        if (imprt.alias && model.imports?.some(item => normalizeImportPath(item.path) === importPath && item.name === imprt.name)) {
+            if (model.base === imprt.name) {
+                model.base = imprt.alias;
+            }
+            if (model.type === imprt.name) {
+                model.type = imprt.alias;
+            }
+        }
+        if (model.link) {
+            applyAliasToModel(model.link, imprt);
+        }
+        if (model.properties?.length) {
+            model.properties.forEach(child => applyAliasToModel(child, imprt));
+        }
+        if (model.enums?.length) {
+            model.enums.forEach(child => applyAliasToModel(child, imprt));
+        }
+    };
     models.forEach(model => {
-        model.imports = model.imports.map(imprt => {
+        const importsWithSourcePath = model.imports.map(imprt => {
+            const sourcePath = imprt.path;
             const importModel = models.find(value => {
                 const normalizedPath = !value.path.startsWith('./') ? `./${value.path}` : value.path;
                 return normalizedPath === imprt.path && value.name === imprt.name;
@@ -69,16 +97,22 @@ function resolveModelImports(models, outputModelsDir) {
                     importPath = `./${file}`;
                 }
                 else if (relativePath.startsWith('./')) {
-                    importPath = `${relativePath}${file}`;
+                    importPath = `${relativePath}/${file}`;
                 }
                 else {
                     importPath = `${relativePath}/${file}`;
                 }
             }
-            return Object.assign(imprt, {
+            const mappedImport = Object.assign(imprt, {
                 alias: importAlias,
                 path: importPath,
             });
+            return { mappedImport, sourcePath };
+        });
+        model.imports = importsWithSourcePath.map(item => item.mappedImport);
+        importsWithSourcePath.forEach(item => {
+            applyAliasToModel(model, item.mappedImport);
+            applyAliasToModel(model, Object.assign({}, item.mappedImport, { path: item.sourcePath }));
         });
     });
     return models;

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

@@ -1 +1 @@
-{"version":3,"file":"postProcessModelImports.d.ts","sourceRoot":"","sources":["../../../src/core/utils/postProcessModelImports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAIzD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CAK9D"}
+{"version":3,"file":"postProcessModelImports.d.ts","sourceRoot":"","sources":["../../../src/core/utils/postProcessModelImports.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAQzD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CAY9D"}

package/dist/core/utils/postProcessModelImports.js

@@ -1,15 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postProcessModelImports = postProcessModelImports;
+const path_1 = __importDefault(require("path"));
 const sort_1 = require("./sort");
 const unique_1 = require("./unique");
+function normalizePath(value) {
+    return value.startsWith('./') ? value.slice(2) : value;
+}
 /**
  * Set unique imports, sorted by name
  * @param model The model that is post-processed
  */
 function postProcessModelImports(model) {
+    const currentModelPath = normalizePath(model.path);
+    const currentModelDir = path_1.default.posix.dirname(currentModelPath);
     return model?.imports
         ?.filter(unique_1.unique)
         ?.sort(sort_1.sort)
-        ?.filter(item => model.name !== item.name);
+        ?.filter(item => {
+        const importPath = normalizePath(item.path);
+        const resolvedFromCurrentModel = path_1.default.posix.normalize(path_1.default.posix.join(currentModelDir, importPath));
+        return resolvedFromCurrentModel !== currentModelPath;
+    });
 }