@things-factory/product-base 8.0.0-beta.9 → 8.0.2

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

@@ -0,0 +1,336 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, In, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import {
+  Bizplace,
+  getCompaniesBizplaces,
+  getCompanyBizplace,
+  getMyBizplace,
+  getPartnersCompanyBizplaces,
+  getPermittedBizplaceIds
+} from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { buildCondition, Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from './product'
+import { ProductList } from './product-types'
+
+const debug = require('debug')('things-factory:product-base:product')
+
+@Resolver(Product)
+export class ProductQuery {
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Product)
+  async product(@Arg('sku') sku: string, @Ctx() context: ResolverContext): Promise<Product> {
+    const { domain, user, bizplace } = context.state
+
+    if (bizplace) {
+      return await getRepository(Product).findOne({
+        where: {
+          domain: { id: domain.id },
+          sku,
+          bizplace: { id: bizplace.id }
+        },
+        relations: ['domain', 'bizplace', 'productRef', 'creator', 'updater']
+      })
+    } else {
+      return await getRepository(Product).findOne({
+        where: {
+          domain: { id: domain.id },
+          sku,
+          bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
+        },
+        relations: ['domain', 'bizplace', 'productRef', 'creator', 'updater']
+      })
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Product)
+  async productById(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Product> {
+    const { domain, user } = context.state
+    return await getRepository(Product).findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'bizplace', 'productRef', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProductList)
+  async products(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ProductList> {
+    const { domain, user } = context.state
+    const { domains }: { domains: Domain[] } = user as any /* TODO clarify this */
+    let bizplaces: Bizplace[]
+
+    if (!params.filters.find((filter: any) => filter.name === 'bizplace_id')) {
+      const warehouseDomain: Domain = domain
+      const companiesBizplaces: Bizplace[] = await getCompaniesBizplaces(domains, warehouseDomain)
+      const partnersCompanyBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(domain, user)
+
+      bizplaces = [...companiesBizplaces, ...partnersCompanyBizplaces]
+    } else {
+      const bizplaceId: string[] = params.filters.filter(param => param.name == 'bizplace_id').map(item => item.value)
+
+      const foundBizplace: Bizplace = await getRepository(Bizplace).findOne({
+        where: { id: bizplaceId[0] },
+        relations: ['company', 'company.domain']
+      })
+
+      if (foundBizplace) {
+        const companyDomain: Domain = foundBizplace.company?.domain
+        const companyBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { domain: { id: companyDomain.id } }
+        })
+
+        bizplaces = [companyBizplace, foundBizplace]
+      }
+    }
+
+    const qb: SelectQueryBuilder<Product> = buildCustomConditions(params, context, bizplaces)
+
+    let [items, total] = await qb
+      .leftJoinAndSelect('Product.productDetails', 'ProductDetails')
+      .leftJoinAndSelect('ProductDetails.childProductDetail', 'ChildProductDetail')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProductList)
+  async myBizplaceProducts(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+      const bizplaceFilter = params.filters.find(filter => filter.name === 'bizplace_id')
+
+      let bizplaces: Bizplace[] = []
+      if (!bizplaceFilter) {
+        bizplaces.push(await getRepository(Bizplace).findOne({ where: { domain: { id: domain.id } } }))
+      }
+
+      const qb: SelectQueryBuilder<Product> = buildCustomConditions(params, context, bizplaces)
+
+      let [items, total] = await qb
+        .leftJoinAndSelect('Product.productDetails', 'ProductDetails')
+        .leftJoinAndSelect('Product.routing', 'Routing')
+        .getManyAndCount()
+
+      items = items.map(itm => {
+        let defaultProductDetail = itm.productDetails.find(itm => itm.isDefault)
+        return {
+          ...itm,
+          ...new ProductDetail(defaultProductDetail, true)
+        }
+      })
+
+      return { items, total }
+    } catch (error) {
+      logger.error(`product-query[myBizplaceProducts]: ${error}`)
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProductList)
+  async productsByBizplace(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductList> {
+    const { domain, user } = context.state
+    const bizplaceFilter = params.filters.find(x => x.name == 'bizplace')
+
+    try {
+      let bizplaces: Bizplace[]
+      if (!bizplaceFilter || bizplaceFilter.value == '') {
+        bizplaces = [await getMyBizplace(domain, user), await getCompanyBizplace(domain, user)]
+      } else {
+        let myBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { id: bizplaceFilter.value },
+          relations: ['company', 'company.domain']
+        })
+
+        bizplaces = [
+          myBizplace,
+          await getRepository(Bizplace).findOne({
+            where: { domain: { id: myBizplace.company.domain.id } }
+          })
+        ]
+      }
+
+      const qb: SelectQueryBuilder<Product> = buildCustomConditions(params, context, bizplaces)
+
+      let [items, total] = await qb.leftJoinAndSelect('Product.productDetails', 'ProductDetails').getManyAndCount()
+
+      items = items.map(itm => {
+        let defaultProductDetail = itm.productDetails?.find(itm => itm.isDefault)
+        return {
+          ...itm,
+          ...new ProductDetail(defaultProductDetail, true)
+        }
+      })
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  /**
+   * @description this resolver was specially made to return huge products data
+   * without dropping off performance due to typegraphql limitations
+   * @returns pure product data only. there will be no other table joined to avoid
+   * ORM lagging issue (converting to object extremely withdraws the performance)
+   * */
+  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProductList)
+  async pureProductsByBizplace(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductList> {
+    const { domain, user } = context.state
+    const bizplaceFilter = params.filters.find(x => x.name == 'bizplace')
+
+    try {
+      let bizplaces: Bizplace[]
+      if (!bizplaceFilter || bizplaceFilter.value == '') {
+        bizplaces = [await getMyBizplace(domain, user), await getCompanyBizplace(domain, user)]
+      } else {
+        let myBizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { id: bizplaceFilter.value },
+          relations: ['company', 'company.domain']
+        })
+
+        bizplaces = [
+          myBizplace,
+          await getRepository(Bizplace).findOne({
+            where: { domain: { id: myBizplace.company.domain.id } }
+          })
+        ]
+      }
+
+      const qb: SelectQueryBuilder<Product> = buildCustomConditions(params, context, bizplaces)
+      let items = await (await qb.getRawMany()).map(item => new Product(item))
+      let total = await qb.getCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() product: Product): Promise<Domain> {
+    if (product.domainId) return await getRepository(Domain).findOneBy({ id: product.domainId })
+    else return null
+  }
+
+  @FieldResolver(type => Bizplace)
+  async bizplace(@Root() product: Product): Promise<Bizplace> {
+    if (product.bizplaceId) return await getRepository(Bizplace).findOneBy({ id: product.bizplaceId })
+    else return null
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() product: Product): Promise<User> {
+    if (product.creatorId) return await getRepository(User).findOneBy({ id: product.creatorId })
+    else return null
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() product: Product): Promise<User> {
+    if (product.updaterId) return await getRepository(User).findOneBy({ id: product.updaterId })
+    else return null
+  }
+
+  @FieldResolver(type => Product)
+  async parentProductRef(@Root() product: Product): Promise<Product> {
+    if (product.parentProductRefId) return await getRepository(Product).findOneBy({ id: product.parentProductRefId })
+    else return null
+  }
+
+  @FieldResolver(type => Product)
+  async productRef(@Root() product: Product): Promise<Product> {
+    if (product.productRefId) return await getRepository(Product).findOneBy({ id: product.productRefId })
+    else return null
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() product: Product): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: product.domainId },
+        refBy: product.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => String)
+  productInformation(@Root() product: Product): String {
+    return `[${product.sku}] ${product.name}${product.description ? ` - ${product.description}` : ''}`
+  }
+
+  @FieldResolver(type => String, { nullable: true })
+  async warehouseName(@Root() product: Product): Promise<String | undefined> {
+    if (!product.warehouseId) return null
+
+    const items = await getRepository(Product).query(`
+      SELECT w.name as "warehouseName" FROM products p LEFT JOIN warehouses w ON p.warehouse_id::uuid = w.id and w.domain_id = p.domain_id WHERE p.id = '${product.id}'
+    `)
+
+    return items[0].warehouseName || null
+  }
+}
+
+function buildCustomConditions(params, context, bizplaces): SelectQueryBuilder<Product> {
+  const deletedFilter = params.filters.find(x => x.name == 'deleted')
+  const productFilters = params.filters.find(x => x.name == 'product_info')
+  const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
+
+  try {
+    params.filters = [
+      ...params.filters.filter(x => ['product_info', 'bizplace', 'bizplaceId', 'deleted'].indexOf(x.name) == -1),
+      { name: 'deletedAt', operator: deletedFilter?.value ? 'is_not_null' : 'is_null' },
+      { name: 'bizplaceId', operator: 'in', value: bizplaces.map(bizplace => bizplace.id) }
+    ]
+  } catch (err) {
+    // error with no bizplace.
+    debug('[WARN] params.filters', err.message)
+  }
+
+  const qb = getQueryBuilderFromListParams({
+    repository: getRepository(Product),
+    alias: 'Product',
+    params,
+    domain: context.domain,
+    searchables: ['sku', 'name', 'description']
+  })
+
+  if (productFilters) {
+    qb.andWhere(
+      new Brackets(qb2 => {
+        productFilterColumns.forEach(filter => {
+          const condition = buildCondition(
+            qb.alias,
+            filter,
+            productFilters.operator,
+            productFilters.value,
+            productFilters.relation,
+            Object.keys(qb.getParameters()).length
+          )
+
+          qb2.orWhere(condition.clause, condition.parameters)
+        })
+      })
+    )
+  }
+
+  return qb
+}