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

package/dist/core/semanticDiff/semanticDiffReportSchema.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSemanticDiffReportSchema = validateSemanticDiffReportSchema;
+const json_schema_1 = require("json-schema");
+const DiffReport_model_1 = require("../types/DiffReport.model");
+/** JSON Schema контракт унифицированного diff-отчёта. */
+const semanticDiffReportJsonSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        schemaVersion: {
+            type: 'string',
+            enum: [DiffReport_model_1.UNIFIED_DIFF_REPORT_SCHEMA_VERSION],
+            required: true,
+        },
+        timestamp: {
+            type: 'string',
+            minLength: 1,
+            required: true,
+        },
+        metadata: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                base: { type: 'string', minLength: 1, required: true },
+                target: { type: 'string', minLength: 1, required: true },
+                baseHash: { type: 'string', minLength: 1, required: true },
+                targetHash: { type: 'string', minLength: 1, required: true },
+            },
+        },
+        semantic: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                summary: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        breaking: { type: 'integer', minimum: 0, required: true },
+                        nonBreaking: { type: 'integer', minimum: 0, required: true },
+                        informational: { type: 'integer', minimum: 0, required: true },
+                    },
+                },
+                recommendation: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        semver: {
+                            type: 'string',
+                            enum: ['major', 'minor', 'patch'],
+                            required: true,
+                        },
+                        confidence: {
+                            type: 'string',
+                            enum: ['high', 'medium', 'low'],
+                            required: true,
+                        },
+                        reason: {
+                            type: 'string',
+                            minLength: 1,
+                            required: true,
+                        },
+                        reasons: {
+                            type: 'array',
+                            minItems: 1,
+                            required: true,
+                            items: {
+                                type: 'string',
+                                enum: ['HAS_BREAKING_CHANGES', 'HAS_BACKWARD_COMPATIBLE_CHANGES', 'HAS_INFORMATIONAL_ONLY_CHANGES', 'NO_API_SURFACE_CHANGES'],
+                            },
+                        },
+                    },
+                },
+                governance: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        summary: {
+                            type: 'object',
+                            additionalProperties: false,
+                            required: true,
+                            properties: {
+                                errors: { type: 'integer', minimum: 0, required: true },
+                                warnings: { type: 'integer', minimum: 0, required: true },
+                                info: { type: 'integer', minimum: 0, required: true },
+                            },
+                        },
+                        violations: {
+                            type: 'array',
+                            required: true,
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                properties: {
+                                    ruleId: { type: 'string', minLength: 1, required: true },
+                                    severity: {
+                                        type: 'string',
+                                        enum: ['error', 'warning', 'info'],
+                                        required: true,
+                                    },
+                                    message: { type: 'string', minLength: 1, required: true },
+                                    path: { type: 'string', minLength: 1, required: true },
+                                },
+                            },
+                        },
+                    },
+                },
+                changes: {
+                    type: 'array',
+                    required: true,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            type: { type: 'string', minLength: 1, required: true },
+                            severity: {
+                                type: 'string',
+                                enum: ['breaking', 'non-breaking', 'informational'],
+                                required: true,
+                            },
+                            message: { type: 'string', minLength: 1, required: true },
+                            path: { type: 'string', minLength: 1, required: true },
+                            from: {},
+                            to: {},
+                            fromRequired: { type: 'boolean' },
+                            toRequired: { type: 'boolean' },
+                            fromNullable: { type: 'boolean' },
+                            toNullable: { type: 'boolean' },
+                        },
+                    },
+                },
+            },
+        },
+        structural: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+                diff: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        breaking: { type: 'array', required: true, items: { type: 'object' } },
+                        warnings: { type: 'array', required: true, items: { type: 'object' } },
+                        info: { type: 'array', required: true, items: { type: 'object' } },
+                        all: { type: 'array', required: true, items: { type: 'object' } },
+                    },
+                },
+                miracles: {
+                    type: 'array',
+                    required: true,
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: {
+                            oldPath: { type: 'string', minLength: 1, required: true },
+                            newPath: { type: 'string', minLength: 1, required: true },
+                            type: {
+                                type: 'string',
+                                enum: ['RENAME', 'TYPE_COERCION'],
+                                required: true,
+                            },
+                            confidence: { type: 'number', minimum: 0, maximum: 1, required: true },
+                            status: {
+                                type: 'string',
+                                enum: ['auto-generated', 'confirmed'],
+                                required: true,
+                            },
+                            modelName: { type: 'string' },
+                            oldProperty: { type: 'string' },
+                            newProperty: { type: 'string' },
+                        },
+                    },
+                },
+                stats: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: true,
+                    properties: {
+                        totalChanges: { type: 'integer', minimum: 0, required: true },
+                        added: { type: 'integer', minimum: 0, required: true },
+                        removed: { type: 'integer', minimum: 0, required: true },
+                        changed: { type: 'integer', minimum: 0, required: true },
+                        ignored: { type: 'integer', minimum: 0 },
+                        stabilityScore: { type: 'integer', minimum: 0, maximum: 100, required: true },
+                    },
+                },
+            },
+        },
+    },
+};
+/**
+ * Валидирует payload diff-отчёта по JSON Schema контракту.
+ * @param report проверяемый отчёт
+ * @returns результат валидации с перечнем ошибок
+ */
+function validateSemanticDiffReportSchema(report) {
+    if (report === null || typeof report !== 'object') {
+        return {
+            valid: false,
+            errors: ['root: report must be an object'],
+        };
+    }
+    const result = (0, json_schema_1.validate)(report, semanticDiffReportJsonSchema);
+    return {
+        valid: result.valid,
+        errors: result.errors.map(error => `${error.property}: ${error.message}`),
+    };
+}

