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

package/dist/cli/analyzeDiff/__tests__/analyzeDiff.cli.test.js

@@ -0,0 +1,365 @@
+"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_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const LoggerMessages_1 = require("../../../common/LoggerMessages");
+const semanticDiffReportSchema_1 = require("../../../core/semanticDiff/semanticDiffReportSchema");
+const analyzeDiff_1 = require("../analyzeDiff");
+const ciSummary_1 = require("../ciSummary");
+const repoRoot = node_path_1.default.join(__dirname, '..', '..', '..', '..');
+function createTempDir(t, prefix) {
+    const generatedRoot = node_path_1.default.join(__dirname, 'generated');
+    (0, node_fs_1.mkdirSync)(generatedRoot, { recursive: true });
+    const tempDir = (0, node_fs_1.mkdtempSync)(node_path_1.default.join(generatedRoot, prefix));
+    t.after(() => {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+}
+async function runAnalyzeDiffCli(options) {
+    const result = await (0, analyzeDiff_1.analyzeDiff)(options);
+    return {
+        exitCode: (0, analyzeDiff_1.toAnalyzeDiffExitCode)(result),
+        result,
+    };
+}
+(0, node_test_1.describe)('@unit: analyzeDiff cli', () => {
+    (0, node_test_1.test)('returns exit code 0 and skips when --input has no base source', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-skip-');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        const inputSpecPath = node_path_1.default.join(repoRoot, 'test/spec/v3.json');
+        const { exitCode, result } = await runAnalyzeDiffCli({
+            input: inputSpecPath,
+            outputReport: reportPath,
+            ci: false,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        node_assert_1.default.strictEqual(result.skipped, true);
+        node_assert_1.default.strictEqual(result.error, undefined);
+    });
+    (0, node_test_1.test)('returns exit code 0 for --input + --git', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-git-');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        const inputSpecPath = node_path_1.default.join(repoRoot, 'test/spec/v3.json');
+        const { exitCode } = await runAnalyzeDiffCli({
+            input: inputSpecPath,
+            outputReport: reportPath,
+            git: 'HEAD',
+            ci: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+    });
+    (0, node_test_1.test)('returns exit code 0 for non-breaking diff in ci mode', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-ok-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '1.1.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+                '/pong': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        const { exitCode } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            ci: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        const schemaValidation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(report);
+        node_assert_1.default.strictEqual(schemaValidation.valid, true, schemaValidation.errors.join('\n'));
+        node_assert_1.default.strictEqual(report.schemaVersion, '1.1.0');
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.ok(report.summary.nonBreaking > 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'minor');
+        node_assert_1.default.ok(report.recommendation.reasons.includes('HAS_BACKWARD_COMPATIBLE_CHANGES'));
+        node_assert_1.default.strictEqual(report.governance.summary.errors, 0);
+        const ciSummary = (0, ciSummary_1.formatCiMarkdownSummary)(report, reportPath);
+        node_assert_1.default.ok(ciSummary.includes('### OpenAPI Semantic Diff'));
+        node_assert_1.default.ok(ciSummary.includes('HAS_BACKWARD_COMPATIBLE_CHANGES'));
+    });
+    (0, node_test_1.test)('returns exit code 1 for breaking diff in ci mode', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-breaking-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '2.0.0' },
+            paths: {},
+        }));
+        const { exitCode } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            ci: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 1);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        const schemaValidation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(report);
+        node_assert_1.default.strictEqual(schemaValidation.valid, true, schemaValidation.errors.join('\n'));
+        node_assert_1.default.strictEqual(report.schemaVersion, '1.1.0');
+        node_assert_1.default.ok(report.summary.breaking > 0);
+        node_assert_1.default.ok(report.changes.some(change => change.severity === 'breaking'));
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'major');
+        node_assert_1.default.ok(report.recommendation.reasons.includes('HAS_BREAKING_CHANGES'));
+        node_assert_1.default.ok(report.governance.violations.some(violation => violation.ruleId === 'NO_BREAKING_WITHOUT_FLAG'));
+        const ciSummary = (0, ciSummary_1.formatCiMarkdownSummary)(report, reportPath);
+        node_assert_1.default.ok(ciSummary.includes('### OpenAPI Semantic Diff'));
+        node_assert_1.default.ok(ciSummary.includes('HAS_BREAKING_CHANGES'));
+    });
+    (0, node_test_1.test)('returns exit code 0 for breaking diff in ci mode when allow-breaking is enabled', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-breaking-allowed-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        operationId: 'getPing',
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '2.0.0' },
+            paths: {},
+        }));
+        const { exitCode } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            ci: true,
+            allowBreaking: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        const schemaValidation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(report);
+        node_assert_1.default.strictEqual(schemaValidation.valid, true, schemaValidation.errors.join('\n'));
+        node_assert_1.default.strictEqual(report.schemaVersion, '1.1.0');
+        node_assert_1.default.ok(report.summary.breaking > 0);
+        node_assert_1.default.ok(!report.governance.violations.some(violation => violation.ruleId === 'NO_BREAKING_WITHOUT_FLAG'));
+        node_assert_1.default.ok((0, ciSummary_1.formatCiMarkdownSummary)(report, reportPath).includes('### OpenAPI Semantic Diff'));
+    });
+    (0, node_test_1.test)('returns exit code 0 for breaking diff in ci mode when governance config disables no-breaking rule', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-breaking-policy-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        const governanceConfigPath = node_path_1.default.join(tempDir, 'governance.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        operationId: 'getPing',
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '2.0.0' },
+            paths: {},
+        }));
+        (0, node_fs_1.writeFileSync)(governanceConfigPath, JSON.stringify({
+            rules: {
+                NO_BREAKING_WITHOUT_FLAG: {
+                    enabled: false,
+                },
+            },
+        }));
+        const { exitCode } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            ci: true,
+            governanceConfig: governanceConfigPath,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        const schemaValidation = (0, semanticDiffReportSchema_1.validateSemanticDiffReportSchema)(report);
+        node_assert_1.default.strictEqual(schemaValidation.valid, true, schemaValidation.errors.join('\n'));
+        node_assert_1.default.strictEqual(report.schemaVersion, '1.1.0');
+        node_assert_1.default.ok(report.summary.breaking > 0);
+        node_assert_1.default.ok(!report.governance.violations.some(violation => violation.ruleId === 'NO_BREAKING_WITHOUT_FLAG'));
+        node_assert_1.default.ok((0, ciSummary_1.formatCiMarkdownSummary)(report, reportPath).includes('### OpenAPI Semantic Diff'));
+    });
+    (0, node_test_1.test)('uses --compare-with over --git when both flags are provided', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-priority-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '1.1.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        const { exitCode, result } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            git: 'HEAD~9999',
+            ci: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        node_assert_1.default.strictEqual(result.success, true);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+        node_assert_1.default.ok(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.COMPARE_WITH_OVERRIDES_GIT('HEAD~9999').includes('Ignoring git ref'));
+    });
+    (0, node_test_1.test)('filters semantic changes with analyze.ignore and recalculates summary', async (t) => {
+        const tempDir = createTempDir(t, 'openapi-cli-analyze-ignore-');
+        const oldSpecPath = node_path_1.default.join(tempDir, 'old.json');
+        const newSpecPath = node_path_1.default.join(tempDir, 'new.json');
+        const reportPath = node_path_1.default.join(tempDir, 'report.json');
+        const configPath = node_path_1.default.join(tempDir, 'openapi.config.json');
+        (0, node_fs_1.writeFileSync)(oldSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'Old', version: '1.0.0' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(newSpecPath, JSON.stringify({
+            openapi: '3.0.0',
+            info: { title: 'New', version: '1.0.1' },
+            paths: {
+                '/ping': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+                '/pong': {
+                    get: {
+                        responses: {
+                            '200': { description: 'ok' },
+                        },
+                    },
+                },
+            },
+        }));
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify({
+            analyze: {
+                ignore: [
+                    {
+                        path: '#/paths/GET /pong',
+                    },
+                ],
+            },
+        }, null, 2));
+        const { exitCode, result } = await runAnalyzeDiffCli({
+            input: newSpecPath,
+            outputReport: reportPath,
+            compareWith: oldSpecPath,
+            openapiConfig: configPath,
+            ci: true,
+        });
+        node_assert_1.default.strictEqual(exitCode, 0);
+        node_assert_1.default.strictEqual(result.ignored, 1);
+        const report = JSON.parse((0, node_fs_1.readFileSync)(reportPath, 'utf8'));
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+        node_assert_1.default.ok(LoggerMessages_1.LOGGER_MESSAGES.ANALYZE_DIFF.IGNORED_CHANGES(1).includes('IGNORED: 1 semantic change'));
+    });
+    (0, node_test_1.test)('fails when --input is missing', async () => {
+        const result = await (0, analyzeDiff_1.analyzeDiff)({ git: 'HEAD~1' });
+        node_assert_1.default.strictEqual((0, analyzeDiff_1.toAnalyzeDiffExitCode)(result), 1);
+        node_assert_1.default.ok(result.error?.includes('"--input" is required for analyze-diff command'));
+    });
+    (0, node_test_1.test)('fails when analyze-diff is invoked without --input (legacy positional args are not accepted)', async () => {
+        const result = await (0, analyzeDiff_1.analyzeDiff)({});
+        node_assert_1.default.strictEqual((0, analyzeDiff_1.toAnalyzeDiffExitCode)(result), 1);
+        node_assert_1.default.ok(result.error?.includes('"--input" is required for analyze-diff command'));
+    });
+});

