@things-factory/product-base 8.0.0-beta.1 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/product-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,9 +24,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/biz-base": "^8.0.0-beta.1",
-    "@things-factory/env": "^8.0.0-beta.1",
-    "@things-factory/routing-base": "^8.0.0-beta.1"
+    "@things-factory/biz-base": "^8.0.0-beta.2",
+    "@things-factory/env": "^8.0.0-beta.2",
+    "@things-factory/routing-base": "^8.0.0-beta.2"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/constants/index.ts

@@ -1 +0,0 @@
-export * from './product'

package/server/constants/product.ts

@@ -1,24 +0,0 @@
-export const PRODUCT_STATUS = {
-  ACTIVE: 'ACTIVE',
-  DELETED: 'DELETED',
-  INACTIVE: 'INACTIVE'
-}
-
-export const PRODUCT_SET_STATUS = {
-  ACTIVE: 'ACTIVE',
-  DELETED: 'DELETED',
-  INACTIVE: 'INACTIVE'
-}
-
-export const PRODUCT_BUNDLE_STATUS = {
-  ACTIVE: 'ACTIVE',
-  DELETED: 'DELETED',
-  INACTIVE: 'INACTIVE'
-}
-
-export const PRODUCT_COMBINATION_STATUS = {
-  ACTIVE: 'ACTIVE',
-  ACTIVATED: 'ACTIVATED',
-  DELETED: 'DELETED',
-  INACTIVE: 'INACTIVE'
-}

package/server/index.ts

@@ -1,2 +0,0 @@
-export * from './service'
-export * from './migrations'

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-const glob = require('glob')
-const path = require('path')
-
-export var migrations = []
-
-glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
-  if (file.indexOf('index.js') !== -1) return
-  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
-})

package/server/service/index.ts

@@ -1,61 +0,0 @@
-import { entities as ProductEntities, resolvers as ProductResolvers } from './product'
-import { entities as ProductBundleEntities, resolvers as ProductBundleResolvers } from './product-bundle'
-import {
-  entities as ProductBundleSettingEntities,
-  resolvers as ProductBundleSettingResolvers
-} from './product-bundle-setting'
-import { entities as ProductDetailEntities, resolvers as ProductDetailResolvers } from './product-detail'
-import {
-  entities as ProductDetailBizplaceSettingEntities,
-  resolvers as ProductDetailBizplaceSettingResolver
-} from './product-detail-bizplace-setting'
-import { entities as ProductSetEntities, resolvers as ProductSetResolvers } from './product-set'
-import { entities as ProductCombinationEntities, resolvers as ProductCombinationResolvers } from './product-combination'
-import {
-  entities as ProductCombinationSettingEntities,
-  resolvers as ProductCombinationSettingResolvers
-} from './product-combination-setting'
-
-/* EXPORT ENTITY TYPES */
-export * from './product-combination-setting/product-combination-setting'
-export * from './product-combination/product-combination'
-export * from './product/product'
-export * from './product-detail/product-detail'
-export * from './product-bundle/product-bundle'
-export * from './product-bundle-setting/product-bundle-setting'
-export * from './product-detail-bizplace-setting/product-detail-bizplace-setting'
-export * from './product-set/product-set'
-
-/* EXPORT TYPES */
-export * from './product-combination/product-combination-type'
-export * from './product-combination-setting/product-combination-setting-type'
-export * from './product/product-types'
-export * from './product-detail/product-detail-types'
-export * from './product-bundle/product-bundle-types'
-export * from './product-bundle-setting/product-bundle-setting-types'
-export * from './product-detail-bizplace-setting/product-detail-bizplace-setting-types'
-export * from './product-set/product-set-types'
-
-export const entities = [
-  ...ProductEntities,
-  ...ProductDetailEntities,
-  ...ProductBundleEntities,
-  ...ProductBundleSettingEntities,
-  ...ProductDetailBizplaceSettingEntities,
-  ...ProductSetEntities,
-  ...ProductCombinationEntities,
-  ...ProductCombinationSettingEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    ...ProductResolvers,
-    ...ProductDetailResolvers,
-    ...ProductBundleResolvers,
-    ...ProductBundleSettingResolvers,
-    ...ProductDetailBizplaceSettingResolver,
-    ...ProductSetResolvers,
-    ...ProductCombinationResolvers,
-    ...ProductCombinationSettingResolvers
-  ]
-}

package/server/service/product/index.ts

@@ -1,6 +0,0 @@
-import { Product } from './product'
-import { ProductMutation } from './product-mutation'
-import { ProductQuery } from './product-query'
-
-export const entities = [Product]
-export const resolvers = [ProductQuery, ProductMutation]

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

