@things-factory/sales-base 8.0.0-beta.1 → 8.0.0-beta.4

package/server/service/retail-replenishment-order/retail-replenishment-order-mutation.ts

@@ -1,382 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import {
-  NewOrderProduct,
-  NewRetailReplenishmentOrder,
-  OrderProduct,
-  OrderVas,
-  RetailReplenishmentOrderPatch
-} from '../'
-import {
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  TRANSFER_ORDER_TYPE
-} from '../../constants'
-import { OrderNoGenerator } from '../../utils'
-import { generateTransferOrder } from '../transfer-order/transfer-order-mutation'
-import { RetailReplenishmentOrder } from './retail-replenishment-order'
-
-@Resolver(RetailReplenishmentOrder)
-export class RetailReplenishmentOrderMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async addRetailReplenishmentOrderProducts(
-    @Arg('sroNo') sroNo: string,
-    @Arg('orderProducts', type => [NewOrderProduct]) orderProducts: NewOrderProduct[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx, user, domain } = context.state
-    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .findOne({
-        where: { name: sroNo },
-        relations: ['bizplace', 'orderProducts']
-      })
-
-    await addRetailReplenishmentOrderProducts(domain, retailReplenishmentOrder, orderProducts, user, tx)
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => RetailReplenishmentOrder)
-  async cancelRetailReplenishmentOrder(
-    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder> {
-    const { tx, domain, user } = context.state
-    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-
-    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .findOne({
-        where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, name: patch.name },
-        relations: ['orderProducts']
-      })
-
-    if (!retailReplenishmentOrder) throw new Error(`Retail replenishment order does not exist.`)
-    if (!patch.status) throw new Error('Status was not specified.')
-    // if (status && (status !== ORDER_STATUS.PENDING_CANCEL || status !== ORDER_STATUS.CANCELLED))
-    //   throw new Error(`Status provided was invalid.`)
-
-    let foundOPs: OrderProduct[] = retailReplenishmentOrder.orderProducts
-
-    // 1. Update status of order products based on status (to PENDING_CANCEL or CANCELLED)
-    if (foundOPs && foundOPs.length) {
-      foundOPs = foundOPs.map((orderProduct: OrderProduct) => {
-        orderProduct.status = patch.status
-        orderProduct.updater = user
-        return orderProduct
-      })
-    }
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 2. Update retail replenishment order status
-    return await tx.getRepository(RetailReplenishmentOrder).save({
-      ...retailReplenishmentOrder,
-      remark: patch.remark, //think another way if warehouse confirm cancellation > no need to overwrite remark
-      status: patch.status,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => RetailReplenishmentOrder)
-  async createRetailReplenishmentOrder(
-    @Arg('retailReplenishmentOrder', type => NewRetailReplenishmentOrder)
-    retailReplenishmentOrder: NewRetailReplenishmentOrder,
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder> {
-    const { tx, domain, user } = context.state
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    let orderVass: OrderVas[] = retailReplenishmentOrder.orderVass as any
-    const myBizplace: Bizplace = await getOutletBizplace(retailReplenishmentOrder.warehouseId)
-
-    // #1 check for allocated qty to identify the status: APPROVED or PENDING
-    const allocatedQty: number = null
-    let status = allocatedQty ? ORDER_STATUS.PENDING : ORDER_STATUS.APPROVED
-    let remark = allocatedQty ? 'INSUFFICIENT QTY' : ''
-
-    let orderProducts: NewOrderProduct[] = retailReplenishmentOrder.orderProducts
-    orderProducts = orderProducts.map((op: NewOrderProduct) => {
-      return {
-        ...op,
-        status: allocatedQty ? ORDER_PRODUCT_STATUS.PENDING : ORDER_PRODUCT_STATUS.APPROVED,
-        remark
-      }
-    })
-
-    const rrNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain: { id: domain.id },
-        name: ORDER_NUMBER_SETTING_KEY.RR_NUMBER_RULE
-      }
-    })
-
-    let orderNo: string = ''
-
-    if (rrNoSetting) {
-      orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RR_NUMBER, seed: {} })
-    } else {
-      orderNo = OrderNoGenerator.retailReplenishmentOrder()
-    }
-
-    // #2 Create Retail Replenishment Order
-    const createdRetailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .save({
-        ...retailReplenishmentOrder,
-        name: orderNo,
-        bizplace: myBizplace,
-        status,
-        domain,
-        creator: user,
-        updater: user
-      })
-
-    // #3 Create retail replenishment order products
-    await addRetailReplenishmentOrderProducts(domain, createdRetailReplenishmentOrder, orderProducts, user, tx)
-
-    // #4 generate transfer order if status is APPROVED
-    if (createdRetailReplenishmentOrder.status === ORDER_STATUS.APPROVED) {
-      const issuedDate: string = retailReplenishmentOrder.issuedDate
-      const remark: string = retailReplenishmentOrder.remark
-      const refNo: string = retailReplenishmentOrder.refNo
-      const ownTransport: boolean = retailReplenishmentOrder.ownTransport
-      const orderInventories: any[] = orderProducts.map((op: NewOrderProduct) => {
-        return {
-          batchId: op.batchId,
-          releaseQty: op.packQty,
-          product: op.product,
-          packingType: op.packingType
-        }
-      })
-
-      await generateTransferOrder(
-        {
-          issuedDate,
-          remark,
-          refNo,
-          type: TRANSFER_ORDER_TYPE.NORMAL,
-          ownTransport,
-          orderInventories,
-          orderVass,
-          bizplace: myBizplace,
-          retailReplenishmentOrder: createdRetailReplenishmentOrder
-        } as any,
-        domain,
-        user,
-        tx
-      )
-    }
-
-    return createdRetailReplenishmentOrder
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => RetailReplenishmentOrder)
-  async completeRetailReplenishmentOrder(
-    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder> {
-    const { tx, domain, user } = context.state
-
-    const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-    let targetOPs: NewOrderProduct[] = patch.orderProducts
-    let partialReceived: Boolean = false
-
-    // #1 Find Retail Replenishment Order
-    const foundRRO: RetailReplenishmentOrder = await tx.getRepository(RetailReplenishmentOrder).findOne({
-      where: { domain: { id: domain.id }, name: patch.name, bizplace: { id: myBizplace.id } },
-      relations: ['orderProducts']
-    })
-
-    if (!foundRRO) throw new Error(`Retail replenishment order does not exist.`)
-
-    if (foundRRO?.status && foundRRO.status === ORDER_STATUS.RECEIVED)
-      throw new Error(`Retail replenishment order is already completed.`)
-
-    // #2 Find related order inventories
-    let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-      where: { domain: { id: domain.id } /* CONFIRMME regarding TYPEORM , transferOrder: foundRRO */ }
-    })
-    if (!foundOPs) throw new Error(`Order products were not found.`)
-
-    foundOPs = foundOPs.map((orderProduct: OrderProduct) => {
-      const foundTargetOP = targetOPs.filter(
-        (targetOP: NewOrderProduct) => targetOP.name === orderProduct.name && targetOP.batchId === orderProduct.batchId
-      )[0]
-
-      orderProduct.status = foundTargetOP.status
-      orderProduct.remark = foundTargetOP?.remark ? foundTargetOP.remark : null
-      if (orderProduct.status.includes(ORDER_PRODUCT_STATUS.NOT_RECEIVED)) partialReceived = true
-      orderProduct.updater = user
-
-      return orderProduct
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // #3 Update status of retail replenishment order (RECEIVED / PARTIALLY_RECEIVED)
-    return await tx.getRepository(RetailReplenishmentOrder).save({
-      ...foundRRO,
-      status: partialReceived ? ORDER_STATUS.PARTIAL_RECEIVED : ORDER_STATUS.RECEIVED,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => RetailReplenishmentOrder)
-  async updateRetailReplenishmentOrder(
-    @Arg('name') name: string,
-    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder> {
-    const { tx, domain, user } = context.state
-
-    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-    const repository = tx.getRepository(RetailReplenishmentOrder)
-
-    delete patch.warehouseId //exclude warehouse Id from patch
-
-    const retailReplenishmentOrder = await repository.findOne({
-      where: { domain: { id: domain.id }, name, bizplace: { id: bizplace.id } },
-      relations: ['orderProducts', 'orderProducts.product']
-    })
-
-    if (!retailReplenishmentOrder) throw new Error(`Retail replenishment order is not found.`)
-    if (retailReplenishmentOrder && retailReplenishmentOrder.status !== ORDER_STATUS.REJECTED)
-      throw new Error(`You are not allowed to update this order with status: ${retailReplenishmentOrder.status}`)
-
-    return await repository.save({
-      ...retailReplenishmentOrder,
-      ...patch,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [RetailReplenishmentOrder])
-  async updateMultipleRetailReplenishmentOrder(
-    @Arg('patches', type => [RetailReplenishmentOrderPatch]) patches: RetailReplenishmentOrderPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder[]> {
-    const { tx, domain, user } = context.state
-
-    let results: RetailReplenishmentOrder[] = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const retailReplenishmentOrderRepo = tx.getRepository(RetailReplenishmentOrder)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await retailReplenishmentOrderRepo.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 retailReplenishmentOrder = await retailReplenishmentOrderRepo.findOneBy({ id: newRecord.id })
-
-        const result = await retailReplenishmentOrderRepo.save({
-          ...retailReplenishmentOrder,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteRetailReplenishmentOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx, domain } = context.state
-    await tx.getRepository(RetailReplenishmentOrder).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteRetailReplenishmentOrders(
-    @Arg('names', type => [String]) names: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx, domain } = context.state
-    await tx.getRepository(RetailReplenishmentOrder).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-    return true
-  }
-}
-export async function addRetailReplenishmentOrderProducts(
-  domain: Domain,
-  retailReplenishmentOrder: RetailReplenishmentOrder,
-  orderProducts: (OrderProduct | NewOrderProduct)[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  if (!retailReplenishmentOrder?.bizplace || !retailReplenishmentOrder?.orderProducts?.length) {
-    retailReplenishmentOrder = await tx.getRepository(RetailReplenishmentOrder).findOne({
-      where: { id: retailReplenishmentOrder.id },
-      relations: ['bizplace', 'orderProducts']
-    })
-  }
-
-  orderProducts = await Promise.all(
-    orderProducts.map(async (op: OrderProduct) => {
-      const foundProduct = await productRepo.findOneBy({
-        domain: { id: domain.id },
-        sku: op.product.sku,
-        name: op.product.name
-      })
-      if (!foundProduct) throw new Error(`Product ${op.product.name} (${op.product.sku}) is not exist.`)
-
-      return {
-        ...op,
-        domain,
-        bizplace: retailReplenishmentOrder.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: foundProduct,
-        retailReplenishmentOrder,
-        //========= need to revise ===========
-        packingType: foundProduct.packingType,
-        uom: foundProduct.weightUnit,
-        uomValue: foundProduct.weight,
-        totalUomValue: `${(foundProduct.weight * op.packQty).toFixed(2)} ${foundProduct.weightUnit}`,
-        //====================================
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  await orderProductRepo.save(orderProducts)
-}

package/server/service/retail-replenishment-order/retail-replenishment-order-query.ts

@@ -1,54 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { RetailReplenishmentOrderList } from '../'
-import { RetailReplenishmentOrder } from './retail-replenishment-order'
-
-@Resolver(RetailReplenishmentOrder)
-export class RetailReplenishmentOrderQuery {
-  @Query(returns => RetailReplenishmentOrderList)
-  async retailReplenishmentOrders(
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<RetailReplenishmentOrderList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    const [items, total] = await getRepository(RetailReplenishmentOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'orderProducts', 'orderProducts.product', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-
-  @Query(returns => RetailReplenishmentOrder)
-  async retailReplenishmentOrder(
-    @Arg('name') name: string,
-    @Ctx() context: ResolverContext
-  ): Promise<RetailReplenishmentOrder> {
-    const { domain } = context.state
-
-    const repository = getRepository(RetailReplenishmentOrder)
-
-    return await repository.findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'orderProducts', 'orderProducts.product', 'creator', 'updater']
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() retailReplenishmentOrder: RetailReplenishmentOrder): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: retailReplenishmentOrder.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() retailReplenishmentOrder: RetailReplenishmentOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: retailReplenishmentOrder.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() retailReplenishmentOrder: RetailReplenishmentOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: retailReplenishmentOrder.updaterId })
-  }
-}

package/server/service/retail-replenishment-order/retail-replenishment-order-types.ts

@@ -1,101 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { NewOrderProduct } from '../order-product/order-product-types'
-import { RetailReplenishmentOrder } from './retail-replenishment-order'
-
-@ObjectType()
-export class RetailReplenishmentOrderList {
-  @Field(type => [RetailReplenishmentOrder], { nullable: true })
-  items: RetailReplenishmentOrder[]
-
-  @Field(type => Int, { nullable: false })
-  total: number
-}
-
-@InputType()
-export class NewRetailReplenishmentOrder {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  refNo: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  ownTransport: boolean
-  @Field({ nullable: true })
-  truckNo: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field(type => [ObjectRef], { nullable: true })
-  orderVass: ObjectRef[]
-
-  @Field(type => [NewOrderProduct], { nullable: true })
-  orderProducts: NewOrderProduct[]
-
-  @Field(type => ObjectRef, { nullable: true })
-  deliveryOrder: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  transferOrder: ObjectRef
-
-  @Field({ nullable: true })
-  issuedDate: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  warehouseId: string // outletID
-}
-
-@InputType()
-export class RetailReplenishmentOrderPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  warehouseId: string // outletID
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  refNo: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  ownTransport: boolean
-  @Field({ nullable: true })
-  truckNo: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderVass: [ObjectRef]
-
-  @Field(type => [NewOrderProduct], { nullable: true })
-  orderProducts: [NewOrderProduct]
-
-  @Field(type => ObjectRef, { nullable: true })
-  deliveryOrder: [ObjectRef]
-
-  @Field(type => ObjectRef, { nullable: true })
-  transferOrder: ObjectRef
-
-  @Field({ nullable: true })
-  issuedDate: string
-
-  @Field({ nullable: true })
-  cuFlag: string
-}

package/server/service/retail-replenishment-order/retail-replenishment-order.ts

@@ -1,115 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-import { DeliveryOrder, OrderProduct, OrderVas } from '../'
-
-@Entity()
-@Index(
-  'ix_retail_replenishment_order_0',
-  (retailReplenishmentOrder: RetailReplenishmentOrder) => [
-    retailReplenishmentOrder.domain,
-    retailReplenishmentOrder.name
-  ],
-  { unique: true }
-)
-@ObjectType()
-export class RetailReplenishmentOrder {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain: Domain
-
-  @RelationId((retailRepOrder: RetailReplenishmentOrder) => retailRepOrder.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @ManyToOne(type => Bizplace)
-  @Field(type => Bizplace, { nullable: true })
-  bizplace: Bizplace
-
-  @RelationId((retailRepOrder: RetailReplenishmentOrder) => retailRepOrder.bizplace)
-  bizplaceId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refNo: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  remark: string
-
-  @Column({ default: false })
-  @Field()
-  ownTransport: Boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  truckNo: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @OneToMany(type => OrderVas, orderVas => orderVas.retailReplenishmentOrder)
-  @Field(type => [OrderVas], { nullable: true })
-  orderVass: OrderVas[]
-
-  @OneToMany(type => OrderProduct, orderProduct => orderProduct.retailReplenishmentOrder)
-  @Field(type => [OrderProduct], { nullable: true })
-  orderProducts: OrderProduct[]
-
-  @OneToMany(type => DeliveryOrder, deliveryOrder => deliveryOrder.retailReplenishmentOrder)
-  @Field(type => [DeliveryOrder], { nullable: true })
-  deliveryOrders: DeliveryOrder[]
-
-  @Column({ type: 'date' })
-  @Field()
-  issuedDate: Date
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((retailRepOrder: RetailReplenishmentOrder) => retailRepOrder.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((retailRepOrder: RetailReplenishmentOrder) => retailRepOrder.updater)
-  updaterId: string
-
-  @Field({ nullable: true })
-  cuFlag: string
-}

package/server/service/return-order/index.ts

@@ -1,9 +0,0 @@
-import { ReturnOrder } from './return-order'
-import { ReturnOrderMutation } from './return-order-mutation'
-import { ReturnOrderQuery } from './return-order-query'
-
-export const entities = [ReturnOrder]
-export const resolvers = [ReturnOrderQuery, ReturnOrderMutation]
-
-export * from './return-order-mutation'
-export * from './return-order-query'