package/dist/cli/analyzeDiff/__tests__/analyzeDiffRenameAndInvalidRegex.test.d.ts

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

package/dist/cli/analyzeDiff/__tests__/analyzeDiffRenameAndInvalidRegex.test.d.ts.map

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

package/dist/cli/analyzeDiff/__tests__/analyzeDiffRenameAndInvalidRegex.test.js

@@ -0,0 +1,142 @@
+"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_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const analyzeDiff_1 = require("../analyzeDiff");
+const writeSpec = (dir, filename, payload) => {
+    const filePath = node_path_1.default.join(dir, filename);
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf-8');
+    return filePath;
+};
+const generatedRoot = node_path_1.default.join(__dirname, 'generated');
+const createTempDir = (t, prefix) => {
+    node_fs_1.default.mkdirSync(generatedRoot, { recursive: true });
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(generatedRoot, prefix));
+    t.after(() => {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+};
+(0, node_test_1.describe)('@unit: analyzeDiff RENAME and invalid-regex handling', () => {
+    (0, node_test_1.test)('detects semantic remove/add entries for property rename-like change', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-rename-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            first_name: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            firstName: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const removed = report.changes.find(change => change.type === 'model.property.removed' && change.path === '#/components/schemas/User/properties/first_name');
+        const added = report.changes.find(change => change.type === 'model.property.added' && change.path === '#/components/schemas/User/properties/firstName');
+        node_assert_1.default.ok(removed, 'Expected semantic removal entry for previous property');
+        node_assert_1.default.ok(added, 'Expected semantic addition entry for renamed property');
+        node_assert_1.default.strictEqual(removed?.severity, 'breaking');
+        node_assert_1.default.strictEqual(added?.severity, 'non-breaking');
+    });
+    (0, node_test_1.test)('invalid regex in config does not crash and valid rules still apply', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-invalidregex-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const configPath = node_path_1.default.join(tmpDir, 'openapi.config.json');
+        node_fs_1.default.writeFileSync(configPath, JSON.stringify({
+            analyze: {
+                ignore: [
+                    {
+                        pattern: '(', // invalid regex
+                        reason: 'invalid pattern',
+                    },
+                    {
+                        path: '#/components/schemas/User/properties/age',
+                        reason: 'Ignore type diff in test',
+                    },
+                ],
+            },
+        }, null, 2), 'utf-8');
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+            openapiConfig: configPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const filteredTypeChange = report.changes.find(change => change.type === 'model.property.type.changed' && change.path === '#/components/schemas/User/properties/age');
+        node_assert_1.default.ok(!filteredTypeChange, 'Expected matching semantic change to be filtered by valid rule while invalid regex is ignored');
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+    });
+});

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.d.ts

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

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.d.ts.map

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

