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

package/dist/common/utils/__tests__/eslintFix.test.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const Consts_1 = require("../../Consts");
+(0, node_test_1.describe)('@unit: eslintFix', () => {
+    let warnMessages = [];
+    let infoMessages = [];
+    let errorWithHintCalls = [];
+    const originalWarn = Consts_1.APP_LOGGER.warn.bind(Consts_1.APP_LOGGER);
+    const originalInfo = Consts_1.APP_LOGGER.info.bind(Consts_1.APP_LOGGER);
+    const originalErrorWithHint = Consts_1.APP_LOGGER.errorWithHint.bind(Consts_1.APP_LOGGER);
+    (0, node_test_1.beforeEach)(() => {
+        warnMessages = [];
+        infoMessages = [];
+        errorWithHintCalls = [];
+        Consts_1.APP_LOGGER.warn = (msg) => {
+            warnMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.info = (msg) => {
+            infoMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.errorWithHint = options => {
+            errorWithHintCalls.push({
+                code: options.code,
+                message: options.message,
+                error: options.error,
+            });
+        };
+    });
+    (0, node_test_1.afterEach)(() => {
+        Consts_1.APP_LOGGER.warn = originalWarn;
+        Consts_1.APP_LOGGER.info = originalInfo;
+        Consts_1.APP_LOGGER.errorWithHint = originalErrorWithHint;
+    });
+    (0, node_test_1.describe)('when eslint is available', () => {
+        (0, node_test_1.test)('calls lintFiles and outputFixes and logs ESLINT_FIX_APPLIED', async () => {
+            // We import eslintFix here after mocking APP_LOGGER.
+            // If ESLint is installed in the project, it will run; otherwise the warn path is tested.
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            const filePath = node_path_1.default.resolve(__dirname, '__fixtures__/dummy.ts');
+            let threw = false;
+            try {
+                await eslintFix(filePath);
+            }
+            catch {
+                threw = true;
+            }
+            if (!threw) {
+                // ESLint is available — it either applied fixes or logged info
+                const fixApplied = infoMessages.some(m => m.includes('ESLint fix applied') || m.includes(filePath));
+                const notInstalled = warnMessages.some(m => m.includes('ESLint is not installed'));
+                node_assert_1.default.ok(fixApplied || notInstalled, 'should log either fix applied or not installed');
+            }
+        });
+    });
+    (0, node_test_1.describe)('when eslint is NOT available (graceful fallback)', () => {
+        (0, node_test_1.test)('logs ESLINT_NOT_INSTALLED warning and does not throw', async () => {
+            // Patch the module by temporarily replacing the tryImportESLint logic
+            // via an environment variable guard checked in eslintFix
+            // Since we can't easily mock dynamic import in tsx, we test the exported function
+            // with a patched internal approach: we verify the module itself handles the error.
+            // Re-import to get a fresh reference; the real behavior depends on whether eslint is installed.
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            // If eslint is not installed in devDeps, calling eslintFix should warn and not throw.
+            // If it IS installed, this test is a no-op (covered by the other test).
+            try {
+                await eslintFix('/non/existent/path/that/wont/lint.ts');
+                // Either it runs eslint on the fake path (may fail) or warns about not installed
+            }
+            catch {
+                // If eslint is installed but fails on non-existent path, verify errorWithHint was called
+                node_assert_1.default.ok(errorWithHintCalls.some(c => c.code === 'ESLINT_FIX_FAILED'), 'should call errorWithHint with ESLINT_FIX_FAILED when eslint throws');
+            }
+        });
+    });
+    (0, node_test_1.describe)('when eslint throws during fix', () => {
+        (0, node_test_1.test)('calls APP_LOGGER.errorWithHint with ESLINT_FIX_FAILED and re-throws', async () => {
+            const { eslintFix } = await Promise.resolve().then(() => __importStar(require('../eslintFix')));
+            // Pass a path that will cause ESLint to fail if installed
+            let threw = false;
+            try {
+                await eslintFix('/path/does/not/exist/file.ts');
+            }
+            catch {
+                threw = true;
+            }
+            if (threw) {
+                node_assert_1.default.ok(errorWithHintCalls.some(c => c.code === 'ESLINT_FIX_FAILED'), 'should log ESLINT_FIX_FAILED before re-throwing');
+            }
+            else {
+                // ESLint not installed — check warn was logged
+                node_assert_1.default.ok(warnMessages.some(m => m.includes('ESLint is not installed')), 'should warn that ESLint is not installed');
+            }
+        });
+    });
+});

package/dist/common/utils/__tests__/format.test.d.ts

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

package/dist/common/utils/__tests__/format.test.d.ts.map

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

package/dist/common/utils/__tests__/format.test.js

@@ -0,0 +1,90 @@
+"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 Consts_1 = require("../../Consts");
+const format_1 = require("../format");
+(0, node_test_1.describe)('@unit: format', () => {
+    let warnMessages = [];
+    let infoMessages = [];
+    let errorWithHintCalls = [];
+    const originalWarn = Consts_1.APP_LOGGER.warn.bind(Consts_1.APP_LOGGER);
+    const originalInfo = Consts_1.APP_LOGGER.info.bind(Consts_1.APP_LOGGER);
+    const originalErrorWithHint = Consts_1.APP_LOGGER.errorWithHint.bind(Consts_1.APP_LOGGER);
+    (0, node_test_1.beforeEach)(() => {
+        warnMessages = [];
+        infoMessages = [];
+        errorWithHintCalls = [];
+        Consts_1.APP_LOGGER.warn = (msg) => {
+            warnMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.info = (msg) => {
+            infoMessages.push(msg);
+        };
+        Consts_1.APP_LOGGER.errorWithHint = options => {
+            errorWithHintCalls.push({
+                code: options.code,
+                message: options.message,
+                error: options.error,
+            });
+        };
+    });
+    (0, node_test_1.afterEach)(() => {
+        Consts_1.APP_LOGGER.warn = originalWarn;
+        Consts_1.APP_LOGGER.info = originalInfo;
+        Consts_1.APP_LOGGER.errorWithHint = originalErrorWithHint;
+    });
+    (0, node_test_1.describe)('default behavior (useProjectConfig=false)', () => {
+        (0, node_test_1.test)('formats valid TypeScript with built-in options', async () => {
+            const input = `const x={a:1,b:2}`;
+            const result = await (0, format_1.format)(input);
+            node_assert_1.default.ok(result.includes('const x'), 'should include variable declaration');
+            node_assert_1.default.ok(result.trim().length > 0, 'should produce non-empty output');
+        });
+        (0, node_test_1.test)('uses typescript parser by default', async () => {
+            const input = `interface IFoo { bar: string; }`;
+            const result = await (0, format_1.format)(input);
+            node_assert_1.default.ok(result.includes('IFoo'), 'should preserve interface name');
+        });
+        (0, node_test_1.test)('respects custom parser argument', async () => {
+            const input = `{"key":"value"}`;
+            const result = await (0, format_1.format)(input, 'json');
+            node_assert_1.default.ok(result.includes('"key"'), 'should format as JSON');
+        });
+        (0, node_test_1.test)('does not call warn or info when useProjectConfig is omitted', async () => {
+            await (0, format_1.format)(`const a = 1;`);
+            node_assert_1.default.strictEqual(warnMessages.length, 0, 'should not warn');
+            node_assert_1.default.strictEqual(infoMessages.length, 0, 'should not log info');
+        });
+    });
+    (0, node_test_1.describe)('useProjectConfig=true', () => {
+        (0, node_test_1.test)('falls back to built-in options and warns when no project config is found', async () => {
+            // Running from workspace root which may not have a .prettierrc matching every field;
+            // the only guaranteed outcome is that the function does not throw and returns formatted code.
+            const input = `const x = 1;`;
+            const result = await (0, format_1.format)(input, undefined, true);
+            node_assert_1.default.ok(result.trim().length > 0, 'should produce non-empty output');
+        });
+        (0, node_test_1.test)('logs info when project config is resolved, or warns when not found', async () => {
+            await (0, format_1.format)(`const x = 1;`, undefined, true);
+            const resolvedSomething = infoMessages.some(m => m.includes('Prettier config resolved')) ||
+                warnMessages.some(m => m.includes('No project Prettier config'));
+            node_assert_1.default.ok(resolvedSomething, 'should log either resolved config path or fallback warning');
+        });
+    });
+    (0, node_test_1.describe)('error handling', () => {
+        (0, node_test_1.test)('throws an Error and calls APP_LOGGER.errorWithHint when prettier fails', async () => {
+            // Feed an unparseable string with a syntax error that prettier cannot fix
+            const invalidInput = `{{{{{{{ this is not valid typescript ;;; !!!`;
+            await node_assert_1.default.rejects(() => (0, format_1.format)(invalidInput, 'typescript', false), (err) => {
+                node_assert_1.default.ok(err instanceof Error, 'should throw an Error');
+                node_assert_1.default.ok(err.message.includes('Could not format'), 'message should mention formatting failure');
+                return true;
+            });
+            node_assert_1.default.ok(errorWithHintCalls.some(c => c.code === 'PRETTIER_FORMAT_FAILED'), 'should call errorWithHint with PRETTIER_FORMAT_FAILED code');
+        });
+    });
+});

package/dist/common/utils/convertArrayToObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertArrayToObject.d.ts","sourceRoot":"","sources":["../../../src/common/utils/convertArrayToObject.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CA2DxH"}
+{"version":3,"file":"convertArrayToObject.d.ts","sourceRoot":"","sources":["../../../src/common/utils/convertArrayToObject.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAgHxH"}

package/dist/common/utils/convertArrayToObject.js

@@ -6,6 +6,7 @@ function convertArrayToObject(optionsArr) {
         items: [],
         excludeCoreServiceFiles: undefined,
         request: undefined,
+        customExecutorPath: undefined,
         useOptions: undefined,
         useCancelableRequest: undefined,
     };
@@ -16,21 +17,12 @@ function convertArrayToObject(optionsArr) {
         if (optionsArr.length === 0) {
             return emptyResult;
         }
-        const items = optionsArr.map(item => ({
-            input: item.input,
-            output: item.output,
-            outputCore: item.outputCore,
-            outputServices: item.outputServices,
-            outputModels: item.outputModels,
-            outputSchemas: item.outputSchemas,
-        }));
-        const firstItem = optionsArr[0];
-        const fieldsToExtract = [
+        const rootDrivenFields = [
             'httpClient',
             'useOptions',
             'useUnionTypes',
             'excludeCoreServiceFiles',
-            'request',
+            'includeSchemasFiles',
             'interfacePrefix',
             'enumPrefix',
             'typePrefix',
@@ -40,13 +32,61 @@ function convertArrayToObject(optionsArr) {
             'sortByRequired',
             'useSeparatedIndexes',
             'validationLibrary',
+            'emptySchemaStrategy',
+            'modelsMode',
+            'useHistory',
+            'diffReport',
         ];
-        const extractedFields = fieldsToExtract.reduce((acc, field) => ({
+        const getNormalizedFieldValue = (item, field) => {
+            if (field === 'httpClient') {
+                return item.httpClient ?? item.client;
+            }
+            return item[field];
+        };
+        const getRootValueOrThrow = (field) => {
+            const definedValues = optionsArr
+                .map(item => getNormalizedFieldValue(item, field))
+                .filter(value => value !== undefined);
+            if (definedValues.length === 0) {
+                return undefined;
+            }
+            const firstValue = definedValues[0];
+            const hasConflict = definedValues.some(value => value !== firstValue);
+            if (hasConflict) {
+                throw new Error(`Legacy array config has conflicting "${field}" values. ` +
+                    `This option must have the same value for all array items.`);
+            }
+            return firstValue;
+        };
+        const getCommonOptionalRootValue = (field) => {
+            const definedValues = optionsArr
+                .map(item => item[field])
+                .filter(value => value !== undefined);
+            if (definedValues.length === 0) {
+                return undefined;
+            }
+            const firstValue = definedValues[0];
+            const hasConflict = definedValues.some(value => value !== firstValue);
+            return hasConflict ? undefined : firstValue;
+        };
+        const items = optionsArr.map(item => ({
+            input: item.input,
+            output: item.output,
+            outputCore: item.outputCore,
+            outputServices: item.outputServices,
+            outputModels: item.outputModels,
+            outputSchemas: item.outputSchemas,
+            request: item.request,
+            customExecutorPath: item.customExecutorPath,
+        }));
+        const extractedRootFields = rootDrivenFields.reduce((acc, field) => ({
             ...acc,
-            [field]: firstItem[field],
+            [field]: getRootValueOrThrow(field),
         }), {});
         return {
-            ...extractedFields,
+            ...extractedRootFields,
+            request: getCommonOptionalRootValue('request'),
+            customExecutorPath: getCommonOptionalRootValue('customExecutorPath'),
             items,
         };
     }

package/dist/common/utils/eslintFix.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs ESLint --fix on the given file using the user's project ESLint config.
+ * Silently skips if ESLint is not installed.
+ * Logs an error and re-throws if ESLint fails during the fix.
+ */
+export declare function eslintFix(filePath: string): Promise<void>;
+//# sourceMappingURL=eslintFix.d.ts.map

package/dist/common/utils/eslintFix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslintFix.d.ts","sourceRoot":"","sources":["../../../src/common/utils/eslintFix.ts"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsB/D"}

package/dist/common/utils/eslintFix.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslintFix = eslintFix;
+const Consts_1 = require("../Consts");
+const LoggerMessages_1 = require("../LoggerMessages");
+/**
+ * Dynamically resolves the ESLint module from the user's project.
+ * Returns null if ESLint is not installed.
+ */
+async function tryImportESLint() {
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require('eslint')));
+        return mod;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Runs ESLint --fix on the given file using the user's project ESLint config.
+ * Silently skips if ESLint is not installed.
+ * Logs an error and re-throws if ESLint fails during the fix.
+ */
+async function eslintFix(filePath) {
+    const eslintModule = await tryImportESLint();
+    if (!eslintModule) {
+        Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_NOT_INSTALLED);
+        return;
+    }
+    try {
+        const eslint = new eslintModule.ESLint({ fix: true });
+        const results = await eslint.lintFiles([filePath]);
+        await eslintModule.ESLint.outputFixes(results);
+        Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_FIX_APPLIED(filePath));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Consts_1.APP_LOGGER.errorWithHint({
+            code: LoggerMessages_1.LOGGER_ERROR_CODES.ESLINT_FIX_FAILED,
+            message: LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.ESLINT_FIX_FAILED(filePath, message),
+            error,
+        });
+        throw error;
+    }
+}

package/dist/common/utils/format.d.ts

@@ -1,3 +1,3 @@
 import { BuiltInParserName, LiteralUnion } from 'prettier';
-export declare function format(input: string, parser?: LiteralUnion<BuiltInParserName>): Promise<string>;
+export declare function format(input: string, parser?: LiteralUnion<BuiltInParserName>, useProjectConfig?: boolean): Promise<string>;
 //# sourceMappingURL=format.d.ts.map

package/dist/common/utils/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/common/utils/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAA2B,YAAY,EAAE,MAAM,UAAU,CAAC;AAEpF,wBAAsB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBrG"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/common/utils/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAA4B,YAAY,EAA6C,MAAM,UAAU,CAAC;AAiBhI,wBAAsB,MAAM,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,YAAY,CAAC,iBAAiB,CAAC,EACxC,gBAAgB,CAAC,EAAE,OAAO,GAC3B,OAAO,CAAC,MAAM,CAAC,CA6BjB"}

package/dist/common/utils/format.js

@@ -2,23 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 const prettier_1 = require("prettier");
-async function format(input, parser) {
+const Consts_1 = require("../Consts");
+const LoggerMessages_1 = require("../LoggerMessages");
+const BUILTIN_PRETTIER_OPTIONS = {
+    tabWidth: 4,
+    printWidth: 120,
+    useTabs: false,
+    singleQuote: true,
+    quoteProps: 'as-needed',
+    trailingComma: 'all',
+    bracketSpacing: true,
+    arrowParens: 'avoid',
+    endOfLine: 'auto',
+};
+async function format(input, parser, useProjectConfig) {
+    let options = { ...BUILTIN_PRETTIER_OPTIONS, parser: parser ?? 'typescript' };
+    if (useProjectConfig) {
+        try {
+            const resolved = await (0, prettier_1.resolveConfig)(process.cwd(), { useCache: false });
+            if (resolved) {
+                Consts_1.APP_LOGGER.info(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.PRETTIER_PROJECT_CONFIG_RESOLVED(process.cwd()));
+                options = { ...resolved, parser: parser ?? resolved.parser ?? 'typescript' };
+            }
+            else {
+                Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.PRETTIER_PROJECT_CONFIG_NOT_FOUND);
+            }
+        }
+        catch {
+            Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.PRETTIER_PROJECT_CONFIG_NOT_FOUND);
+        }
+    }
     try {
-        const formatedCode = await (0, prettier_1.format)(input, {
-            parser: parser ?? 'typescript',
-            tabWidth: 4,
-            printWidth: 120,
-            useTabs: false,
-            singleQuote: true,
-            quoteProps: 'as-needed',
-            trailingComma: 'all',
-            bracketSpacing: true,
-            arrowParens: 'avoid',
-            endOfLine: 'auto',
-        });
+        const formatedCode = await (0, prettier_1.format)(input, options);
         return formatedCode;
     }
-    catch {
-        throw new Error('Could not to format the value via prettier');
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        Consts_1.APP_LOGGER.errorWithHint({
+            code: LoggerMessages_1.LOGGER_ERROR_CODES.PRETTIER_FORMAT_FAILED,
+            message: LoggerMessages_1.LOGGER_MESSAGES.FORMATTING.PRETTIER_FORMAT_FAILED('(generated content)', message),
+            error,
+        });
+        throw new Error(`Could not format the value via prettier: ${message}`);
     }
 }

package/dist/common/utils/jsonPath.d.ts

@@ -0,0 +1,5 @@
+type JsonPathSegment = string | number;
+export declare const toJsonPath: (segments: JsonPathSegment[]) => string;
+export declare const parseJsonPath: (path: string) => string[];
+export {};
+//# sourceMappingURL=jsonPath.d.ts.map

package/dist/common/utils/jsonPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPath.d.ts","sourceRoot":"","sources":["../../../src/common/utils/jsonPath.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvC,eAAO,MAAM,UAAU,GAAI,UAAU,eAAe,EAAE,KAAG,MAcxD,CAAC;AAIF,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MAAM,EAQlD,CAAC"}

package/dist/common/utils/jsonPath.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonPath = exports.toJsonPath = void 0;
+const toJsonPath = (segments) => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return segments.reduce((path, seg) => {
+        const segment = String(seg);
+        const needsBrackets = segment.includes('.') || segment.includes('/') || segment.includes('-') || segment.includes('[') || segment.includes(']');
+        if (segment === '') {
+            return path;
+        }
+        return path + (needsBrackets ? `['${segment}']` : `.${segment}`);
+    }, '$');
+};
+exports.toJsonPath = toJsonPath;
+const JSON_PATH_SEGMENT_REGEX = /\[['"]([^'"]+)['"]\]|\.([A-Za-z0-9_$]+)/g;
+const parseJsonPath = (path) => {
+    const segments = [];
+    JSON_PATH_SEGMENT_REGEX.lastIndex = 0;
+    let match;
+    while ((match = JSON_PATH_SEGMENT_REGEX.exec(path)) !== null) {
+        segments.push(match[1] ?? match[2]);
+    }
+    return segments.filter(segment => segment.length > 0);
+};
+exports.parseJsonPath = parseJsonPath;

package/dist/common/utils/normalizeObject.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizeObject: (value: any) => any;
+//# sourceMappingURL=normalizeObject.d.ts.map

package/dist/common/utils/normalizeObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeObject.d.ts","sourceRoot":"","sources":["../../../src/common/utils/normalizeObject.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,KAAG,GA2B5C,CAAC"}

package/dist/common/utils/normalizeObject.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeObject = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const isPlainObject = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const mergeObjects = (base, next) => {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(next)) {
+        const existing = result[key];
+        if (isPlainObject(existing) && isPlainObject(value)) {
+            result[key] = mergeObjects(existing, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+const expandAllOf = (value) => {
+    const allOf = Array.isArray(value.allOf) ? value.allOf : null;
+    if (!allOf)
+        return value;
+    let merged = {};
+    for (const item of allOf) {
+        if (isPlainObject(item)) {
+            merged = mergeObjects(merged, item);
+        }
+    }
+    const rest = {};
+    for (const [key, val] of Object.entries(value)) {
+        if (key === 'allOf')
+            continue;
+        rest[key] = val;
+    }
+    return mergeObjects(merged, rest);
+};
+const normalizeObject = (value) => {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => (0, exports.normalizeObject)(item));
+    }
+    if (typeof value !== 'object') {
+        return value;
+    }
+    const expanded = expandAllOf(value);
+    const entries = Object.entries(expanded).sort(([a], [b]) => {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    });
+    const result = {};
+    for (const [key, val] of entries) {
+        result[key] = (0, exports.normalizeObject)(val);
+    }
+    return result;
+};
+exports.normalizeObject = normalizeObject;

package/dist/core/Context.d.ts

@@ -1,4 +1,5 @@
 import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from 'json-schema';
+import { OpenApiGeneratorPlugin, SchemaTypeOverrideContext } from './plugins/GeneratorPlugin.model';
 import { OutputPaths } from './types/base/OutputPaths.model';
 import { PrefixArtifacts } from './types/base/PrefixArtifacts.model';
 import { $Root } from './types/base/Root.model';
@@ -7,6 +8,7 @@ type TContextProps = {
     output: OutputPaths;
     prefix?: PrefixArtifacts;
     sortByRequired?: boolean;
+    plugins?: OpenApiGeneratorPlugin[];
 };
 type RefsLike = {
     values: (...args: any[]) => Record<string, any>;
@@ -32,10 +34,11 @@ export declare class Context {
     private _output;
     prefix: PrefixArtifacts;
     private _sortByRequired;
+    private _plugins;
     private specRoot;
     private entryFile?;
     private virtualFiles;
-    constructor({ input, output, prefix, sortByRequired }: TContextProps);
+    constructor({ input, output, prefix, sortByRequired, plugins }: TContextProps);
     addRefs(refs: RefsLike): Context;
     values(...types: string[]): Record<string, any>;
     get($ref: string, parentSourceFile?: string): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
@@ -45,6 +48,10 @@ export declare class Context {
     get output(): OutputPaths;
     get sortByRequired(): boolean;
     get root(): $Root | undefined;
+    /**
+     * Resolves custom type override for schema via registered plugins.
+     */
+    resolveSchemaTypeOverride(schema: Record<string, any>, context: SchemaTypeOverrideContext): string | undefined;
     private canonicalizeRef;
     private mapSourceToOutput;
     private walkSchemaForFragments;