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

package/dist/core/governance/__tests__/loadGovernanceConfig.test.js

@@ -0,0 +1,71 @@
+"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 loadGovernanceConfig_1 = require("../loadGovernanceConfig");
+function createTempDir(prefix) {
+    const generatedRoot = node_path_1.default.join(__dirname, 'generated');
+    (0, node_fs_1.mkdirSync)(generatedRoot, { recursive: true });
+    return (0, node_fs_1.mkdtempSync)(node_path_1.default.join(generatedRoot, prefix));
+}
+(0, node_test_1.describe)('@unit: loadGovernanceConfig', () => {
+    (0, node_test_1.test)('returns undefined when path is not provided', async () => {
+        const config = await (0, loadGovernanceConfig_1.loadGovernanceConfig)();
+        node_assert_1.default.strictEqual(config, undefined);
+    });
+    (0, node_test_1.test)('loads valid governance config', async (t) => {
+        const tempDir = createTempDirWithCleanup(t, 'openapi-governance-config-valid-');
+        const configPath = node_path_1.default.join(tempDir, 'governance.json');
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify({
+            rules: {
+                NO_BREAKING_WITHOUT_FLAG: {
+                    enabled: true,
+                    severity: 'error',
+                },
+                REQUIRE_OPERATION_ID: {
+                    allowList: [{ operation: '/users GET' }],
+                },
+            },
+        }));
+        const config = await (0, loadGovernanceConfig_1.loadGovernanceConfig)(configPath);
+        node_assert_1.default.ok(config);
+        node_assert_1.default.strictEqual(config?.rules?.NO_BREAKING_WITHOUT_FLAG?.severity, 'error');
+        node_assert_1.default.strictEqual(config?.rules?.REQUIRE_OPERATION_ID?.allowList?.[0]?.operation, '/users GET');
+    });
+    (0, node_test_1.test)('throws with path details for invalid severity', async (t) => {
+        const tempDir = createTempDirWithCleanup(t, 'openapi-governance-config-invalid-severity-');
+        const configPath = node_path_1.default.join(tempDir, 'governance.json');
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify({
+            rules: {
+                NO_DEFAULT_WITHOUT_2XX: {
+                    severity: 'fatal',
+                },
+            },
+        }));
+        await node_assert_1.default.rejects(async () => (0, loadGovernanceConfig_1.loadGovernanceConfig)(configPath), (error) => error instanceof Error && error.message.includes('rules.NO_DEFAULT_WITHOUT_2XX.severity'));
+    });
+    (0, node_test_1.test)('throws with path details for invalid allowList item', async (t) => {
+        const tempDir = createTempDirWithCleanup(t, 'openapi-governance-config-invalid-allowlist-');
+        const configPath = node_path_1.default.join(tempDir, 'governance.json');
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify({
+            rules: {
+                REQUIRE_OPERATION_ID: {
+                    allowList: [{}],
+                },
+            },
+        }));
+        await node_assert_1.default.rejects(async () => (0, loadGovernanceConfig_1.loadGovernanceConfig)(configPath), (error) => error instanceof Error && error.message.includes('rules.REQUIRE_OPERATION_ID.allowList.[0]'));
+    });
+});
+function createTempDirWithCleanup(t, prefix) {
+    const tempDir = createTempDir(prefix);
+    t.after(() => {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+}

package/dist/core/governance/evaluateGovernanceRules.d.ts

@@ -0,0 +1,42 @@
+import { CommonOpenApi } from '../types/shared/CommonOpenApi.model';
+type GovernanceSeverity = 'error' | 'warning' | 'info';
+export type GovernanceRuleId = 'NO_BREAKING_WITHOUT_FLAG' | 'REQUIRE_OPERATION_ID' | 'NO_DEFAULT_WITHOUT_2XX';
+type GovernanceSummary = {
+    errors: number;
+    warnings: number;
+    info: number;
+};
+export type GovernanceViolation = {
+    ruleId: GovernanceRuleId;
+    severity: GovernanceSeverity;
+    message: string;
+    path: string;
+};
+export type GovernanceReport = {
+    summary: GovernanceSummary;
+    violations: GovernanceViolation[];
+};
+export type GovernanceAllowListItem = {
+    operation?: string;
+    path?: string;
+};
+export type GovernanceRuleConfig = {
+    enabled?: boolean;
+    severity?: GovernanceSeverity;
+    allowList?: GovernanceAllowListItem[];
+};
+export type GovernancePolicyConfig = {
+    rules?: Partial<Record<GovernanceRuleId, GovernanceRuleConfig>>;
+};
+type GovernanceInput = {
+    openApi: CommonOpenApi;
+    allowBreaking?: boolean;
+    breakingChangesCount?: number;
+    governanceConfig?: GovernancePolicyConfig;
+};
+/**
+ * Evaluates governance rules and returns machine-readable violations.
+ */
+export declare function evaluateGovernanceRules(params: GovernanceInput): GovernanceReport;
+export {};
+//# sourceMappingURL=evaluateGovernanceRules.d.ts.map

package/dist/core/governance/evaluateGovernanceRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateGovernanceRules.d.ts","sourceRoot":"","sources":["../../../src/core/governance/evaluateGovernanceRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,KAAK,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEvD,MAAM,MAAM,gBAAgB,GAAG,0BAA0B,GAAG,sBAAsB,GAAG,wBAAwB,CAAC;AAE9G,KAAK,iBAAiB,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE,mBAAmB,EAAE,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,SAAS,CAAC,EAAE,uBAAuB,EAAE,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,oBAAoB,CAAC,CAAC,CAAC;CACnE,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AAwFF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CAqEjF"}

package/dist/core/governance/evaluateGovernanceRules.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateGovernanceRules = evaluateGovernanceRules;
+const HTTP_METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'];
+/**
+ * Checks whether response key is an explicit successful HTTP status code key.
+ */
+function isSuccessResponseCode(responseCode) {
+    return /^\s*2\d\d\s*$/.test(responseCode) || /^\s*2xx\s*$/i.test(responseCode);
+}
+/**
+ * Builds governance summary counters from violations.
+ */
+function buildSummary(violations) {
+    return violations.reduce((summary, violation) => {
+        if (violation.severity === 'error') {
+            summary.errors += 1;
+        }
+        else if (violation.severity === 'warning') {
+            summary.warnings += 1;
+        }
+        else {
+            summary.info += 1;
+        }
+        return summary;
+    }, {
+        errors: 0,
+        warnings: 0,
+        info: 0,
+    });
+}
+const RULE_DEFAULTS = {
+    NO_BREAKING_WITHOUT_FLAG: {
+        enabled: true,
+        severity: 'error',
+    },
+    REQUIRE_OPERATION_ID: {
+        enabled: true,
+        severity: 'warning',
+    },
+    NO_DEFAULT_WITHOUT_2XX: {
+        enabled: true,
+        severity: 'warning',
+    },
+};
+/**
+ * Resolves effective rule config using defaults overridden by user policy.
+ */
+function getEffectiveRuleConfig(ruleId, governanceConfig) {
+    const defaults = RULE_DEFAULTS[ruleId];
+    const configuredRule = governanceConfig?.rules?.[ruleId] ?? {};
+    return {
+        enabled: configuredRule.enabled ?? defaults.enabled,
+        severity: configuredRule.severity ?? defaults.severity,
+        allowList: Array.isArray(configuredRule.allowList) ? configuredRule.allowList : [],
+    };
+}
+/**
+ * Returns true when violation is allowed by operation/path allow list.
+ */
+function isViolationAllowed(allowList, operation, violationPath) {
+    return allowList.some(item => {
+        const operationAllowed = typeof item.operation === 'string' && operation ? item.operation === operation : false;
+        const pathAllowed = typeof item.path === 'string' && item.path.trim().length > 0
+            ? violationPath === item.path || violationPath.startsWith(item.path)
+            : false;
+        return operationAllowed || pathAllowed;
+    });
+}
+/**
+ * Evaluates governance rules and returns machine-readable violations.
+ */
+function evaluateGovernanceRules(params) {
+    const { openApi, allowBreaking = false, breakingChangesCount = 0, governanceConfig } = params;
+    const violations = [];
+    const noBreakingRule = getEffectiveRuleConfig('NO_BREAKING_WITHOUT_FLAG', governanceConfig);
+    if (noBreakingRule.enabled && !allowBreaking && breakingChangesCount > 0) {
+        const violationPath = '#/summary/breaking';
+        if (!isViolationAllowed(noBreakingRule.allowList, undefined, violationPath)) {
+            violations.push({
+                ruleId: 'NO_BREAKING_WITHOUT_FLAG',
+                severity: noBreakingRule.severity,
+                message: `Breaking changes are not allowed without explicit allow flag. Found ${breakingChangesCount}.`,
+                path: violationPath,
+            });
+        }
+    }
+    const paths = openApi.paths;
+    for (const [routePath, pathItemRaw] of Object.entries(paths ?? {})) {
+        const pathItem = pathItemRaw ?? {};
+        for (const method of HTTP_METHODS) {
+            const operationRaw = pathItem[method];
+            if (!operationRaw || typeof operationRaw !== 'object') {
+                continue;
+            }
+            const operation = operationRaw;
+            const operationPath = `${routePath} ${method.toUpperCase()}`;
+            const requireOperationIdRule = getEffectiveRuleConfig('REQUIRE_OPERATION_ID', governanceConfig);
+            if (requireOperationIdRule.enabled && !operation.operationId) {
+                if (!isViolationAllowed(requireOperationIdRule.allowList, operationPath, operationPath)) {
+                    violations.push({
+                        ruleId: 'REQUIRE_OPERATION_ID',
+                        severity: requireOperationIdRule.severity,
+                        message: 'Operation must define operationId.',
+                        path: operationPath,
+                    });
+                }
+            }
+            const responses = operation.responses;
+            if (!responses || typeof responses !== 'object') {
+                continue;
+            }
+            const responseCodes = Object.keys(responses);
+            const hasDefaultResponse = responseCodes.includes('default');
+            const hasSuccessResponse = responseCodes.some(isSuccessResponseCode);
+            const noDefaultWithout2xxRule = getEffectiveRuleConfig('NO_DEFAULT_WITHOUT_2XX', governanceConfig);
+            if (noDefaultWithout2xxRule.enabled && hasDefaultResponse && !hasSuccessResponse) {
+                const violationPath = `${operationPath} responses.default`;
+                if (!isViolationAllowed(noDefaultWithout2xxRule.allowList, operationPath, violationPath)) {
+                    violations.push({
+                        ruleId: 'NO_DEFAULT_WITHOUT_2XX',
+                        severity: noDefaultWithout2xxRule.severity,
+                        message: 'Default response is present without an explicit 2xx response.',
+                        path: violationPath,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        summary: buildSummary(violations),
+        violations,
+    };
+}

package/dist/core/governance/governanceConfigSchema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { GovernancePolicyConfig } from './evaluateGovernanceRules';
+export declare const governancePolicyConfigSchema: z.ZodType<GovernancePolicyConfig>;
+//# sourceMappingURL=governanceConfigSchema.d.ts.map

package/dist/core/governance/governanceConfigSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governanceConfigSchema.d.ts","sourceRoot":"","sources":["../../../src/core/governance/governanceConfigSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAoCnE,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAI9D,CAAC"}

package/dist/core/governance/governanceConfigSchema.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.governancePolicyConfigSchema = void 0;
+const zod_1 = require("zod");
+const GOVERNANCE_SEVERITIES = ['error', 'warning', 'info'];
+const allowListItemSchema = zod_1.z
+    .object({
+    operation: zod_1.z.string().min(1).optional(),
+    path: zod_1.z.string().min(1).optional(),
+})
+    .strict()
+    .superRefine((item, ctx) => {
+    if (!item.operation && !item.path) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'allowList item must define at least one of: operation or path',
+            path: [],
+        });
+    }
+});
+const governanceRuleConfigSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean().optional(),
+    severity: zod_1.z.enum(GOVERNANCE_SEVERITIES).optional(),
+    allowList: zod_1.z.array(allowListItemSchema).optional(),
+})
+    .strict();
+const governanceRulesSchema = zod_1.z
+    .object({
+    NO_BREAKING_WITHOUT_FLAG: governanceRuleConfigSchema.optional(),
+    REQUIRE_OPERATION_ID: governanceRuleConfigSchema.optional(),
+    NO_DEFAULT_WITHOUT_2XX: governanceRuleConfigSchema.optional(),
+})
+    .strict();
+exports.governancePolicyConfigSchema = zod_1.z
+    .object({
+    rules: governanceRulesSchema.optional(),
+})
+    .strict();

package/dist/core/governance/loadGovernanceConfig.d.ts

@@ -0,0 +1,7 @@
+import { GovernancePolicyConfig } from './evaluateGovernanceRules';
+/**
+ * Loads governance policy config JSON from file path.
+ * Returns undefined when path is not provided.
+ */
+export declare function loadGovernanceConfig(governanceConfigPath?: string): Promise<GovernancePolicyConfig | undefined>;
+//# sourceMappingURL=loadGovernanceConfig.d.ts.map

package/dist/core/governance/loadGovernanceConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadGovernanceConfig.d.ts","sourceRoot":"","sources":["../../../src/core/governance/loadGovernanceConfig.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAkCnE;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CA6BrH"}

package/dist/core/governance/loadGovernanceConfig.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGovernanceConfig = loadGovernanceConfig;
+const fileSystemHelpers_1 = require("../../common/utils/fileSystemHelpers");
+const pathHelpers_1 = require("../../common/utils/pathHelpers");
+const governanceConfigSchema_1 = require("./governanceConfigSchema");
+/**
+ * Formats Zod path for governance JSON config context.
+ */
+function formatGovernanceConfigPath(path) {
+    if (path.length === 0) {
+        return 'root';
+    }
+    return path
+        .map(segment => {
+        if (typeof segment === 'number') {
+            return `[${segment}]`;
+        }
+        return String(segment);
+    })
+        .join('.');
+}
+/**
+ * Formats governance config validation errors as user-readable message.
+ */
+function formatGovernanceConfigValidationError(error) {
+    if (!error.issues.length) {
+        return 'Unknown governance config validation error';
+    }
+    return error.issues
+        .map(issue => `${formatGovernanceConfigPath(issue.path)}: ${issue.message}`)
+        .join('\n');
+}
+/**
+ * Loads governance policy config JSON from file path.
+ * Returns undefined when path is not provided.
+ */
+async function loadGovernanceConfig(governanceConfigPath) {
+    if (!governanceConfigPath) {
+        return undefined;
+    }
+    const resolvedPath = (0, pathHelpers_1.resolveHelper)(process.cwd(), governanceConfigPath);
+    const exists = await fileSystemHelpers_1.fileSystemHelpers.exists(resolvedPath);
+    if (!exists) {
+        throw new Error(`Governance config file does not exist: ${resolvedPath}`);
+    }
+    const rawContent = await fileSystemHelpers_1.fileSystemHelpers.readFile(resolvedPath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse governance config JSON at "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const validationResult = governanceConfigSchema_1.governancePolicyConfigSchema.safeParse(parsed);
+    if (!validationResult.success) {
+        throw new Error(`Invalid governance config at "${resolvedPath}":\n${formatGovernanceConfigValidationError(validationResult.error)}`);
+    }
+    return validationResult.data;
+}

package/dist/core/index.d.ts

@@ -1,4 +1,7 @@
 import { TRawOptions } from '../common/TRawOptions';
+export type { OpenApiGeneratorPlugin, SchemaTypeOverrideContext, SchemaTypeOverrideInput, TOpenApiVersion } from './plugins';
+export type { ApplySemanticDiffPluginHooksResult, PluginHookDiagnostic, PluginHookName } from './plugins';
+export { applySemanticDiffPluginHooks } from './plugins';
 export { HttpClient } from './types/enums/HttpClient.enum';
 export declare function generate(rawOptions: TRawOptions): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIpD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,wBAAsB,QAAQ,CAAC,UAAU,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAKrE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIpD,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC7H,YAAY,EAAE,kCAAkC,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC1G,OAAO,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,wBAAsB,QAAQ,CAAC,UAAU,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAKrE"}

package/dist/core/index.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpClient = void 0;
+exports.HttpClient = exports.applySemanticDiffPluginHooks = void 0;
 exports.generate = generate;
 const OpenApiClient_1 = require("./OpenApiClient");
 const validateRawOptions_1 = require("./utils/validateRawOptions");
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "applySemanticDiffPluginHooks", { enumerable: true, get: function () { return plugins_1.applySemanticDiffPluginHooks; } });
 var HttpClient_enum_1 = require("./types/enums/HttpClient.enum");
 Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return HttpClient_enum_1.HttpClient; } });
 async function generate(rawOptions) {
-    (0, validateRawOptions_1.validateRawOptions)(rawOptions);
+    await (0, validateRawOptions_1.validateRawOptions)(rawOptions);
     const openApiClient = new OpenApiClient_1.OpenApiClient();
     await openApiClient.generate(rawOptions);
 }

