@things-factory/process 6.0.57

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

@@ -0,0 +1,117 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Process } from './process'
+import { ProcessList } from './process-type'
+
+@Resolver(Process)
+export class ProcessQuery {
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Process!, { nullable: true, description: 'To fetch a Process' })
+  async process(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Process> {
+    const { domain } = context.state
+
+    return await getRepository(Process).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Process!, { nullable: true, description: 'To fetch a Process by name' })
+  async processByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Process> {
+    const { domain } = context.state
+
+    return await getRepository(Process).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  }
+
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessList, { description: 'To fetch multiple Processes' })
+  async processes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProcessList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: getRepository(Process),
+      alias: 'process',
+      searchables: ['name', 'description', 'supervisoryRole']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessList, { description: 'To fetch the list of processes that I can report on' })
+  async supervisableProcesses(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProcessList> {
+    var { domain, user } = context.state
+
+    /* 조회한 사용자가 assigner 역할을 가진 process-instance 리스트만 반환 */
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+    const roles = user.roles.filter(role => role.domainId === domain.id).map(role => role.id)
+
+    if (!roles.length) {
+      return { items: [], total: 0 }
+    }
+
+    const [items, total] = await getQueryBuilderFromListParams({
+      repository: getRepository(Process),
+      params,
+      domain,
+      alias: 'process',
+      searchables: ['name', 'description']
+    })
+      .andWhere(`process.supervisoryRole IN (:...roles)`, { roles })
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() process: Process): Promise<Role> {
+    return (
+      process.supervisoryRole ||
+      (process.supervisoryRoleId &&
+        (await getRepository(Role).findOneBy({
+          id: process.supervisoryRoleId
+        })))
+    )
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() process: Process): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: process.domainId },
+        refType: Process.name,
+        refBy: process.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() process: Process): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: process.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() process: Process): Promise<User> {
+    return await getRepository(User).findOneBy({ id: process.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() process: Process): Promise<User> {
+    return await getRepository(User).findOneBy({ id: process.creatorId })
+  }
+}

package/server/service/process/process-search-key-item-type.ts

@@ -0,0 +1,16 @@
+import { Field, ObjectType } from 'type-graphql'
+
+@ObjectType({ description: 'Entity for ProcessSearchKeyItem' })
+export class ProcessSearchKeyItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  inputKey: string
+
+  @Field({ nullable: true })
+  tKey?: string
+}

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