@@ -1,407 +0,0 @@
-import promisesAll from 'promises-all'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In, Repository } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { getRepository } from '@things-factory/shell'
-
-import { PRODUCT_STATUS } from '../../constants'
-import { ProductDetail } from '../product-detail/product-detail'
-import {
-  createProductDetail,
-  updateMultipleProductDetail,
-  updateProductDetail
-} from '../product-detail/product-detail-mutation'
-import { ProductSet } from '../product-set/product-set'
-import { Product } from './product'
-import { NewProduct, ProductPatch } from './product-types'
-import { validateProduct } from './validate-product'
-
-@Resolver(Product)
-export class ProductMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Product)
-  async createProduct(@Arg('product') product: NewProduct, @Ctx() context: ResolverContext): Promise<Product> {
-    return await createProduct(product, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Product])
-  async createProducts(
-    @Arg('products', type => [NewProduct]) products: NewProduct[],
-    @Ctx() context: ResolverContext
-  ): Promise<Product[]> {
-    return await createProducts(products, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Product)
-  async updateProduct(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ProductPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Product> {
-    return await updateProduct(id, patch, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Product])
-  async importMultipleProduct(
-    @Arg('patches', type => [ProductPatch]) patches: ProductPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Product[]> {
-    try {
-      let results = []
-
-      //// 1. Group and massage data based on sku for Product and Product Details.
-      let massagedPatch = patches.reduce(function (acc, currentObj) {
-        let existingParent = acc.find(itm => itm.sku == currentObj.sku)
-        if (existingParent) {
-          existingParent.productDetails = [
-            ...existingParent.productDetails,
-            new ProductDetail({ ...currentObj, childProductDetail: currentObj.childGtin })
-          ]
-          return acc
-        } else {
-          let newProduct = {
-            ...currentObj,
-            productDetails: [
-              new ProductDetail({ ...currentObj, childProductDetail: currentObj.childGtin, isDefault: true })
-            ]
-          }
-          return [...acc, newProduct]
-        }
-      }, [])
-
-      //// 2. Update all Grouped Product data and Product Details Data
-      for (let i = 0; i < massagedPatch.length; i++) {
-        const patch: Product = massagedPatch[i]
-        const result = await createProduct(patch, context)
-        results.push({ ...result, cuFlag: '+' })
-      }
-
-      return results
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Product])
-  async updateMultipleProduct(
-    @Arg('patches', type => [ProductPatch]) patches: ProductPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Product[]> {
-    try {
-      let results = []
-      const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-      const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-      if (_createRecords.length > 0) {
-        for (let i = 0; i < _createRecords.length; i++) {
-          const patch: NewProduct = _createRecords[i]
-          const result = await createProduct(patch, context)
-          results.push({ ...result, cuFlag: '+' })
-        }
-      }
-
-      if (_updateRecords.length > 0) {
-        for (let i = 0; i < _updateRecords.length; i++) {
-          const patch: ProductPatch = _updateRecords[i]
-          const result = await updateProduct(patch.id, patch, context)
-          results.push({ ...result, cuFlag: 'M' })
-        }
-      }
-
-      return results
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@privilege(category: "order", privilege: "mutation") ')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async linkProduct(
-    @Arg('productSetId') productSetId: string,
-    @Arg('patches', type => [ProductPatch]) patches: ProductPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { tx } = context.state
-
-    let productSet = await tx.getRepository(ProductSet).findOne({
-      where: { id: productSetId },
-      relations: ['domain', 'creator', 'updater', 'product']
-    })
-
-    let existingProductLink: any = productSet.product
-
-    let newProductLink: Product[] = patches.reduce((acc, curr) => {
-      if (!existingProductLink.find(itm => itm.id == curr.id)) {
-        acc.push({ id: curr.id })
-      }
-      return acc
-    }, [])
-
-    let removeProductLink: Product[] = existingProductLink.reduce((acc, curr) => {
-      if (!patches.find(itm => itm.id == curr.id)) {
-        acc.push({ id: curr.id })
-      }
-      return acc
-    }, [])
-
-    if (newProductLink.length > 0) {
-      for (let i = 0; i < newProductLink.length; i++) {
-        const patch: Product = { ...newProductLink[i], productSet }
-        await updateProduct(newProductLink[i].id, patch, context)
-      }
-    }
-
-    if (removeProductLink.length > 0) {
-      for (let i = 0; i < removeProductLink.length; i++) {
-        const patch: Product = { ...removeProductLink[i], productSet: null }
-        await updateProduct(removeProductLink[i].id, patch, context)
-      }
-    }
-
-    return true
-  }
-
-  @Directive('@privilege(category: "order", privilege: "mutation") ')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteProduct(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, user, domain } = context.state
-    const productSetRepo: Repository<Product> = tx.getRepository(Product)
-    const productSet = await productSetRepo.findOneBy({ domain: { id: domain.id }, id })
-
-    await productSetRepo.save({
-      ...productSet,
-      status: PRODUCT_STATUS.DELETED,
-      updater: user
-    })
-
-    return true
-  }
-
-  @Directive('@privilege(category: "order", privilege: "mutation") ')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteProducts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, user } = context.state
-    const productRepo = tx.getRepository(Product)
-
-    await productRepo.update(
-      {
-        id: In(ids)
-      },
-      {
-        deletedAt: new Date()
-      }
-    )
-
-    return true
-  }
-
-  @Directive('@privilege(category: "order", privilege: "mutation") ')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async undeleteProducts(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { tx, user } = context.state
-    const productRepo = tx.getRepository(Product)
-
-    await productRepo.update(
-      {
-        id: In(ids)
-      },
-      {
-        deletedAt: null
-      }
-    )
-
-    return true
-  }
-}
-
-export async function createProduct(product: any, context: ResolverContext) {
-  try {
-    const { domain, user, tx } = context.state
-
-    const productRepo: Repository<Product> = tx.getRepository(Product) || getRepository(Product)
-    const bizplaceRepo: Repository<Bizplace> = tx.getRepository(Bizplace) || getRepository(Bizplace)
-
-    let bizplace: Bizplace
-    if (product.bizplace?.id) {
-      bizplace = await bizplaceRepo.findOneBy({ id: product.bizplace.id })
-    } else if (context.state?.bizplace) {
-      bizplace = context.state.bizplace
-    } else {
-      bizplace = await bizplaceRepo.findOne({ where: { domain: { id: domain.id } } })
-    }
-
-    if (product?.productRef?.id) {
-      product.productRef = await productRepo.findOneBy({ id: product.productRef.id })
-    }
-
-    if (!product?.id) delete product.id
-
-    await validateProduct(
-      {
-        ...product,
-        bizplace,
-        domain
-      },
-      context
-    )
-
-    if (product.uom) {
-      product.primaryUnit = product.uom
-    }
-
-    if (product.uomValue) {
-      product.primaryValue = product.uomValue
-    }
-
-    const result = await productRepo.save({
-      ...product,
-      bizplace,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    let productDetails = product.productDetails
-    if (!productDetails) {
-      productDetails = [new ProductDetail({ ...product, product: result, isDefault: true })]
-      if (productDetails[0].gtin == null || productDetails[0] == undefined) {
-        productDetails[0].gtin = product.sku
-      }
-    }
-
-    await updateMultipleProductDetail(result.id, productDetails, context)
-
-    if (product.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: product.thumbnail,
-            refType: Product.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  } catch (error) {
-    throw error
-  }
-}
-
-export async function createProducts(products, context: ResolverContext) {
-  const { resolve, reject } = await promisesAll.all(products.map(product => createProduct(product, context)))
-
-  if (reject.length) {
-    reject.forEach(({ name, message }) => logger.error(`${name}: ${message}`))
-
-    return reject
-  }
-
-  return resolve
-}
-
-export async function updateProduct(id: string, patch, context) {
-  try {
-    const { user, tx, domain } = context.state
-
-    const bizplaceRepo: Repository<Bizplace> = tx.getRepository(Bizplace)
-    const productRepo: Repository<Product> = tx.getRepository(Product)
-    const productDetailRepo: Repository<ProductDetail> = tx.getRepository(ProductDetail)
-
-    let product = await productRepo.findOne({ where: { id }, relations: ['domain'] })
-
-    let productDetail = await productDetailRepo.findOne({
-      where: { product: { id }, isDefault: true },
-      relations: ['domain']
-    })
-
-    if (patch.productRef && patch.productRef.id) {
-      patch.productRef = await productRepo.findOne(patch.productRef.id)
-    }
-
-    let bizplace: Bizplace
-    if (product.bizplace?.id) {
-      bizplace = await bizplaceRepo.findOneBy({ id: product.bizplace.id })
-    } else {
-      bizplace = await bizplaceRepo.findOne({ where: { name: domain.name } })
-    }
-
-    await validateProduct(
-      {
-        ...product,
-        ...patch,
-        bizplace,
-        domain
-      },
-      context
-    )
-
-    if (patch.uom) {
-      product.primaryUnit = patch.uom
-    }
-
-    if (patch.uomValue) {
-      product.primaryValue = patch.uomValue
-    }
-
-    product = await productRepo.save({
-      ...product,
-      ...patch,
-      domain,
-      updater: user
-    })
-
-    if (productDetail) {
-      if (product.gtin) {
-        delete product.gtin
-      }
-      productDetail = await updateProductDetail(
-        productDetail.id,
-        new ProductDetail({ ...product, ...patch, product }),
-        context
-      )
-    } else {
-      productDetail = await createProductDetail(
-        new ProductDetail({ ...product, ...patch, product, isDefault: true }),
-        context
-      )
-    }
-
-    const productId = id
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [productId] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: Product.name,
-            refBy: product.id
-          }
-        },
-        context
-      )
-    }
-
-    return product
-  } catch (error) {
-    throw error
-  }
-}