package/dist/core/plugins/GeneratorPlugin.model.d.ts

@@ -0,0 +1,42 @@
+import type { SemanticDiffReport } from '../semanticDiff/analyzeOpenApiDiff';
+export type TOpenApiVersion = 'v2' | 'v3';
+export type OpenApiCodegenPluginApiVersion = '1' | '2';
+export interface SchemaTypeOverrideContext {
+    openApiVersion: TOpenApiVersion;
+    parentRef: string;
+}
+export interface SchemaTypeOverrideInput {
+    schema: Record<string, any>;
+    context: SchemaTypeOverrideContext;
+}
+export interface SemanticDiffPluginContext {
+    report: SemanticDiffReport;
+    options: {
+        allowBreaking: boolean;
+    };
+}
+export interface RecommendationPluginContext {
+    recommendation: SemanticDiffReport['recommendation'];
+    summary: SemanticDiffReport['summary'];
+    governance: SemanticDiffReport['governance'];
+}
+export interface BeforeReportWritePluginContext {
+    report: SemanticDiffReport;
+    reportPath: string;
+}
+export interface OpenApiGeneratorPlugin {
+    name: string;
+    version?: string;
+    apiVersion?: OpenApiCodegenPluginApiVersion;
+    resolveSchemaTypeOverride?: (input: SchemaTypeOverrideInput) => string | undefined;
+    afterSemanticDiff?: (ctx: SemanticDiffPluginContext) => SemanticDiffReport | void | Promise<SemanticDiffReport | void>;
+    mapRecommendation?: (ctx: RecommendationPluginContext) => SemanticDiffReport['recommendation'] | void | Promise<SemanticDiffReport['recommendation'] | void>;
+    beforeReportWrite?: (ctx: BeforeReportWritePluginContext) => {
+        report?: SemanticDiffReport;
+        reportPath?: string;
+    } | void | Promise<{
+        report?: SemanticDiffReport;
+        reportPath?: string;
+    } | void>;
+}
+//# sourceMappingURL=GeneratorPlugin.model.d.ts.map

