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

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.d.ts

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

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.d.ts.map

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

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.js

@@ -0,0 +1,111 @@
+"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 prepareDtoModels_1 = require("../prepareDtoModels");
+const resolveClassesModeTypes_1 = require("../resolveClassesModeTypes");
+const createArrayResult = (itemBase, itemPath) => ({
+    in: 'response',
+    name: '',
+    alias: '',
+    path: '',
+    code: 200,
+    description: null,
+    export: 'array',
+    type: itemBase,
+    base: itemBase,
+    template: null,
+    link: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [{ name: itemBase, alias: '', path: `./${itemPath}` }],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+(0, node_test_1.describe)('@unit: resolveClassesModeTypes', () => {
+    (0, node_test_1.test)('resolves array result types and imports to aliased export names', () => {
+        const ingredientCanonical = {
+            name: 'IIngredient',
+            alias: '',
+            path: 'components/schemas-v2/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const ingredient = {
+            name: 'IIngredient',
+            alias: 'IIngredient$2',
+            path: 'components/schemas/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const service = {
+            name: 'IngredientsService',
+            originName: 'Ingredients',
+            imports: [{ name: 'IIngredient', alias: '', path: './components/schemas/Ingredient' }],
+            operations: [
+                {
+                    service: 'IngredientsService',
+                    name: 'listSequenceIngredients',
+                    summary: null,
+                    description: null,
+                    deprecated: false,
+                    method: 'GET',
+                    path: '/sequences/{sequenceId}/ingredients',
+                    parameters: [],
+                    parametersPath: [],
+                    parametersQuery: [],
+                    parametersForm: [],
+                    parametersHeader: [],
+                    parametersCookie: [],
+                    parametersBody: null,
+                    imports: [],
+                    errors: [],
+                    results: [createArrayResult('IIngredient', 'components/schemas/Ingredient')],
+                    responseHeader: null,
+                    responseType: null,
+                },
+            ],
+        };
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [ingredientCanonical, ingredient],
+            services: [service],
+        };
+        const prepared = (0, resolveClassesModeTypes_1.resolveClassesModeTypes)((0, prepareDtoModels_1.prepareDtoModels)(client));
+        const operation = prepared.services[0]?.operations[0];
+        node_assert_1.default.strictEqual(prepared.services[0]?.imports[0].name, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].base, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].type, 'IIngredient$2');
+    });
+});

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.d.ts

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

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.d.ts.map

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

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.js

@@ -0,0 +1,68 @@
+"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 semanticChangesToDiffEntries_1 = require("../semanticChangesToDiffEntries");
+(0, node_test_1.describe)('@unit: semanticChangesToDiffEntries', () => {
+    (0, node_test_1.test)('maps property type change to legacy diff entry', () => {
+        const change = {
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'Property "age" type changed',
+            from: 'string',
+            to: 'integer',
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.severity, 'breaking');
+        node_assert_1.default.strictEqual(entry.path, '$.components.schemas.User.properties.age.type');
+        node_assert_1.default.strictEqual(entry.from, 'string');
+        node_assert_1.default.strictEqual(entry.to, 'integer');
+        node_assert_1.default.strictEqual(entry.note, change.message);
+    });
+    (0, node_test_1.test)('maps operation removed with metadata payload', () => {
+        const change = {
+            type: 'operation.removed',
+            severity: 'breaking',
+            path: '#/paths/GET /pets',
+            message: 'Operation removed',
+            from: {
+                operationId: 'listPets',
+                summary: 'List pets',
+                tags: ['pets'],
+            },
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'removed');
+        node_assert_1.default.strictEqual(entry.path, "$.paths['/pets'].get");
+        node_assert_1.default.deepStrictEqual(entry.from, change.from);
+    });
+    (0, node_test_1.test)('maps required flag change via fromRequired/toRequired', () => {
+        const change = {
+            type: 'model.property.required.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/required/email',
+            message: 'required changed',
+            fromRequired: false,
+            toRequired: true,
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.from, false);
+        node_assert_1.default.strictEqual(entry.to, true);
+    });
+    (0, node_test_1.test)('exposes semantic mapping helpers', () => {
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeTypeToAction)('model.property.removed'), 'removed');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticSeverityToDiffSeverity)('non-breaking'), 'warning');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeToJsonPath)({
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'type',
+        }), '$.components.schemas.User.properties.age.type');
+    });
+});

