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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/routing-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "",
@@ -23,9 +23,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^8.0.0-beta.1",
-    "@things-factory/auth-base": "^8.0.0-beta.1",
-    "@things-factory/shell": "^8.0.0-beta.1"
+    "@things-factory/attachment-base": "^8.0.0-beta.2",
+    "@things-factory/auth-base": "^8.0.0-beta.2",
+    "@things-factory/shell": "^8.0.0-beta.2"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/index.ts

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

package/server/service/index.ts

@@ -1,43 +0,0 @@
-import {
-  entities as OperationEntities,
-  resolvers as OperationResolvers
-} from './operation'
-import {
-  entities as RoutingEntities,
-  resolvers as RoutingResolvers
-} from './routing'
-import {
-  entities as RoutingItemEntities,
-  resolvers as RoutingItemResolvers
-} from './routing-item'
-
-/* EXPORT ENTITY TYPES */
-export * from './routing/routing'
-export * from './routing-item/routing-item'
-export * from './operation/operation'
-
-/* EXPORT TYPES */
-export * from './routing/routing-type'
-export * from './operation/operation-type'
-export * from './routing-item/routing-item-type'
-
-/* EXPORT MUTAIONS */
-export * from './routing/routing-mutation'
-export * from './operation/operation-mutation'
-export * from './routing-item/routing-item-mutation'
-
-/* EXPORT QUERIES */
-export * from './routing/routing-query'
-export * from './operation/operation-query'
-export * from './routing-item/routing-item-query'
-
-export const entities = [
-  /* ENTITIES */
-  ...RoutingEntities,
-  ...RoutingItemEntities,
-  ...OperationEntities
-]
-
-export const schema = {
-  resolverClasses: [...RoutingResolvers, ...RoutingItemResolvers, ...OperationResolvers]
-}

package/server/service/operation/index.ts

@@ -1,9 +0,0 @@
-import { Operation } from './operation'
-import { OperationMutation } from './operation-mutation'
-import { OperationQuery } from './operation-query'
-
-export const entities = [Operation]
-export const resolvers = [OperationQuery, OperationMutation]
-
-export * from './operation-query'
-export * from './operation-mutation'

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

@@ -1,185 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
-import { Operation } from './operation'
-import { NewOperation, OperationPatch } from './operation-type'
-
-@Resolver(Operation)
-export class OperationMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Operation, { description: 'To create new Operation' })
-  async createOperation(
-    @Arg('operation') operation: NewOperation,
-    @Ctx() context: ResolverContext
-  ): Promise<Operation> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Operation).save({
-      ...operation,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (operation.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: operation.thumbnail,
-            refType: Operation.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Operation, { description: 'To modify Operation information' })
-  async updateOperation(
-    @Arg('id') id: string,
-    @Arg('patch') patch: OperationPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Operation> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Operation)
-    const operation = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...operation,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      // ?? { refBys: [operation.id] }
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: Operation.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Operation], { description: "To modify multiple Operations' information" })
-  async updateMultipleOperation(
-    @Arg('patches', type => [OperationPatch]) patches: OperationPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Operation[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const operationRepo = tx.getRepository(Operation)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await operationRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: Operation.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const operation = await operationRepo.findOneBy({ id: newRecord.id })
-
-        const result = await operationRepo.save({
-          ...operation,
-          ...newRecord,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: Operation.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Operation' })
-  async deleteOperation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Operation).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple operations' })
-  async deleteOperations(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Operation).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-}

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

@@ -1,66 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Operation } from './operation'
-import { OperationList } from './operation-type'
-
-@Resolver(Operation)
-export class OperationQuery {
-  @Query(returns => Operation, { description: 'To fetch a Operation' })
-  async operation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Operation> {
-    const { domain } = context.state
-
-    return await getRepository(Operation).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => OperationList, { description: 'To fetch multiple Operations' })
-  async operations(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<OperationList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Operation),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() operation: Operation): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: operation.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() operation: Operation): Promise<User> {
-    return await getRepository(User).findOneBy({ id: operation.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() operation: Operation): Promise<User> {
-    return await getRepository(User).findOneBy({ id: operation.creatorId })
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() operation: Operation): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: operation.domainId },
-        refBy: operation.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-}

package/server/service/operation/operation-type.ts

