Return a full Product type from the update() mutation

modules/core/api/product/product.resolver.ts

@@ -33,7 +33,7 @@ export class ProductResolver {
     }
 
     @Mutation()
-    updateProduct(_, args): Promise<Product> {
+    updateProduct(_, args): Promise<Product | undefined> {
         const { productId, input } = args;
         return this.productService.update(input);
     }

modules/core/common/common-types.ts

@@ -0,0 +1 @@
+export type DeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> };

modules/core/entity/product/product-translation.entity.ts

@@ -1,19 +1,14 @@
 import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { DeepPartial } from '../../common/common-types';
 import { LanguageCode } from '../../locale/language-code';
 import { Translation, TranslationInput } from '../../locale/locale-types';
 import { Product } from './product.entity';
 
 @Entity('product_translation')
 export class ProductTranslation implements Translation<Product> {
-    constructor(input?: TranslationInput<Product>) {
+    constructor(input?: DeepPartial<TranslationInput<Product>>) {
         if (input) {
-            if (input.id !== undefined) {
-                this.id = input.id;
-            }
-            this.languageCode = input.languageCode;
-            this.name = input.name;
-            this.slug = input.slug;
-            this.description = input.description;
+            Object.assign(this, input);
         }
     }
 

modules/core/entity/product/product.entity.ts

@@ -8,13 +8,20 @@ import {
     PrimaryGeneratedColumn,
     UpdateDateColumn,
 } from 'typeorm';
-import { LocaleString, Translatable, Translation } from '../../locale/locale-types';
+import { DeepPartial } from '../../common/common-types';
+import { LocaleString, Translatable, Translation, TranslationInput } from '../../locale/locale-types';
 import { ProductOptionGroup } from '../product-option-group/product-option-group.entity';
 import { ProductVariant } from '../product-variant/product-variant.entity';
 import { ProductTranslation } from './product-translation.entity';
 
 @Entity('product')
 export class Product implements Translatable {
+    constructor(input?: DeepPartial<Product>) {
+        if (input) {
+            Object.assign(this, input);
+        }
+    }
+
     @PrimaryGeneratedColumn() id: number;
 
     name: LocaleString;

modules/core/entity/product/product.graphql

@@ -1,5 +1,6 @@
 type Product {
     id: Int!
+    languageCode: LanguageCode
     name: String
     slug: String
     description: String

modules/core/repository/product-repository.ts

@@ -37,12 +37,18 @@ export class ProductRepository extends AbstractRepository<Product> {
         return this.manager.save(productEntity);
     }
 
+    /**
+     * Updates an existing Product and manages its ProductTranslations.
+     */
     async update(
-        product: UpdateProductDto,
+        productDto: UpdateProductDto,
         translationsToUpdate: ProductTranslation[],
         translationsToAdd: ProductTranslation[],
         translationsToDelete: ProductTranslation[],
-    ): Promise<any> {
+    ): Promise<Product> {
+        const product = new Product(productDto);
+        product.translations = [];
+
         if (translationsToUpdate.length) {
             for (const toUpdate of translationsToUpdate) {
                 await this.manager
@@ -52,32 +58,28 @@ export class ProductRepository extends AbstractRepository<Product> {
                     .where('id = :id', { id: toUpdate.id })
                     .execute();
             }
+            product.translations = product.translations.concat(translationsToUpdate);
         }
 
         if (translationsToAdd.length) {
             for (const toAdd of translationsToAdd) {
                 const translation = new ProductTranslation(toAdd);
-                translation.base = product as Product;
-                await this.manager.getRepository(ProductTranslation).save(translation);
-                product.translations.push(translation);
+                translation.base = product;
+                const newTranslation = await this.manager.getRepository(ProductTranslation).save(translation);
+                product.translations.push(newTranslation);
             }
         }
 
         if (translationsToDelete.length) {
             const toDeleteEntities = translationsToDelete.map(toDelete => {
                 const translation = new ProductTranslation(toDelete);
-                translation.base = product as Product;
+                translation.base = product;
                 return translation;
             });
             await this.manager.getRepository(ProductTranslation).remove(toDeleteEntities);
         }
 
-        await this.manager
-            .createQueryBuilder()
-            .update(Product)
-            .set(product)
-            .where('id = :id', { id: product.id })
-            .execute();
+        return this.manager.save(product);
     }
 
     private getProductQueryBuilder(languageCode: LanguageCode): SelectQueryBuilder<Product> {