api-tests-coverage 1.0.22 → 1.0.24

package/dist/src/compatibilityCoverage.js

@@ -42,6 +42,7 @@ exports.parseContractFiles = parseContractFiles;
 exports.verifyContracts = verifyContracts;
 exports.computeCompatibilityPercent = computeCompatibilityPercent;
 exports.computeContractCoveragePercent = computeContractCoveragePercent;
+exports.computeCanDeploy = computeCanDeploy;
 exports.buildCompatibilityReport = buildCompatibilityReport;
 exports.generateCompatibilityReports = generateCompatibilityReports;
 const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
@@ -77,6 +78,183 @@ function getParameters(op) {
 function paramKey(p) {
     return `${p.in}:${p.name}`;
 }
+function createEndpointChange(change) {
+    var _a;
+    const breaking = (_a = change.breaking) !== null && _a !== void 0 ? _a : change.severity === 'BREAKING';
+    return { ...change, breaking };
+}
+function schemaObject(schema) {
+    if (!schema || typeof schema !== 'object')
+        return undefined;
+    return schema;
+}
+function getSchemaType(schema) {
+    if (!schema)
+        return undefined;
+    if (Array.isArray(schema.type))
+        return schema.type.join('|');
+    return typeof schema.type === 'string' ? schema.type : undefined;
+}
+function getRequiredFields(schema) {
+    return new Set(Array.isArray(schema === null || schema === void 0 ? void 0 : schema.required) ? schema.required : []);
+}
+function describeFieldRemoval(context, fieldPath) {
+    if (context.kind === 'response') {
+        return `Response field removed from ${context.method.toUpperCase()} ${context.path}: ${fieldPath}`;
+    }
+    return `Schema field removed from ${context.method.toUpperCase()} ${context.path}: ${fieldPath}`;
+}
+function getOperationSecurity(api, operation) {
+    var _a;
+    if (operation.security)
+        return operation.security;
+    return ((_a = api.security) !== null && _a !== void 0 ? _a : []);
+}
+function isPublicEndpoint(security) {
+    return security.length === 0;
+}
+function compareEnumValues(oldSchema, newSchema, context, fieldPath) {
+    const oldEnum = Array.isArray(oldSchema.enum) ? oldSchema.enum.map(String) : [];
+    const newEnum = Array.isArray(newSchema.enum) ? newSchema.enum.map(String) : [];
+    if (oldEnum.length === 0 && newEnum.length === 0)
+        return [];
+    const changes = [];
+    const removedValues = oldEnum.filter((value) => !newEnum.includes(value));
+    for (const value of removedValues) {
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: 'removed-enum-value',
+            severity: 'BREAKING',
+            description: `Enum value removed from ${context.method.toUpperCase()} ${context.path}: ${fieldPath} no longer allows '${value}'`,
+            affectedField: fieldPath,
+            oldValue: value,
+        }));
+    }
+    const addedValues = newEnum.filter((value) => !oldEnum.includes(value));
+    for (const value of addedValues) {
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: 'added-enum-value',
+            severity: 'SAFE',
+            description: `Enum value added for ${context.method.toUpperCase()} ${context.path}: ${fieldPath} now allows '${value}'`,
+            affectedField: fieldPath,
+            newValue: value,
+        }));
+    }
+    return changes;
+}
+function compareSchemasRecursive(oldSchema, newSchema, context, fieldPath) {
+    var _a, _b, _c;
+    if (fieldPath === void 0) { fieldPath = (_a = context.location) !== null && _a !== void 0 ? _a : 'body'; }
+    if (!oldSchema || !newSchema)
+        return [];
+    const changes = [];
+    const oldType = getSchemaType(oldSchema);
+    const newType = getSchemaType(newSchema);
+    if (oldType && newType && oldType !== newType) {
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: context.kind === 'response' ? 'changed-response-schema' : 'changed-schema',
+            severity: 'BREAKING',
+            description: `Schema type changed for ${context.method.toUpperCase()} ${context.path}: ${fieldPath} (${oldType} → ${newType})`,
+            affectedField: fieldPath,
+            oldValue: oldType,
+            newValue: newType,
+        }));
+        return changes;
+    }
+    changes.push(...compareEnumValues(oldSchema, newSchema, context, fieldPath));
+    if (oldSchema.nullable !== true && newSchema.nullable === true) {
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: context.kind === 'response' ? 'changed-response-schema' : 'changed-schema',
+            severity: 'DANGEROUS',
+            description: `Field became nullable in ${context.method.toUpperCase()} ${context.path}: ${fieldPath}`,
+            affectedField: fieldPath,
+            oldValue: 'non-nullable',
+            newValue: 'nullable',
+        }));
+    }
+    if (oldSchema.default !== undefined && newSchema.default !== undefined && oldSchema.default !== newSchema.default) {
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: context.kind === 'response' ? 'changed-response-schema' : 'changed-schema',
+            severity: 'DANGEROUS',
+            description: `Default value changed in ${context.method.toUpperCase()} ${context.path}: ${fieldPath}`,
+            affectedField: fieldPath,
+            oldValue: JSON.stringify(oldSchema.default),
+            newValue: JSON.stringify(newSchema.default),
+        }));
+    }
+    const oldProperties = ((_b = oldSchema.properties) !== null && _b !== void 0 ? _b : {});
+    const newProperties = ((_c = newSchema.properties) !== null && _c !== void 0 ? _c : {});
+    const oldRequired = getRequiredFields(oldSchema);
+    const newRequired = getRequiredFields(newSchema);
+    for (const [propName, propSchema] of Object.entries(oldProperties)) {
+        const nestedPath = fieldPath === 'body' ? propName : `${fieldPath}.${propName}`;
+        const newPropSchema = newProperties[propName];
+        if (!newPropSchema) {
+            changes.push(createEndpointChange({
+                method: context.method,
+                path: context.path,
+                changeType: context.kind === 'response' ? 'changed-response-schema' : 'changed-schema',
+                severity: 'BREAKING',
+                description: describeFieldRemoval(context, nestedPath),
+                affectedField: nestedPath,
+            }));
+            continue;
+        }
+        changes.push(...compareSchemasRecursive(propSchema, newPropSchema, context, nestedPath));
+    }
+    for (const [propName] of Object.entries(newProperties)) {
+        if (oldProperties[propName])
+            continue;
+        const nestedPath = fieldPath === 'body' ? propName : `${fieldPath}.${propName}`;
+        const requiredAdded = newRequired.has(propName) && !oldRequired.has(propName);
+        const severity = context.kind === 'response' ? 'SAFE' : requiredAdded ? 'BREAKING' : 'SAFE';
+        changes.push(createEndpointChange({
+            method: context.method,
+            path: context.path,
+            changeType: context.kind === 'response' ? 'changed-response-schema' : 'changed-schema',
+            severity,
+            description: `${requiredAdded ? 'Required' : 'Optional'} field added to ${context.kind} schema for ${context.method.toUpperCase()} ${context.path}: ${nestedPath}`,
+            affectedField: nestedPath,
+        }));
+    }
+    const oldItems = oldSchema.type === 'array' ? schemaObject(oldSchema.items) : undefined;
+    const newItems = newSchema.type === 'array' ? schemaObject(newSchema.items) : undefined;
+    if (oldItems && newItems) {
+        changes.push(...compareSchemasRecursive(oldItems, newItems, context, `${fieldPath}[]`));
+    }
+    return changes;
+}
+function getRequestBodySchema(op) {
+    var _a;
+    const requestBody = op.requestBody;
+    const content = (_a = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content) !== null && _a !== void 0 ? _a : {};
+    for (const media of Object.values(content)) {
+        const schema = schemaObject(media.schema);
+        if (schema)
+            return schema;
+    }
+    return undefined;
+}
+function getResponseSchema(op, code) {
+    var _a, _b;
+    const response = (_a = op.responses) === null || _a === void 0 ? void 0 : _a[code];
+    const content = (_b = response === null || response === void 0 ? void 0 : response.content) !== null && _b !== void 0 ? _b : {};
+    for (const media of Object.values(content)) {
+        const schema = schemaObject(media.schema);
+        if (schema)
+            return schema;
+    }
+    return undefined;
+}
 // ─── Spec comparison ──────────────────────────────────────────────────────────
 /**
  * Load and dereference an OpenAPI/Swagger spec from a file path.
@@ -89,7 +267,7 @@ async function loadSpec(specPath) {
  * Compare two API specs and return a list of detected changes.
  */
 function compareSpecs(oldApi, newApi) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const changes = [];
     const oldEndpoints = extractEndpoints(oldApi);
     const newEndpoints = extractEndpoints(newApi);
