@odata2ts/odata2ts 0.20.3 → 0.22.0

package/lib/generator/ServiceGenerator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateServices = void 0;
 const tslib_1 = require("tslib");
 const odata_core_1 = require("@odata2ts/odata-core");
+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");
@@ -26,7 +27,7 @@ class ServiceGenerator {
         this.project = project;
         this.version = version;
         this.namingHelper = namingHelper;
-        this.generateQOperationProps = (operation) => {
+        this.generateQOperationProp = (operation) => {
             return {
                 scope: ts_morph_1.Scope.Private,
                 name: this.namingHelper.getPrivatePropName(operation.qName),
@@ -45,97 +46,131 @@ class ServiceGenerator {
             const importContainer = new ImportContainer_1.ImportContainer(this.namingHelper.getFileNames());
             importContainer.addFromClientApi("ODataClient");
             importContainer.addFromService(ROOT_SERVICE);
+            const { properties, methods } = (0, deepmerge_1.default)(this.generateMainServiceProperties(container, importContainer), this.generateMainServiceOperations(unboundOperations, importContainer));
             sourceFile.addClass({
                 isExported: true,
                 name: serviceName,
                 typeParameters: ["ClientType extends ODataClient"],
                 extends: `${ROOT_SERVICE}<ClientType>`,
-                properties: [
-                    {
-                        scope: ts_morph_1.Scope.Private,
-                        name: this.namingHelper.getPrivatePropName("name"),
-                        type: "string",
-                        initializer: `"${this.namingHelper.getODataServiceName()}"`,
-                    },
-                    ...this.generateEntityServiceResolverProp(container.entitySets, importContainer),
-                    ...this.generateServiceGettersByAssignment(container.entitySets),
-                    ...this.generateServiceTypeProps(container.singletons, this.namingHelper.getServiceName, importContainer),
-                    ...Object.values(unboundOperations).map(({ operation }) => this.generateQOperationProps(operation)),
-                ],
-                methods: [
-                    ...this.generateServiceTypeGetters(container.singletons, this.namingHelper.getServiceName),
-                    ...this.generateUnboundOperations(unboundOperations, importContainer),
-                ],
+                properties /*: [
+                  {
+                    scope: Scope.Private,
+                    name: this.namingHelper.getPrivatePropName("name"),
+                    type: "string",
+                    initializer: `"${this.namingHelper.getODataServiceName()}"`,
+                  },
+                ]*/,
+                methods,
             });
             sourceFile.addImportDeclarations(importContainer.getImportDeclarations(false));
         });
     }
-    generateEntityServiceResolverProp(services, importContainer) {
-        return Object.values(services).map(({ name, entityType }) => {
-            const resolverName = this.namingHelper.getServiceResolverName(entityType.name);
-            importContainer.addGeneratedService(this.namingHelper.getServiceName(entityType.name), resolverName);
-            return {
-                name: this.namingHelper.getPublicPropNameForService(name),
-                scope: ts_morph_1.Scope.Public,
-                initializer: `${resolverName}(this.client, this.getPath(), "${name}")`,
-            };
+    generateMainServiceProperties(container, importContainer) {
+        const result = { properties: [], methods: [] };
+        Object.values(container.entitySets).forEach(({ name, entityType }) => {
+            result.methods.push(this.generateRelatedServiceGetter(name, entityType, importContainer));
         });
-    }
-    generateServiceGettersByAssignment(services) {
-        return Object.values(services).map(({ name, odataName, entityType }) => {
-            const propName = this.namingHelper.getPublicPropNameForService(name);
-            return {
-                scope: ts_morph_1.Scope.Public,
-                name: this.namingHelper.getRelatedServiceGetter(name),
-                initializer: `this.${propName}.get.bind(this.${propName})`,
-            };
+        Object.values(container.singletons).forEach((singleton) => {
+            result.properties.push(this.generateSingletonProp(singleton, importContainer));
+            result.methods.push(this.generateSingletonGetter(singleton));
         });
+        return result;
     }
-    generateServiceTypeProps(services, typeRetriever, importContainer) {
-        return Object.values(services).map(({ name, entityType }) => {
-            const type = typeRetriever(entityType.name);
-            importContainer.addGeneratedService(this.namingHelper.getServiceName(entityType.name), type);
-            return {
-                scope: ts_morph_1.Scope.Private,
-                name: this.namingHelper.getPrivatePropName(name),
-                type: `${type}<ClientType>`,
-                hasQuestionToken: true,
-            };
+    generateMainServiceOperations(ops, importContainer) {
+        const result = { properties: [], methods: [] };
+        ops.forEach(({ operation, name }) => {
+            result.properties.push(this.generateQOperationProp(operation));
+            result.methods.push(this.generateMethod(name, operation, importContainer));
         });
+        return result;
     }
-    generateServiceTypeGetters(services, typeRetriever) {
-        return Object.values(services).map(({ name, odataName, entityType }) => {
-            const propName = "this." + this.namingHelper.getPrivatePropName(name);
-            const serviceType = typeRetriever(entityType.name);
-            return {
-                scope: ts_morph_1.Scope.Public,
-                name: this.namingHelper.getRelatedServiceGetter(name),
-                statements: [
-                    `if(!${propName}) {`,
-                    // prettier-ignore
-                    `  ${propName} = new ${serviceType}(this.client, this.getPath(), "${odataName}")`,
-                    "}",
-                    `return ${propName}`,
-                ],
-            };
-        });
+    generateRelatedServiceGetter(propName, entityType, importContainer, currentServiceName) {
+        const idName = entityType.idModelName;
+        const idFunctionName = entityType.qIdFunctionName;
+        const serviceName = this.namingHelper.getServiceName(entityType.name);
+        const collectionName = this.namingHelper.getCollectionServiceName(entityType.name);
+        importContainer.addFromClientApi("ODataClient");
+        importContainer.addGeneratedModel(idName);
+        importContainer.addGeneratedQObject(idFunctionName);
+        // make sure to not falsely import self-referential stuff
+        if (!currentServiceName || currentServiceName !== serviceName) {
+            importContainer.addGeneratedService(serviceName, collectionName, serviceName);
+        }
+        return {
+            scope: ts_morph_1.Scope.Public,
+            name: this.namingHelper.getRelatedServiceGetter(propName),
+            parameters: [
+                {
+                    name: "id",
+                    type: `${idName} | undefined`,
+                    hasQuestionToken: true,
+                },
+            ],
+            overloads: [
+                {
+                    parameters: [],
+                    returnType: `${collectionName}<ClientType>`,
+                },
+                {
+                    parameters: [
+                        {
+                            name: "id",
+                            type: idName,
+                        },
+                    ],
+                    returnType: `${serviceName}<ClientType>`,
+                },
+            ],
+            statements: [
+                `const fieldName = "${propName}";`,
+                'return typeof id === "undefined" || id === null',
+                `? new ${collectionName}(this.client, this.getPath(), fieldName)`,
+                `: new ${serviceName}(this.client, this.getPath(), new ${idFunctionName}(fieldName).buildUrl(id));`,
+            ],
+        };
+    }
+    generateSingletonProp(singleton, importContainer) {
+        const { name, entityType } = singleton;
+        const type = this.namingHelper.getServiceName(entityType.name);
+        importContainer.addGeneratedService(this.namingHelper.getServiceName(entityType.name), type);
+        return {
+            scope: ts_morph_1.Scope.Private,
+            name: this.namingHelper.getPrivatePropName(name),
+            type: `${type}<ClientType>`,
+            hasQuestionToken: true,
+        };
+    }
+    generateSingletonGetter(singleton) {
+        const { name, odataName, entityType } = singleton;
+        const propName = "this." + this.namingHelper.getPrivatePropName(name);
+        const serviceType = this.namingHelper.getServiceName(entityType.name);
+        return {
+            scope: ts_morph_1.Scope.Public,
+            name: this.namingHelper.getRelatedServiceGetter(name),
+            statements: [
+                `if(!${propName}) {`,
+                // prettier-ignore
+                `  ${propName} = new ${serviceType}(this.client, this.getPath(), "${odataName}")`,
+                "}",
+                `return ${propName}`,
+            ],
+        };
     }
     getVersionSuffix() {
         return this.version === odata_core_1.ODataVersions.V2 ? "V2" : "V4";
     }
-    generateModelService(model, serviceName, serviceFile, importContainer) {
+    generateEntityTypeService(model, serviceName, serviceFile, importContainer) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const entityServiceType = "EntityTypeService" + this.getVersionSuffix();
-            const collectionServiceType = "CollectionService" + this.getVersionSuffix();
             const editableModelName = model.editableName;
+            const qObjectName = (0, processors_1.firstCharLowerCase)(model.qName);
             const operations = this.dataModel.getOperationTypeByBinding(model.name);
             const props = [...model.baseProps, ...model.props];
-            const modelProps = props.filter((prop) => prop.dataType === "ModelType" /* DataTypes.ModelType */ || prop.dataType === "ComplexType" /* DataTypes.ComplexType */);
-            const primColProps = props.filter((prop) => prop.isCollection && prop.dataType !== "ModelType" /* DataTypes.ModelType */ && prop.dataType !== "ComplexType" /* DataTypes.ComplexType */);
             importContainer.addFromService(entityServiceType);
             importContainer.addFromClientApi("ODataClient");
             importContainer.addGeneratedModel(model.name, editableModelName);
-            importContainer.addGeneratedQObject(model.qName, (0, processors_1.firstCharLowerCase)(model.qName));
+            importContainer.addGeneratedQObject(model.qName, qObjectName);
+            const { properties, methods } = (0, deepmerge_1.default)(this.generateServiceProperties(serviceName, props, importContainer), this.generateServiceOperations(operations, importContainer));
             // generate EntityTypeService
             serviceFile.addClass({
                 isExported: true,
@@ -149,119 +184,134 @@ class ServiceGenerator {
                             { name: "basePath", type: "string" },
                             { name: "name", type: "string" },
                         ],
-                        statements: [`super(client, basePath, name, ${(0, processors_1.firstCharLowerCase)(model.qName)});`],
+                        statements: [`super(client, basePath, name, ${qObjectName});`],
                     },
                 ],
-                properties: [
-                    ...this.generateModelProps(modelProps, collectionServiceType, serviceName, importContainer),
-                    ...this.generatePrimitiveCollectionProps(primColProps, collectionServiceType, importContainer),
-                    ...operations.map(this.generateQOperationProps),
-                ],
-                methods: [
-                    ...this.generateModelPropGetters(modelProps, collectionServiceType),
-                    ...this.generatePrimitiveCollectionGetters(primColProps, collectionServiceType),
-                    ...this.generateBoundOperations(operations, importContainer),
-                ],
+                properties,
+                methods,
             });
         });
     }
-    generateModelProps(modelProps, collectionServiceType, serviceName, importContainer) {
-        return modelProps.map((prop) => {
-            const complexType = this.dataModel.getComplexType(prop.type);
-            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}>`;
+    generateServiceProperties(serviceName, props, importContainer) {
+        const collectionServiceType = "CollectionService" + this.getVersionSuffix();
+        const result = { properties: [], methods: [] };
+        props.forEach((prop) => {
+            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));
             }
-            else {
-                // don't include imports for this type
-                if (serviceName !== key) {
-                    importContainer.addGeneratedService(key, propModelType);
+            else if (prop.isCollection) {
+                // collection of entity types
+                if (prop.dataType === "ModelType" /* DataTypes.ModelType */) {
+                    const entityType = this.dataModel.getModel(prop.type);
+                    result.methods.push(this.generateRelatedServiceGetter(prop.name, entityType, importContainer, serviceName));
+                }
+                // collection of primitive or complex types
+                else {
+                    result.properties.push(this.generatePrimitiveCollectionProp(prop, collectionServiceType, importContainer));
+                    result.methods.push(this.generatePrimitiveCollectionGetter(prop, collectionServiceType));
                 }
-                propModelType = `${propModelType}<ClientType>`;
             }
-            return {
-                scope: ts_morph_1.Scope.Private,
-                name: this.namingHelper.getPrivatePropName(prop.name),
-                type: propModelType,
-                hasQuestionToken: true,
-            };
         });
+        return result;
     }
-    generatePrimitiveCollectionProps(primColProps, collectionServiceType, importContainer) {
-        return primColProps.map((prop) => {
-            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" : `Q${type}`;
-            const collectionType = `${collectionServiceType}<ClientType, ${type}, ${qType}>`;
-            if (!prop.qObject) {
-                throw new Error("Illegal State: [qObject] must be provided for Collection types!");
-            }
+    generateServiceOperations(operations, importContainer) {
+        const result = { properties: [], methods: [] };
+        operations.forEach((operation) => {
+            result.properties.push(this.generateQOperationProp(operation));
+            result.methods.push(this.generateMethod(operation.name, operation, importContainer));
+        });
+        return result;
+    }
+    generateModelProp(prop, collectionServiceType, serviceName, importContainer) {
+        const complexType = this.dataModel.getComplexType(prop.type);
+        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.addFromQObject(prop.qObject, (0, processors_1.firstCharLowerCase)(prop.qObject));
-            if (isEnum) {
-                importContainer.addGeneratedModel(prop.type);
-                importContainer.addFromQObject("EnumCollection");
-            }
-            else {
-                importContainer.addFromQObject(type);
+            importContainer.addGeneratedModel(complexType.name, editableName);
+            importContainer.addGeneratedQObject(complexType.qName, (0, processors_1.firstCharLowerCase)(complexType.qName));
+            propModelType = `${collectionServiceType}<ClientType, ${complexType.name}, ${complexType.qName}, ${editableName}>`;
+        }
+        else {
+            // don't include imports for this type
+            if (serviceName !== key) {
+                importContainer.addGeneratedService(key, propModelType);
             }
-            return {
-                scope: ts_morph_1.Scope.Private,
-                name: this.namingHelper.getPrivatePropName(prop.name),
-                type: `${collectionType}`,
-                hasQuestionToken: true,
-            };
-        });
+            propModelType = `${propModelType}<ClientType>`;
+        }
+        return {
+            scope: ts_morph_1.Scope.Private,
+            name: this.namingHelper.getPrivatePropName(prop.name),
+            type: propModelType,
+            hasQuestionToken: true,
+        };
     }
-    generateModelPropGetters(modelProps, collectionServiceType) {
-        return modelProps.map((prop) => {
-            const complexType = this.dataModel.getComplexType(prop.type);
-            const isComplexCollection = prop.isCollection && complexType;
-            const type = isComplexCollection
-                ? collectionServiceType
-                : prop.isCollection
-                    ? this.namingHelper.getCollectionServiceName(prop.type)
-                    : this.namingHelper.getServiceName(prop.type);
-            const typeWithGenerics = isComplexCollection
-                ? `${collectionServiceType}<ClientType, ${complexType.name}, ${complexType.qName}, ${complexType.editableName}>`
-                : `${type}<ClientType>`;
-            const privateSrvProp = "this." + this.namingHelper.getPrivatePropName(prop.name);
-            return {
-                scope: ts_morph_1.Scope.Public,
-                name: this.namingHelper.getRelatedServiceGetter(prop.name),
-                returnType: typeWithGenerics,
-                statements: [
-                    `if(!${privateSrvProp}) {`,
-                    // prettier-ignore
-                    `  ${privateSrvProp} = new ${type}(this.client, this.getPath(), "${prop.odataName}"${isComplexCollection ? `, ${(0, processors_1.firstCharLowerCase)(complexType.qName)}` : ""})`,
-                    "}",
-                    `return ${privateSrvProp}`,
-                ],
-            };
-        });
+    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" : `Q${type}`;
+        const collectionType = `${collectionServiceType}<ClientType, ${type}, ${qType}>`;
+        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");
+        }
+        else {
+            importContainer.addFromQObject(type);
+        }
+        return {
+            scope: ts_morph_1.Scope.Private,
+            name: this.namingHelper.getPrivatePropName(prop.name),
+            type: `${collectionType}`,
+            hasQuestionToken: true,
+        };
     }
-    generatePrimitiveCollectionGetters(primColProps, collectionServiceType) {
-        return primColProps.map((prop) => {
-            const propName = "this." + this.namingHelper.getPrivatePropName(prop.name);
-            return {
-                scope: ts_morph_1.Scope.Public,
-                name: this.namingHelper.getRelatedServiceGetter(prop.name),
-                statements: [
-                    `if(!${propName}) {`,
-                    // prettier-ignore
-                    `  ${propName} = new ${collectionServiceType}(this.client, this.getPath(), "${prop.odataName}", ${(0, processors_1.firstCharLowerCase)(prop.qObject)})`,
-                    "}",
-                    `return ${propName}`,
-                ],
-            };
-        });
+    generateModelPropGetter(prop, collectionServiceType) {
+        const complexType = this.dataModel.getComplexType(prop.type);
+        const isComplexCollection = prop.isCollection && complexType;
+        const type = isComplexCollection
+            ? collectionServiceType
+            : prop.isCollection
+                ? this.namingHelper.getCollectionServiceName(prop.type)
+                : this.namingHelper.getServiceName(prop.type);
+        const typeWithGenerics = isComplexCollection
+            ? `${collectionServiceType}<ClientType, ${complexType.name}, ${complexType.qName}, ${complexType.editableName}>`
+            : `${type}<ClientType>`;
+        const privateSrvProp = "this." + this.namingHelper.getPrivatePropName(prop.name);
+        return {
+            scope: ts_morph_1.Scope.Public,
+            name: this.namingHelper.getRelatedServiceGetter(prop.name),
+            returnType: typeWithGenerics,
+            statements: [
+                `if(!${privateSrvProp}) {`,
+                // prettier-ignore
+                `  ${privateSrvProp} = new ${type}(this.client, this.getPath(), "${prop.odataName}"${isComplexCollection ? `, ${(0, processors_1.firstCharLowerCase)(complexType.qName)}` : ""})`,
+                "}",
+                `return ${privateSrvProp}`,
+            ],
+        };
+    }
+    generatePrimitiveCollectionGetter(prop, collectionServiceType) {
+        const propName = "this." + this.namingHelper.getPrivatePropName(prop.name);
+        return {
+            scope: ts_morph_1.Scope.Public,
+            name: this.namingHelper.getRelatedServiceGetter(prop.name),
+            statements: [
+                `if(!${propName}) {`,
+                // prettier-ignore
+                `  ${propName} = new ${collectionServiceType}(this.client, this.getPath(), "${prop.odataName}", ${(0, processors_1.firstCharLowerCase)(prop.qObject)})`,
+                "}",
+                `return ${propName}`,
+            ],
+        };
     }
-    generateEntityCollectionService(model, serviceName, serviceFile, importContainer) {
+    generateEntityCollectionService(model, serviceFile, importContainer) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const entitySetServiceType = "EntitySetService" + this.getVersionSuffix();
             const editableModelName = model.editableName;
@@ -270,12 +320,13 @@ class ServiceGenerator {
             importContainer.addGeneratedModel(model.idModelName);
             importContainer.addGeneratedQObject(model.qIdFunctionName);
             const collectionOperations = this.dataModel.getOperationTypeByBinding(`Collection(${model.name})`);
+            const { properties, methods } = this.generateServiceOperations(collectionOperations, importContainer);
             serviceFile.addClass({
                 isExported: true,
                 name: this.namingHelper.getCollectionServiceName(model.name),
                 typeParameters: ["ClientType extends ODataClient"],
                 extends: entitySetServiceType +
-                    `<ClientType, ${model.name}, ${editableModelName}, ${model.qName}, ${model.idModelName}, ${serviceName}<ClientType>>`,
+                    `<ClientType, ${model.name}, ${editableModelName}, ${model.qName}, ${model.idModelName}>`,
                 ctors: [
                     {
                         parameters: [
@@ -283,44 +334,14 @@ class ServiceGenerator {
                             { name: "basePath", type: "string" },
                             { name: "name", type: "string" },
                         ],
-                        statements: [
-                            `super(client, basePath, name, ${qObjectName}, ${serviceName}, new ${model.qIdFunctionName}(name));`,
-                        ],
+                        statements: [`super(client, basePath, name, ${qObjectName}, new ${model.qIdFunctionName}(name));`],
                     },
                 ],
-                properties: [...collectionOperations.map(this.generateQOperationProps)],
-                methods: [...this.generateBoundOperations(collectionOperations, importContainer)],
+                properties,
+                methods,
             });
         });
     }
-    generateEntityServiceResolver(model, serviceName, serviceFile, importContainer) {
-        const idFunctionName = model.qIdFunctionName;
-        const collectionName = this.namingHelper.getCollectionServiceName(model.name);
-        importContainer.addFromClientApi("ODataClient");
-        importContainer.addFromService("EntityServiceResolver");
-        importContainer.addGeneratedQObject(idFunctionName);
-        serviceFile.addFunction({
-            name: this.namingHelper.getServiceResolverName(model.name),
-            isExported: true,
-            parameters: [
-                {
-                    name: "client",
-                    type: "ODataClient",
-                },
-                {
-                    name: "basePath",
-                    type: "string",
-                },
-                {
-                    name: "entityName",
-                    type: "string",
-                },
-            ],
-            statements: [
-                `return new EntityServiceResolver(client, basePath, entityName, ${idFunctionName}, ${serviceName}, ${collectionName});`,
-            ],
-        });
-    }
     generateModelServices() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             // build service file for each entity, consisting of EntityTypeService & EntityCollectionService
@@ -329,11 +350,9 @@ class ServiceGenerator {
                 const serviceFile = yield this.project.createServiceFile(serviceName);
                 const importContainer = new ImportContainer_1.ImportContainer(this.namingHelper.getFileNames());
                 // entity type service
-                yield this.generateModelService(model, serviceName, serviceFile, importContainer);
+                yield this.generateEntityTypeService(model, serviceName, serviceFile, importContainer);
                 // entity collection service
-                yield this.generateEntityCollectionService(model, serviceName, serviceFile, importContainer);
-                // the resolver function
-                yield this.generateEntityServiceResolver(model, serviceName, serviceFile, importContainer);
+                yield this.generateEntityCollectionService(model, serviceFile, importContainer);
                 serviceFile.addImportDeclarations(importContainer.getImportDeclarations(true));
             }
             // build service file for complex types
@@ -342,23 +361,11 @@ class ServiceGenerator {
                 const serviceFile = yield this.project.createServiceFile(serviceName);
                 const importContainer = new ImportContainer_1.ImportContainer(this.namingHelper.getFileNames());
                 // entity type service
-                yield this.generateModelService(model, serviceName, serviceFile, importContainer);
+                yield this.generateEntityTypeService(model, serviceName, serviceFile, importContainer);
                 serviceFile.addImportDeclarations(importContainer.getImportDeclarations(true));
             }
         });
     }
-    generateBoundOperations(operations, importContainer) {
-        return operations.reduce((collector, operation) => {
-            collector.push(this.generateMethod(operation.name, operation, importContainer));
-            return collector;
-        }, []);
-    }
-    generateUnboundOperations(operations, importContainer) {
-        return Object.values(operations).reduce((collector, { name, operation }) => {
-            collector.push(this.generateMethod(name, operation, importContainer));
-            return collector;
-        }, []);
-    }
     generateMethod(name, operation, importContainer) {
         var _a, _b;
         const isFunc = operation.type === "Function" /* OperationTypes.Function */;