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

package/dist/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.js

@@ -4,38 +4,83 @@ exports.determineBestMatchingSchemaVersion = determineBestMatchingSchemaVersion;
 const validateZodOptions_1 = require("../../Validation/validateZodOptions");
 const getUniqueKeysFromSchemas_1 = require("./getUniqueKeysFromSchemas");
 const getUniqueObjectKeys_1 = require("./getUniqueObjectKeys");
-// Determining the most appropriate schema version
+/**
+ * Counts unknown keys using a strict schema variant.
+ * The strict check is used only for ranking candidates, not for final validation.
+ */
+function getStrictUnrecognizedKeyCount(schema, inputData) {
+    const strictResult = (0, validateZodOptions_1.validateZodOptionsRaw)(schema.strict(), inputData);
+    if (strictResult.success) {
+        return 0;
+    }
+    return strictResult.error.issues.reduce((count, issue) => {
+        if (issue.code !== 'unrecognized_keys' || !('keys' in issue)) {
+            return count;
+        }
+        return count + issue.keys.length;
+    }, 0);
+}
+/**
+ * Compares two schema candidates and returns the better one.
+ * Priority:
+ * 1) fewer structural errors;
+ * 2) fewer strict-mode unknown keys;
+ * 3) more matching keys;
+ * 4) newer version inside the same schema family;
+ * 5) lower index when schema families differ.
+ */
+function compareCandidates(best, current) {
+    if (current.structuralErrorCount !== best.structuralErrorCount) {
+        return current.structuralErrorCount < best.structuralErrorCount ? current : best;
+    }
+    if (current.strictUnrecognizedKeyCount !== best.strictUnrecognizedKeyCount) {
+        return current.strictUnrecognizedKeyCount < best.strictUnrecognizedKeyCount ? current : best;
+    }
+    if (current.matchingKeysCount !== best.matchingKeysCount) {
+        return current.matchingKeysCount > best.matchingKeysCount ? current : best;
+    }
+    if (current.type === best.type) {
+        return current.index > best.index ? current : best;
+    }
+    return current.index < best.index ? current : best;
+}
+/**
+ * Determines the best matching schema version for input data.
+ * `invalid_value` issues are intentionally ignored to allow migration from older enum/value variants.
+ */
 function determineBestMatchingSchemaVersion(inputData, versionedSchemas) {
     if (!versionedSchemas.length) {
         throw new Error('The list of schemes cannot be empty');
     }
     const inputKeys = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)(inputData);