@@ -101,99 +279,134 @@ function compareSpecs(oldApi, newApi) {
     for (const ep of newEndpoints) {
         newMap.set(`${ep.method}:${ep.path}`, ep);
     }
-    // Removed endpoints (breaking)
     for (const [key, oldEp] of oldMap) {
         if (!newMap.has(key)) {
-            changes.push({
+            const removedDeprecated = oldEp.operation.deprecated === true;
+            changes.push(createEndpointChange({
                 method: oldEp.method,
                 path: oldEp.path,
-                changeType: 'removed',
-                breaking: true,
+                changeType: removedDeprecated ? 'removed-deprecated' : 'removed',
+                severity: 'BREAKING',
                 description: `Endpoint removed: ${oldEp.method.toUpperCase()} ${oldEp.path}`,
-            });
+            }));
         }
     }
-    // Added endpoints (non-breaking)
     for (const [key, newEp] of newMap) {
         if (!oldMap.has(key)) {
-            changes.push({
+            changes.push(createEndpointChange({
                 method: newEp.method,
                 path: newEp.path,
                 changeType: 'added',
-                breaking: false,
+                severity: 'SAFE',
                 description: `Endpoint added: ${newEp.method.toUpperCase()} ${newEp.path}`,
-            });
+            }));
         }
     }
-    // Changed endpoints
     for (const [key, oldEp] of oldMap) {
         const newEp = newMap.get(key);
         if (!newEp)
             continue;
-        // Check response codes
+        if (!oldEp.operation.deprecated && newEp.operation.deprecated) {
+            changes.push(createEndpointChange({
+                method: oldEp.method,
+                path: oldEp.path,
+                changeType: 'deprecated',
+                severity: 'SAFE',
+                description: `Endpoint deprecated: ${oldEp.method.toUpperCase()} ${oldEp.path}`,
+            }));
+        }
+        const oldSecurity = getOperationSecurity(oldApi, oldEp.operation);
+        const newSecurity = getOperationSecurity(newApi, newEp.operation);
+        if (JSON.stringify(oldSecurity) !== JSON.stringify(newSecurity)) {
+            const oldPublic = isPublicEndpoint(oldSecurity);
+            const newPublic = isPublicEndpoint(newSecurity);
+            changes.push(createEndpointChange({
+                method: oldEp.method,
+                path: oldEp.path,
+                changeType: 'changed-auth-requirement',
+                severity: oldPublic && !newPublic ? 'BREAKING' : 'SAFE',
+                description: `Authentication requirement changed for ${oldEp.method.toUpperCase()} ${oldEp.path}`,
+                oldValue: oldPublic ? 'public' : 'authenticated',
+                newValue: newPublic ? 'public' : 'authenticated',
+            }));
+        }
         const oldCodes = new Set(getResponseCodes(oldEp.operation));
         const newCodes = new Set(getResponseCodes(newEp.operation));
         const removedCodes = [...oldCodes].filter((c) => !newCodes.has(c));
         if (removedCodes.length > 0) {
-            changes.push({
+            changes.push(createEndpointChange({
                 method: oldEp.method,
                 path: oldEp.path,
                 changeType: 'changed-response-codes',
-                breaking: true,
+                severity: 'BREAKING',
                 description: `Response codes removed from ${oldEp.method.toUpperCase()} ${oldEp.path}: ${removedCodes.join(', ')}`,
-            });
+                oldValue: removedCodes.join(', '),
+            }));
+        }
+        for (const responseCode of [...oldCodes].filter((code) => newCodes.has(code))) {
+            changes.push(...compareSchemasRecursive(getResponseSchema(oldEp.operation, responseCode), getResponseSchema(newEp.operation, responseCode), { kind: 'response', method: oldEp.method, path: oldEp.path, location: `responses.${responseCode}` }));
         }
-        // Check parameters
+        changes.push(...compareSchemasRecursive(getRequestBodySchema(oldEp.operation), getRequestBodySchema(newEp.operation), { kind: 'request', method: oldEp.method, path: oldEp.path }));
         const oldParams = getParameters(oldEp.operation);
         const newParams = getParameters(newEp.operation);
         const newParamMap = new Map(newParams.map((p) => [paramKey(p), p]));
         for (const oldParam of oldParams) {
             const newParam = newParamMap.get(paramKey(oldParam));
             if (!newParam) {
-                // Parameter removed — breaking if it was required
-                changes.push({
+                changes.push(createEndpointChange({
                     method: oldEp.method,
                     path: oldEp.path,
                     changeType: 'changed-parameter',
-                    breaking: oldParam.required === true,
+                    severity: oldParam.required === true ? 'BREAKING' : 'DANGEROUS',
                     description: `Parameter removed from ${oldEp.method.toUpperCase()} ${oldEp.path}: ${oldParam.in} '${oldParam.name}'${oldParam.required ? ' (required)' : ''}`,
-                });
+                    affectedField: `${oldParam.in}.${oldParam.name}`,
+                }));
                 continue;
             }
-            // Parameter type/format changed — breaking
-            const oldSchema = ((_a = oldParam.schema) !== null && _a !== void 0 ? _a : {});
-            const newSchema = ((_b = newParam.schema) !== null && _b !== void 0 ? _b : {});
-            if (oldSchema['type'] !== newSchema['type'] || oldSchema['format'] !== newSchema['format']) {
-                changes.push({
+            const oldSchema = schemaObject(oldParam.schema);
+            const newSchema = schemaObject(newParam.schema);
+            if (getSchemaType(oldSchema) !== getSchemaType(newSchema) || (oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.format) !== (newSchema === null || newSchema === void 0 ? void 0 : newSchema.format)) {
+                changes.push(createEndpointChange({
                     method: oldEp.method,
                     path: oldEp.path,
-                    changeType: 'changed-parameter',
-                    breaking: true,
-                    description: `Parameter type/format changed for ${oldEp.method.toUpperCase()} ${oldEp.path}: '${oldParam.name}' (${oldSchema['type']}/${oldSchema['format']} → ${newSchema['type']}/${newSchema['format']})`,
-                });
+                    changeType: 'changed-parameter-type',
+                    severity: 'BREAKING',
+                    description: `Parameter type/format changed for ${oldEp.method.toUpperCase()} ${oldEp.path}: '${oldParam.name}' (${getSchemaType(oldSchema)}/${oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.format} → ${getSchemaType(newSchema)}/${newSchema === null || newSchema === void 0 ? void 0 : newSchema.format})`,
+                    affectedField: `${oldParam.in}.${oldParam.name}`,
+                    oldValue: `${(_a = getSchemaType(oldSchema)) !== null && _a !== void 0 ? _a : 'unknown'}/${(_b = oldSchema === null || oldSchema === void 0 ? void 0 : oldSchema.format) !== null && _b !== void 0 ? _b : 'none'}`,
+                    newValue: `${(_c = getSchemaType(newSchema)) !== null && _c !== void 0 ? _c : 'unknown'}/${(_d = newSchema === null || newSchema === void 0 ? void 0 : newSchema.format) !== null && _d !== void 0 ? _d : 'none'}`,
+                }));
             }
-            // Required flag changed from optional to required — breaking
             if (!oldParam.required && newParam.required) {
-                changes.push({
+                changes.push(createEndpointChange({
                     method: oldEp.method,
                     path: oldEp.path,
-                    changeType: 'changed-parameter',
-                    breaking: true,
+                    changeType: 'changed-parameter-required',
+                    severity: 'BREAKING',
                     description: `Parameter '${oldParam.name}' became required in ${oldEp.method.toUpperCase()} ${oldEp.path}`,
-                });
+                    affectedField: `${oldParam.in}.${oldParam.name}`,
+                }));
+            }
+            if (oldSchema && newSchema) {
+                changes.push(...compareSchemasRecursive(oldSchema, newSchema, {
+                    kind: 'parameter',
+                    method: oldEp.method,
+                    path: oldEp.path,
+                    location: `${oldParam.in}.${oldParam.name}`,
+                }));
             }
         }
-        // New required parameters added — breaking
         const oldParamMap = new Map(oldParams.map((p) => [paramKey(p), p]));
         for (const newParam of newParams) {
-            if (!oldParamMap.has(paramKey(newParam)) && newParam.required) {
-                changes.push({
+            if (!oldParamMap.has(paramKey(newParam))) {
+                changes.push(createEndpointChange({
                     method: newEp.method,
                     path: newEp.path,
-                    changeType: 'changed-parameter',
-                    breaking: true,
-                    description: `Required parameter added to ${newEp.method.toUpperCase()} ${newEp.path}: ${newParam.in} '${newParam.name}'`,
-                });
+                    changeType: newParam.required ? 'changed-parameter-required' : 'changed-parameter',
+                    severity: newParam.required ? 'BREAKING' : 'SAFE',
+                    description: `${newParam.required ? 'Required' : 'Optional'} parameter added to ${newEp.method.toUpperCase()} ${newEp.path}: ${newParam.in} '${newParam.name}'`,
+                    affectedField: `${newParam.in}.${newParam.name}`,
+                }));
             }
         }
     }
@@ -204,14 +417,16 @@ function compareSpecs(oldApi, newApi) {
  * Parse Pact-format JSON contract files matching the given glob pattern or directory.
  */
 async function parseContractFiles(contractsGlob) {
-    let pattern = contractsGlob;
-    // If the provided path is a directory, search recursively for JSON files inside it
-    if (fs.existsSync(contractsGlob) && fs.statSync(contractsGlob).isDirectory()) {
-        pattern = path.join(contractsGlob, '**/*.json').replace(/\\/g, '/');
+    let patterns = contractsGlob
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (patterns.length === 1 && fs.existsSync(patterns[0]) && fs.statSync(patterns[0]).isDirectory()) {
+        patterns = [path.join(patterns[0], '**/*.json').replace(/\\/g, '/')];
     }
-    const files = await (0, fast_glob_1.default)(pattern, { absolute: true });
+    const files = await (0, fast_glob_1.default)(patterns, { absolute: true, onlyFiles: true, unique: true });
     const contracts = [];
-    for (const filePath of files) {
+    for (const filePath of files.filter((filePath) => filePath.endsWith('.json'))) {
         try {
             const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
             const contract = parsePactContract(raw, filePath);
@@ -263,33 +478,20 @@ function parsePactContract(raw, filePath) {
     return { consumer, provider, interactions, filePath };
 }
 // ─── Contract verification ────────────────────────────────────────────────────
-/**
- * Normalise a path template by replacing Pact-style `:param` segments with
- * OpenAPI-style `{param}` segments so the two formats can be compared.
- */
 function normalisePath(p) {
     return p.replace(/:([^/]+)/g, '{$1}');
 }
-/**
- * Check whether a path from a contract matches an OpenAPI spec path,
- * accounting for path parameter placeholders in different styles.
- */
 function pathMatchesSpec(contractPath, specPath) {
     const normalised = normalisePath(contractPath);
     if (normalised === specPath)
         return true;
-    // Build a regex from the spec path template and test the contract path
     const regexStr = '^' + specPath.replace(/\{[^}]+\}/g, '[^/]+') + '$';
     return new RegExp(regexStr).test(contractPath);
 }
-/**
- * Verify consumer contracts against a new API spec.
- */
 function verifyContracts(contracts, newApi) {
     const endpoints = extractEndpoints(newApi);
     return contracts.map((contract) => {
         const interactionResults = contract.interactions.map((interaction) => {
-            // Find matching endpoint in spec
             const match = endpoints.find((ep) => ep.method === interaction.method && pathMatchesSpec(interaction.path, ep.path));
             if (!match) {
                 return {
@@ -298,11 +500,9 @@ function verifyContracts(contracts, newApi) {
                     reason: `Endpoint not found in new spec: ${interaction.method.toUpperCase()} ${interaction.path}`,
                 };
             }
-            // Check expected response status code is present in spec
             const responseCodes = getResponseCodes(match.operation);
             const statusStr = String(interaction.expectedStatus);
-            if (!responseCodes.includes(statusStr) &&
-                !responseCodes.includes('default')) {
+            if (!responseCodes.includes(statusStr) && !responseCodes.includes('default')) {
                 return {
                     interaction,
                     passed: false,
@@ -316,23 +516,18 @@ function verifyContracts(contracts, newApi) {
     });
 }
 // ─── Metrics ──────────────────────────────────────────────────────────────────
-/**
- * Compute compatibility percentage based on detected breaking changes.
- */
 function computeCompatibilityPercent(totalOldEndpoints, breakingChanges) {
     if (totalOldEndpoints === 0)
         return 100;
-    // Count uniquely affected old endpoints (by method+path)
+    const unaffected = countCompatibleEndpoints(totalOldEndpoints, breakingChanges);
+    return parseFloat(((unaffected / totalOldEndpoints) * 100).toFixed(2));
+}
+function countCompatibleEndpoints(totalOldEndpoints, breakingChanges) {
     const affectedKeys = new Set(breakingChanges
         .filter((c) => c.changeType !== 'added')
         .map((c) => `${c.method}:${c.path}`));
-    const unaffected = Math.max(0, totalOldEndpoints - affectedKeys.size);
-    return parseFloat(((unaffected / totalOldEndpoints) * 100).toFixed(2));
+    return Math.max(0, totalOldEndpoints - affectedKeys.size);
 }
-/**
- * Compute what fraction of new spec endpoints are covered by at least one
- * contract interaction.
- */
 function computeContractCoveragePercent(contracts, newApi) {
     const endpoints = extractEndpoints(newApi);
     const coveredKeys = new Set();
@@ -348,14 +543,69 @@ function computeContractCoveragePercent(contracts, newApi) {
     const coveragePercent = total === 0 ? 100 : parseFloat(((covered / total) * 100).toFixed(2));
     return { coveredEndpoints: covered, totalEndpoints: total, coveragePercent };
 }
+function buildSeveritySummary(changes) {
+    return changes.reduce((summary, change) => {
+        switch (change.severity) {
+            case 'BREAKING':
+                summary.breaking += 1;
+                break;
+            case 'DANGEROUS':
+                summary.dangerous += 1;
+                break;
+            case 'SAFE':
+                summary.safe += 1;
+                break;
+            case 'INFO':
+                summary.info += 1;
+                break;
+        }
+        return summary;
+    }, { breaking: 0, dangerous: 0, safe: 0, info: 0 });
+}
+function buildPerConsumerCoverage(verificationResults) {
+    return verificationResults.map((result) => {
+        const interactionCount = result.interactionResults.length;
+        const passingInteractions = result.interactionResults.filter((entry) => entry.passed).length;
+        const coveragePercent = interactionCount === 0 ? 100 : parseFloat(((passingInteractions / interactionCount) * 100).toFixed(2));
+        return {
+            consumerName: result.contract.consumer,
+            interactionCount,
+            passingInteractions,
+            coveragePercent,
+        };
+    });
+}
+function buildDeployBlockers(report) {
+    const blockers = [];
+    if (report.breakingChanges.some((c) => c.severity === 'BREAKING')) {
+        blockers.push('BREAKING API changes detected');
+    }
+    if (report.contractVerificationResults.some((r) => !r.passed)) {
+        blockers.push('One or more consumer contract verifications failed');
+    }
+    if (report.schemaEvolutionResults.some((r) => r.overallRisk === 'BREAKING')) {
+        blockers.push('Breaking schema evolution detected');
+    }
+    return blockers;
+}
+function computeCanDeploy(report) {
+    if (report.breakingChanges.some((c) => c.severity === 'BREAKING'))
+        return false;
+    if (report.contractVerificationResults.some((r) => !r.passed))
+        return false;
+    if (report.schemaEvolutionResults.some((r) => r.overallRisk === 'BREAKING'))
+        return false;
+    return true;
+}
 // ─── Report builder ───────────────────────────────────────────────────────────
-function buildCompatibilityReport(oldApi, newApi, changes, verificationResults, oldSpecPath, newSpecPath) {
+function buildCompatibilityReport(oldApi, newApi, changes, verificationResults, oldSpecPath, newSpecPath, options = {}) {
+    var _a, _b, _c;
     const oldEndpoints = extractEndpoints(oldApi);
     const breakingChanges = changes.filter((c) => c.breaking);
     const nonBreakingChanges = changes.filter((c) => !c.breaking);
     const compatibilityPercent = computeCompatibilityPercent(oldEndpoints.length, breakingChanges);
     const coverageMetrics = computeContractCoveragePercent(verificationResults.map((r) => r.contract), newApi);
-    return {
+    const report = {
         generatedAt: new Date().toISOString(),
         oldSpecPath,
         newSpecPath,
@@ -367,12 +617,35 @@ function buildCompatibilityReport(oldApi, newApi, changes, verificationResults,
         totalNewEndpoints: coverageMetrics.totalEndpoints,
         contractCoveredEndpoints: coverageMetrics.coveredEndpoints,
         contractCoveragePercent: coverageMetrics.coveragePercent,
+        severitySummary: buildSeveritySummary(changes),
+        springCloudContracts: (_a = options.springCloudContracts) !== null && _a !== void 0 ? _a : [],
+        schemaEvolutionResults: (_b = options.schemaEvolutionResults) !== null && _b !== void 0 ? _b : [],
+        matrix: (_c = options.matrix) !== null && _c !== void 0 ? _c : null,
+        canDeploy: true,
+        deployBlockers: [],
+        perConsumerCoverage: buildPerConsumerCoverage(verificationResults),
     };
+    report.canDeploy = computeCanDeploy(report);
+    report.deployBlockers = buildDeployBlockers(report);
+    return report;
 }
 // ─── Report writers ───────────────────────────────────────────────────────────
 function writeCompatibilityJson(report, reportsDir) {
-    const outPath = path.join(reportsDir, 'compatibility-contracts.json');
-    fs.writeFileSync(outPath, JSON.stringify(report, null, 2), 'utf-8');
+    const payload = {
+        ...report,
+        items: [...report.breakingChanges, ...report.nonBreakingChanges].map((change) => ({
+            id: `${change.method.toUpperCase()} ${change.path} (${change.changeType})`,
+            covered: !change.breaking,
+            description: change.description,
+            tests: change.affectedConsumers,
+        })),
+        coveragePercent: report.compatibilityPercent,
+        coveredItems: countCompatibleEndpoints(report.totalOldEndpoints, report.breakingChanges),
+        totalItems: report.totalOldEndpoints,
+    };
+    for (const fileName of ['compatibility-contracts.json', 'compatibility-coverage.json']) {
+        fs.writeFileSync(path.join(reportsDir, fileName), JSON.stringify(payload, null, 2), 'utf-8');
+    }
 }
 function writeCompatibilityHtml(report, reportsDir) {
     const breakingRows = report.breakingChanges
@@ -380,6 +653,7 @@ function writeCompatibilityHtml(report, reportsDir) {
       <td>${c.method.toUpperCase()}</td>
       <td>${c.path}</td>
       <td>${c.changeType}</td>
+      <td>${c.severity}</td>
       <td>${c.description}</td>
     </tr>`)
         .join('\n');
@@ -388,6 +662,7 @@ function writeCompatibilityHtml(report, reportsDir) {
       <td>${c.method.toUpperCase()}</td>
       <td>${c.path}</td>
       <td>${c.changeType}</td>
+      <td>${c.severity}</td>
       <td>${c.description}</td>
     </tr>`)
         .join('\n');
@@ -404,6 +679,16 @@ function writeCompatibilityHtml(report, reportsDir) {
     </tr>`;
     }))
         .join('\n');
+    const schemaRows = report.schemaEvolutionResults
+        .flatMap((result) => result.changes.map((change) => `    <tr class="${change.breaking ? 'fail' : 'pass'}">
+      <td>${result.topicOrQueue}</td>
+      <td>${result.format}</td>
+      <td>${change.field}</td>
+      <td>${change.changeType}</td>
+      <td>${change.breaking ? 'BREAKING' : 'SAFE'}</td>
+      <td>${change.fixHint}</td>
+    </tr>`))
+        .join('\n');
     const compatColor = report.compatibilityPercent >= 80
         ? '#e6ffe6'
         : report.compatibilityPercent >= 50
@@ -424,7 +709,7 @@ function writeCompatibilityHtml(report, reportsDir) {
     h1 { margin-bottom: 0.25rem; }
     h2 { margin-top: 2rem; }
     .meta { color: #666; font-size: 0.9rem; margin-bottom: 1.5rem; }
-    table { border-collapse: collapse; width: 100%; max-width: 1000px; margin-bottom: 1.5rem; }
+    table { border-collapse: collapse; width: 100%; max-width: 1100px; margin-bottom: 1.5rem; }
     th, td { border: 1px solid #ccc; padding: 0.5rem 1rem; text-align: left; }
     th { background: #f0f0f0; }
     tr.breaking { background: #ffe6e6; }
@@ -447,6 +732,9 @@ function writeCompatibilityHtml(report, reportsDir) {
       Contract Coverage: ${report.contractCoveragePercent}%
       (${report.contractCoveredEndpoints}/${report.totalNewEndpoints} endpoints)
     </div>
+    <div class="summary-box" style="background:${report.canDeploy ? '#e6ffe6' : '#ffe6e6'}">
+      Can Deploy: ${report.canDeploy ? 'YES' : 'NO'}
+    </div>
   </div>
 
   <h2>Breaking Changes</h2>
@@ -454,7 +742,7 @@ function writeCompatibilityHtml(report, reportsDir) {
         ? '<p>No breaking changes detected. ✅</p>'
         : `<table>
     <thead>
-      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Description</th></tr>
+      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Severity</th><th>Description</th></tr>
     </thead>
     <tbody>
 ${breakingRows}
@@ -466,7 +754,7 @@ ${breakingRows}
         ? '<p>No non-breaking changes detected.</p>'
         : `<table>
     <thead>
-      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Description</th></tr>
+      <tr><th>Method</th><th>Path</th><th>Change Type</th><th>Severity</th><th>Description</th></tr>
     </thead>
     <tbody>
 ${nonBreakingRows}
@@ -484,14 +772,28 @@ ${nonBreakingRows}
 ${contractRows}
     </tbody>
   </table>`}
+
+  <h2>Schema Evolution</h2>
+  ${schemaRows.length === 0
+        ? '<p>No schema evolution changes detected.</p>'
+        : `<table>
+    <thead>
+      <tr><th>Topic / Queue</th><th>Format</th><th>Field</th><th>Change Type</th><th>Risk</th><th>Fix Hint</th></tr>
+    </thead>
+    <tbody>
+${schemaRows}
+    </tbody>
+  </table>`}
+
+  ${report.deployBlockers.length === 0
+        ? '<p>No deployment blockers.</p>'
+        : `<h2>Deploy Blockers</h2><ul>${report.deployBlockers.map((blocker) => `<li>${blocker}</li>`).join('')}</ul>`}
 </body>
 </html>`;
-    const outPath = path.join(reportsDir, 'compatibility-contracts.html');
-    fs.writeFileSync(outPath, html, 'utf-8');
+    for (const fileName of ['compatibility-contracts.html', 'compatibility-coverage.html']) {
+        fs.writeFileSync(path.join(reportsDir, fileName), html, 'utf-8');
+    }
 }
-/**
- * Generate JSON and HTML compatibility reports.
- */
 function generateCompatibilityReports(report, reportsDir) {
     if (!fs.existsSync(reportsDir)) {
         fs.mkdirSync(reportsDir, { recursive: true });