@@ -0,0 +1,65 @@
+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 { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { Process, ProcessStatus } from './process'
+import { ProcessSearchKeyItem } from './process-search-key-item-type'
+
+@InputType()
+export class NewProcess {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  searchKeys?: ProcessSearchKeyItem[]
+
+  @Field({ nullable: true })
+  state?: ProcessStatus
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+}
+
+@InputType()
+export class ProcessPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  searchKeys?: ProcessSearchKeyItem[]
+
+  @Field({ nullable: true })
+  state?: ProcessStatus
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ProcessList {
+  @Field(type => [Process])
+  items: Process[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/process/process.ts

@@ -0,0 +1,97 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn,
+  VersionColumn
+} from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ProcessSearchKeyItem } from './process-search-key-item-type'
+
+export enum ProcessStatus {
+  Draft = 'draft',
+  Released = 'released',
+  Deprecated = 'deprecated'
+}
+
+registerEnumType(ProcessStatus, {
+  name: 'ProcessStatus',
+  description: 'state enumeration of a process'
+})
+
+@Entity()
+@Index('ix_process_0', (process: Process) => [process.domain, process.name], { unique: true })
+@Index('ix_process_1', (process: Process) => [process.domain, process.state], { unique: false })
+@ObjectType({ description: 'Entity for Process' })
+export class Process {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain?: Domain
+
+  @RelationId((process: Process) => process.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: ProcessStatus
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => [ProcessSearchKeyItem], { nullable: true })
+  searchKeys?: ProcessSearchKeyItem[]
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true, description: 'The final authority on a given process.' })
+  supervisoryRole?: Role
+
+  @RelationId((process: Process) => process.supervisoryRole)
+  supervisoryRoleId?: string
+
+  @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((process: Process) => process.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((process: Process) => process.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+}

package/server/service/process-instance/event-subscriber.ts

@@ -0,0 +1,44 @@
+import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+import { pubsub } from '@things-factory/shell'
+
+import { ProcessInstance } from './process-instance'
+import { ProcessInstanceHistory } from './process-instance-history'
+
+@EventSubscriber()
+export class ProcessInstanceSubscriber implements EntitySubscriberInterface<ProcessInstance> {
+  listenTo() {
+    return ProcessInstance
+  }
+
+  async afterInsert(event: InsertEvent<ProcessInstance>): Promise<any | void> {
+    const { entity: processInstance, manager: tx } = event
+
+    pubsub.publish('process-instance', {
+      processInstance
+    })
+  }
+
+  async afterUpdate(event: UpdateEvent<ProcessInstance>): Promise<any | void> {
+    const { entity: processInstance, manager: tx } = event
+
+    pubsub.publish('process-instance', {
+      processInstance
+    })
+  }
+}
+
+@EventSubscriber()
+export class ProcessInstanceHistoryEntitySubscriber extends HistoryEntitySubscriber<
+  ProcessInstance,
+  ProcessInstanceHistory
+> {
+  public get entity() {
+    return ProcessInstance
+  }
+
+  public get historyEntity() {
+    return ProcessInstanceHistory
+  }
+}

package/server/service/process-instance/index.ts

@@ -0,0 +1,10 @@
+import { ProcessInstance } from './process-instance'
+import { ProcessInstanceHistory } from './process-instance-history'
+import { ProcessInstanceMutation } from './process-instance-mutation'
+import { ProcessInstanceQuery } from './process-instance-query'
+import { ProcessInstanceSubscription } from './process-instance-subscription'
+import { ProcessInstanceHistoryEntitySubscriber, ProcessInstanceSubscriber } from './event-subscriber'
+
+export const entities = [ProcessInstance, ProcessInstanceHistory]
+export const resolvers = [ProcessInstanceQuery, ProcessInstanceMutation, ProcessInstanceSubscription]
+export const subscribers = [ProcessInstanceSubscriber, ProcessInstanceHistoryEntitySubscriber]

package/server/service/process-instance/process-instance-history.ts

@@ -0,0 +1,148 @@
+import { Field, ID, Int, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
+
+import {
+  HistoryActionColumn,
+  HistoryActionType,
+  HistoryEntityInterface,
+  HistoryOriginalIdColumn
+} from '@operato/typeorm-history'
+import { Role, User } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { ProcessInstance, ProcessInstanceStatus } from './process-instance'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_process_instance_history_0',
+  (processInstanceHistory: ProcessInstanceHistory) => [
+    processInstanceHistory.originalId,
+    processInstanceHistory.version
+  ],
+  { unique: true }
+)
+@Index(
+  'ix_process_instance_history_1',
+  (processInstanceHistory: ProcessInstanceHistory) => [
+    processInstanceHistory.domain,
+    processInstanceHistory.originalId,
+    processInstanceHistory.version
+  ],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of ProcessInstance' })
+export class ProcessInstanceHistory implements HistoryEntityInterface<ProcessInstance> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({
+    nullable: true,
+    default: 1
+  })
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key01?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key02?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key03?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key04?: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  key05?: string = ''
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: ProcessInstanceStatus
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  reason?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refBy?: string
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true })
+  supervisoryRole?: Role
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.supervisoryRole)
+  supervisoryRoleId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dueAt?: Date
+
+  @Column()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  terminatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.updater)
+  updaterId?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    enum: HistoryActionType
+  })
+  public action!: HistoryActionType
+}

package/server/service/process-instance/process-instance-mutation.ts

