@odata2ts/odata2ts 0.33.1 → 0.34.0

package/lib/generator/ServiceGenerator.js

@@ -7,24 +7,18 @@ const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
 const ts_morph_1 = require("ts-morph");
 const upper_case_first_1 = require("upper-case-first");
 const processors_1 = require("xml2js/lib/processors");
-const ImportContainer_1 = require("./ImportContainer");
-const ROOT_SERVICE = "ODataService";
-const RESPONSE_TYPES = {
-    collection: "ODataCollectionResponse",
-    model: "ODataModelResponse",
-    value: "ODataValueResponse",
-};
-function generateServices(dataModel, project, version, namingHelper, options) {
+const ImportObjects_1 = require("./import/ImportObjects");
+function generateServices(project, dataModel, version, namingHelper, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const generator = new ServiceGenerator(dataModel, project, version, namingHelper, options);
+        const generator = new ServiceGenerator(project, dataModel, version, namingHelper, options);
         return generator.generate();
     });
 }
 exports.generateServices = generateServices;
 class ServiceGenerator {
-    constructor(dataModel, project, version, namingHelper, options = {}) {
-        this.dataModel = dataModel;
+    constructor(project, dataModel, version, namingHelper, options = {}) {
         this.project = project;
+        this.dataModel = dataModel;
         this.version = version;
         this.namingHelper = namingHelper;
         this.options = options;
@@ -42,19 +36,30 @@ class ServiceGenerator {
     }
     generate() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const sourceFile = yield this.project.createMainServiceFile();
-            const serviceName = this.namingHelper.getMainServiceName();
+            const mainServiceName = this.namingHelper.getMainServiceName();
+            this.project.initServices();
+            yield Promise.all([
+                this.generateMainService(mainServiceName),
+                ...this.generateEntityTypeServices(),
+                ...this.generateComplexTypeServices(),
+            ]);
+            return this.project.finalizeServices();
+        });
+    }
+    generateMainService(mainServiceName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const mainServiceFile = this.project.getMainServiceFile();
+            const importContainer = mainServiceFile.getImports();
             const container = this.dataModel.getEntityContainer();
             const unboundOperations = [...Object.values(container.functions), ...Object.values(container.actions)];
-            const importContainer = new ImportContainer_1.ImportContainer(this.namingHelper.getFileNames());
-            importContainer.addFromClientApi("ODataHttpClient");
-            importContainer.addFromService(ROOT_SERVICE);
+            const [httpClient] = importContainer.addClientApi(ImportObjects_1.ClientApiImports.ODataHttpClient);
+            const [rootService] = importContainer.addServiceObject(this.version, ImportObjects_1.ServiceImports.ODataService);
             const { properties, methods } = (0, deepmerge_1.default)(this.generateMainServiceProperties(container, importContainer), this.generateMainServiceOperations(unboundOperations, importContainer));
-            sourceFile.addClass({
+            mainServiceFile.getFile().addClass({
                 isExported: true,
-                name: serviceName,
-                typeParameters: ["ClientType extends ODataHttpClient"],
-                extends: `${ROOT_SERVICE}<ClientType>`,
+                name: mainServiceName,
+                typeParameters: [`ClientType extends ${httpClient}`],
+                extends: `${rootService}<ClientType>`,
                 ctors: this.isV4BigNumber()
                     ? [
                         {
@@ -69,8 +74,6 @@ class ServiceGenerator {
                 properties,
                 methods,
             });
-            yield this.generateModelServices(sourceFile, importContainer);
-            sourceFile.addImportDeclarations(importContainer.getImportDeclarations(false));
         });
     }
     generateMainServiceProperties(container, importContainer) {
@@ -79,7 +82,7 @@ class ServiceGenerator {
             result.methods.push(this.generateRelatedServiceGetter(name, odataName, entityType, importContainer));
         });
         Object.values(container.singletons).forEach((singleton) => {
-            result.properties.push(this.generateSingletonProp(singleton, importContainer));
+            result.properties.push(this.generateSingletonProp(importContainer, singleton));
             result.methods.push(this.generateSingletonGetter(singleton));
         });
         return result;
@@ -92,18 +95,15 @@ class ServiceGenerator {
                 throw new Error(`Operation "${operation}" not found!`);
             }
             result.properties.push(this.generateQOperationProp(op));
-            result.methods.push(this.generateMethod(name, op, importContainer));
+            result.methods.push(this.generateMethod(name, op, importContainer, ""));
         });
         return result;
     }