package/dist/cli/analyzeDiff/__tests__/analyzeDiffTypeCoercion.test.js

@@ -0,0 +1,137 @@
+"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_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const analyzeDiff_1 = require("../analyzeDiff");
+const writeSpec = (dir, filename, payload) => {
+    const filePath = node_path_1.default.join(dir, filename);
+    node_fs_1.default.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf-8');
+    return filePath;
+};
+const generatedRoot = node_path_1.default.join(__dirname, 'generated');
+const createTempDir = (t, prefix) => {
+    node_fs_1.default.mkdirSync(generatedRoot, { recursive: true });
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(generatedRoot, prefix));
+    t.after(() => {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+};
+(0, node_test_1.describe)('@unit: analyzeDiff TYPE_COERCION miracles', () => {
+    (0, node_test_1.test)('detects semantic type change for scalar property transition', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-test-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown error'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const typeChange = report.changes.find(change => change.type === 'model.property.type.changed');
+        node_assert_1.default.ok(typeChange, 'Expected semantic type-change entry');
+        node_assert_1.default.strictEqual(typeChange?.path, '#/components/schemas/User/properties/age');
+        node_assert_1.default.strictEqual(typeChange?.severity, 'breaking');
+        node_assert_1.default.ok(report.summary.breaking > 0);
+    });
+    (0, node_test_1.test)('filters semantic type-change entry when rule matches path', async (t) => {
+        const tmpDir = createTempDir(t, 'openapi-diff-test-');
+        const reportPath = node_path_1.default.join(tmpDir, 'report.json');
+        const previousSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const currentSpec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.1.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const previousPath = writeSpec(tmpDir, 'previous.json', previousSpec);
+        const currentPath = writeSpec(tmpDir, 'current.json', currentSpec);
+        const configPath = node_path_1.default.join(tmpDir, 'openapi.config.json');
+        node_fs_1.default.writeFileSync(configPath, JSON.stringify({
+            analyze: {
+                ignore: [
+                    {
+                        path: '#/components/schemas/User/properties/age',
+                        reason: 'Ignore type diff in test',
+                    },
+                ],
+            },
+        }, null, 2), 'utf-8');
+        const result = await (0, analyzeDiff_1.analyzeDiff)({
+            input: currentPath,
+            compareWith: previousPath,
+            outputReport: reportPath,
+            openapiConfig: configPath,
+        });
+        node_assert_1.default.ok(result.success, `analyzeDiff failed: ${result.error ?? 'unknown error'}`);
+        const reportRaw = node_fs_1.default.readFileSync(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const filteredTypeChange = report.changes.find(change => change.type === 'model.property.type.changed' && change.path === '#/components/schemas/User/properties/age');
+        node_assert_1.default.ok(!filteredTypeChange, 'Expected semantic type-change to be filtered by analyze.ignore');
+        node_assert_1.default.strictEqual(report.summary.breaking, 0);
+        node_assert_1.default.strictEqual(report.summary.nonBreaking, 0);
+        node_assert_1.default.strictEqual(report.summary.informational, 0);
+        node_assert_1.default.strictEqual(report.recommendation.semver, 'patch');
+    });
+});