@things-factory/process 8.0.39 → 9.0.0-9.0.0-beta.59.0

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

@@ -1,46 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

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

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

@@ -1,57 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

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