@things-factory/product-base 4.3.122 → 4.3.138

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@things-factory/product-base",
-  "version": "4.3.122",
+  "version": "4.3.138",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
-  "license": "MIT",
   "author": "",
   "description": "Server module that handles product",
   "publishConfig": {
@@ -24,8 +23,8 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/biz-base": "^4.3.122",
-    "@things-factory/routing-base": "^4.3.122"
+    "@things-factory/biz-base": "^4.3.138",
+    "@things-factory/routing-base": "^4.3.138"
   },
-  "gitHead": "3edd80e6ca68480b22ee0e25eba34d13ab0e49f1"
+  "gitHead": "1d4e0a3ff6b8792c843b9735a28a3f5fb946b144"
 }

package/server/service/index.ts

@@ -15,8 +15,10 @@ import {
   entities as ProductCombinationSettingEntities,
   resolvers as ProductCombinationSettingResolvers
 } from './product-combination-setting'
+import { entities as ProductBarcodeEntities, resolvers as ProductBarcodeResolvers } from './product-barcode'
 
 /* EXPORT ENTITY TYPES */
+export * from './product-barcode/product-barcode'
 export * from './product-combination-setting/product-combination-setting'
 export * from './product-combination/product-combination'
 export * from './product/product'
@@ -27,6 +29,7 @@ export * from './product-detail-bizplace-setting/product-detail-bizplace-setting
 export * from './product-set/product-set'
 
 /* EXPORT TYPES */
+export * from './product-barcode/product-barcode-type'
 export * from './product-combination/product-combination-type'
 export * from './product-combination-setting/product-combination-setting-type'
 export * from './product/product-types'
@@ -44,7 +47,8 @@ export const entities = [
   ...ProductDetailBizplaceSettingEntities,
   ...ProductSetEntities,
   ...ProductCombinationEntities,
-  ...ProductCombinationSettingEntities
+  ...ProductCombinationSettingEntities,
+  ...ProductBarcodeEntities
 ]
 
 export const schema = {
@@ -56,6 +60,7 @@ export const schema = {
     ...ProductDetailBizplaceSettingResolver,
     ...ProductSetResolvers,
     ...ProductCombinationResolvers,
-    ...ProductCombinationSettingResolvers
+    ...ProductCombinationSettingResolvers,
+    ...ProductBarcodeResolvers
   ]
 }

package/server/service/product/product-mutation.ts

@@ -10,6 +10,7 @@ import { Domain } from '@things-factory/shell'
 
 import { PRODUCT_STATUS } from '../../constants'
 import { ProductDetail } from '../product-detail/product-detail'
+import { ProductBarcode } from '../product-barcode/product-barcode'
 import {
   createProductDetail,
   updateMultipleProductDetail,
@@ -269,11 +270,27 @@ export async function createProduct(product: any, context: any) {
       updater: user
     })
 