-    generateRelatedServiceGetter(propName, odataPropName, entityType, importContainer) {
-        const idName = entityType.idModelName;
-        const idFunctionName = entityType.qIdFunctionName;
-        const serviceName = this.namingHelper.getServiceName(entityType.name);
-        const collectionName = this.namingHelper.getCollectionServiceName(entityType.name);
-        importContainer.addFromClientApi("ODataHttpClient");
-        importContainer.addGeneratedModel(idName);
-        importContainer.addGeneratedQObject(idFunctionName);
+    generateRelatedServiceGetter(propName, odataPropName, entityType, imports) {
+        const idName = imports.addGeneratedModel(entityType.id.fqName, entityType.id.modelName);
+        const idFunctionName = imports.addGeneratedQObject(entityType.id.fqName, entityType.id.qName);
+        const serviceName = imports.addGeneratedService(entityType.fqName, entityType.serviceName);
+        const collectionName = imports.addGeneratedService(entityType.fqName, entityType.serviceCollectionName);
         return {
             scope: ts_morph_1.Scope.Public,
             name: this.namingHelper.getRelatedServiceGetter(propName),
@@ -138,9 +138,9 @@ class ServiceGenerator {
             ],
         };
     }
-    generateSingletonProp(singleton, importContainer) {
+    generateSingletonProp(importContainer, singleton) {
         const { name, entityType } = singleton;
-        const type = this.namingHelper.getServiceName(entityType.name);
+        const type = entityType.serviceName;
         return {
             scope: ts_morph_1.Scope.Private,
             name: this.namingHelper.getPrivatePropName(name),
@@ -151,7 +151,7 @@ class ServiceGenerator {
     generateSingletonGetter(singleton) {
         const { name, odataName, entityType } = singleton;
         const propName = "this." + this.namingHelper.getPrivatePropName(name);
-        const serviceType = this.namingHelper.getServiceName(entityType.name);
+        const serviceType = entityType.serviceName;
         return {
             scope: ts_morph_1.Scope.Public,
             name: this.namingHelper.getRelatedServiceGetter(name),
@@ -165,26 +165,24 @@ class ServiceGenerator {
             ],
         };
     }
-    getVersionSuffix() {
-        return this.version === odata_core_1.ODataVersions.V2 ? "V2" : "V4";
-    }
-    generateEntityTypeService(model, serviceName, serviceFile, importContainer) {
-        const entityServiceType = "EntityTypeService" + this.getVersionSuffix();
-        const editableModelName = model.editableName;
-        const qObjectName = (0, processors_1.firstCharLowerCase)(model.qName);
+    generateEntityTypeService(file, model) {
+        const importContainer = file.getImports();
         const operations = this.dataModel.getEntityTypeOperations(model.fqName);
         const props = [...model.baseProps, ...model.props];
-        importContainer.addFromService(entityServiceType);
-        importContainer.addFromClientApi("ODataHttpClient");
-        importContainer.addGeneratedModel(model.name, editableModelName);
-        importContainer.addGeneratedQObject(model.qName, qObjectName);
-        const { properties, methods } = (0, deepmerge_1.default)(this.generateServiceProperties(serviceName, props, importContainer), this.generateServiceOperations(operations, importContainer));
+        const [entityServiceType] = importContainer.addServiceObject(this.version, ImportObjects_1.ServiceImports.EntityTypeService);
+        const [httpClient] = importContainer.addClientApi(ImportObjects_1.ClientApiImports.ODataHttpClient);
+        // note: predictable first imports => no need to take renaming into account
+        const modelName = importContainer.addGeneratedModel(model.fqName, model.modelName);
+        const editableModelName = importContainer.addGeneratedModel(model.fqName, model.editableName);
+        const qName = importContainer.addGeneratedQObject(model.fqName, model.qName);
+        const qObjectName = importContainer.addGeneratedQObject(model.fqName, (0, processors_1.firstCharLowerCase)(model.qName));
+        const { properties, methods } = (0, deepmerge_1.default)(this.generateServiceProperties(importContainer, model.serviceName, props), this.generateServiceOperations(importContainer, model, operations));
         // generate EntityTypeService
-        serviceFile.addClass({
+        file.getFile().addClass({
             isExported: true,
-            name: serviceName,
-            typeParameters: ["ClientType extends ODataHttpClient"],
-            extends: entityServiceType + `<ClientType, ${model.name}, ${editableModelName}, ${model.qName}>`,
+            name: model.serviceName,
+            typeParameters: [`ClientType extends ${httpClient}`],
+            extends: entityServiceType + `<ClientType, ${modelName}, ${editableModelName}, ${qName}>`,
             ctors: [
                 {
                     parameters: [
@@ -199,16 +197,13 @@ class ServiceGenerator {
             methods,
         });
     }
-    getPrimitiveServiceType() {
-        return "PrimitiveTypeService" + this.getVersionSuffix();
-    }
-    generateServiceProperties(serviceName, props, importContainer) {
-        const collectionServiceType = "CollectionService" + this.getVersionSuffix();
+    generateServiceProperties(importContainer, serviceName, props) {
         const result = { properties: [], methods: [] };
         props.forEach((prop) => {
+            // complex types, collection of complex types or entityTypes
             if ((prop.dataType === "ModelType" /* DataTypes.ModelType */ && !prop.isCollection) || prop.dataType === "ComplexType" /* DataTypes.ComplexType */) {
-                result.properties.push(this.generateModelProp(prop, collectionServiceType, serviceName, importContainer));
-                result.methods.push(this.generateModelPropGetter(prop, collectionServiceType));
+                result.properties.push(this.generateModelProp(importContainer, prop));
+                result.methods.push(this.generateModelPropGetter(importContainer, prop));
             }
             else if (prop.isCollection) {
                 // collection of entity types
@@ -219,40 +214,41 @@ class ServiceGenerator {
                     }
                     result.methods.push(this.generateRelatedServiceGetter(prop.name, prop.odataName, entityType, importContainer));
                 }
-                // collection of primitive or complex types
+                // collection of primitive or enum types
                 else {
-                    result.properties.push(this.generatePrimitiveCollectionProp(prop, collectionServiceType, importContainer));
-                    result.methods.push(this.generatePrimitiveCollectionGetter(prop, collectionServiceType));
+                    result.properties.push(this.generatePrimitiveCollectionProp(importContainer, prop));
+                    result.methods.push(this.generatePrimitiveCollectionGetter(importContainer, prop));
                 }
             }
+            // generation of services for each primitive property: turned off by default
             else if (this.options.enablePrimitivePropertyServices && prop.dataType === "PrimitiveType" /* DataTypes.PrimitiveType */) {
-                result.properties.push(this.generatePrimitiveTypeProp(prop, importContainer));
-                result.methods.push(this.generatePrimitiveTypeGetter(prop));
+                result.properties.push(this.generatePrimitiveTypeProp(importContainer, prop));
+                result.methods.push(this.generatePrimitiveTypeGetter(importContainer, prop));
             }
         });
         return result;
     }
-    generateServiceOperations(operations, importContainer) {
+    generateServiceOperations(importContainer, model, operations) {
         const result = { properties: [], methods: [] };
         operations.forEach((operation) => {
             result.properties.push(this.generateQOperationProp(operation));
-            result.methods.push(this.generateMethod(operation.name, operation, importContainer));
+            result.methods.push(this.generateMethod(operation.name, operation, importContainer, model.fqName));
         });
         return result;
     }
-    generateModelProp(prop, collectionServiceType, serviceName, importContainer) {
-        const complexType = this.dataModel.getComplexType(prop.fqType);
-        const key = this.namingHelper.getServiceName(prop.type);
-        let propModelType = prop.isCollection ? this.namingHelper.getCollectionServiceName(prop.type) : key;
-        if (prop.isCollection && complexType) {
-            const editableName = complexType.editableName;
-            importContainer.addFromService(collectionServiceType);
-            importContainer.addGeneratedModel(complexType.name, editableName);
-            importContainer.addGeneratedQObject(complexType.qName, (0, processors_1.firstCharLowerCase)(complexType.qName));
-            propModelType = `${collectionServiceType}<ClientType, ${complexType.name}, ${complexType.qName}, ${editableName}>`;
+    generateModelProp(imports, prop) {
+        const propModel = this.dataModel.getModel(prop.fqType);
+        let propModelType;
+        if (prop.isCollection) {
+            const modelName = imports.addGeneratedModel(propModel.fqName, propModel.modelName);
+            const editableModelName = imports.addGeneratedModel(propModel.fqName, propModel.editableName);
+            const qModelName = imports.addGeneratedQObject(propModel.fqName, propModel.qName);
+            const [collectionServiceType] = imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.CollectionService);
+            propModelType = `${collectionServiceType}<ClientType, ${modelName}, ${qModelName}, ${editableModelName}>`;
         }
         else {
-            propModelType = `${propModelType}<ClientType>`;
+            const serviceName = imports.addGeneratedService(propModel.fqName, propModel.serviceName);
+            propModelType = `${serviceName}<ClientType>`;
         }
         return {
             scope: ts_morph_1.Scope.Private,
@@ -261,23 +257,25 @@ class ServiceGenerator {
             hasQuestionToken: true,
         };
     }
-    generatePrimitiveCollectionProp(prop, collectionServiceType, importContainer) {
-        const isEnum = prop.dataType === "EnumType" /* DataTypes.EnumType */;
-        const type = isEnum ? `EnumCollection<${prop.type}>` : `${(0, upper_case_first_1.upperCaseFirst)(prop.type)}Collection`;
-        const qType = isEnum ? "QEnumCollection" : prop.qObject;
-        const collectionType = `${collectionServiceType}<ClientType, ${type}, ${qType}>`;
+    generatePrimitiveCollectionProp(imports, prop) {
         if (!prop.qObject) {
             throw new Error("Illegal State: [qObject] must be provided for Collection types!");
         }
-        importContainer.addFromService(collectionServiceType);
-        importContainer.addFromQObject(prop.qObject, (0, processors_1.firstCharLowerCase)(prop.qObject));
-        if (isEnum) {
-            importContainer.addGeneratedModel(prop.type);
-            importContainer.addFromQObject("EnumCollection");
+        const [collectionServiceType] = imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.CollectionService);
+        const isEnum = prop.dataType === "EnumType" /* DataTypes.EnumType */;
+        let qType;
+        let type;
+        if (!isEnum) {
+            // TODO move string concat (StringCollection, GuidCollection...) to better place
+            [type, qType] = imports.addFromQObject(`${(0, upper_case_first_1.upperCaseFirst)(prop.type)}Collection`, prop.qObject);
         }
         else {
-            importContainer.addFromQObject(type);
+            const propEnum = this.dataModel.getModel(prop.fqType);
+            const propTypeModel = imports.addGeneratedModel(propEnum.fqName, propEnum.modelName);
+            [type, qType] = imports.addQObject(ImportObjects_1.QueryObjectImports.EnumCollection, ImportObjects_1.QueryObjectImports.QEnumCollection);
+            type = `${type}<${propTypeModel}>`;
         }
+        const collectionType = `${collectionServiceType}<ClientType, ${type}, ${qType}>`;
         return {
             scope: ts_morph_1.Scope.Private,
             name: this.namingHelper.getPrivatePropName(prop.name),
@@ -285,29 +283,26 @@ class ServiceGenerator {
             hasQuestionToken: true,
         };
     }
-    generatePrimitiveTypeProp(prop, importContainer) {
-        const serviceType = this.getPrimitiveServiceType();
-        importContainer.addFromService(serviceType);
-        if (prop.typeModule) {
-            importContainer.addCustomType(prop.typeModule, prop.type);
-        }
+    generatePrimitiveTypeProp(imports, prop) {
+        const [serviceType] = imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.PrimitiveTypeService);
+        const type = prop.typeModule ? imports.addCustomType(prop.typeModule, prop.type) : prop.type;
         return {
             scope: ts_morph_1.Scope.Private,
             name: this.namingHelper.getPrivatePropName(prop.name),
-            type: `${serviceType}<ClientType, ${prop.type}>`,
+            type: `${serviceType}<ClientType, ${type}>`,
             hasQuestionToken: true,
         };
     }
-    generateModelPropGetter(prop, collectionServiceType) {
-        const complexType = this.dataModel.getComplexType(prop.fqType);
-        const isComplexCollection = prop.isCollection && complexType;
+    generateModelPropGetter(imports, prop) {
+        const model = this.dataModel.getModel(prop.fqType);
+        const isComplexCollection = prop.isCollection && model.dataType === "ComplexType" /* DataTypes.ComplexType */;
         const type = isComplexCollection
-            ? collectionServiceType
+            ? imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.CollectionService)[0]
             : prop.isCollection
-                ? this.namingHelper.getCollectionServiceName(prop.type)
-                : this.namingHelper.getServiceName(prop.type);
+                ? model.serviceCollectionName
+                : model.serviceName;
         const typeWithGenerics = isComplexCollection
-            ? `${collectionServiceType}<ClientType, ${complexType.name}, ${complexType.qName}, ${complexType.editableName}>`
+            ? `${type}<ClientType, ${imports.addGeneratedModel(model.fqName, model.modelName)}, ${imports.addGeneratedQObject(model.fqName, model.qName)}, ${imports.addGeneratedModel(model.fqName, model.editableName)}>`
             : `${type}<ClientType>`;
         const privateSrvProp = "this." + this.namingHelper.getPrivatePropName(prop.name);
         return {
@@ -318,13 +313,16 @@ class ServiceGenerator {
                 `if(!${privateSrvProp}) {`,
                 `  const { client, path } = this.__base;`,
                 // prettier-ignore
-                `  ${privateSrvProp} = new ${type}(client, path, "${prop.odataName}"${isComplexCollection ? `, ${(0, processors_1.firstCharLowerCase)(complexType.qName)}` : ""})`,
+                `  ${privateSrvProp} = new ${type}(client, path, "${prop.odataName}"${isComplexCollection ? `, ${imports.addGeneratedQObject(model.fqName, (0, processors_1.firstCharLowerCase)(model.qName))}` : ""})`,
                 "}",
                 `return ${privateSrvProp}`,
             ],
         };
     }
-    generatePrimitiveCollectionGetter(prop, collectionServiceType) {
+    generatePrimitiveCollectionGetter(imports, prop) {
+        const [collectionServiceType] = imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.CollectionService);
+        const instanceName = (0, processors_1.firstCharLowerCase)(prop.qObject);
+        const [qInstanceName] = imports.addFromQObject(instanceName);
         const propName = "this." + this.namingHelper.getPrivatePropName(prop.name);
         return {
             scope: ts_morph_1.Scope.Public,
@@ -333,14 +331,14 @@ class ServiceGenerator {
                 `if(!${propName}) {`,
                 `  const { client, path } = this.__base;`,
                 // prettier-ignore
-                `  ${propName} = new ${collectionServiceType}(client, path, "${prop.odataName}", ${(0, processors_1.firstCharLowerCase)(prop.qObject)}${this.isV4BigNumber() ? ", true" : ""})`,
+                `  ${propName} = new ${collectionServiceType}(client, path, "${prop.odataName}", ${qInstanceName}${this.isV4BigNumber() ? ", true" : ""})`,
                 "}",
                 `return ${propName}`,
             ],
         };
     }
-    generatePrimitiveTypeGetter(prop) {
-        const serviceType = this.getPrimitiveServiceType();
+    generatePrimitiveTypeGetter(imports, prop) {
+        const [serviceType] = imports.addServiceObject(this.version, ImportObjects_1.ServiceImports.PrimitiveTypeService);
         const propName = "this." + this.namingHelper.getPrivatePropName(prop.name);
         // for V2: mapped name must be specified
         const useMappedName = this.version === odata_core_1.ODataVersions.V2 && prop.name !== prop.odataName;
@@ -359,21 +357,21 @@ class ServiceGenerator {
             ],
         };
     }
-    generateEntityCollectionService(model, serviceFile, importContainer) {
-        const entitySetServiceType = "EntitySetService" + this.getVersionSuffix();
+    generateEntityCollectionService(file, model) {
+        const importContainer = file.getImports();
         const editableModelName = model.editableName;
         const qObjectName = (0, processors_1.firstCharLowerCase)(model.qName);
-        importContainer.addFromService(entitySetServiceType);
-        importContainer.addGeneratedModel(model.idModelName);
-        importContainer.addGeneratedQObject(model.qIdFunctionName);
+        const [entitySetServiceType] = importContainer.addServiceObject(this.version, ImportObjects_1.ServiceImports.EntitySetService);
+        const paramsModelName = importContainer.addGeneratedModel(model.id.fqName, model.id.modelName);
+        const qIdFunctionName = importContainer.addGeneratedQObject(model.id.fqName, model.id.qName);
         const collectionOperations = this.dataModel.getEntitySetOperations(model.fqName);
-        const { properties, methods } = this.generateServiceOperations(collectionOperations, importContainer);
-        serviceFile.addClass({
+        const { properties, methods } = this.generateServiceOperations(importContainer, model, collectionOperations);
+        file.getFile().addClass({
             isExported: true,
-            name: this.namingHelper.getCollectionServiceName(model.name),
+            name: model.serviceCollectionName,
             typeParameters: ["ClientType extends ODataHttpClient"],
             extends: entitySetServiceType +
-                `<ClientType, ${model.name}, ${editableModelName}, ${model.qName}, ${model.idModelName}>`,
+                `<ClientType, ${model.modelName}, ${editableModelName}, ${model.qName}, ${paramsModelName}>`,
             ctors: [
                 {
                     parameters: [
@@ -382,7 +380,7 @@ class ServiceGenerator {
                         { name: "name", type: "string" },
                     ],
                     statements: [
-                        `super(client, basePath, name, ${qObjectName}, new ${model.qIdFunctionName}(name)${this.isV4BigNumber() ? ", true" : ""});`,
+                        `super(client, basePath, name, ${qObjectName}, new ${qIdFunctionName}(name)${this.isV4BigNumber() ? ", true" : ""});`,
                     ],
                 },
             ],
@@ -390,67 +388,60 @@ class ServiceGenerator {
             methods,
         });
     }
-    generateModelServices(serviceFile, importContainer) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // build service file for each entity, consisting of EntityTypeService & EntityCollectionService
-            const entities = this.dataModel.getEntityTypes().filter((et) => !et.abstract);
-            for (const model of entities) {
-                const serviceName = this.namingHelper.getServiceName(model.name);
-                // entity type service
-                this.generateEntityTypeService(model, serviceName, serviceFile, importContainer);
-                // entity collection service if this entity specified keys at all
-                if (model.keyNames.length) {
-                    this.generateEntityCollectionService(model, serviceFile, importContainer);
-                }
-            }
-            // build service file for complex types
-            const complexTypes = this.dataModel.getComplexTypes().filter((ct) => !ct.abstract);
-            for (const model of complexTypes) {
-                const serviceName = this.namingHelper.getServiceName(model.name);
-                // entity type service
-                this.generateEntityTypeService(model, serviceName, serviceFile, importContainer);
+    generateEntityTypeServices() {
+        // build service file for each entity, consisting of EntityTypeService & EntityCollectionService
+        return this.dataModel.getEntityTypes().map((model) => {
+            const file = this.project.createOrGetServiceFile(model.folderPath, model.serviceName, [
+                model.serviceName,
+                model.serviceCollectionName,
+            ]);
+            // entity type service
+            this.generateEntityTypeService(file, model);
+            // entity collection service if this entity specified keys at all
+            if (model.keyNames.length) {
+                this.generateEntityCollectionService(file, model);
             }
+            return this.project.finalizeFile(file);
         });
     }
-    generateMethod(name, operation, importContainer) {
-        var _a, _b;
+    generateComplexTypeServices() {
+        // build service file for complex types
+        return this.dataModel.getComplexTypes().map((model) => {
+            const file = this.project.createOrGetServiceFile(model.folderPath, model.serviceName, [model.serviceName]);
+            // entity type service
+            this.generateEntityTypeService(file, model);
+            return this.project.finalizeFile(file);
+        });
+    }
+    generateMethod(name, operation, importContainer, baseFqName) {
         const isFunc = operation.type === "Function" /* OperationTypes.Function */;
-        const odataType = ((_a = operation.returnType) === null || _a === void 0 ? void 0 : _a.isCollection)
-            ? RESPONSE_TYPES.collection + this.getVersionSuffix()
-            : ((_b = operation.returnType) === null || _b === void 0 ? void 0 : _b.dataType) === "PrimitiveType" /* DataTypes.PrimitiveType */
-                ? RESPONSE_TYPES.value + this.getVersionSuffix()
-                : RESPONSE_TYPES.model + this.getVersionSuffix();
         const returnType = operation.returnType;
+        const hasParams = operation.parameters.length > 0;
+        // importing dependencies
+        const [httpClientConfigModel, odataResponse] = importContainer.addClientApi(ImportObjects_1.ClientApiImports.ODataHttpClientConfig, ImportObjects_1.ClientApiImports.HttpResponseModel);
+        const responseStructure = this.importReturnType(importContainer, returnType);
+        const qOperationName = importContainer.addGeneratedQObject(baseFqName, operation.qName);
+        const rtType = (returnType === null || returnType === void 0 ? void 0 : returnType.type) && returnType.dataType !== "PrimitiveType" /* DataTypes.PrimitiveType */
+            ? importContainer.addGeneratedModel(returnType.fqType, returnType.type)
+            : returnType === null || returnType === void 0 ? void 0 : returnType.type;
+        const paramsModelName = hasParams
+            ? importContainer.addGeneratedModel(baseFqName, operation.paramsModelName)
+            : undefined;
         const requestConfigParam = {
             name: "requestConfig",
             hasQuestionToken: true,
-            type: "ODataHttpClientConfig<ClientType>",
+            type: `${httpClientConfigModel}<ClientType>`,
         };
-        const hasParams = operation.parameters.length > 0;
-        // importing dependencies
-        importContainer.addFromClientApi("ODataHttpClientConfig", "ODataResponse");
-        importContainer.addFromCore(odataType);
-        if (returnType === null || returnType === void 0 ? void 0 : returnType.type) {
-            if (["EnumType" /* DataTypes.EnumType */, "ModelType" /* DataTypes.ModelType */, "ComplexType" /* DataTypes.ComplexType */].includes(returnType.dataType)) {
-                importContainer.addGeneratedModel(returnType.type);
-            }
-        }
-        importContainer.addGeneratedQObject(operation.qName);
-        if (hasParams) {
-            importContainer.addGeneratedModel(operation.paramsModelName);
-        }
         const qOpProp = "this." + this.namingHelper.getPrivatePropName(operation.qName);
         return {
             scope: ts_morph_1.Scope.Public,
             isAsync: true,
             name,
-            parameters: hasParams
-                ? [{ name: "params", type: operation.paramsModelName }, requestConfigParam]
-                : [requestConfigParam],
-            returnType: `ODataResponse<${odataType}<${(returnType === null || returnType === void 0 ? void 0 : returnType.type) || "void"}>>`,
+            parameters: hasParams ? [{ name: "params", type: paramsModelName }, requestConfigParam] : [requestConfigParam],
+            returnType: `Promise<${odataResponse}<${responseStructure}<${rtType || "void"}>>>`,
             statements: [
                 `if(!${qOpProp}) {`,
-                `  ${qOpProp} = new ${operation.qName}()`,
+                `  ${qOpProp} = new ${qOperationName}()`,
                 "}",
                 `const { addFullPath, client, getDefaultHeaders } = this.__base;`,
                 `const url = addFullPath(${qOpProp}.buildUrl(${isFunc && hasParams ? "params" : ""}));`,
@@ -466,5 +457,13 @@ class ServiceGenerator {
             ],
         };
     }
+    importReturnType(imports, returnType) {
+        const typeToImport = (returnType === null || returnType === void 0 ? void 0 : returnType.isCollection)
+            ? ImportObjects_1.CoreImports.ODataCollectionResponse
+            : (returnType === null || returnType === void 0 ? void 0 : returnType.dataType) === "PrimitiveType" /* DataTypes.PrimitiveType */
+                ? ImportObjects_1.CoreImports.ODataValueResponse
+                : ImportObjects_1.CoreImports.ODataModelResponse;
+        return imports.addCoreLib(this.version, typeToImport)[0];
+    }
 }
 //# sourceMappingURL=ServiceGenerator.js.map