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

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,61 @@
+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(type => ListParam) 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.updaterId && (await getRepository(User).findOneBy({ id: processThread.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() processThread: ProcessThread): Promise<User> {
+    return processThread.creatorId && (await getRepository(User).findOneBy({ id: processThread.creatorId }))
+  }
+}

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

@@ -0,0 +1,42 @@
+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 { 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 pipe(
+        pubsub.subscribe('process-thread'),
+        filter(async (payload: { processThread: ProcessThread }) => {
+          const { processThread } = payload
+          const { domainId } = processThread
+
+          if (domainId !== domain?.id) {
+            return false
+          }
+
+          return await User.hasPrivilege('query', 'process-thread', domain, user)
+        })
+      )
+    }
+  })
+  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(type => Domain)
+  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(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((processThread: ProcessThread) => processThread.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { 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": ["./**/*"]
+}