-    const matchingSchemas = versionedSchemas
-        .map(({ schema, version }, idx) => {
+    const schemaMatches = versionedSchemas.map(({ schema, baseSchema, version, type }, idx) => {
+        const schemaKeys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([schema]);
+        const matchingKeysCount = inputKeys.filter(key => schemaKeys.has(key)).length;
+        const strictUnrecognizedKeyCount = getStrictUnrecognizedKeyCount(baseSchema, inputData);
         const validationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(schema, inputData);
-        const errorFields = !validationResult.success ? validationResult.error.issues.filter(err => err.code !== 'invalid_value') : [];
-        return errorFields.length === 0 ? { version, index: idx } : null;
-    })
-        .filter((match) => match !== null);
-    if (matchingSchemas.length > 0) {
-        const latestMatch = matchingSchemas.reduce((prev, curr) => (curr.index > prev.index ? curr : prev));
+        const structuralErrorCount = !validationResult.success
+            ? validationResult.error.issues.filter(issue => issue.code !== 'invalid_value').length
+            : 0;
         return {
-            lastVersionIndex: latestMatch.index,
-            latestVersion: latestMatch.version,
-            firstVersion: matchingSchemas[0].version,
+            index: idx,
+            version,
+            type,
+            structuralErrorCount,
+            strictUnrecognizedKeyCount,
+            matchingKeysCount,
         };
-    }
-    const schemaMatches = versionedSchemas.map(({ schema, version }, idx) => {
-        const schemaKeys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([schema]);
-        const validationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(schema, inputData);
-        const errorFields = !validationResult.success ? validationResult.error.issues.filter(err => err.code !== 'invalid_value') : [];
-        const matchingKeys = inputKeys.filter(key => schemaKeys.has(key));
-        return { index: idx, version, errorFields, matchingKeys };
     });
-    const bestMatch = schemaMatches.reduce((best, current) => {
-        const isBetterMatch = current.matchingKeys.length >= best.matchingKeys.length && current.errorFields.length <= best.errorFields.length;
-        return isBetterMatch ? current : best;
-    }, schemaMatches[0]);
+    const structurallyValidMatches = schemaMatches.filter(match => match.structuralErrorCount === 0);
+    if (structurallyValidMatches.length > 0) {
+        const bestStructurallyValidMatch = structurallyValidMatches.reduce(compareCandidates);
+        const firstVersion = structurallyValidMatches.reduce((earliest, current) => (current.index < earliest.index ? current : earliest)).version;
+        return {
+            lastVersionIndex: bestStructurallyValidMatch.index,
+            latestVersion: bestStructurallyValidMatch.version,
+            firstVersion,
+        };
+    }
+    const bestMatch = schemaMatches.reduce(compareCandidates);
     return {
         lastVersionIndex: bestMatch.index,
         latestVersion: bestMatch.version,

package/dist/common/VersionedSchema/Utils/getUniqueKeysFromSchemas.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 /**
  * Get all the unique parameter keys of all Joi schemes in the array
- * @param schemas array of joi schemes
+ * @param schemas array of zod schemes
  * @returns All the unique parameter keys of all Joi schemes in the array
  */
 export declare function getUniqueKeysFromSchemas(schemas: z.ZodTypeAny[]): Set<string>;

package/dist/common/VersionedSchema/Utils/getUniqueKeysFromSchemas.js

@@ -18,7 +18,7 @@ function collectKeys(schema, result) {
 }
 /**
  * Get all the unique parameter keys of all Joi schemes in the array
- * @param schemas array of joi schemes
+ * @param schemas array of zod schemes
  * @returns All the unique parameter keys of all Joi schemes in the array
  */
 function getUniqueKeysFromSchemas(schemas) {

package/dist/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.d.ts

@@ -2,18 +2,28 @@ import { z } from 'zod';
 import { EMigrationMode } from '../../Enums';
 import { EVersionedSchemaType } from '../Enums';
 import { SchemaMigrationPlan, VersionedSchema, VersionMatchResult } from '../Types';
+/**
+ * Input arguments for migrating arbitrary config data to the latest schema version.
+ */
 type MigrateToLatestProps = {
     rawInput: Record<string, any>;
     migrationPlans: SchemaMigrationPlan<Record<string, any>, Record<string, any>>[];
     versionedSchemas: VersionedSchema<z.ZodTypeAny>[];
     migrationMode: EMigrationMode;
 };
+/**
+ * Result of successful migration to the latest schema.
+ */
 type MigrateToLatestResult = {
     value: Record<string, any>;
     guessedVersion: VersionMatchResult;
     schemaVersion: string;
     schemaType: EVersionedSchemaType;
 };
+/**
+ * Migrates raw input through the migration graph to the latest schema version.
+ * Migration path is resolved by `fromVersion -> toVersion` links from `migrationPlans`.
+ */
 export declare function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedSchemas, migrationMode }: MigrateToLatestProps): MigrateToLatestResult | null;
 export {};
 //# sourceMappingURL=migrateDataToLatestSchemaVersion.d.ts.map

package/dist/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrateDataToLatestSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AASpF,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,cAAc,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAChF,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC;IAClD,aAAa,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,cAAc,EAAE,kBAAkB,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAiElK"}
+{"version":3,"file":"migrateDataToLatestSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AASpF;;GAEG;AACH,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,cAAc,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAChF,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC;IAClD,aAAa,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,KAAK,qBAAqB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,cAAc,EAAE,kBAAkB,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAkFlK"}

package/dist/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrateDataToLatestSchemaVersion = migrateDataToLatestSchemaVersion;
+const Consts_1 = require("../../Consts");
+const LoggerMessages_1 = require("../../LoggerMessages");
 const Enums_1 = require("../../Enums");
 const validateZodOptions_1 = require("../../Validation/validateZodOptions");
 const determineBestMatchingSchemaVersion_1 = require("./determineBestMatchingSchemaVersion");
@@ -10,6 +12,10 @@ const getUniqueKeysFromSchemas_1 = require("./getUniqueKeysFromSchemas");
 const getUniqueObjectKeys_1 = require("./getUniqueObjectKeys");
 const replaceInvalidKeysWithMappedNames_1 = require("./replaceInvalidKeysWithMappedNames");
 const validateAndSuggestKeyCorrections_1 = require("./validateAndSuggestKeyCorrections");
+/**
+ * Migrates raw input through the migration graph to the latest schema version.
+ * Migration path is resolved by `fromVersion -> toVersion` links from `migrationPlans`.
+ */
 function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedSchemas, migrationMode }) {
     const schemas = versionedSchemas.map(el => el.schema);
     const allUniqueKeysFromSchemas = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)(schemas);