package/dist/core/strict/__tests__/validateOpenApiStrict.test.d.ts

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

package/dist/core/strict/__tests__/validateOpenApiStrict.test.d.ts.map

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

package/dist/core/strict/__tests__/validateOpenApiStrict.test.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const validateOpenApiStrict_1 = require("../validateOpenApiStrict");
+(0, node_test_1.describe)('@unit: validateOpenApiStrict', () => {
+    (0, node_test_1.test)('reports unresolved refs, fallback media type, suspicious default response, and missing operationId', () => {
+        const openApi = {
+            paths: {
+                '/pets': {
+                    post: {
+                        requestBody: {
+                            content: {
+                                'text/plain': {
+                                    schema: { type: 'string' },
+                                },
+                            },
+                        },
+                        responses: {
+                            default: {
+                                description: 'ok',
+                                content: {
+                                    'application/problem+json': {
+                                        schema: { type: 'object' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi,
+            context: {
+                paths: () => ['/spec/main.yaml'],
+                get: () => ({
+                    components: {
+                        schemas: {
+                            Pet: {
+                                $ref: '#/components/schemas/Missing',
+                            },
+                        },
+                    },
+                }),
+                exists: () => false,
+            },
+        });
+        node_assert_1.default.strictEqual(report.summary.errors, 1);
+        node_assert_1.default.strictEqual(report.summary.warnings, 3);
+        node_assert_1.default.strictEqual(report.summary.info, 1);
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'UNRESOLVED_REF'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'CONTENT_MEDIA_TYPE_FALLBACK'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'SUSPICIOUS_DEFAULT_RESPONSE'));
+        node_assert_1.default.ok(report.issues.some(issue => issue.code === 'MISSING_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'REQUIRE_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'NO_DEFAULT_WITHOUT_2XX'));
+    });
+    (0, node_test_1.test)('returns clean report when no strict issues found', () => {
+        const openApi = {
+            paths: {
+                '/pets': {
+                    get: {
+                        operationId: 'getPets',
+                        responses: {
+                            '200': {
+                                description: 'ok',
+                                content: {
+                                    'application/json': {
+                                        schema: { type: 'array' },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi,
+            context: {
+                paths: () => ['/spec/main.yaml'],
+                get: () => ({}),
+                exists: () => true,
+            },
+        });
+        node_assert_1.default.deepStrictEqual(report.summary, {
+            errors: 0,
+            warnings: 0,
+            info: 0,
+        });
+        node_assert_1.default.deepStrictEqual(report.issues, []);
+        node_assert_1.default.deepStrictEqual(report.governance.violations, []);
+    });
+    (0, node_test_1.test)('includes preIssues from parser validation into final report', () => {
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi: { paths: {} },
+            context: {
+                paths: () => [],
+                get: () => ({}),
+                exists: () => true,
+            },
+            preIssues: [
+                {
+                    severity: 'error',
+                    code: 'OPENAPI_PARSER_VALIDATION_FAILED',
+                    message: 'Parser validation failed',
+                    path: '/spec/openapi.yaml',
+                },
+            ],
+        });
+        node_assert_1.default.strictEqual(report.summary.errors, 1);
+        node_assert_1.default.strictEqual(report.summary.warnings, 0);
+        node_assert_1.default.strictEqual(report.summary.info, 0);
+        node_assert_1.default.strictEqual(report.issues.length, 1);
+        node_assert_1.default.strictEqual(report.issues[0].code, 'OPENAPI_PARSER_VALIDATION_FAILED');
+        node_assert_1.default.deepStrictEqual(report.governance.violations, []);
+    });
+    (0, node_test_1.test)('applies governance config overrides in strict mode', () => {
+        const report = (0, validateOpenApiStrict_1.validateOpenApiStrict)({
+            openApi: {
+                paths: {
+                    '/pets': {
+                        get: {
+                            responses: {
+                                default: {
+                                    description: 'fallback',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            context: {
+                paths: () => [],
+                get: () => ({}),
+                exists: () => true,
+            },
+            governanceConfig: {
+                rules: {
+                    REQUIRE_OPERATION_ID: {
+                        enabled: false,
+                    },
+                    NO_DEFAULT_WITHOUT_2XX: {
+                        severity: 'error',
+                    },
+                },
+            },
+        });
+        node_assert_1.default.ok(!report.governance.violations.some(violation => violation.ruleId === 'REQUIRE_OPERATION_ID'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'NO_DEFAULT_WITHOUT_2XX' && violation.severity === 'error'));
+    });
+});

package/dist/core/strict/validateOpenApiStrict.d.ts

@@ -0,0 +1,43 @@
+import { Context } from '../Context';
+import { GovernancePolicyConfig, GovernanceReport } from '../governance/evaluateGovernanceRules';
+import { CommonOpenApi } from '../types/shared/CommonOpenApi.model';
+type StrictIssueSeverity = 'error' | 'warning' | 'info';
+type StrictIssue = {
+    severity: StrictIssueSeverity;
+    code: 'UNRESOLVED_REF' | 'CONTENT_MEDIA_TYPE_FALLBACK' | 'SUSPICIOUS_DEFAULT_RESPONSE' | 'MISSING_OPERATION_ID' | 'OPENAPI_PARSER_VALIDATION_FAILED';
+    message: string;
+    path: string;
+};
+type StrictSummary = {
+    errors: number;
+    warnings: number;
+    info: number;
+};
+export type StrictOpenApiReport = {
+    summary: StrictSummary;
+    governance: GovernanceReport;
+    issues: StrictIssue[];
+};
+type StrictValidationContext = Pick<Context, 'paths' | 'get' | 'exists'> & Partial<Pick<Context, 'getAllCanonicalRefs'>>;
+type ValidateOpenApiStrictParams = {
+    openApi: CommonOpenApi;
+    context: StrictValidationContext;
+    preIssues?: StrictIssue[];
+    governanceConfig?: GovernancePolicyConfig;
+};
+/**
+ * Runs SwaggerParser built-in `validate` and converts parser failure into strict issues.
+ * This check complements (but does not replace) custom strict diagnostics.
+ */
+export declare function validateWithSwaggerParser(inputPath: string): Promise<StrictIssue[]>;
+/**
+ * Runs strict OpenAPI diagnostics and returns a structured report.
+ */
+export declare function validateOpenApiStrict(params: ValidateOpenApiStrictParams): StrictOpenApiReport;
+/**
+ * Writes strict diagnostics report to a JSON file and returns absolute file path.
+ * Creates target directory if it does not exist.
+ */
+export declare function writeOpenApiStrictReport(report: StrictOpenApiReport, reportFilePath: string): Promise<string>;
+export {};
+//# sourceMappingURL=validateOpenApiStrict.d.ts.map

package/dist/core/strict/validateOpenApiStrict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateOpenApiStrict.d.ts","sourceRoot":"","sources":["../../../src/core/strict/validateOpenApiStrict.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAA2B,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAC1H,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,KAAK,mBAAmB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAExD,KAAK,WAAW,GAAG;IACf,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,GAAG,6BAA6B,GAAG,6BAA6B,GAAG,sBAAsB,GAAG,kCAAkC,CAAC;IACrJ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,aAAa,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,WAAW,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,uBAAuB,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;AAEzH,KAAK,2BAA2B,GAAG;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,uBAAuB,CAAC;IACjC,SAAS,CAAC,EAAE,WAAW,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AAqNF;;;GAGG;AACH,wBAAsB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAiBzF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,2BAA2B,GAAG,mBAAmB,CAe9F;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAanH"}

package/dist/core/strict/validateOpenApiStrict.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWithSwaggerParser = validateWithSwaggerParser;
+exports.validateOpenApiStrict = validateOpenApiStrict;
+exports.writeOpenApiStrictReport = writeOpenApiStrictReport;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const path_1 = __importDefault(require("path"));
+const fileSystemHelpers_1 = require("../../common/utils/fileSystemHelpers");
+const format_1 = require("../../common/utils/format");
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const getContent_1 = require("../api/v3/parser/getContent");
+const evaluateGovernanceRules_1 = require("../governance/evaluateGovernanceRules");
+const HTTP_METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+/**
+ * Normalizes a media type value by:
+ * 1) removing parameters after `;`
+ * 2) trimming surrounding spaces
+ * 3) converting to lowercase.
+ */
+function normalizeMediaType(mediaType) {
+    return mediaType.split(';')[0].trim().toLowerCase();
+}
+/**
+ * Checks whether a response code key is an explicit success code.
+ * Supports exact `2xx` numeric codes and OpenAPI range form `2XX`.
+ */
+function isSuccessResponseCode(responseCode) {
+    return /^\s*2\d\d\s*$/.test(responseCode) || /^\s*2xx\s*$/i.test(responseCode);
+}
+/**
+ * Builds aggregated counters for report summary from collected issues.
+ */
+function createSummary(issues) {
+    return issues.reduce((summary, issue) => {
+        if (issue.severity === 'error') {
+            summary.errors += 1;
+        }
+        else if (issue.severity === 'warning') {
+            summary.warnings += 1;
+        }
+        else {
+            summary.info += 1;
+        }
+        return summary;
+    }, { errors: 0, warnings: 0, info: 0 });
+}
+/**
+ * Extracts source file path from a canonical ref.
+ * Example: `/spec/pet.yaml#/components/schemas/Pet` -> `/spec/pet.yaml`.
+ */
+function getSourceFileFromRef(ref) {
+    return ref.split('#')[0] || ref;
+}
+/**
+ * Returns refs to traverse for strict `$ref` checks.
+ *
+ * Priority:
+ * 1) Canonical refs from `context.getAllCanonicalRefs()` when available.
+ * 2) Fallback to file-level refs from `context.paths()`.
+ */
+function getSchemaTraversalRefs(context) {
+    if (typeof context.getAllCanonicalRefs === 'function') {
+        const canonicalRefs = context.getAllCanonicalRefs();
+        if (canonicalRefs.length > 0) {
+            return canonicalRefs;
+        }
+    }
+    return context.paths();
+}
+/**
+ * Traverses resolved schemas and collects diagnostics for unresolved `$ref`.
+ *
+ * Uses Context methods:
+ * - `getAllCanonicalRefs()` to iterate canonical refs with fragments (when available)
+ * - `paths()` to iterate source schema files
+ * - `get()` to load schema data
+ * - `exists()` to validate each discovered `$ref`
+ *
+ * Duplicate diagnostics are removed via a local dedupe set.
+ */
+function collectUnresolvedRefIssues(context) {
+    const issues = [];
+    const dedupe = new Set();
+    const walk = (node, sourceFile, pathSegments) => {
+        if (!node || typeof node !== 'object') {
+            return;
+        }
+        const objectNode = node;
+        if (typeof objectNode.$ref === 'string') {
+            const ref = objectNode.$ref;
+            const isRefExists = context.exists(ref, sourceFile);
+            if (!isRefExists) {
+                const issuePath = `${sourceFile} ${pathSegments.join('.') || '$'}.$ref`;
+                const dedupeKey = `${sourceFile}|${issuePath}|${ref}`;
+                if (!dedupe.has(dedupeKey)) {
+                    dedupe.add(dedupeKey);
+                    issues.push({
+                        severity: 'error',
+                        code: 'UNRESOLVED_REF',
+                        message: `Unresolved $ref: ${ref}`,
+                        path: issuePath,
+                    });
+                }
+            }
+        }
+        if (Array.isArray(node)) {
+            node.forEach((item, index) => walk(item, sourceFile, [...pathSegments, `[${index}]`]));
+            return;
+        }
+        for (const [key, value] of Object.entries(objectNode)) {
+            walk(value, sourceFile, [...pathSegments, key]);
+        }
+    };
+    const traversalRefs = getSchemaTraversalRefs(context);
+    for (const traversalRef of traversalRefs) {
+        try {
+            const schema = context.get(traversalRef);
+            const sourceFile = getSourceFileFromRef(traversalRef);
+            walk(schema, sourceFile, []);
+        }
+        catch {
+            // Ignore non-schema technical refs.
+        }
+    }
+    return issues;
+}
+/**
+ * Collects operation-level diagnostics:
+ * - `info` for missing `operationId`
+ * - `warning` for fallback media type selection
+ * - `warning` for `default` response without explicit `2xx`.
+ */
+function collectOperationIssues(openApi) {
+    const issues = [];
+    const paths = openApi.paths;
+    for (const [routePath, pathItem] of Object.entries(paths ?? {})) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem?.[method];
+            if (!operation || typeof operation !== 'object') {
+                continue;
+            }
+            const operationPath = `${routePath} ${method.toUpperCase()}`;
+            if (!operation.operationId) {
+                issues.push({
+                    severity: 'info',
+                    code: 'MISSING_OPERATION_ID',
+                    message: 'Operation does not define operationId.',
+                    path: operationPath,
+                });
+            }
+            const requestBodyContent = operation?.requestBody?.content;
+            if (requestBodyContent && typeof requestBodyContent === 'object') {
+                const selectedContent = (0, getContent_1.getContent)(requestBodyContent);
+                if (selectedContent && normalizeMediaType(selectedContent.mediaType) !== 'application/json') {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'CONTENT_MEDIA_TYPE_FALLBACK',
+                        message: `No application/json found, fallback media type selected: ${selectedContent.mediaType}`,
+                        path: `${operationPath} requestBody.content`,
+                    });
+                }
+            }
+            const responses = operation?.responses;
+            if (responses && typeof responses === 'object') {
+                const responseCodes = Object.keys(responses);
+                const hasDefaultResponse = responseCodes.includes('default');
+                const hasExplicitSuccessResponse = responseCodes.some(isSuccessResponseCode);
+                if (hasDefaultResponse && !hasExplicitSuccessResponse) {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'SUSPICIOUS_DEFAULT_RESPONSE',
+                        message: 'Default response is used without an explicit 2xx response.',
+                        path: `${operationPath} responses.default`,
+                    });
+                }
+                for (const responseCode of responseCodes) {
+                    const response = responses[responseCode];
+                    const responseContent = response?.content;
+                    if (!responseContent || typeof responseContent !== 'object') {
+                        continue;
+                    }
+                    const selectedContent = (0, getContent_1.getContent)(responseContent);
+                    if (selectedContent && normalizeMediaType(selectedContent.mediaType) !== 'application/json') {
+                        issues.push({
+                            severity: 'warning',
+                            code: 'CONTENT_MEDIA_TYPE_FALLBACK',
+                            message: `No application/json found, fallback media type selected: ${selectedContent.mediaType}`,
+                            path: `${operationPath} responses.${responseCode}.content`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Runs SwaggerParser built-in `validate` and converts parser failure into strict issues.
+ * This check complements (but does not replace) custom strict diagnostics.
+ */
+async function validateWithSwaggerParser(inputPath) {
+    const parser = new swagger_parser_1.default();
+    const absoluteInputPath = (0, pathHelpers_1.resolveHelper)(inputPath);
+    try {
+        await parser.validate(absoluteInputPath);
+        return [];
+    }
+    catch (error) {
+        return [
+            {
+                severity: 'error',
+                code: 'OPENAPI_PARSER_VALIDATION_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                path: absoluteInputPath,
+            },
+        ];
+    }
+}
+/**
+ * Runs strict OpenAPI diagnostics and returns a structured report.
+ */
+function validateOpenApiStrict(params) {
+    const { openApi, context, preIssues = [], governanceConfig } = params;
+    const issues = [...preIssues, ...collectUnresolvedRefIssues(context), ...collectOperationIssues(openApi)];
+    const governance = (0, evaluateGovernanceRules_1.evaluateGovernanceRules)({
+        openApi,
+        allowBreaking: true,
+        governanceConfig,
+    });
+    return {
+        summary: createSummary(issues),
+        governance,
+        issues,
+    };
+}
+/**
+ * Writes strict diagnostics report to a JSON file and returns absolute file path.
+ * Creates target directory if it does not exist.
+ */
+async function writeOpenApiStrictReport(report, reportFilePath) {
+    const resolvedReportPath = (0, pathHelpers_1.resolveHelper)(process.cwd(), reportFilePath);
+    const reportDir = path_1.default.dirname(resolvedReportPath);
+    const isReportDirExists = await fileSystemHelpers_1.fileSystemHelpers.exists(reportDir);
+    if (!isReportDirExists) {
+        await fileSystemHelpers_1.fileSystemHelpers.mkdir(reportDir);
+    }
+    const reportContent = await (0, format_1.format)(JSON.stringify(report), 'json');
+    await fileSystemHelpers_1.fileSystemHelpers.writeFile(resolvedReportPath, reportContent);
+    return resolvedReportPath;
+}