package/dist/core/utils/__tests__/serviceHelpers.test.js

@@ -95,6 +95,7 @@ function createOperationResponse(overrides = {}) {
             errors: [],
             results: [resultFooB],
             responseHeader: null,
+            responseType: null,
         };
         const service = {
             name: 'PetService',
@@ -106,16 +107,15 @@ function createOperationResponse(overrides = {}) {
         const aliasByPath = new Map(service.imports.map(item => [item.path, item.alias]));
         const aliasA = aliasByPath.get('models/a/Foo');
         const aliasB = aliasByPath.get('models/b/Foo');
-        node_assert_1.default.ok(aliasA);
-        node_assert_1.default.ok(aliasB);
-        node_assert_1.default.notEqual(aliasA, aliasB);
-        node_assert_1.default.equal(paramFooA.base, aliasA);
-        node_assert_1.default.equal(paramFooA.type, aliasA);
-        node_assert_1.default.equal(paramFooBArray.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.type, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.type, aliasB);
-        node_assert_1.default.equal(operation.results[0].base, aliasB);
-        node_assert_1.default.equal(operation.results[0].type, aliasB);
+        node_assert_1.default.strictEqual(aliasA, '');
+        node_assert_1.default.strictEqual(aliasB, 'Foo$2');
+        node_assert_1.default.equal(paramFooA.base, 'Foo');
+        node_assert_1.default.equal(paramFooA.type, 'Foo');
+        node_assert_1.default.equal(paramFooBArray.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.type, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.type, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].base, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].type, 'Foo$2');
     });
 });

package/dist/core/utils/__tests__/sortByRequiredExtended.test.js

@@ -14,24 +14,15 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('optional', { isRequired: false }),
             (0, createOperationParameter_1.createOperationParameter)('required', { isRequired: true }),
             (0, createOperationParameter_1.createOperationParameter)('optional-with-default', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
-        node_assert_1.default.deepStrictEqual(sortedNames, [
-            'required',
-            'required-with-default',
-            'optional',
-            'optional-with-default'
-        ]);
+        node_assert_1.default.deepStrictEqual(sortedNames, ['required', 'required-with-default', 'optional', 'optional-with-default']);
     });
     // Comparison tests within groups
     (0, node_test_1.test)('must sort by name within the required group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Gamma']);
@@ -40,18 +31,14 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Zeta', { isRequired: true, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Zeta']);
     });
     (0, node_test_1.test)('it should sort by name within the optional group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['First', 'Second', 'Third']);
@@ -60,7 +47,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Dog', { isRequired: false, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Cat', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -73,7 +60,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         ['required', 'optional-with-default'],
         ['required-with-default', 'optional'],
         ['required-with-default', 'optional-with-default'],
-        ['optional', 'optional-with-default']
+        ['optional', 'optional-with-default'],
     ];
     for (const [groupA, groupB] of groupPairs) {
         (0, node_test_1.test)(`must place "${groupA}" before "${groupB}"`, () => {
@@ -118,7 +105,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: false }), // optional
             (0, createOperationParameter_1.createOperationParameter)('Delta', { isRequired: true, default: 'def' }), // required-with-default
             (0, createOperationParameter_1.createOperationParameter)('Epsilon', { isRequired: false, default: 'def' }), // optional-with-default
-            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }) // required
+            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }), // required
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -128,16 +115,12 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             'Delta', // required-with-default
             'Beta', // optional
             'Gamma', // optional
-            'Epsilon' // optional-with-default
+            'Epsilon', // optional-with-default
         ]);
     });
     // A test for borderline cases
     (0, node_test_1.test)('It must handle empty names correctly.', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['', 'A', 'B']);

package/dist/core/utils/__tests__/templateRendering.test.d.ts

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

package/dist/core/utils/__tests__/templateRendering.test.d.ts.map

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

package/dist/core/utils/__tests__/templateRendering.test.js

