@things-factory/process 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,154 @@
+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(type => Domain)
+  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(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { 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'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
+  })
+  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,141 @@
+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(type => ListParam) 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(type => ListParam) 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.updaterId && (await getRepository(User).findOneBy({ id: processInstance.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() processInstance: ProcessInstance): Promise<User> {
+    return processInstance.creatorId && (await getRepository(User).findOneBy({ id: processInstance.creatorId }))
+  }
+}

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

@@ -0,0 +1,46 @@
+import { filter, pipe } from 'graphql-yoga'
+import { Resolver, Root, Subscription } from 'type-graphql'
+
+import { pubsub } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+import { ProcessInstance } from './process-instance'
+
+@Resolver(ProcessInstance)
+export class ProcessInstanceSubscription {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      return pipe(
+        pubsub.subscribe('process-instance'),
+        filter(async (payload: { processInstance: ProcessInstance }) => {
+          const { processInstance } = payload
+          const { domainId } = processInstance
+
+          if (domainId !== domain?.id) {
+            return false
+          }
+
+          if (processInstance.creatorId === user.id) {
+            return true
+          }
+
+          return await User.hasPrivilege('query', 'process-instance', domain, user)
+        })
+      )
+    }
+  })
+  processInstance(@Root() payload: { processInstance: ProcessInstance }): ProcessInstance {
+    return payload.processInstance
+  }
+}

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

@@ -0,0 +1,71 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Role } from '@things-factory/auth-base'
+import { ObjectRef, ScalarDate, ScalarObject } from '@things-factory/shell'
+import { ProcessInstance } from './process-instance'
+
+@InputType()
+export class ProcessInstanceDraft {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  processId: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  reason?: string
+
+  @Field(type => ScalarDate, { nullable: true })
+  dueAt?: Date
+
+  @Field({ nullable: true })
+  refBy?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: Role
+}
+
+@InputType()
+export class ProcessInstanceIssue {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  processId?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  reason?: string
+
+  @Field(type => ScalarDate, { nullable: true })
+  dueAt?: Date
+
+  @Field({ nullable: true })
+  refBy?: string
+
+  @Field({ nullable: true })
+  viewSource?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: Role
+}
+
+@ObjectType()
+export class ProcessInstanceList {
+  @Field(type => [ProcessInstance])
+  items: ProcessInstance[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,147 @@
+import { Field, ID, Int, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn,
+  VersionColumn
+} from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { ProcessThread } from '../process-thread/process-thread'
+import { Process } from '../process/process'
+
+export enum ProcessInstanceStatus {
+  Started = 'started',
+  Pending = 'pending',
+  Ended = 'ended',
+  Aborted = 'aborted'
+}
+
+registerEnumType(ProcessInstanceStatus, {
+  name: 'ProcessInstanceStatus',
+  description: 'state enumeration of a process instance'
+})
+
+@Entity()
+@Index('ix_process_instance_0', (processInstance: ProcessInstance) => [processInstance.domain, processInstance.name], {
+  unique: false
+})
+@Index('ix_process_instance_1', (processInstance: ProcessInstance) => [processInstance.domain, processInstance.state], {
+  unique: false
+})
+@ObjectType({ description: 'Entity for ProcessInstance' })
+export class ProcessInstance {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  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 = ''
+
+  @OneToMany(type => ProcessThread, processThread => processThread.processInstance)
+  @Field(type => [ProcessThread])
+  processThreads?: ProcessThread[]
+
+  @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 => Process, { nullable: true })
+  @Field(type => Process, { nullable: true })
+  process?: Process
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.process)
+  processId?: 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
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  terminatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((processInstance: ProcessInstance) => processInstance.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+}

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

@@ -0,0 +1,3 @@
+import { ProcessStatsQuery } from './process-stats-query'
+
+export const resolvers = [ProcessStatsQuery]

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

@@ -0,0 +1,57 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ProcessEvent, ProcessEventStatus } from './process-stats-type'
+import { ProcessThread, ProcessThreadStatus } from '../process-thread/process-thread'
+
+@Resolver(ProcessStatsQuery)
+export class ProcessStatsQuery {
+  @Query(returns => [ProcessEvent], { description: 'To fetch process events by period' })
+  async processEvents(
+    @Arg('from') from: string,
+    @Arg('to') to: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessEvent[]> {
+    const { domain, user } = context.state
+
+    if (!from) {
+      const beginOfToday = new Date()
+      beginOfToday.setHours(0, 0, 0, 0)
+      from = beginOfToday.toISOString().split('T').join(' ')
+    }
+
+    if (!to) {
+      const endOfToday = new Date()
+      endOfToday.setDate(endOfToday.getDate() + 1)
+      endOfToday.setHours(0, 0, 0, 0)
+      to = endOfToday.toISOString().split('T').join(' ')
+    }
+
+    const status = [ProcessThreadStatus.Ended, ProcessThreadStatus.Aborted]
+
+    var params = { filters: [{ name: 'terminatedAt', operator: 'between', value: [from, to] }] }
+
+    var doneItems = await getQueryBuilderFromListParams({
+      repository: getRepository(ProcessThread),
+      params,
+      domain,
+      alias: 'at'
+    })
+      .leftJoinAndSelect('at.processInstance', 'ai')
+      .andWhere('at.state IN (:...status)', { status })
+      .andWhere('at.assignee = :user', { user: user.id })
+      .getMany()
+
+    const processThreadDoneEvents = doneItems.map(({ id, processInstance, terminatedAt }) => {
+      return {
+        id,
+        name: processInstance.name,
+        date: terminatedAt,
+        state: ProcessEventStatus.Done,
+        type: 'process-thread'
+      }
+    })
+
+    return [...processThreadDoneEvents]
+  }
+}

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

@@ -0,0 +1,31 @@
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+export enum ProcessEventStatus {
+  Done = 'done',
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected'
+}
+
+registerEnumType(ProcessEventStatus, {
+  name: 'ProcessEventStatus',
+  description: 'state enumeration of a Process Event'
+})
+
+@ObjectType()
+export class ProcessEvent {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  state?: ProcessEventStatus
+
+  @Field({ nullable: true })
+  date?: Date
+}