@things-factory/sales-base 8.0.0-beta.8 → 8.0.0

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

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

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

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

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

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