@things-factory/marketplace-base 8.0.0-beta.9 → 8.0.0

package/server/graphql/resolvers/marketplace-product/sync-marketplace-store-products.ts

@@ -0,0 +1,222 @@
+import { getConnection, In } from 'typeorm'
+
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { getRepository, publishProgress } from '@things-factory/shell'
+
+import { MarketplaceProduct, MarketplaceProductAttribute, MarketplaceProductVariation } from '../../../entities'
+
+const debug = require('debug')('things-factory:marketplace-base:sync-marketplace-store-product')
+
+export async function syncMarketplaceStoreProducts({ domain, user, tag, marketplaceStore }) {
+  try {
+    let totalPages: number = 1
+    let processedData: number = 0
+    let pageInfo: string
+    var limit: number = 50
+
+    for (let page = 0; page < totalPages; page++) {
+      const {
+        results: marketplaceProducts,
+        total,
+        page_info
+      } = await StoreAPI.getStoreProducts(marketplaceStore, {
+        pagination: { page, limit },
+        pageInfo
+      })
+
+      if (marketplaceProducts?.length == 0) throw new Error('There is no product available to sync')
+
+      if (page_info) pageInfo = page_info
+      totalPages = Math.ceil(total / limit)
+
+      // search for existing product
+      const existingMarketplaceProducts: MarketplaceProduct[] = await getRepository(MarketplaceProduct).find({
+        where: {
+          domain: { id: domain.id },
+          marketplaceStore: { id: marketplaceStore.id },
+          itemId: In(marketplaceProducts.map(product => product.itemId.toString()))
+        },
+        relations: ['marketplaceProductVariations', 'marketplaceProductAttributes']
+      })
+
+      const existingItemIds: any[] = existingMarketplaceProducts.map(product => product.itemId)
+
+      const newMarketplaceProducts: MarketplaceProduct[] = marketplaceProducts.filter(
+        product => !existingItemIds.includes(product.itemId.toString())
+      )
+
+      let marketplaceProductVariations: MarketplaceProductVariation[] = []
+      let marketplaceProductAttributes: MarketplaceProductAttribute[] = []
+
+      if (existingMarketplaceProducts?.length > 0) {
+        for (var i = 0; i < existingMarketplaceProducts.length; i++) {
+          await getConnection().transaction(async tx => {
+            var existingProduct: MarketplaceProduct = existingMarketplaceProducts[i]
+
+            const matchedItem = marketplaceProducts.filter(
+              product => product.itemId.toString() === existingProduct.itemId
+            )[0]
+
+            // prep marketplace product data for saving
+            await tx.getRepository(MarketplaceProduct).save({
+              ...existingProduct,
+              ...matchedItem,
+              updater: user
+            })
+
+            // pre-load all existing marketplace product variation status = 'INACTIVE'
+            marketplaceProductVariations = existingProduct?.marketplaceProductVariations.map(variation => {
+              return {
+                ...variation,
+                status: 'INACTIVE'
+              }
+            })
+
+            // pre-load all existing marketplace product attributes status = 'INACTIVE'
+            marketplaceProductAttributes = existingProduct?.marketplaceProductAttributes.map(attribute => {
+              return {
+                ...attribute,
+                status: 'INACTIVE'
+              }
+            })
+
+            matchedItem.variations.map(variation => {
+              let matchedVariationIndex = marketplaceProductVariations.findIndex(
+                itm => itm.variationId == variation.variationId
+              )
+
+              if (matchedVariationIndex >= 0) {
+                marketplaceProductVariations[matchedVariationIndex] = {
+                  ...marketplaceProductVariations[matchedVariationIndex],
+                  ...variation,
+                  status: 'ACTIVE',
+                  updater: user
+                }
+              } else {
+                marketplaceProductVariations.push({
+                  ...variation,
+                  domain: domain,
+                  marketplaceProduct: existingProduct,
+                  status: 'ACTIVE',
+                  creator: user,
+                  updater: user
+                })
+              }
+            })
+
+            await tx.getRepository(MarketplaceProductVariation).save(marketplaceProductVariations)
+
+            // update status = 'ACTIVE' for matching existing with latest marketplace product attribute
+            matchedItem.attributes.map(attribute => {
+              let matchedAttributeIndex = marketplaceProductAttributes.findIndex(
+                itm => itm.attributeId == attribute.attributeId
+              )
+
+              if (matchedAttributeIndex >= 0) {
+                marketplaceProductAttributes[matchedAttributeIndex] = {
+                  ...marketplaceProductAttributes[matchedAttributeIndex],
+                  ...attribute,
+                  status: 'ACTIVE',
+                  updater: user
+                }
+              } else {
+                marketplaceProductAttributes.push({ ...attribute, status: 'ACTIVE', creator: user, updater: user })
+              }
+            })
+
+            await tx.getRepository(MarketplaceProductAttribute).save(marketplaceProductAttributes)
+
+            processedData++
+            debug('processed data', processedData)
+
+            publishProgress({
+              domain,
+              tag,
+              progress: Math.floor((processedData / total) * 100),
+              message: `${processedData} / ${total}`
+            })
+          })
+        }
+      }
+
+      if (newMarketplaceProducts?.length > 0) {
+        for (var i = 0; i < newMarketplaceProducts.length; i++) {
+          await getConnection().transaction(async tx => {
+            var product: any = newMarketplaceProducts[i]
+
+            // prep marketplace product data for saving
+            let marketplaceProduct: MarketplaceProduct = new MarketplaceProduct(product)
+            marketplaceProduct.marketplaceStore = marketplaceStore
+            marketplaceProduct.domain = domain
+            marketplaceProduct.creator = user
+            marketplaceProduct.updater = user
+            await tx.getRepository(MarketplaceProduct).save(marketplaceProduct)
+
+            marketplaceProductVariations = product.variations.map(variation => {
+              return {
+                ...variation,
+                status: 'ACTIVE',
+                marketplaceProduct,
+                domain: domain,
+                creator: user,
+                updater: user
+              }
+            })
+            await tx.getRepository(MarketplaceProductVariation).save(marketplaceProductVariations)
+
+            // pre-load all existing marketplace product attributes status = 'ACTIVE'
+            marketplaceProductAttributes = product.attributes.map(attribute => {
+              return {
+                ...attribute,
+                status: 'ACTIVE',
+                marketplaceProduct,
+                domain: domain,
+                creator: user,
+                updater: user
+              }
+            })
+            await tx.getRepository(MarketplaceProductAttribute).save(marketplaceProductAttributes)
+
+            processedData++
+            debug('processed data', processedData)
+
+            publishProgress({
+              domain,
+              tag,
+              progress: Math.floor((processedData / total) * 100),
+              message: `${processedData} / ${total}`
+            })
+          })
+        }
+      }
+    }
+  } catch (ex) {
+    publishProgress({
+      domain,
+      tag,
+      progress: -1,
+      message: 'failed'
+    })
+
+    throw ex
+  }
+}
+
+export const syncMarketplaceStoreProductsResolver = {
+  async syncMarketplaceStoreProducts(_: any, { storeId }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+    const tag = `progress-sync-product`
+
+    // don't make following line asynchronous (await)
+    syncMarketplaceStoreProducts({
+      domain,
+      user,
+      tag,
+      marketplaceStore
+    })
+
+    return
+  }
+}