package/dist/core/plugins/GeneratorPlugin.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorPlugin.model.d.ts","sourceRoot":"","sources":["../../../src/core/plugins/GeneratorPlugin.model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,CAAC;AAC1C,MAAM,MAAM,8BAA8B,GAAG,GAAG,GAAG,GAAG,CAAC;AAEvD,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,eAAe,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,EAAE,yBAAyB,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE;QACL,aAAa,EAAE,OAAO,CAAC;KAC1B,CAAC;CACL;AAED,MAAM,WAAW,2BAA2B;IACxC,cAAc,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;IACrD,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvC,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,8BAA8B;IAC3C,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,8BAA8B,CAAC;IAC5C,yBAAyB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,MAAM,GAAG,SAAS,CAAC;IACnF,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,kBAAkB,GAAG,IAAI,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IACvH,iBAAiB,CAAC,EAAE,CAChB,GAAG,EAAE,2BAA2B,KAC/B,kBAAkB,CAAC,gBAAgB,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,CAAC;IACxG,iBAAiB,CAAC,EAAE,CAChB,GAAG,EAAE,8BAA8B,KAClC;QAAE,MAAM,CAAC,EAAE,kBAAkB,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,OAAO,CAAC;QAAE,MAAM,CAAC,EAAE,kBAAkB,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CAC3I"}