@@ -0,0 +1,190 @@
+"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 HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
+const ModelsMode_enum_1 = require("../../types/enums/ModelsMode.enum");
+const ValidationLibrary_enum_1 = require("../../types/enums/ValidationLibrary.enum");
+const registerHandlebarTemplates_1 = require("../registerHandlebarTemplates");
+const requestContext = {
+    httpClient: HttpClient_enum_1.HttpClient.FETCH,
+    server: 'https://api.example.com',
+    version: '1.0.0',
+    useCancelableRequest: false,
+    useSeparatedIndexes: false,
+};
+const schemaModel = {
+    name: 'UserSchema',
+    alias: '',
+    path: 'schemas',
+    export: 'interface',
+    type: 'UserSchema',
+    base: 'UserSchema',
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: true,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties: [
+        {
+            name: 'id',
+            alias: '',
+            path: 'schemas',
+            export: 'generic',
+            type: 'string',
+            base: 'string',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: false,
+            isReadOnly: false,
+            isRequired: true,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        },
+    ],
+};
+const exportClientContext = {
+    outputCore: './generated/core',
+    useCustomRequest: false,
+    services: [],
+};
+const exportModelsContext = {
+    models: [schemaModel],
+    httpClient: HttpClient_enum_1.HttpClient.FETCH,
+    useUnionTypes: false,
+    useOptions: false,
+    outputCore: '../core',
+    modelsMode: ModelsMode_enum_1.ModelsMode.CLASSES,
+};
+(0, node_test_1.describe)('@unit: templateRendering', () => {
+    for (const httpClient of Object.values(HttpClient_enum_1.HttpClient)) {
+        for (const useCancelableRequest of [false, true]) {
+            (0, node_test_1.test)(`renders request template for ${httpClient} (cancelable=${useCancelableRequest})`, () => {
+                const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
+                    httpClient,
+                    useOptions: false,
+                    useUnionTypes: false,
+                    validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+                });
+                const output = templates.core.request({
+                    ...requestContext,
+                    httpClient,
+                    useCancelableRequest,
+                });
+                node_assert_1.default.ok(output.length > 100);
+                node_assert_1.default.match(output, /function request/i);
+            });
+        }
+    }
+    (0, node_test_1.test)('renders exportClient and exportModels templates', () => {
+        const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useOptions: false,
+            useUnionTypes: false,
+            validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+        });
+        const clientOutput = templates.exports.client(exportClientContext);
+        const modelsOutput = templates.exports.models(exportModelsContext);
+        node_assert_1.default.match(clientOutput, /createClient|RequestExecutor/i);
+        node_assert_1.default.match(modelsOutput, /BaseDto|fromArray/);
+    });
+    (0, node_test_1.test)('renders exportModels with ghost properties and type aliases', () => {
+        const modelWithGhost = {
+            ...schemaModel,
+            name: 'IUser',
+            type: 'IUser',
+            base: 'IUser',
+            rawName: 'IUserRaw',
+            dtoName: 'IUserDto',
+            exportName: 'IUser',
+            dtoKind: 'class',
+            ghostProperties: [
+                {
+                    name: 'legacyField',
+                    alias: '',
+                    path: 'models',
+                    export: 'generic',
+                    type: 'unknown',
+                    base: 'unknown',
+                    template: null,
+                    link: null,
+                    description: null,
+                    isDefinition: false,
+                    isReadOnly: false,
+                    isRequired: false,
+                    isNullable: false,
+                    imports: [],
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                    isGhost: true,
+                },
+            ],
+            properties: [
+                {
+                    name: 'id',
+                    alias: '',
+                    path: 'models',
+                    export: 'generic',
+                    type: 'string',
+                    base: 'string',
+                    template: null,
+                    link: null,
+                    description: null,
+                    isDefinition: false,
+                    isReadOnly: false,
+                    isRequired: true,
+                    isNullable: false,
+                    imports: [],
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                    rawType: 'string',
+                    dtoType: 'string',
+                    dtoInit: 'data.id',
+                    dtoTarget: '.id',
+                },
+            ],
+        };
+        const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useOptions: false,
+            useUnionTypes: false,
+            validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+        });
+        const output = templates.exports.models({
+            ...exportModelsContext,
+            models: [modelWithGhost],
+        });
+        node_assert_1.default.match(output, /legacyField\?: unknown/);
+        node_assert_1.default.match(output, /export type IUser = IUserRaw/);
+    });
+    (0, node_test_1.test)('renders schema export with validation library context', () => {
+        const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useOptions: false,
+            useUnionTypes: false,
+            validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.ZOD,
+        });
+        const output = templates.exports.schema({
+            ...schemaModel,
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useUnionTypes: false,
+            validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.ZOD,
+        });
+        node_assert_1.default.ok(output.length > 20);
+        node_assert_1.default.match(output, /UserSchema/i);
+    });
+});

