@things-factory/marketplace-base 8.0.7 → 9.0.0-beta.12

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

@@ -1,222 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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
-  }
-}