package/dist/core/plugins/GeneratorPlugin.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/plugins/__tests__/applySemanticDiffPluginHooks.test.d.ts

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

package/dist/core/plugins/__tests__/applySemanticDiffPluginHooks.test.d.ts.map

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

package/dist/core/plugins/__tests__/applySemanticDiffPluginHooks.test.js

@@ -0,0 +1,115 @@
+"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 applySemanticDiffPluginHooks_1 = require("../applySemanticDiffPluginHooks");
+function createBaseReport() {
+    return {
+        schemaVersion: '1.1.0',
+        summary: {
+            breaking: 1,
+            nonBreaking: 0,
+            informational: 0,
+        },
+        recommendation: {
+            semver: 'major',
+            confidence: 'medium',
+            reason: 'Breaking changes detected.',
+            reasons: ['HAS_BREAKING_CHANGES'],
+        },
+        governance: {
+            summary: {
+                errors: 1,
+                warnings: 0,
+                info: 0,
+            },
+            violations: [
+                {
+                    ruleId: 'NO_BREAKING_WITHOUT_FLAG',
+                    severity: 'error',
+                    message: 'breaking changes found',
+                    path: '#/paths/GET /users',
+                },
+            ],
+        },
+        changes: [
+            {
+                type: 'operation.removed',
+                severity: 'breaking',
+                message: 'Operation "GET /users" was removed.',
+                path: '#/paths/GET /users',
+            },
+        ],
+    };
+}
+(0, node_test_1.describe)('@unit: applySemanticDiffPluginHooks', () => {
+    (0, node_test_1.test)('applies v2 hooks in deterministic order', async () => {
+        const pluginA = {
+            name: 'plugin-a',
+            apiVersion: '2',
+            afterSemanticDiff: ({ report }) => ({
+                ...report,
+                summary: {
+                    ...report.summary,
+                    informational: 1,
+                },
+            }),
+            mapRecommendation: ({ recommendation }) => ({
+                ...recommendation,
+                confidence: 'high',
+            }),
+            beforeReportWrite: ({ reportPath }) => ({
+                reportPath: reportPath.replace('.json', '.v2.json'),
+            }),
+        };
+        const result = await (0, applySemanticDiffPluginHooks_1.applySemanticDiffPluginHooks)({
+            report: createBaseReport(),
+            reportPath: './report.json',
+            plugins: [pluginA],
+            allowBreaking: false,
+            strictPluginMode: false,
+        });
+        node_assert_1.default.strictEqual(result.report.summary.informational, 1);
+        node_assert_1.default.strictEqual(result.report.recommendation.confidence, 'high');
+        node_assert_1.default.strictEqual(result.reportPath, './report.v2.json');
+        node_assert_1.default.ok(result.diagnostics.length >= 3);
+        node_assert_1.default.ok(result.diagnostics.every(item => item.status === 'applied'));
+    });
+    (0, node_test_1.test)('non-strict mode keeps working when plugin hook fails', async () => {
+        const faultyPlugin = {
+            name: 'faulty-plugin',
+            apiVersion: '2',
+            afterSemanticDiff: () => {
+                throw new Error('boom');
+            },
+        };
+        const result = await (0, applySemanticDiffPluginHooks_1.applySemanticDiffPluginHooks)({
+            report: createBaseReport(),
+            reportPath: './report.json',
+            plugins: [faultyPlugin],
+            allowBreaking: false,
+            strictPluginMode: false,
+        });
+        node_assert_1.default.strictEqual(result.reportPath, './report.json');
+        node_assert_1.default.ok(result.diagnostics.some(item => item.pluginName === 'faulty-plugin' && item.status === 'failed'));
+    });
+    (0, node_test_1.test)('strict mode throws when plugin hook fails', async () => {
+        const faultyPlugin = {
+            name: 'faulty-plugin',
+            apiVersion: '2',
+            mapRecommendation: () => {
+                throw new Error('map failed');
+            },
+        };
+        await node_assert_1.default.rejects(async () => (0, applySemanticDiffPluginHooks_1.applySemanticDiffPluginHooks)({
+            report: createBaseReport(),
+            reportPath: './report.json',
+            plugins: [faultyPlugin],
+            allowBreaking: false,
+            strictPluginMode: true,
+        }), (error) => error instanceof Error && error.message.includes('faulty-plugin'));
+    });
+});