package/dist/core/utils/__tests__/writeClientModels.test.js

@@ -7,6 +7,7 @@ const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
+const ModelsMode_enum_1 = require("../../types/enums/ModelsMode.enum");
 const WriteClient_1 = require("../../WriteClient");
 const templates_1 = require("../__mocks__/templates");
 (0, node_test_1.describe)('@unit: writeClientModels', () => {
@@ -50,4 +51,53 @@ const templates_1 = require("../__mocks__/templates");
         // Restoring the original function
         fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
     });
+    (0, node_test_1.test)('writes models.ts for classes mode', async () => {
+        const writeFileCalls = [];
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const models = [
+            {
+                export: 'interface',
+                name: 'IUser',
+                path: 'IUser',
+                type: 'IUser',
+                base: 'IUser',
+                template: null,
+                link: null,
+                description: null,
+                isDefinition: true,
+                isReadOnly: false,
+                isRequired: false,
+                isNullable: false,
+                imports: [],
+                enum: [],
+                enums: [],
+                properties: [],
+                alias: '',
+                rawName: 'IUserRaw',
+                dtoName: 'IUserDto',
+                dtoGetters: [{ oldName: 'oldName', newName: 'fullName', target: 'this.fullName', confidence: 1 }],
+            },
+        ];
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientModels({
+            models,
+            templates: templates_1.templates,
+            outputModelsPath: '/',
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useUnionTypes: false,
+            modelsMode: ModelsMode_enum_1.ModelsMode.CLASSES,
+            outputCorePath: '../core',
+        });
+        const wroteModels = writeFileCalls.some(([filePath, content]) => {
+            const file = filePath.toString();
+            if (!file.endsWith('models.ts'))
+                return false;
+            return content.toString().includes('// models:IUserRaw:IUserDto:1');
+        });
+        node_assert_1.default.ok(wroteModels, 'Expected models.ts to be written for classes mode');
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
+    });
 });

package/dist/core/utils/__tests__/writeFileIfChanged.test.d.ts

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

package/dist/core/utils/__tests__/writeFileIfChanged.test.d.ts.map

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

package/dist/core/utils/__tests__/writeFileIfChanged.test.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = require("node:test");
+const writeFileIfChanged_1 = require("../writeFileIfChanged");
+(0, node_test_1.describe)('@unit: writeFileIfChanged', () => {
+    (0, node_test_1.test)('writes new file and skips unchanged content', async () => {
+        const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'openapi-codegen-'));
+        const file = (0, node_path_1.join)(dir, 'index.ts');
+        try {
+            const firstResult = await (0, writeFileIfChanged_1.writeFileIfChanged)(file, 'export const a = 1;\n');
+            const secondResult = await (0, writeFileIfChanged_1.writeFileIfChanged)(file, 'export const a = 1;\n');
+            const thirdResult = await (0, writeFileIfChanged_1.writeFileIfChanged)(file, 'export const a = 2;\n');
+            const content = await (0, promises_1.readFile)(file, 'utf8');
+            strict_1.default.equal(firstResult, 'written');
+            strict_1.default.equal(secondResult, 'unchanged');
+            strict_1.default.equal(thirdResult, 'written');
+            strict_1.default.equal(content, 'export const a = 2;\n');
+        }
+        finally {
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/core/utils/adapters/__tests__/semanticToStructural.test.d.ts

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

package/dist/core/utils/adapters/__tests__/semanticToStructural.test.d.ts.map

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