-    let productDetails = product.productDetails
-    if (!productDetails) {
+    let productDetails
+    if (product.productDetails) {
+      productDetails = product.productDetails.reduce((acc, currentObj) => {
+        let existingProductDetail = acc.find(
+          itm => itm.packingType == currentObj.packingType && itm.uom == currentObj.uom
+        )
+        if (existingProductDetail) {
+          existingProductDetail.productBarcodes = [...existingProductDetail.productBarcodes, { gtin: currentObj.gtin }]
+          return acc
+        } else {
+          let newProductDetail = {
+            ...currentObj,
+            productBarcodes: [{ gtin: currentObj.gtin }]
+          }
+          return [...acc, newProductDetail]
+        }
+      }, [])
+    } else {
       productDetails = [new ProductDetail({ ...product, product: result, isDefault: true })]
-      if (productDetails[0].gtin == null || productDetails[0] == undefined) {
-        productDetails[0].gtin = product.sku
+      if (!productDetails[0].productBarcodes || productDetails[0].productBarcodes.length < 1) {
+        productDetails[0].productBarcodes = [{ gtin: product.sku }]
       }
     }
 

package/server/service/product/product.ts

@@ -18,6 +18,7 @@ import { Routing } from '@things-factory/routing-base'
 import { Domain } from '@things-factory/shell'
 
 import { ProductDetail } from '../product-detail/product-detail'
+import { ProductBarcode } from '../product-barcode/product-barcode'
 import { ProductSet } from '../product-set/product-set'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -115,6 +116,10 @@ export class Product {
   @Field(type => [ProductDetail], { nullable: true })
   productDetails: ProductDetail[]
 
+  @OneToMany(type => ProductBarcode, productBarcodes => productBarcodes.product, { nullable: true })
+  @Field(type => [ProductBarcode], { nullable: true })
+  productBarcodes: ProductBarcode[]
+
   @ManyToOne(type => Product, { nullable: true })
   @Field({ nullable: true })
   productRef: Product

package/server/service/product-barcode/index.ts

@@ -0,0 +1,6 @@
+import { ProductBarcode } from './product-barcode'
+import { ProductBarcodeQuery } from './product-barcode-query'
+import { ProductBarcodeMutation } from './product-barcode-mutation'
+
+export const entities = [ProductBarcode]
+export const resolvers = [ProductBarcodeQuery, ProductBarcodeMutation]

package/server/service/product-barcode/product-barcode-mutation.ts

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { ProductBarcode } from './product-barcode'
+import { NewProductBarcode, ProductBarcodePatch } from './product-barcode-type'
+
+@Resolver(ProductBarcode)
+export class ProductBarcodeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ProductBarcode, { description: 'To create new ProductBarcode' })
+  async createProductBarcode(
+    @Arg('productBarcode') productBarcode: NewProductBarcode,
+    @Ctx() context: any
+  ): Promise<ProductBarcode> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ProductBarcode).save({
+      ...productBarcode,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ProductBarcode, { description: 'To modify ProductBarcode information' })
+  async updateProductBarcode(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProductBarcodePatch,
+    @Ctx() context: any
+  ): Promise<ProductBarcode> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ProductBarcode)
+    const productBarcode = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...productBarcode,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ProductBarcode], { description: "To modify multiple ProductBarcodes' information" })
+  async updateMultipleProductBarcode(
+    @Arg('patches', type => [ProductBarcodePatch]) patches: ProductBarcodePatch[],
+    @Ctx() context: any
+  ): Promise<ProductBarcode[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const productBarcodeRepo = tx.getRepository(ProductBarcode)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await productBarcodeRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const productBarcode = await productBarcodeRepo.findOne(newRecord.id)
+
+        const result = await productBarcodeRepo.save({
+          ...productBarcode,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ProductBarcode' })
+  async deleteProductBarcode(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductBarcode).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple productBarcodes' })
+  async deleteProductBarcodes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ProductBarcode).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/product-barcode/product-barcode-query.ts

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ProductBarcode } from './product-barcode'
+import { ProductBarcodeList } from './product-barcode-type'
+
+@Resolver(ProductBarcode)
+export class ProductBarcodeQuery {
+  @Query(returns => ProductBarcode, { description: 'To fetch a ProductBarcode' })
+  async productBarcode(@Arg('id') id: string, @Ctx() context: any): Promise<ProductBarcode> {
+    const { domain } = context.state
+
+    return await getRepository(ProductBarcode).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => ProductBarcodeList, { description: 'To fetch multiple ProductBarcodes' })
+  async productBarcodes(@Args() params: ListParam, @Ctx() context: any): Promise<ProductBarcodeList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(ProductBarcode).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() productBarcode: ProductBarcode): Promise<Domain> {
+    return await getRepository(Domain).findOne(productBarcode.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() productBarcode: ProductBarcode): Promise<User> {
+    return await getRepository(User).findOne(productBarcode.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() productBarcode: ProductBarcode): Promise<User> {
+    return await getRepository(User).findOne(productBarcode.creatorId)
+  }
+}

package/server/service/product-barcode/product-barcode-type.ts

@@ -0,0 +1,35 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductBarcode } from './product-barcode'
+
+@InputType()
+export class NewProductBarcode {
+  @Field()
+  name: string
+
+  @Field()
+  productDetail: ObjectRef
+}
+
+@InputType()
+export class ProductBarcodePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  gtin?: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}
+
+@ObjectType()
+export class ProductBarcodeList {
+  @Field(type => [ProductBarcode])
+  items: ProductBarcode[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/product-barcode/product-barcode.ts

@@ -0,0 +1,78 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_product_barcode_0', (productBarcode: ProductBarcode) => [productBarcode.domain, productBarcode.id], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for ProductBarcode' })
+export class ProductBarcode {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((productBarcode: ProductBarcode) => productBarcode.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  gtin: string
+
+  @ManyToOne(type => Product)
+  @Field(type => Product)
+  product?: Product
+
+  @RelationId((productBarcode: ProductBarcode) => productBarcode.product)
+  productId?: string
+
+  @ManyToOne(type => ProductDetail)
+  @Field(type => ProductDetail)
+  productDetail?: ProductDetail
+
+  @RelationId((productBarcode: ProductBarcode) => productBarcode.productDetail)
+  productDetailId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((productBarcode: ProductBarcode) => productBarcode.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((productBarcode: ProductBarcode) => productBarcode.updater)
+  updaterId?: string
+}

package/server/service/product-bundle-setting/product-bundle-setting-query.ts

@@ -86,10 +86,14 @@ export class ProductBundleSettingQuery {
     }
 
     let productBundleSets = await qb
-      .offset((page - 1) * limit)
-      .limit(limit)
       .getRawMany()
 
+    const total = productBundleSets.length
+    productBundleSets = await qb
+    .offset((page - 1) * limit)
+    .limit(limit)
+    .getRawMany()
+
     const items = productBundleSets.map(item => {
       return {
         // id: item.pbs_id,
@@ -126,8 +130,6 @@ export class ProductBundleSettingQuery {
       }
     })
 
-    const total = await qb.getCount()
-
     return { items, total }
   }
 }

package/server/service/product-detail/product-detail-mutation.ts

@@ -1,6 +1,7 @@
 import _ from 'lodash'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { getRepository, In, Raw } from 'typeorm'
+import { ProductBarcode } from '../product-barcode/product-barcode'
 
 import { Product } from '../product/product'
 import { ProductDetail } from './product-detail'
@@ -89,14 +90,39 @@ export async function updateMultipleProductDetail(productId, patches, context: a
     const { domain, user, tx } = context.state
 
     let results = []
-    const _createRecords = patches.filter((patch: any) => !patch.id)
-    const _updateRecords = patches.filter((patch: any) => patch.id)
     // const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
 
+    patches.map(itm => {
+      let name = itm.name ? itm.name : itm.packingType + '-' + itm.packingSize + '-' + itm.uom
+
+      let maxCounter = 1
+      patches.find(itm => {
+        if (itm.name && itm.name.includes(name)) {
+          let itmCounter = parseInt(itm.name[itm.name.indexOf('(') + 1])
+
+          if (itmCounter && itmCounter == maxCounter) {
+            maxCounter = itmCounter + 1
+          }
+        }
+      })
+
+      name += '(' + maxCounter + ')'
+
+      if (!itm.name || itm.name == '') {
+        itm.name = name
+      }
+    })
+
+    const _createRecords = patches.filter((patch: any) => !patch.id)
+    const _updateRecords = patches.filter((patch: any) => patch.id)
     const productRepo = tx.getRepository(Product)
     const productDetailRepo = tx.getRepository(ProductDetail)
+    const productBarcodeRepo = tx.getRepository(ProductBarcode)
 
-    const product: Product = await productRepo.findOne({ where: { id: productId }, relations: ['productDetails'] })
+    const product: Product = await productRepo.findOne({
+      where: { id: productId },
+      relations: ['productDetails']
+    })
 
     const defaultProductDetail: ProductDetail = patches.find(x => x.isDefault)
 
@@ -104,8 +130,9 @@ export async function updateMultipleProductDetail(productId, patches, context: a
       for (let i = 0; i < _createRecords.length; i++) {
         const newRecord = {
           ..._createRecords[i],
-          name: _createRecords[i].gtin,
+          gtin: _createRecords[i]?.productBarcodes[0].gtin,
           product,
+          packingSize: _createRecords[i].packingSize <= 0 ? 1 : _createRecords[i].packingSize,
           childProductDetail: null,
           childQty: 0,
           domain: domain,
@@ -113,11 +140,23 @@ export async function updateMultipleProductDetail(productId, patches, context: a
           updater: user
         }
 
-        if (newRecord.gtin == null || newRecord.gtin == undefined) {
+        if (!newRecord.productBarcodes || newRecord.productBarcodes.length < 1) {
           throw new Error('GTIN cannot be empty.')
         }
 
         const result = await productDetailRepo.save(newRecord)
+        for (let i = 0; i < newRecord.productBarcodes.length; i++) {
+          const newProductBarcode = {
+            gtin: newRecord.productBarcodes[i].gtin,
+            product,
+            productDetail: newRecord.id,
+            domain: domain,
+            creator: user,
+            updater: user
+          }
+
+          await productBarcodeRepo.save(newProductBarcode)
+        }
 
         results.push({ ...result, cuFlag: '+' })
       }
@@ -128,42 +167,71 @@ export async function updateMultipleProductDetail(productId, patches, context: a
       let updateRecords = _updateRecords.find(ur => ur.id == product.productDetails[x].id)
 
       if (updateRecords) {
-        const productDetail: ProductDetail = await productDetailRepo.findOne({ id: updateRecords.id })
+        const productDetail: ProductDetail = await productDetailRepo.findOne({
+          where: { id: updateRecords.id },
+          relations: ['productBarcodes']
+        })
 
         const updateRecord = {
           ...productDetail,
           ...updateRecords,
-          name: updateRecords.gtin,
+          name: updateRecords.name,
           product,
           childProductDetail: null,
           childQty: 0,
           updater: user
         }
 
-        if (updateRecord.gtin == '' || updateRecord.gtin == null || updateRecord.gtin == undefined) {
+        if (!updateRecord.productBarcodes || updateRecord.productBarcodes.length < 1) {
           throw new Error('GTIN cannot be empty.')
         }
 
         const result = await productDetailRepo.save({
           ...productDetail,
           ...updateRecord,
-          name: updateRecord.gtin,
+          name: updateRecord.name,
           product,
           childProductDetail: null,
           childQty: 0,
           updater: user
         })
 
+        for (let i = 0; i < updateRecord.productBarcodes.length; i++) {
+          let foundProductBarcode = productDetail.productBarcodes.find(
+            itm => itm.gtin == updateRecord.productBarcodes[i].gtin
+          )
+          if (!foundProductBarcode) {
+            const newProductBarcode = {
+              gtin: updateRecord.productBarcodes[i].gtin,
+              product,
+              productDetail: updateRecord.id,
+              domain: domain,
+              creator: user,
+              updater: user
+            }
+
+            await productBarcodeRepo.save(newProductBarcode)
+          }
+        }
+        let deleteProductBarcodeIds = productDetail.productBarcodes.map(itm => {
+          if (!updateRecord.productBarcodes.find(pb => pb.gtin == itm.gtin)) {
+            return itm.id
+          }
+        })
+
+        await productBarcodeRepo.delete({ id: In(deleteProductBarcodeIds) })
+
         results.push({ ...result, cuFlag: 'M' })
       } else {
         deleteIds.push(product.productDetails[x].id)
       }
     }
 
+    await productBarcodeRepo.delete({ productDetail: In(deleteIds) })
     await productDetailRepo.delete({ id: In(deleteIds) })
 
     for await (let patch of patches.filter(x => x.childProductDetail)) {
-      let matchedChildProductDetail = results.find(itm => itm.gtin == patch.childProductDetail)
+      let matchedChildProductDetail = results.find(itm => itm.name == patch.childProductDetail)
 
       if (matchedChildProductDetail) {
         const childProductDetail: ProductDetail = await productDetailRepo.findOne({
@@ -171,7 +239,7 @@ export async function updateMultipleProductDetail(productId, patches, context: a
           relations: ['product']
         })
         const productDetail: ProductDetail = await productDetailRepo.findOne({
-          where: { gtin: patch.gtin, product: childProductDetail.product }
+          where: { name: patch.name, product: childProductDetail.product }
         })
 
         await productDetailRepo.save({

package/server/service/product-detail/product-detail-query.ts

@@ -7,6 +7,7 @@ import { buildCondition, buildQuery, Domain, Filter, Pagination, Sorting } from
 
 import { ProductDetail } from './product-detail'
 import { ProductDetailList } from './product-detail-types'
+import { ProductBarcode } from '../product-barcode/product-barcode'
 
 @Resolver(ProductDetail)
 export class ProductDetailQuery {
@@ -76,6 +77,9 @@ export class ProductDetailQuery {
     const qb: SelectQueryBuilder<ProductDetail> = getRepository(ProductDetail).createQueryBuilder('ProductDetail')
     qb.innerJoinAndSelect('ProductDetail.product', 'Product', '"Product"."deleted_at" IS NULL')
     qb.innerJoinAndSelect('Product.bizplace', 'Bizplace')
+    qb.innerJoin('ProductDetail.productBarcodes', 'ProductBarcode')
+    qb.addSelect('ProductBarcode.id')
+    qb.addSelect('ProductBarcode.gtin')
     qb.leftJoinAndSelect('ProductDetail.childProductDetail', 'ChildProductDetail')
     qb.leftJoinAndSelect('Product.creator', 'Creator')
     qb.leftJoinAndSelect('Product.updater', 'Updater')
@@ -154,10 +158,11 @@ export class ProductDetailQuery {
       return {
         ...item,
         productId: item.product.id,
-        name: item.product.name,
+        name: item.name,
         description: item.product.description,
         type: item.product.type,
         sku: item.product.sku,
+        brand: item.product.brand,
         isRequireSerialNumberScanningInbound: item.product.isRequireSerialNumberScanningInbound,
         isRequireSerialNumberScanningOutbound: item.product.isRequireSerialNumberScanningOutbound
       }
@@ -173,20 +178,21 @@ export class ProductDetailQuery {
     @Ctx() context: any
   ): Promise<ProductDetailList> {
     try {
-      const { tx } = context.state
-
       const customerDomainId: Domain = await getRepository(Domain).findOne(customerCompanyDomainId)
       if (!customerDomainId) throw new Error('Unable to find company domain')
-      var foundProductDetails
 
-      let [items, total] = await getRepository(ProductDetail).findAndCount({
+      const res: ProductBarcode[] = await getRepository(ProductBarcode).find({
         where: { domain: customerDomainId, gtin },
-        relations: ['product']
+        relations: ['productDetail', 'productDetail.product']
       })
 
-      if (items?.length <= 0) throw new Error('No product candidate found')
+      // validate there is a match for the gtin
+      if (res.length <= 0) throw new Error('No product candidate found')
+
+      // get productDetails from response
+      const productDetails: ProductDetail[] = res.map(x => x.productDetail)
 
-      return { items, total }
+      return { items: productDetails, total: productDetails.length }
     } catch (e) {
       throw new Error(e)
     }

package/server/service/product-detail/product-detail-types.ts

@@ -3,6 +3,7 @@ import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
 import { ObjectRef } from '@things-factory/shell'
 
 import { ProductDetail } from './product-detail'
+import { ProductBarcodePatch } from '../product-barcode/product-barcode-type'
 
 @InputType()
 export class NewProductDetail {
@@ -149,8 +150,11 @@ export class ProductDetailPatch {
   @Field({ nullable: true })
   name?: string
 
-  @Field({ nullable: true })
-  gtin?: string
+  // @Field({ nullable: true })
+  // gtin?: string
+
+  @Field(type => [ProductBarcodePatch], { nullable: true })
+  productBarcodes: ProductBarcodePatch[]
 
   @Field({ nullable: true })
   refCode?: string