package/dist/core/plugins/__tests__/loadGeneratorPlugins.test.d.ts

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

package/dist/core/plugins/__tests__/loadGeneratorPlugins.test.d.ts.map

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

package/dist/core/plugins/__tests__/loadGeneratorPlugins.test.js

@@ -0,0 +1,62 @@
+"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_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const loadGeneratorPlugins_1 = require("../loadGeneratorPlugins");
+(0, node_test_1.describe)('@unit: loadGeneratorPlugins', () => {
+    (0, node_test_1.test)('loads cjs plugin and keeps builtin fallback plugins', async () => {
+        const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'openapi-plugin-'));
+        const pluginPath = (0, node_path_1.join)(tempDir, 'custom-plugin.cjs');
+        (0, node_fs_1.writeFileSync)(pluginPath, `module.exports = {
+                name: 'custom-type-override',
+                resolveSchemaTypeOverride: ({ schema }) => schema['x-custom-type']
+            };`);
+        try {
+            const plugins = await (0, loadGeneratorPlugins_1.loadGeneratorPlugins)([pluginPath]);
+            node_assert_1.default.ok(plugins.length >= 2);
+            node_assert_1.default.strictEqual(plugins[0]?.name, 'custom-type-override');
+            node_assert_1.default.ok(plugins.some(plugin => plugin.name === 'x-typescript-type'));
+        }
+        finally {
+            (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.test)('loads esm plugin from .mjs', async () => {
+        const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'openapi-plugin-esm-'));
+        const pluginPath = (0, node_path_1.join)(tempDir, 'custom-plugin.mjs');
+        (0, node_fs_1.writeFileSync)(pluginPath, `export default {
+                name: 'esm-type-override',
+                resolveSchemaTypeOverride: ({ schema }) => schema['x-esm-type']
+            };`);
+        try {
+            const plugins = await (0, loadGeneratorPlugins_1.loadGeneratorPlugins)([pluginPath]);
+            node_assert_1.default.strictEqual(plugins[0]?.name, 'esm-type-override');
+            node_assert_1.default.ok(plugins.some(plugin => plugin.name === 'x-typescript-type'));
+        }
+        finally {
+            (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+        }
+    });
+    (0, node_test_1.test)('loads typescript plugin when runtime supports ts imports', async () => {
+        const tempDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'openapi-plugin-ts-'));
+        const pluginPath = (0, node_path_1.join)(tempDir, 'custom-plugin.ts');
+        (0, node_fs_1.writeFileSync)(pluginPath, `export default {
+                name: 'ts-type-override',
+                resolveSchemaTypeOverride: ({ schema }: { schema: Record<string, unknown> }) => schema['x-ts-type']
+            };`);
+        try {
+            const plugins = await (0, loadGeneratorPlugins_1.loadGeneratorPlugins)([pluginPath]);
+            node_assert_1.default.strictEqual(plugins[0]?.name, 'ts-type-override');
+            node_assert_1.default.ok(plugins.some(plugin => plugin.name === 'x-typescript-type'));
+        }
+        finally {
+            (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+        }
+    });
+});