@things-factory/process 6.0.57

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

@@ -0,0 +1,52 @@
+import { withFilter } from 'graphql-subscriptions'
+import { Resolver, Root, Subscription } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository, pubsub } from '@things-factory/shell'
+
+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 withFilter(
+        () => pubsub.asyncIterator('process-instance'),
+        async (payload, variables, context, info) => {
+          const { processInstance } = payload
+          const { domainId } = processInstance
+
+          if (domainId !== domain?.id) {
+            return false
+          }
+
+          if (processInstance.creatorId === user.id) {
+            return true
+          }
+
+          // check if the user has that role
+          const userWithRoles: User = await getRepository(User).findOne({
+            where: { id: user.id },
+            relations: ['roles']
+          })
+
+          return !!userWithRoles.roles.find(role => role.id === processInstance.assigneeRoleId)
+        }
+      )(_, args, context, info)
+    }
+  })
+  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({ 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 = ''
+
+  @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({ 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
+
+  @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
+}

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

@@ -0,0 +1,31 @@
+import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
+
+import { pubsub } from '@things-factory/shell'
+
+import { ProcessThread } from './process-thread'
+
+@EventSubscriber()
+export class ProcessThreadSubscriber implements EntitySubscriberInterface<ProcessThread> {
+  listenTo() {
+    return ProcessThread
+  }
+
+  async afterInsert(event: InsertEvent<ProcessThread>): Promise<any> {
+    const processThread = event.entity
+
+    pubsub.publish('process-thread', {
+      processThread
+    })
+
+    console.log('process-thread created', processThread.id)
+  }
+
+  async afterUpdate(event: UpdateEvent<ProcessThread>): Promise<any> {
+    const processThread = event.entity
+
+    pubsub.publish('process-thread', {
+      processThread
+    })
+    console.log('process-thread updated', processThread.id)
+  }
+}

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

@@ -0,0 +1,9 @@
+import { ProcessThread } from './process-thread'
+import { ProcessThreadMutation } from './process-thread-mutation'
+import { ProcessThreadQuery } from './process-thread-query'
+import { ProcessThreadSubscription } from './process-thread-subscription'
+import { ProcessThreadSubscriber } from './event-subscriber'
+
+export const entities = [ProcessThread]
+export const resolvers = [ProcessThreadQuery, ProcessThreadMutation, ProcessThreadSubscription]
+export const subscribers = [ProcessThreadSubscriber]

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

@@ -0,0 +1,34 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { abort, start } from '../../controllers/process-thread'
+import { ProcessThread } from './process-thread'
+
+@Resolver(ProcessThread)
+export class ProcessThreadMutation {
+  /* transactions ... */
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => ProcessThread!, { nullable: true, description: 'To start ProcessThread' })
+  async startProcessThread(
+    @Arg('id') id: string,
+    @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessThread> {
+    return await start(id, output, reason, context)
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => ProcessThread, { description: 'To abort a ProcessThread' })
+  async abortProcessThread(
+    @Arg('id') id: string,
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ProcessThread> {
+    return await abort({ id, reason }, context)
+  }
+}

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

@@ -0,0 +1,58 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { ProcessInstance } from '../process-instance/process-instance'
+import { ProcessThread, ProcessThreadStatus } from './process-thread'
+import { ProcessThreadList } from './process-thread-type'
+
+@Resolver(ProcessThread)
+export class ProcessThreadQuery {
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessThread!, { nullable: true, description: 'To fetch a ProcessThread' })
+  async processThread(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ProcessThread> {
+    const { domain } = context.state
+
+    return await getRepository(ProcessThread).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "process", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => ProcessThreadList, { description: 'To fetch multiple ProcessThreads' })
+  async processThreads(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ProcessThreadList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: getRepository(ProcessThread),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => ProcessInstance)
+  async processInstance(@Root() processThread: ProcessThread): Promise<ProcessInstance> {
+    return await getRepository(ProcessInstance).findOneBy({ id: processThread.processInstanceId })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() processThread: ProcessThread): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: processThread.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() processThread: ProcessThread): Promise<User> {
+    return processThread.updater && (await getRepository(User).findOneBy({ id: processThread.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() processThread: ProcessThread): Promise<User> {
+    return processThread.creator && (await getRepository(User).findOneBy({ id: processThread.creatorId }))
+  }
+}

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

@@ -0,0 +1,41 @@
+import { withFilter } from 'graphql-subscriptions'
+import { Resolver, Root, Subscription } from 'type-graphql'
+
+import { pubsub } from '@things-factory/shell'
+
+import { ProcessThread } from './process-thread'
+
+@Resolver(ProcessThread)
+export class ProcessThreadSubscription {
+  @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 withFilter(
+        () => pubsub.asyncIterator('process-thread'),
+        async (payload, variables, context, info) => {
+          const { processThread } = payload
+          const { domainId } = processThread
+
+          if (domainId !== domain?.id) {
+            return false
+          }
+
+          return processThread.assigneeId === user.id
+        }
+      )(_, args, context, info)
+    }
+  })
+  processThread(@Root() payload: { processThread: ProcessThread }): ProcessThread {
+    return payload.processThread
+  }
+}

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

@@ -0,0 +1,15 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+
+import { ProcessThread, ProcessThreadStatus } from './process-thread'
+import { User } from '@things-factory/auth-base'
+
+@ObjectType()
+export class ProcessThreadList {
+  @Field(type => [ProcessThread])
+  items: ProcessThread[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,90 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  OneToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  VersionColumn,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, ScalarObject } from '@things-factory/shell'
+
+import { ProcessInstance } from '../process-instance/process-instance'
+
+export enum ProcessThreadStatus {
+  Assigned = 'assigned',
+  Started = 'started',
+  Delegated = 'delegated',
+  Submitted = 'submitted',
+  Escalated = 'escalated',
+  Rejected = 'rejected',
+  Ended = 'ended',
+  Aborted = 'aborted'
+}
+
+registerEnumType(ProcessThreadStatus, {
+  name: 'ProcessThreadStatus',
+  description: 'state enumeration of a ProcessThread'
+})
+
+@Entity()
+@ObjectType({ description: 'Entity for ProcessThread' })
+export class ProcessThread {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((processThread: ProcessThread) => processThread.domain)
+  domainId?: string
+
+  @VersionColumn({ default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => ProcessInstance, processInstance => processInstance.processThreads)
+  @Field(type => ProcessInstance, { nullable: true })
+  processInstance?: ProcessInstance
+
+  @RelationId((processThread: ProcessThread) => processThread.processInstance)
+  processInstanceId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: ProcessThreadStatus
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  terminatedAt?: Date
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((processThread: ProcessThread) => processThread.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((processThread: ProcessThread) => processThread.updater)
+  updaterId?: string
+}

package/server/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}

package/things-factory.config.js

@@ -0,0 +1,13 @@
+import route from './dist-client/route'
+import bootstrap from './dist-client/bootstrap'
+
+export default {
+  route,
+  routes: [
+    { tagname: 'process-main', page: 'process-main' },
+    { tagname: 'process-list-page', page: 'process-list' },
+    { tagname: 'process-instance-list-page', page: 'process-instance-list' },
+    { tagname: 'process-thread-list-page', page: 'process-thread-list' }
+  ],
+  bootstrap
+}

package/translations/en.json

@@ -0,0 +1 @@
+{}

package/translations/ko.json

@@ -0,0 +1 @@
+{}

package/translations/ms.json

@@ -0,0 +1 @@
+{}

package/translations/zh.json

@@ -0,0 +1 @@
+{}