@@ -20,34 +26,47 @@ function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedS
     const schemaPossibleKeys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([guessedValidationSchema]);
     const replacingKeysMap = (0, generateKeyMappingForInvalidKeys_1.generateKeyMappingForInvalidKeys)(allUniqueKeysFromRawInput, schemaPossibleKeys);
     let currentData = replacingKeysMap.size ? (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)(rawInput, replacingKeysMap) : rawInput;
-    const actualVersionIndex = versionedSchemas.length - 1;
-    const actualSchema = versionedSchemas[actualVersionIndex];
-    for (let idx = guessedVersion.lastVersionIndex; idx < versionedSchemas.length - 1; idx++) {
-        const currentVersionSchema = versionedSchemas[idx];
-        const firstValidationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(currentVersionSchema.schema, currentData);
+    const actualSchema = versionedSchemas[versionedSchemas.length - 1];
+    const schemasByVersion = new Map(versionedSchemas.map(schemaInfo => [schemaInfo.version, schemaInfo.schema]));
+    const migrationPlanByFromVersion = new Map(migrationPlans.map(plan => [plan.fromVersion, plan]));
+    let currentVersion = guessedVersion.latestVersion;
+    const visitedVersions = new Set([currentVersion]);
+    while (currentVersion !== actualSchema.version) {
+        const currentVersionSchema = schemasByVersion.get(currentVersion);
+        if (!currentVersionSchema) {
+            throw new Error(`No schema found for version ${currentVersion}.`);
+        }
+        const firstValidationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(currentVersionSchema, currentData);
         if (!firstValidationResult.success) {
             (0, getCurrentErrorMessage_1.getCurrentErrorMessage)(firstValidationResult.error, replacingKeysMap);
         }
-        const fromVersion = currentVersionSchema.version;
-        const migrationPlan = migrationPlans.find(p => p.fromVersion === fromVersion);
+        const migrationPlan = migrationPlanByFromVersion.get(currentVersion);
         if (!migrationPlan) {
-            const availableVersions = migrationPlans.map(p => p.fromVersion).join(', ');
-            throw new Error(`No migration plan from ${fromVersion}. ` +
+            const availableVersions = Array.from(migrationPlanByFromVersion.keys()).join(', ');
+            throw new Error(`No migration plan from ${currentVersion}. ` +
                 `Available migration plans: ${availableVersions}. ` +
                 `This usually means the migration chain is incomplete.`);
         }
-        const toVersion = versionedSchemas[idx + 1].version;
+        const nextVersion = migrationPlan.toVersion;
+        const nextSchema = schemasByVersion.get(nextVersion);
+        if (!nextSchema) {
+            throw new Error(`Migration plan from ${migrationPlan.fromVersion} points to unknown schema version ${nextVersion}.`);
+        }
         const migratedRaw = migrationPlan.migrate(currentData);
-        const validationResult = (0, validateZodOptions_1.validateZodOptions)(versionedSchemas[idx + 1].schema, migratedRaw);
+        const validationResult = (0, validateZodOptions_1.validateZodOptions)(nextSchema, migratedRaw);
         if (!validationResult.success) {
-            throw new Error(`Migration from ${fromVersion} to ${toVersion} failed validation. ` +
+            throw new Error(`Migration from ${currentVersion} to ${nextVersion} failed validation. ` +
                 `Error: ${validationResult.errors.join('\n')}. ` +
                 `Migration description: ${migrationPlan.description || 'No description provided'}.`);
         }
         currentData = { ...migratedRaw };
-        const isLastIteration = idx + 1 === actualVersionIndex;
-        if (isLastIteration && migrationMode === Enums_1.EMigrationMode.GENERATE_OPENAPI) {
-            console.warn('Для выполнения генерации OpenApi потребовалось мигрировать схему Ваших данных на актуальную. Для обновленмя конфигурации в файле используйте команду `npm name_cli_tool update-config`');
+        currentVersion = nextVersion;
+        if (visitedVersions.has(currentVersion)) {
+            throw new Error(`Migration loop detected at version ${currentVersion}.`);
+        }
+        visitedVersions.add(currentVersion);
+        if (currentVersion === actualSchema.version && migrationMode === Enums_1.EMigrationMode.GENERATE_OPENAPI) {
+            Consts_1.APP_LOGGER.warn(LoggerMessages_1.LOGGER_MESSAGES.MIGRATION.OPENAPI_SCHEMA_MIGRATED);
         }
     }
     const validationResult = (0, validateZodOptions_1.validateZodOptionsRaw)(actualSchema.schema, currentData);

package/dist/common/__tests__/Logger.test.d.ts

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

package/dist/common/__tests__/Logger.test.d.ts.map

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

package/dist/common/__tests__/Logger.test.js

@@ -0,0 +1,100 @@
+"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 Enums_1 = require("../Enums");
+const Logger_1 = require("../Logger");
+const LoggerMessages_1 = require("../LoggerMessages");
+(0, node_test_1.describe)('@unit: Logger', () => {
+    (0, node_test_1.test)('errorWithHint should log error with recommendation for known code', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.ERROR,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const loggerErrorMock = node_test_1.mock.fn();
+        const loggerInfoMock = node_test_1.mock.fn();
+        const loggerWarnMock = node_test_1.mock.fn();
+        logger._logger = {
+            error: loggerErrorMock,
+            info: loggerInfoMock,
+            warn: loggerWarnMock,
+            level: 'error',
+            log: node_test_1.mock.fn(),
+        };
+        const code = LoggerMessages_1.LOGGER_ERROR_CODES.CONFIG_FILE_MISSING;
+        const recommendation = LoggerMessages_1.LOGGER_ERROR_RECOMMENDATIONS[code];
+        const exitMock = node_test_1.mock.method(process, 'exit', () => {
+            // nothing
+        });
+        logger.errorWithHint({ code });
+        node_assert_1.default.strictEqual(loggerErrorMock.mock.callCount(), 1);
+        node_assert_1.default.ok(String(loggerErrorMock.mock.calls[0].arguments[0]).includes('Error:'), 'error message should contain "Error:" prefix');
+        node_assert_1.default.ok(loggerInfoMock.mock.callCount() >= 2);
+        const infoMessages = loggerInfoMock.mock.calls.map(call => String(call.arguments[0]));
+        node_assert_1.default.ok(infoMessages.some(msg => msg.includes('What you can do next')), 'info should contain recommendation title');
+        node_assert_1.default.ok(infoMessages.some(msg => msg.includes(recommendation)), 'info should contain concrete recommendation text');
+        // Logger no longer calls process.exit; caller is responsible for flush and exit
+        node_assert_1.default.strictEqual(exitMock.mock.callCount(), 0);
+    });
+    (0, node_test_1.test)('success should delegate to internal logger with success level', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.INFO,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const logMock = node_test_1.mock.fn();
+        logger._logger = {
+            log: logMock,
+            level: 'info',
+        };
+        logger.success('Done');
+        node_assert_1.default.strictEqual(logMock.mock.callCount(), 1);
+        const [level, message] = logMock.mock.calls[0].arguments;
+        node_assert_1.default.strictEqual(level, 'success');
+        node_assert_1.default.strictEqual(message, 'Done');
+    });
+    (0, node_test_1.test)('error should not call process.exit', () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.ERROR,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        const loggerErrorMock = node_test_1.mock.fn();
+        logger._logger = { error: loggerErrorMock, level: 'error' };
+        const exitMock = node_test_1.mock.method(process, 'exit', () => {
+            throw new Error('process.exit should not be called by Logger.error');
+        });
+        logger.error('Something failed');
+        node_assert_1.default.strictEqual(loggerErrorMock.mock.callCount(), 1);
+        node_assert_1.default.strictEqual(exitMock.mock.callCount(), 0);
+    });
+    (0, node_test_1.test)('shutdownLoggerAsync should resolve and close transports', async () => {
+        const logger = new Logger_1.Logger({
+            instanceId: 'test',
+            level: Enums_1.ELogLevel.INFO,
+            logOutput: Enums_1.ELogOutput.CONSOLE,
+            disableColors: true,
+        });
+        let closeCalled = false;
+        const mockTransport = {
+            close(cb) {
+                closeCalled = true;
+                if (typeof cb === 'function')
+                    cb();
+            },
+        };
+        logger._logger = {
+            transports: [mockTransport],
+            close: node_test_1.mock.fn(),
+        };
+        await logger.shutdownLoggerAsync();
+        node_assert_1.default.strictEqual(closeCalled, true);
+    });
+});

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

@@ -7,67 +7,74 @@ const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const convertArrayToObject_1 = require("../convertArrayToObject");
 (0, node_test_1.describe)('@unit: convertArrayToObject', () => {
-    (0, node_test_1.test)('Empty array', () => {
-        const input = [];
-        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        const expected = {
+    (0, node_test_1.test)('returns default shape for null', () => {
+        const result = (0, convertArrayToObject_1.convertArrayToObject)(null);
+        node_assert_1.default.deepStrictEqual(result, {
             items: [],
             excludeCoreServiceFiles: undefined,
             request: undefined,
+            customExecutorPath: undefined,
             useOptions: undefined,
             useCancelableRequest: undefined,
-        };
-        node_assert_1.default.deepStrictEqual(result, expected);
+        });
+    });
+    (0, node_test_1.test)('returns default shape for empty array', () => {
+        const result = (0, convertArrayToObject_1.convertArrayToObject)([]);
+        node_assert_1.default.deepStrictEqual(result, {
+            items: [],
+            excludeCoreServiceFiles: undefined,
+            request: undefined,
+            customExecutorPath: undefined,
+            useOptions: undefined,
+            useCancelableRequest: undefined,
+        });
+    });
+    (0, node_test_1.test)('passes through object config unchanged', () => {
+        const input = { input: './spec.json', output: './generated', httpClient: 'axios' };
+        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
+        node_assert_1.default.strictEqual(result, input);
     });
-    (0, node_test_1.test)('An array with one element', () => {
+    (0, node_test_1.test)('converts legacy array and keeps per-item request/customExecutorPath', () => {
         const input = [
             {
                 input: 'url1',
                 output: 'res1',
-                exportCore: true,
                 request: 'req1',
+                customExecutorPath: 'exec-1',
+                httpClient: 'axios',
+                useOptions: true,
+            },
+            {
+                input: 'url2',
+                output: 'res2',
+                request: 'req2',
+                customExecutorPath: 'exec-2',
+                httpClient: 'axios',
                 useOptions: true,
             },
         ];
-        const expected = {
-            enumPrefix: undefined,
+        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, {
+            httpClient: 'axios',
+            useOptions: true,
+            useUnionTypes: undefined,
             excludeCoreServiceFiles: undefined,
-            httpClient: undefined,
+            includeSchemasFiles: undefined,
             interfacePrefix: undefined,
-            items: [
-                {
-                    input: 'url1',
-                    output: 'res1',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-            ],
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
             logLevel: undefined,
             logTarget: undefined,
-            request: 'req1',
             sortByRequired: undefined,
-            typePrefix: undefined,
-            useCancelableRequest: undefined,
-            useOptions: true,
             useSeparatedIndexes: undefined,
-            useUnionTypes: undefined,
-            validationLibrary: undefined
-        };
-        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        node_assert_1.default.deepStrictEqual(result, expected);
-    });
-    (0, node_test_1.test)('Multiple elements with the same outer margins', () => {
-        const input = [
-            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
-            { input: 'url2', output: 'res2', exportCore: true, request: 'req1', useOptions: true },
-        ];
-        const expected = {
-            enumPrefix: undefined,
-            excludeCoreServiceFiles: undefined,
-            httpClient: undefined,
-            interfacePrefix: undefined,
+            validationLibrary: undefined,
+            emptySchemaStrategy: undefined,
+            modelsMode: undefined,
+            useHistory: undefined,
+            diffReport: undefined,
+            request: undefined,
+            customExecutorPath: undefined,
             items: [
                 {
                     input: 'url1',
@@ -76,6 +83,8 @@ const convertArrayToObject_1 = require("../convertArrayToObject");
                     outputServices: undefined,
                     outputModels: undefined,
                     outputSchemas: undefined,
+                    request: 'req1',
+                    customExecutorPath: 'exec-1',
                 },
                 {
                     input: 'url2',
@@ -84,146 +93,35 @@ const convertArrayToObject_1 = require("../convertArrayToObject");
                     outputServices: undefined,
                     outputModels: undefined,
                     outputSchemas: undefined,
+                    request: 'req2',
+                    customExecutorPath: 'exec-2',
                 },
             ],
-            logLevel: undefined,
-            logTarget: undefined,
-            request: 'req1',
-            sortByRequired: undefined,
-            typePrefix: undefined,
-            useCancelableRequest: undefined,
-            useOptions: true,
-            useSeparatedIndexes: undefined,
-            useUnionTypes: undefined,
-            validationLibrary: undefined
-        };
-        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        node_assert_1.default.deepStrictEqual(result, expected);
+        });
     });
-    (0, node_test_1.test)('Multiple elements with different external margins', () => {
+    (0, node_test_1.test)('promotes request/customExecutorPath to root when they are equal for all items', () => {
         const input = [
-            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
-            { input: 'url2', output: 'res2', exportCore: false, request: 'req2', useOptions: false },
+            { input: 'url1', output: 'res1', request: 'req', customExecutorPath: 'exec' },
+            { input: 'url2', output: 'res2', request: 'req', customExecutorPath: 'exec' },
         ];
-        const expected = {
-            enumPrefix: undefined,
-            excludeCoreServiceFiles: undefined,
-            httpClient: undefined,
-            interfacePrefix: undefined,
-            items: [
-                {
-                    input: 'url1',
-                    output: 'res1',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-                {
-                    input: 'url2',
-                    output: 'res2',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-            ],
-            logLevel: undefined,
-            logTarget: undefined,
-            request: 'req1',
-            sortByRequired: undefined,
-            typePrefix: undefined,
-            useCancelableRequest: undefined,
-            useOptions: true,
-            useSeparatedIndexes: undefined,
-            useUnionTypes: undefined,
-            validationLibrary: undefined
-        };
         const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        node_assert_1.default.deepStrictEqual(result, expected);
+        node_assert_1.default.strictEqual(result.request, 'req');
+        node_assert_1.default.strictEqual(result.customExecutorPath, 'exec');
     });
-    (0, node_test_1.test)('No optional fields', () => {
+    (0, node_test_1.test)('supports legacy "client" alias by normalizing it to httpClient', () => {
         const input = [
-            { input: 'url1', output: 'res1' },
-            { input: 'url2', output: 'res2' },
+            { input: 'url1', output: 'res1', client: 'axios', useOptions: true },
+            { input: 'url2', output: 'res2', client: 'axios', useOptions: true },
         ];
-        const expected = {
-            enumPrefix: undefined,
-            excludeCoreServiceFiles: undefined,
-            httpClient: undefined,
-            interfacePrefix: undefined,
-            items: [
-                {
-                    input: 'url1',
-                    output: 'res1',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-                {
-                    input: 'url2',
-                    output: 'res2',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-            ],
-            logLevel: undefined,
-            logTarget: undefined,
-            request: undefined,
-            sortByRequired: undefined,
-            typePrefix: undefined,
-            useCancelableRequest: undefined,
-            useOptions: undefined,
-            useSeparatedIndexes: undefined,
-            useUnionTypes: undefined,
-            validationLibrary: undefined
-        };
         const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        node_assert_1.default.deepStrictEqual(result, expected);
+        node_assert_1.default.strictEqual(result.httpClient, 'axios');
+        node_assert_1.default.strictEqual(result.useOptions, true);
     });
-    (0, node_test_1.test)('Mixed presence of optional fields', () => {
+    (0, node_test_1.test)('throws on conflicting root-driven fields', () => {
         const input = [
-            { input: 'url1', output: 'res1', exportCore: true },
-            { input: 'url2', output: 'res2', request: 'req2' },
+            { input: 'url1', output: 'res1', useOptions: true },
+            { input: 'url2', output: 'res2', useOptions: false },
         ];
-        const expected = {
-            enumPrefix: undefined,
-            excludeCoreServiceFiles: undefined,
-            httpClient: undefined,
-            interfacePrefix: undefined,
-            items: [
-                {
-                    input: 'url1',
-                    output: 'res1',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-                {
-                    input: 'url2',
-                    output: 'res2',
-                    outputCore: undefined,
-                    outputServices: undefined,
-                    outputModels: undefined,
-                    outputSchemas: undefined,
-                },
-            ],
-            logLevel: undefined,
-            logTarget: undefined,
-            request: undefined,
-            sortByRequired: undefined,
-            typePrefix: undefined,
-            useCancelableRequest: undefined,
-            useOptions: undefined,
-            useSeparatedIndexes: undefined,
-            useUnionTypes: undefined,
-            validationLibrary: undefined
-        };
-        const result = (0, convertArrayToObject_1.convertArrayToObject)(input);
-        node_assert_1.default.deepStrictEqual(result, expected);
+        node_assert_1.default.throws(() => (0, convertArrayToObject_1.convertArrayToObject)(input), /conflicting "useOptions" values/);
     });
 });

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

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

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

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