package/server/graphql/resolvers/marketplace-product/update-marketplace-product.ts

@@ -0,0 +1,24 @@
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProduct } from '../../../entities'
+
+export const updateMarketplaceProductResolver = {
+  async updateMarketplaceProduct(_: any, { foundProduct, marketplaceProduct }, context: ResolverContext) {
+    const { user, tx } = context.state
+
+    return await updateMarketplaceProduct(foundProduct, marketplaceProduct, user, tx)
+  }
+}
+
+export async function updateMarketplaceProduct(foundProduct: MarketplaceProduct, marketplaceProduct: any, user: User, trxMgr?: EntityManager): Promise<any> {
+  const marketplaceProdRepo: Repository<MarketplaceProduct> = trxMgr?.getRepository(MarketplaceProduct) || getRepository(MarketplaceProduct)
+
+  await marketplaceProdRepo.save({
+    ...foundProduct,
+    ...marketplaceProduct,
+    updater: user
+  })
+}

package/server/graphql/resolvers/marketplace-product/upsert-marketplace-product.ts

@@ -0,0 +1,39 @@
+import { EntityManager } from 'typeorm'
+
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ATTACHMENT_TYPE } from '../../../constants'
+import { MarketplaceProduct } from '../../../entities'
+import { createMarketplaceProduct } from './create-marketplace-product'
+import { updateMarketplaceProduct } from './update-marketplace-product'
+
+export const upsertMarketplaceProduct = {
+  async upsertMarketplaceProduct(_: any, { marketplaceProduct, file }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    let foundProduct: MarketplaceProduct
+    foundProduct = await tx.getRepository(MarketplaceProduct).findOne({
+      where: { domain: { id: domain.id }, name: marketplaceProduct.name, isku: marketplaceProduct.isku }
+    })
+
+    if (foundProduct) {
+      await updateMarketplaceProduct(foundProduct, marketplaceProduct, user, tx)
+    } else {
+      const foundProd: MarketplaceProduct = await createMarketplaceProduct(domain, marketplaceProduct, user, tx)
+
+      if (file?.length) {
+        const attachments: Attachment[] = file.map(attachment => {
+          return {
+            file: attachment,
+            refType: ATTACHMENT_TYPE.MARKETPLACE_PRODUCT,
+            refBy: foundProd.id,
+            category: ATTACHMENT_TYPE.MARKETPLACE_PRODUCT /* TODO use refType */
+          }
+        })
+        await createAttachments(_, { attachments }, context)
+      }
+    }
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/create-marketplace-product-attribute.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const createMarketplaceProductAttribute = {
+  async createMarketplaceProductAttribute(_: any, { marketplaceProductAttribute }, context: ResolverContext) {
+    return await getRepository(MarketplaceProductAttribute).save({
+      ...marketplaceProductAttribute,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/delete-marketplace-product-attribute.ts

@@ -0,0 +1,10 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const deleteMarketplaceProductAttribute = {
+  async deleteMarketplaceProductAttribute(_: any, { name }, context: ResolverContext) {
+    await getRepository(MarketplaceProductAttribute).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/delete-marketplace-product-attributes.ts

@@ -0,0 +1,17 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const deleteMarketplaceProductAttributes = {
+  async deleteMarketplaceProductAttributes(_: any, { names }, context: ResolverContext) {
+    const { domain } = context.state
+
+    await getRepository(MarketplaceProductAttribute).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/index.ts

@@ -0,0 +1,22 @@
+import { marketplaceProductAttributeResolver } from './marketplace-product-attribute'
+import { marketplaceProductAttributesResolver } from './marketplace-product-attributes'
+
+import { updateMarketplaceProductAttribute } from './update-marketplace-product-attribute'
+import { updateMultipleMarketplaceProductAttribute } from './update-multiple-marketplace-product-attribute'
+import { createMarketplaceProductAttribute } from './create-marketplace-product-attribute'
+import { deleteMarketplaceProductAttribute } from './delete-marketplace-product-attribute'
+import { deleteMarketplaceProductAttributes } from './delete-marketplace-product-attributes'
+
+export const MarketplaceProductAttributeResolver = {
+  Query: {
+    ...marketplaceProductAttributesResolver,
+    ...marketplaceProductAttributeResolver
+  },
+  Mutation: {
+    ...updateMarketplaceProductAttribute,
+    ...updateMultipleMarketplaceProductAttribute,
+    ...createMarketplaceProductAttribute,
+    ...deleteMarketplaceProductAttribute,
+    ...deleteMarketplaceProductAttributes
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/marketplace-product-attribute.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const marketplaceProductAttributeResolver = {
+  async marketplaceProductAttribute(_: any, { name }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceProductAttribute)
+
+    return await getRepository(MarketplaceProductAttribute).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/marketplace-product-attributes.ts

@@ -0,0 +1,14 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const marketplaceProductAttributesResolver = {
+  async marketplaceProductAttributes(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(MarketplaceProductAttribute).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/update-marketplace-product-attribute.ts

@@ -0,0 +1,18 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const updateMarketplaceProductAttribute = {
+  async updateMarketplaceProductAttribute(_: any, { name, patch }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceProductAttribute)
+    const marketplaceProductAttribute = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...marketplaceProductAttribute,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-attribute/update-multiple-marketplace-product-attribute.ts

@@ -0,0 +1,44 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductAttribute } from '../../../entities'
+
+export const updateMultipleMarketplaceProductAttribute = {
+  async updateMultipleMarketplaceProductAttribute(_: any, { patches }, context: ResolverContext) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const marketplaceProductAttributeRepo = getRepository(MarketplaceProductAttribute)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceProductAttributeRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceProductAttribute = await marketplaceProductAttributeRepo.findOneBy({ id: newRecord.id })
+
+        const result = await marketplaceProductAttributeRepo.save({
+          ...marketplaceProductAttribute,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/create-marketplace-product-category.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const createMarketplaceProductCategory = {
+  async createMarketplaceProductCategory(_: any, { marketplaceProductCategory }, context: ResolverContext) {
+    return await getRepository(MarketplaceProductCategory).save({
+      ...marketplaceProductCategory,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/delete-marketplace-product-categories.ts

@@ -0,0 +1,17 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const deleteMarketplaceProductCategories = {
+  async deleteMarketplaceProductCategories(_: any, { names }, context: ResolverContext) {
+    const { domain } = context.state
+
+    await getRepository(MarketplaceProductCategory).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/delete-marketplace-product-category.ts

@@ -0,0 +1,10 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const deleteMarketplaceProductCategory = {
+  async deleteMarketplaceProductCategory(_: any, { name }, context: ResolverContext) {
+    await getRepository(MarketplaceProductCategory).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/index.ts

@@ -0,0 +1,22 @@
+import { marketplaceProductCategoryResolver } from './marketplace-product-category'
+import { marketplaceProductCategoriesResolver } from './marketplace-product-categories'
+
+import { updateMarketplaceProductCategory } from './update-marketplace-product-category'
+import { updateMultipleMarketplaceProductCategory } from './update-multiple-marketplace-product-category'
+import { createMarketplaceProductCategory } from './create-marketplace-product-category'
+import { deleteMarketplaceProductCategory } from './delete-marketplace-product-category'
+import { deleteMarketplaceProductCategories } from './delete-marketplace-product-categories'
+
+export const MarketplaceProductCategoryResolver = {
+  Query: {
+    ...marketplaceProductCategoriesResolver,
+    ...marketplaceProductCategoryResolver
+  },
+  Mutation: {
+    ...updateMarketplaceProductCategory,
+    ...updateMultipleMarketplaceProductCategory,
+    ...createMarketplaceProductCategory,
+    ...deleteMarketplaceProductCategory,
+    ...deleteMarketplaceProductCategories
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/marketplace-product-categories.ts

@@ -0,0 +1,14 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const marketplaceProductCategoriesResolver = {
+  async marketplaceProductCategories(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(MarketplaceProductCategory).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/marketplace-product-category.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const marketplaceProductCategoryResolver = {
+  async marketplaceProductCategory(_: any, { name }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceProductCategory)
+
+    return await getRepository(MarketplaceProductCategory).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/update-marketplace-product-category.ts

@@ -0,0 +1,18 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const updateMarketplaceProductCategory = {
+  async updateMarketplaceProductCategory(_: any, { name, patch }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceProductCategory)
+    const marketplaceProductCategory = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...marketplaceProductCategory,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-category/update-multiple-marketplace-product-category.ts

@@ -0,0 +1,44 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductCategory } from '../../../entities'
+
+export const updateMultipleMarketplaceProductCategory = {
+  async updateMultipleMarketplaceProductCategory(_: any, { patches }, context: ResolverContext) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const marketplaceProductCategoryRepo = getRepository(MarketplaceProductCategory)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceProductCategoryRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceProductCategory = await marketplaceProductCategoryRepo.findOneBy({ id: newRecord.id })
+
+        const result = await marketplaceProductCategoryRepo.save({
+          ...marketplaceProductCategory,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/create-marketplace-product-variation.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const createMarketplaceProductVariationResolver = {
+  async createMarketplaceProductVariation(_: any, { marketplaceProductVariation }, context: ResolverContext) {
+    return await getRepository(MarketplaceProductVariation).save({
+      ...marketplaceProductVariation,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/delete-marketplace-product-variation.ts

@@ -0,0 +1,10 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const deleteMarketplaceProductVariationResolver = {
+  async deleteMarketplaceProductVariation(_: any, { name }, context: ResolverContext) {
+    await getRepository(MarketplaceProductVariation).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/delete-marketplace-product-variations.ts

@@ -0,0 +1,17 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const deleteMarketplaceProductVariationsResolver = {
+  async deleteMarketplaceProductVariations(_: any, { names }, context: ResolverContext) {
+    const { domain } = context.state
+
+    await getRepository(MarketplaceProductVariation).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}