@@ -1,68 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { Operation } from './operation'
-
-@InputType()
-export class NewOperation {
-  @Field({ nullable: false })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  operationStdChart?: string
-
-  @Field({ nullable: true })
-  operationStdTime?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class OperationPatch {
-  @Field(type => ID, { nullable: true })
-  id!: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  operationStdChart?: string
-
-  @Field({ nullable: true })
-  operationStdTime?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class OperationList {
-  @Field(type => [Operation])
-  items: Operation[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/operation/operation.ts

@@ -1,109 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-export enum OperationStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B',
-  ASSY = 'Assembly',
-  INV = 'Inventory',
-  PACK = 'Packing',
-  SMT = 'SMT',
-  STD = 'Standard',
-  TEST = 'Test'
-}
-
-registerEnumType(OperationStatus, {
-  name: 'OperationStatus',
-  description: 'state enumeration of a operation'
-})
-
-@Entity()
-@Index('ix_operation_0', (operation: Operation) => [operation.domain, operation.name], { unique: true })
-@ObjectType({ description: 'Entity for Operation' })
-export class Operation {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { nullable: false })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: false })
-  domain: Domain
-
-  @RelationId((operation: Operation) => operation.domain)
-  domainId: string
-
-  @Column()
-  @Field({ nullable: false })
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  type?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  operationStdChart?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  operationStdTime?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((operation: Operation) => operation.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((operation: Operation) => operation.updater)
-  updaterId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-}

package/server/service/routing/index.ts

@@ -1,9 +0,0 @@
-import { Routing } from './routing'
-import { RoutingMutation } from './routing-mutation'
-import { RoutingQuery } from './routing-query'
-
-export const entities = [Routing]
-export const resolvers = [RoutingQuery, RoutingMutation]
-
-export * from './routing-query'
-export * from './routing-mutation'

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

@@ -1,110 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Routing } from './routing'
-import { NewRouting, RoutingPatch } from './routing-type'
-
-@Resolver(Routing)
-export class RoutingMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Routing, { description: 'To create new Routing' })
-  async createRouting(@Arg('routing') routing: NewRouting, @Ctx() context: ResolverContext): Promise<Routing> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Routing).save({
-      ...routing,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Routing, { description: 'To modify Routing information' })
-  async updateRouting(
-    @Arg('id') id: string,
-    @Arg('patch') patch: RoutingPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Routing> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Routing)
-    const routing = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...routing,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Routing], { description: "To modify multiple Routings' information" })
-  async updateMultipleRouting(
-    @Arg('patches', type => [RoutingPatch]) patches: RoutingPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Routing[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const routingRepo = tx.getRepository(Routing)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await routingRepo.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 routing = await routingRepo.findOneBy({ id: newRecord.id })
-
-        const result = await routingRepo.save({
-          ...routing,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Routing' })
-  async deleteRouting(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Routing).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple routings' })
-  async deleteRoutings(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Routing).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,213 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Operation } from '../operation/operation'
-import { Routing } from './routing'
-import { RoutingList } from './routing-type'
-
-@Resolver(Routing)
-export class RoutingQuery {
-  @Query(returns => Routing, { description: 'To fetch a Routing' })
-  async routing(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Routing> {
-    const { domain } = context.state
-
-    return await getRepository(Routing).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => RoutingList, { description: 'To fetch multiple Routings' })
-  async routings(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<RoutingList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Routing),
-      params,
-      domain,
-      searchables: ['name']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() routing: Routing): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: routing.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() routing: Routing): Promise<User> {
-    return await getRepository(User).findOneBy({ id: routing.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() routing: Routing): Promise<User> {
-    return await getRepository(User).findOneBy({ id: routing.creatorId })
-  }
-}
-
-export async function firstOperation(routingId: string, context: ResolverContext): Promise<Operation> {
-  const { domain, user, tx } = context.state
-  const operation: Operation = await tx.getRepository(Operation).query(
-    `
-        select 
-          * 
-        from 
-          operations 
-        where 
-          id = 
-            (
-              select 
-                operation_id 
-              from 
-                routing_items 
-              where 
-                routing_id = '${routingId}' 
-              and 
-                rank = 
-                  (
-                    select 
-                      min(rank) 
-                    from 
-                      routing_items 
-                    where 
-                      routing_id = '${routingId}'
-                  )
-              )
-      `
-  )
-  return operation
-}
-
-export async function nextOperation(
-  operationId: string,
-  routingId: string,
-  context: ResolverContext
-): Promise<Operation> {
-  const operation = await getRepository(Operation).query(
-    `
-        select 
-          * 
-        from 
-          operations 
-        where 
-          id = 
-            (
-              select 
-                operation_id 
-              from 
-                routing_items 
-              where 
-                routing_id = '${routingId}' 
-              and 
-                rank = 
-                  (
-                    select 
-                      min(rank) 
-                    from 
-                      routing_items 
-                    where 
-                      routing_id = '${routingId}' 
-                    and 
-                      rank > 
-                        (
-                          select 
-                            rank 
-                          from 
-                            routing_items 
-                          where 
-                            routing_id = '${routingId}' 
-                          and 
-                            operation_id = '${operationId}'
-                        )
-                    )
-              )
-      `
-  )
-  return operation
-}
-
-export async function prevOperation(
-  operationId: string,
-  routingId: string,
-  context: ResolverContext
-): Promise<Operation> {
-  const operation = await getRepository(Operation).query(
-    `
-        select 
-          * 
-        from 
-          operations 
-        where 
-          id = 
-            (
-              select 
-                operation_id 
-              from 
-                routing_items 
-              where 
-                routing_id = '${routingId}' 
-              and 
-                rank = 
-                  (
-                    select 
-                      max(rank) 
-                    from 
-                      routing_items 
-                    where 
-                      routing_id = '${routingId}' 
-                    and 
-                      rank < 
-                        (
-                          select 
-                            rank 
-                          from 
-                            routing_items 
-                          where 
-                            routing_id = '${routingId}' 
-                          and 
-                            operation_id = '${operationId}'
-                        )
-                    )
-              )
-      `
-  )
-
-  return operation
-}
-
-export async function lastOperation(routingId: string, context: ResolverContext): Promise<Operation> {
-  const operation = await getRepository(Operation).query(
-    `
-        select 
-          * 
-        from 
-          operations 
-        where 
-          id = 
-            (
-              select 
-                operation_id 
-              from 
-                routing_items 
-              where 
-                routing_id = '${routingId}' 
-              and 
-                rank = 
-                  (
-                    select 
-                      max(rank) 
-                    from 
-                      routing_items 
-                    where 
-                      routing_id = '${routingId}'
-                  )
-              )
-      `
-  )
-  return operation
-}

package/server/service/routing/routing-type.ts

@@ -1,48 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Routing } from './routing'
-
-@InputType()
-export class NewRouting {
-  @Field({ nullable: false })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  createdLot?: boolean
-
-  @Field({ nullable: true })
-  active?: boolean
-}
-
-@InputType()
-export class RoutingPatch {
-  @Field(type => ID, { nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  createdLot?: boolean
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class RoutingList {
-  @Field(type => [Routing])
-  items: Routing[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/routing/routing.ts

@@ -1,88 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum RoutingStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(RoutingStatus, {
-  name: 'RoutingStatus',
-  description: 'state enumeration of a routing'
-})
-
-@Entity()
-@Index('ix_routing_0', (routing: Routing) => [routing.domain, routing.name], { unique: true })
-@ObjectType({ description: 'Entity for Routing' })
-export class Routing {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { nullable: false })
-  readonly id: string
-
-  @ManyToOne(type => Domain, { nullable: false })
-  @Field({ nullable: false })
-  domain?: Domain
-
-  @RelationId((routing: Routing) => routing.domain)
-  domainId?: string
-
-  @Column({ nullable: false })
-  @Field({ nullable: false })
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  createdLot?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((routing: Routing) => routing.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((routing: Routing) => routing.updater)
-  updaterId?: string
-}

package/server/service/routing-item/index.ts

@@ -1,9 +0,0 @@
-import { RoutingItem } from './routing-item'
-import { RoutingItemMutation } from './routing-item-mutation'
-import { RoutingItemQuery } from './routing-item-query'
-
-export const entities = [RoutingItem]
-export const resolvers = [RoutingItemQuery, RoutingItemMutation]
-
-export * from './routing-item-query'
-export * from './routing-item-mutation'

package/server/service/routing-item/routing-item-mutation.ts

@@ -1,126 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-import { Routing } from '../routing/routing'
-
-import { RoutingItem } from './routing-item'
-import { NewRoutingItem, RoutingItemPatch } from './routing-item-type'
-
-@Resolver(RoutingItem)
-export class RoutingItemMutation {
-  @Directive('@transaction')
-  @Mutation(returns => RoutingItem, { description: 'To create new RoutingItem' })
-  async createRoutingItem(
-    @Arg('routingItem') routingItem: NewRoutingItem,
-    @Ctx() context: ResolverContext
-  ): Promise<RoutingItem> {
-    const { domain, user, tx } = context.state
-    const routing = await tx
-      .getRepository(Routing)
-      .findOne({ where: { domain: { id: domain.id }, id: routingItem.routingId } })
-
-    return await tx.getRepository(RoutingItem).save({
-      ...routingItem,
-      routing,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => RoutingItem, { description: 'To modify RoutingItem information' })
-  async updateRoutingItem(
-    @Arg('id') id: string,
-    @Arg('patch') patch: RoutingItemPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<RoutingItem> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(RoutingItem)
-    const routingItem = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['routing']
-    })
-
-    return await repository.save({
-      ...routingItem,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [RoutingItem], { description: "To modify multiple RoutingItems' information" })
-  async updateMultipleRoutingItem(
-    @Arg('patches', type => [RoutingItemPatch]) patches: RoutingItemPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<RoutingItem[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const routingItemRepo = tx.getRepository(RoutingItem)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-        const routing = await tx
-          .getRepository(Routing)
-          .findOne({ where: { domain: { id: domain.id }, id: _createRecords[i].routingId } })
-
-        const result = await routingItemRepo.save({
-          ...newRecord,
-          routing,
-          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 routingItem = await routingItemRepo.findOneBy({ id: newRecord.id })
-
-        const result = await routingItemRepo.save({
-          ...routingItem,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete RoutingItem' })
-  async deleteRoutingItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(RoutingItem).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple routingItems' })
-  async deleteRoutingItems(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(RoutingItem).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

package/server/service/routing-item/routing-item-query.ts

@@ -1,60 +0,0 @@
-import { Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Operation } from '../operation/operation'
-import { Routing } from '../routing/routing'
-import { RoutingItem } from './routing-item'
-import { RoutingItemList } from './routing-item-type'
-
-@Resolver(RoutingItem)
-export class RoutingItemQuery {
-  @Query(returns => RoutingItemList, { description: 'To fetch multiple RoutingItems' })
-  async routingItems(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<RoutingItemList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(RoutingItem),
-      params,
-      domain,
-      alias: 'ri',
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder
-      .leftJoinAndSelect('ri.routing', 'routing')
-      .leftJoinAndSelect('ri.operation', 'operation')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Routing)
-  async routing(@Root() routingItem: RoutingItem): Promise<Routing> {
-    return routingItem.routing || (await getRepository(Routing).findOneBy({ id: routingItem.routingId }))
-  }
-
-  @FieldResolver(type => Operation)
-  async operation(@Root() routingItem: RoutingItem): Promise<Operation> {
-    return routingItem.operation || (await getRepository(Operation).findOneBy({ id: routingItem.operationId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() routingItem: RoutingItem): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: routingItem.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() routingItem: RoutingItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: routingItem.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() routingItem: RoutingItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: routingItem.creatorId })
-  }
-}

package/server/service/routing-item/routing-item-type.ts

@@ -1,67 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-import { ObjectRef } from '@things-factory/shell'
-
-import { RoutingItem } from './routing-item'
-
-@InputType()
-export class NewRoutingItem {
-  @Field({ nullable: true })
-  routingId?: string
-
-  @Field({ nullable: true })
-  rank: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  operation: ObjectRef
-
-  @Field({ nullable: true })
-  startedTransaction?: string
-
-  @Field({ nullable: true })
-  isStock?: boolean
-
-  @Field({ nullable: true })
-  operatorViewId?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-}
-
-@InputType()
-export class RoutingItemPatch {
-  @Field(type => ID, { nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  routingId?: string
-
-  @Field({ nullable: true })
-  rank: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  operation?: ObjectRef
-
-  @Field({ nullable: true })
-  startedTransaction?: string
-
-  @Field({ nullable: true })
-  isStock?: boolean
-
-  @Field({ nullable: true })
-  operatorViewId?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class RoutingItemList {
-  @Field(type => [RoutingItem])
-  items: RoutingItem[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/routing-item/routing-item.ts

@@ -1,117 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { Operation } from '../operation/operation'
-import { Routing } from '../routing/routing'
-
-export enum RoutingItemStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(RoutingItemStatus, {
-  name: 'RoutingItemStatus',
-  description: 'state enumeration of a routingItem'
-})
-
-@Entity()
-@Index(
-  'ix_routing_item_0',
-  (routingItem: RoutingItem) => [routingItem.rank, routingItem.domain, routingItem.routing, routingItem.operation],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for RoutingItem' })
-export class RoutingItem {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { nullable: false })
-  readonly id: string
-
-  @ManyToOne(type => Domain, { nullable: false })
-  @Field({ nullable: false })
-  domain: Domain
-
-  @RelationId((routingItem: RoutingItem) => routingItem.domain)
-  domainId: string
-
-  @ManyToOne(type => Routing, { nullable: true })
-  @Field({ nullable: true })
-  routing: Routing
-
-  @RelationId((routingItem: RoutingItem) => routingItem.routing)
-  routingId: string
-
-  @Column({
-    nullable: false
-  })
-  @Field({ nullable: false })
-  rank: string
-
-  @ManyToOne(type => Operation, { nullable: true })
-  @Field({ nullable: true })
-  operation: Operation
-
-  @RelationId((routingItem: RoutingItem) => routingItem.operation)
-  operationId: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  startedTransaction?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  isStock?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  operatorViewId?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((routingItem: RoutingItem) => routingItem.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((routingItem: RoutingItem) => routingItem.updater)
-  updaterId?: string
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig-base.json",
-  "compilerOptions": {
-    "outDir": "./dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./server/**/*"],
-  "exclude": ["**/*.spec.ts"]
-}