@@ -0,0 +1,33 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+
+import { abort, end } from '../../controllers/process-instance'
+import { ProcessInstance } from './process-instance'
+import { ProcessInstanceIssue, ProcessInstanceDraft } from './process-instance-type'
+
+@Resolver(ProcessInstance)
+export class ProcessInstanceMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => ProcessInstance, { description: 'To end a ProcessInstance' })
+  async endProcessInstance(
+    @Arg('id') id: string,
+    @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessInstance> {
+    return await end({ id, output, reason }, context)
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => ProcessInstance, { description: 'To abort a ProcessInstance' })
+  async abortProcessInstance(
+    @Arg('id') id: string,
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessInstance> {
+    return await abort({ id, reason }, context)
+  }
+}

package/server/service/process-instance/process-instance-query.ts

@@ -0,0 +1,138 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { ProcessThread } from '../process-thread/process-thread'
+import { Process } from '../process/process'
+import { ProcessInstance, ProcessInstanceStatus } from './process-instance'
+import { ProcessInstanceList } from './process-instance-type'
+
+@Resolver(ProcessInstance)
+export class ProcessInstanceQuery {
+  @Directive('@privilege(category: "process-instance", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessInstance!, { nullable: true, description: 'To fetch a ProcessInstance' })
+  async processInstance(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ProcessInstance> {
+    const { domain } = context.state
+
+    return await getRepository(ProcessInstance).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "process-instance", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessInstanceList, { description: 'To fetch multiple ProcessInstances' })
+  async processInstances(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProcessInstanceList> {
+    const { domain } = context.state
+
+    const [items, total] = await getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: getRepository(ProcessInstance),
+      searchables: ['name', 'description']
+    }).getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "process-instance", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessInstanceList, { description: 'To fetch multiple process instances by process' })
+  async processInstancesByProcess(
+    @Arg('processId') processId: string,
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessInstanceList> {
+    const { domain } = context.state
+
+    const process = await getRepository(Process).findOneBy({ id: processId })
+    const searchables = process?.searchKeys?.map((item, index) => `key0${index + 1}`) || []
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(ProcessInstance),
+      params,
+      domain,
+      alias: 'pi',
+      searchables: ['name', 'description'].concat(searchables)
+    }).where('pi.process = :process', { process: processId })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Process)
+  async process(@Root() processInstance: ProcessInstance): Promise<Process> {
+    const { processId } = processInstance
+
+    return await getRepository(Process).findOneBy({ id: processId })
+  }
+
+  @FieldResolver(type => [ProcessThread])
+  async processThreads(
+    @Root() processInstance: ProcessInstance,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessThread[]> {
+    const { user } = context.state
+    const { supervisoryRoleId } = processInstance
+
+    if (supervisoryRoleId) {
+      /* only user having supervisoryRole can get whole processThreads */
+      const roles = (
+        (await getRepository(User).findOne({
+          where: { id: user.id },
+          relations: ['roles']
+        })) as User
+      ).roles.map(role => role.id)
+
+      if (!roles.includes(supervisoryRoleId)) {
+        return
+      }
+    }
+
+    return await getRepository(ProcessThread).findBy({
+      processInstance: { id: processInstance.id }
+    })
+  }
+
+  @FieldResolver(type => Role)
+  async supervisoryRole(@Root() processInstance: ProcessInstance): Promise<Role> {
+    return (
+      processInstance.supervisoryRole ||
+      (processInstance.supervisoryRoleId &&
+        (await getRepository(Role).findOneBy({
+          id: processInstance.supervisoryRoleId
+        })))
+    )
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() processInstance: ProcessInstance): Promise<string | undefined> {
+    const { processId } = processInstance
+    const attachment: Attachment =
+      processId &&
+      (await getRepository(Attachment).findOne({
+        where: {
+          domain: { id: processInstance.domainId },
+          refBy: processId
+        }
+      }))
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() processInstance: ProcessInstance): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: processInstance.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() processInstance: ProcessInstance): Promise<User> {
+    return processInstance.updater && (await getRepository(User).findOneBy({ id: processInstance.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() processInstance: ProcessInstance): Promise<User> {
+    return processInstance.creator && (await getRepository(User).findOneBy({ id: processInstance.creatorId }))
+  }
+}