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

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

@@ -0,0 +1,26 @@
+"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 postProcessServiceImports_1 = require("../postProcessServiceImports");
+(0, node_test_1.describe)('@unit: postProcessServiceImports', () => {
+    (0, node_test_1.test)('keeps import when model name equals service name', () => {
+        const service = {
+            name: 'UserService',
+            originName: 'UserService',
+            operations: [],
+            imports: [
+                { name: 'UserService', alias: '', path: '../models/UserService' },
+                { name: 'UserService', alias: 'UserService$1', path: '../models/path/UserService' },
+            ],
+        };
+        const result = (0, postProcessServiceImports_1.postProcessServiceImports)(service);
+        node_assert_1.default.deepStrictEqual(result.map(item => `${item.name}:${item.alias}:${item.path}`), [
+            'UserService:UserService$1:../models/path/UserService',
+            'UserService::../models/UserService',
+        ]);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,116 @@
+"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 createPrimitiveModel = (name, type) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'generic',
+    type,
+    base: type,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+const createInterfaceModel = (name, properties) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'interface',
+    type: name,
+    base: name,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: true,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties,
+});
+(0, node_test_1.describe)('@unit: prepareDtoModels', () => {
+    (0, node_test_1.test)('builds dto init/toJSON for references and arrays of references', () => {
+        const profile = createInterfaceModel('IProfile', [createPrimitiveModel('bio', 'string')]);
+        const profileRef = {
+            ...createPrimitiveModel('profile', 'IProfile'),
+            export: 'reference',
+            type: 'IProfile',
+            isRequired: true,
+        };
+        const profilesArray = {
+            ...createPrimitiveModel('profiles', 'IProfile'),
+            export: 'array',
+            link: { ...createPrimitiveModel('IProfile', 'IProfile'), export: 'reference', type: 'IProfile' },
+            isRequired: false,
+        };
+        const user = createInterfaceModel('IUser', [profileRef, profilesArray]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user, profile],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedUser = prepared.models.find(model => model.name === 'IUser');
+        node_assert_1.default.ok(preparedUser);
+        const preparedProfile = prepared.models.find(model => model.name === 'IProfile');
+        node_assert_1.default.ok(preparedProfile);
+        node_assert_1.default.strictEqual(preparedProfile?.rawName, 'IProfileRaw');
+        node_assert_1.default.strictEqual(preparedProfile?.dtoName, 'IProfileDto');
+        const profileProperty = preparedUser?.properties.find(prop => prop.name === 'profile');
+        node_assert_1.default.ok(profileProperty);
+        node_assert_1.default.strictEqual(profileProperty?.dtoType, 'IProfileDto');
+        node_assert_1.default.strictEqual(profileProperty?.rawType, 'IProfileRaw');
+        node_assert_1.default.strictEqual(profileProperty?.dtoInit, 'new IProfileDto(data.profile)');
+        node_assert_1.default.strictEqual(profileProperty?.dtoToJSON, 'this.profile.toJSON()');
+        const profilesProperty = preparedUser?.properties.find(prop => prop.name === 'profiles');
+        node_assert_1.default.ok(profilesProperty);
+        node_assert_1.default.strictEqual(profilesProperty?.dtoType, 'IProfileDto[]');
+        node_assert_1.default.strictEqual(profilesProperty?.rawType, 'IProfileRaw[]');
+        node_assert_1.default.strictEqual(profilesProperty?.dtoInit, 'data.profiles ? fromArray(IProfileDto, data.profiles) : undefined');
+        node_assert_1.default.strictEqual(profilesProperty?.dtoToJSON, 'this.profiles ? this.profiles.map(item => item.toJSON()) : undefined');
+    });
+    (0, node_test_1.test)('attaches dto getters from confirmed miracles', () => {
+        const user = createInterfaceModel('IUser', [createPrimitiveModel('fullName', 'string')]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user],
+            services: [],
+            miracles: [
+                {
+                    type: 'RENAME',
+                    oldPath: '$.components.schemas.User.properties.oldName',
+                    newPath: '$.components.schemas.User.properties.fullName',
+                    confidence: 1,
+                    status: 'confirmed',
+                    modelName: 'IUser',
+                    oldProperty: 'oldName',
+                    newProperty: 'fullName',
+                },
+            ],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedUser = prepared.models.find(model => model.name === 'IUser');
+        node_assert_1.default.ok(preparedUser?.dtoGetters);
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.length, 1);
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].oldName, 'oldName');
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].newName, 'fullName');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,22 @@
+"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 parseRef_1 = require("../parseRef");
+const resolveRefPath_1 = require("../resolveRefPath");
+(0, node_test_1.describe)('@unit: resolveRefPath', () => {
+    (0, node_test_1.test)('should keep repeated folder names in absolute path', () => {
+        const parsedRef = {
+            type: parseRef_1.RefType.EXTERNAL_FILE,
+            originalRef: 'schemas/base/ModelWithString.yml',
+            filePath: 'schemas/base/ModelWithString.yml',
+            fragment: undefined,
+        };
+        const parentFilePath = '/home/runner/work/openapi-codegen/openapi-codegen/test/spec/v3.withDifferentRefs.yml';
+        const result = (0, resolveRefPath_1.resolveRefPath)(parsedRef, parentFilePath);
+        node_assert_1.default.strictEqual(result, '/home/runner/work/openapi-codegen/openapi-codegen/test/spec/schemas/base/ModelWithString.yml');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,122 @@
+"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 serviceHelpers_1 = require("../serviceHelpers");
+function createModel(overrides = {}) {
+    return {
+        name: 'Model',
+        alias: '',
+        path: 'Model',
+        export: 'reference',
+        type: 'Model',
+        base: 'Model',
+        template: null,
+        link: null,
+        description: null,
+        isDefinition: false,
+        isReadOnly: false,
+        isRequired: false,
+        isNullable: false,
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+        ...overrides,
+    };
+}
+function createOperationParameter(overrides = {}) {
+    return {
+        ...createModel(overrides),
+        in: 'query',
+        prop: 'value',
+        mediaType: null,
+        ...overrides,
+    };
+}
+function createOperationResponse(overrides = {}) {
+    return {
+        ...createModel(overrides),
+        in: 'response',
+        code: 200,
+        ...overrides,
+    };
+}
+(0, node_test_1.describe)('@unit: serviceHelpers', () => {
+    (0, node_test_1.test)('finalizeServiceImports should assign duplicate aliases and propagate to params/results', () => {
+        const importFooA = { name: 'Foo', alias: '', path: 'models/a/Foo' };
+        const importFooB = { name: 'Foo', alias: '', path: 'models/b/Foo' };
+        const paramFooA = createOperationParameter({
+            name: 'paramFooA',
+            path: './models/a/Foo',
+            type: 'Foo',
+            base: 'Foo',
+            imports: [{ ...importFooA }],
+        });
+        const paramFooBArray = createOperationParameter({
+            name: 'paramFooBArray',
+            export: 'array',
+            type: 'Foo',
+            base: 'Foo',
+            imports: [{ ...importFooB }],
+            link: createModel({
+                path: './models/b/Foo',
+                type: 'Foo',
+                base: 'Foo',
+                imports: [{ ...importFooB }],
+            }),
+        });
+        const resultFooB = createOperationResponse({
+            name: 'resultFooB',
+            path: './models/b/Foo',
+            type: 'Foo',
+            base: 'Foo',
+            imports: [{ ...importFooB }],
+        });
+        const operation = {
+            service: 'PetService',
+            name: 'getPet',
+            summary: null,
+            description: null,
+            deprecated: false,
+            method: 'GET',
+            path: '/pets/{id}',
+            imports: [],
+            parameters: [paramFooA, paramFooBArray],
+            parametersPath: [],
+            parametersQuery: [],
+            parametersForm: [],
+            parametersCookie: [],
+            parametersHeader: [],
+            parametersBody: null,
+            errors: [],
+            results: [resultFooB],
+            responseHeader: null,
+            responseType: null,
+        };
+        const service = {
+            name: 'PetService',
+            originName: 'PetService',
+            operations: [operation],
+            imports: [importFooA, importFooB],
+        };
+        (0, serviceHelpers_1.finalizeServiceImports)(service);
+        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);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,20 @@
+"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 writeClientExecutor_1 = require("../writeClientExecutor");
+(0, node_test_1.describe)('@unit: writeClientExecutor', () => {
+    (0, node_test_1.test)('deduplicateServicesByName should keep first service by name', () => {
+        const services = [
+            { name: 'V2Service', originName: 'V2Service', operations: [], imports: [] },
+            { name: 'V2Service', originName: 'V2ServiceCopy', operations: [], imports: [] },
+            { name: 'SimpleService', originName: 'SimpleService', operations: [], imports: [] },
+        ];
+        const result = (0, writeClientExecutor_1.deduplicateServicesByName)(services);
+        node_assert_1.default.deepStrictEqual(result.map(item => item.name), ['V2Service', 'SimpleService']);
+        node_assert_1.default.equal(result[0].originName, 'V2Service');
+    });
+});

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__/writeClientSchemas.test.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
+const EmptySchemaStrategy_enum_1 = require("../../types/enums/EmptySchemaStrategy.enum");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const ValidationLibrary_enum_1 = require("../../types/enums/ValidationLibrary.enum");
 const WriteClient_1 = require("../../WriteClient");
@@ -47,6 +48,7 @@ const templates_1 = require("../__mocks__/templates");
             httpClient: HttpClient_enum_1.HttpClient.FETCH,
             useUnionTypes: false,
             validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+            emptySchemaStrategy: EmptySchemaStrategy_enum_1.EmptySchemaStrategy.KEEP,
         });
         node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModelSchema.ts') && content.toString().includes('schema')), 'Expected writeFile to be called with schema content for MyModelSchema.ts');
         // Restoring the original function

package/dist/core/utils/applyDiffReportToClient.d.ts

@@ -0,0 +1,14 @@
+import type { PrefixArtifacts } from '../types/base/PrefixArtifacts.model';
+import type { Client } from '../types/shared/Client.model';
+import { OpenApiVersion } from './getOpenApiVersion';
+import type { DiffReport } from './loadDiffReport';
+type ApplyDiffParams = {
+    client: Client;
+    openApi: Record<string, unknown>;
+    openApiVersion: OpenApiVersion;
+    diffReport: DiffReport | null;
+    prefix: PrefixArtifacts;
+};
+export declare const applyDiffReportToClient: ({ client, openApi, openApiVersion, diffReport, prefix }: ApplyDiffParams) => Client;
+export {};
+//# sourceMappingURL=applyDiffReportToClient.d.ts.map

package/dist/core/utils/applyDiffReportToClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyDiffReportToClient.d.ts","sourceRoot":"","sources":["../../../src/core/utils/applyDiffReportToClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAW3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,kBAAkB,CAAC;AAGpE,KAAK,eAAe,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,eAAe,CAAC;CAC3B,CAAC;AA2WF,eAAO,MAAM,uBAAuB,GAAI,yDAAyD,eAAe,KAAG,MAwClH,CAAC"}