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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/process",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,18 +27,18 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@operato/event-view": "^8.0.0-beta",
-    "@operato/graphql": "^8.0.0-beta",
-    "@operato/grist-editor": "^8.0.0-beta",
-    "@operato/shell": "^8.0.0-beta",
-    "@things-factory/attachment-base": "^8.0.0-beta.9",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/board-service": "^8.0.0-beta.9",
-    "@things-factory/context-ui": "^8.0.0-beta.9",
-    "@things-factory/organization": "^8.0.0-beta.9",
-    "@things-factory/scheduler-client": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9",
-    "@things-factory/worklist": "^8.0.0-beta.9"
+    "@operato/event-view": "^8.0.0",
+    "@operato/graphql": "^8.0.0",
+    "@operato/grist-editor": "^8.0.0",
+    "@operato/shell": "^8.0.0",
+    "@things-factory/attachment-base": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/board-service": "^8.0.0",
+    "@things-factory/context-ui": "^8.0.0",
+    "@things-factory/organization": "^8.0.0",
+    "@things-factory/scheduler-client": "^8.0.0",
+    "@things-factory/shell": "^8.0.0",
+    "@things-factory/worklist": "^8.0.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controllers/common.ts

@@ -0,0 +1,90 @@
+import { Role, User } from '@things-factory/auth-base'
+
+import { ProcessSearchKeyItem } from '../service/process/process-search-key-item-type'
+import { ProcessInstance, ProcessInstanceStatus } from '../service/process-instance/process-instance'
+import { ProcessThread, ProcessThreadStatus } from '../service/process-thread/process-thread'
+
+export async function updateProcessInstanceState(id: string, context: ResolverContext) {
+  const { tx } = context.state
+
+  var processInstance = await tx.getRepository(ProcessInstance).findOne({
+    where: { id },
+    relations: ['domain', 'process', 'assigneeRole', 'supervisoryRole', 'updater', 'creator', 'starter', 'terminator']
+  })
+
+  processInstance = await tx.getRepository(ProcessInstance).save({
+    ...processInstance,
+    transaction: 'thread' /* change by transaction of process thread */,
+    ...(await evalProcessInstanceState(id, context))
+  })
+}
+
+export async function evalProcessInstanceState(
+  id: string,
+  context: ResolverContext
+): Promise<Partial<ProcessInstance>> {
+  const { tx, user } = context.state
+
+  const processInstance = await tx.getRepository(ProcessInstance).findOne({
+    where: { id },
+    relations: ['processThreads', 'process']
+  })
+  const { processThreads, state } = processInstance
+
+  switch (true) {
+    case state === ProcessInstanceStatus.Ended:
+    case state === ProcessInstanceStatus.Aborted:
+      return {}
+    default:
+      return {
+        state: processThreads.find(thread => thread.state == ProcessThreadStatus.Aborted)
+          ? ProcessInstanceStatus.Aborted
+          : ProcessInstanceStatus.Ended,
+        reason: '',
+        terminatedAt: new Date()
+      }
+  }
+}
+
+export async function createProcessThreadForUser(
+  transaction: string,
+  processInstance: ProcessInstance,
+  assignee: User,
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  const threadRepo = tx.getRepository(ProcessThread)
+  const now = new Date()
+
+  const result = await threadRepo.save({
+    domain,
+    assignee,
+    state: ProcessThreadStatus.Assigned,
+    processInstance,
+    transaction,
+    dueAt: processInstance.dueAt,
+    assignedAt: now,
+    creator: user,
+    updater: user,
+    createdAt: now
+  })
+
+  await updateProcessInstanceState(processInstance.id, context)
+
+  return result
+}
+
+export function fillProcessSearchKeys(searchKeys: ProcessSearchKeyItem[], input: { [key: string]: any }) {
+  if (!input || typeof input !== 'object') {
+    return
+  }
+
+  return searchKeys?.reduce((sum, key, index) => {
+    const value = input[key.inputKey]
+    if (value != null) {
+      sum[`key0${index + 1}`] = value instanceof Array ? value[0] : value
+    }
+    return sum
+  }, {})
+}

package/server/controllers/process-instance/abort.ts

@@ -0,0 +1,75 @@
+import { ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { ProcessInstance, ProcessInstanceStatus } from '../../service/process-instance/process-instance'
+import { evalProcessInstanceState } from '../common'
+
+import { _abort as abortProcessThread } from '../process-thread/_abort'
+
+export async function abort(
+  { id, reason }: { id: string; reason: string },
+  context: ResolverContext
+): Promise<ProcessInstance> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ProcessInstance)
+
+  var processInstance = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: [
+      'domain',
+      'process',
+      'processThreads',
+      'assigneeRole',
+      'supervisoryRole',
+      'updater',
+      'creator',
+      'starter',
+      'terminator'
+    ]
+  })
+
+  if (!processInstance) {
+    throw new Error(
+      context.t('error.process-instance not found', {
+        processInstance: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a Task to Be Aborted.
+    - The previous state of the task must not be End or Aborted.
+  */
+  if (processInstance.state == ProcessInstanceStatus.Aborted || processInstance.state == ProcessInstanceStatus.Ended) {
+    throw new Error(
+      context.t(`error.process-instance is already terminated`, {
+        id,
+        state: processInstance.state
+      })
+    )
+  }
+
+  /* 
+    Actions to be processed when a task is aborted
+    - All related process threads must be aborted.
+  */
+
+  const TERMINATED = [ProcessThreadStatus.Aborted, ProcessThreadStatus.Delegated, ProcessThreadStatus.Ended]
+
+  for (let processThread of processInstance.processThreads) {
+    if (TERMINATED.includes(processThread.state)) {
+      continue
+    }
+
+    await abortProcessThread({ processThread, reason }, context)
+  }
+
+  return await repository.save({
+    ...processInstance,
+    reason,
+    ...(await evalProcessInstanceState(id, context)),
+    transaction: 'abort',
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  })
+}

package/server/controllers/process-instance/end.ts

@@ -0,0 +1,74 @@
+import { ProcessInstance, ProcessInstanceStatus } from '../../service/process-instance/process-instance'
+import { ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { evalProcessInstanceState } from '../common'
+
+export async function end(
+  { id, output, reason }: { id: string; output?: object; reason?: string },
+  context: ResolverContext
+): Promise<ProcessInstance> {
+  const { domain, user, tx } = context.state
+  const repository = tx.getRepository(ProcessInstance)
+
+  var processInstance = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: [
+      'domain',
+      'process',
+      'processThreads',
+      'assigneeRole',
+      'supervisoryRole',
+      'updater',
+      'creator',
+      'starter',
+      'terminator'
+    ]
+  })
+
+  if (!processInstance) {
+    throw new Error(
+      context.t('error.process-instance not found', {
+        processInstance: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a Task to Be End.
+    - The previous state of the task must not be End or Aborted.
+    - There should be no unfinished process threads.
+  */
+  if (processInstance.state == ProcessInstanceStatus.Aborted || processInstance.state == ProcessInstanceStatus.Ended) {
+    throw new Error(
+      context.t(`error.process-instance is already terminated`, {
+        id,
+        state: processInstance.state
+      })
+    )
+  }
+
+  const TERMINATED = [ProcessThreadStatus.Aborted, ProcessThreadStatus.Delegated, ProcessThreadStatus.Ended]
+
+  for (let processThread of processInstance.processThreads) {
+    if (TERMINATED.includes(processThread.state)) {
+      continue
+    }
+
+    throw new Error(
+      context.t(`error.all process threads should be terminated`, {
+        processThread: processThread.id,
+        state: processInstance.state
+      })
+    )
+  }
+
+  return await repository.save({
+    ...processInstance,
+    reason,
+    output,
+    transaction: 'end',
+    state: await evalProcessInstanceState(id, context),
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  } as any)
+}

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

@@ -0,0 +1,2 @@
+export * from './abort'
+export * from './end'

package/server/controllers/process-thread/_abort.ts

@@ -0,0 +1,20 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+
+export async function _abort(
+  { processThread, reason }: { processThread: ProcessThread; reason: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ProcessThread)
+
+  return await repository.save({
+    ...processThread,
+    reason,
+    state: ProcessThreadStatus.Aborted,
+    transaction: 'abort',
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  })
+}

package/server/controllers/process-thread/abort.ts

@@ -0,0 +1,48 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+import { _abort } from './_abort'
+
+export async function abort(
+  { id, reason }: { id: string; reason: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ProcessThread)
+
+  var processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: ['domain', 'processInstance', 'assignee', 'creator', 'updater']
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be Aborted.
+    - The previous state of the process thread must not be End or Aborted.
+  */
+  if (
+    processThread.state == ProcessThreadStatus.Aborted ||
+    processThread.state == ProcessThreadStatus.Ended ||
+    processThread.state == ProcessThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.process-thread is already terminated`, {
+        id,
+        state: processThread.state
+      })
+    )
+  }
+
+  const result = await _abort({ processThread, reason }, context)
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return result
+}

package/server/controllers/process-thread/end.ts

@@ -0,0 +1,54 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+
+export async function end(
+  { id, output, reason }: { id: string; output?: object; reason?: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  const repository = tx.getRepository(ProcessThread)
+
+  var processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id }
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be End.
+    - The previous state of the process thread must not be End or End.
+  */
+  if (
+    processThread.state == ProcessThreadStatus.Aborted ||
+    processThread.state == ProcessThreadStatus.Ended ||
+    processThread.state == ProcessThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.process-thread is already terminated`, {
+        id,
+        actual: processThread.state
+      })
+    )
+  }
+
+  processThread = await repository.save({
+    ...processThread,
+    reason,
+    output,
+    transaction: 'end',
+    state: ProcessThreadStatus.Ended,
+    updater: user,
+    terminatedAt: new Date()
+  })
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return processThread
+}

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

@@ -0,0 +1,3 @@
+export * from './abort'
+export * from './end'
+export * from './start'

package/server/controllers/process-thread/start.ts

@@ -0,0 +1,49 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+
+export async function start(
+  id: string,
+  output: object,
+  reason: string,
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  const repository = tx.getRepository(ProcessThread)
+  const processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id }
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be Started.
+    - The previous state of the process thread must not be terminated.
+  */
+  if (processThread.state !== ProcessThreadStatus.Assigned) {
+    throw new Error(
+      context.t(`error.process-thread should not be started`, {
+        id,
+        actual: processThread.state
+      })
+    )
+  }
+
+  const result = await tx.getRepository(ProcessThread).save({
+    ...processThread,
+    reason,
+    state: ProcessThreadStatus.Started,
+    transaction: 'start',
+    updater: user
+  })
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return result
+}

package/server/index.ts

@@ -0,0 +1,4 @@
+export * from './migrations'
+export * from './middlewares'
+
+import './routes'

package/server/middlewares/index.ts

@@ -0,0 +1,3 @@
+export function initMiddlewares(app) {
+  /* can add middlewares into app */
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -0,0 +1,80 @@
+const debug = require('debug')('things-factory:process:routes')
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+  /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */
+  // globalPrivateRouter.post('/callback-schedule-for-start-event', async (context, next) => {
+  //   const { client } = context.request.body as ScheduleRegisterRequest
+  //   if (!client || typeof client !== 'object') {
+  //     throw new Error('client property should be a part of callback body.')
+  //   }
+  //   const { group: domainId, key: dataSetId } = client
+  //   if (!domainId || !dataSetId) {
+  //     throw new Error(`group(${domainId}) and key(${dataSetId}) properties should not be empty`)
+  //   }
+  //   await getDataSource().transaction(async tx => {
+  //     const domain = await tx.getRepository(Domain).findOneBy({ id: domainId })
+  //     if (!domain) {
+  //       throw new Error(`domain(${domainId}) not found`)
+  //     }
+  //     const dataSet = await tx.getRepository(DataSet).findOne({ where: { domain: { id: domainId }, id: dataSetId } })
+  //     const activity = (await tx.getRepository(Activity).findOneBy({
+  //       domain: { id: domainId },
+  //       name: 'Collect Data'
+  //     })) as Activity
+  //     if (activity) {
+  //       const { assignees } = dataSet
+  //       /* 해당 dataset에 대한 데이타 수집 태스크를 dataset assignees에게 할당한다. */
+  //       if (assignees && assignees instanceof Array && assignees.length > 0) {
+  //         const activityInstance = {
+  //           name: `[Data 수집] ${dataSet.name}`,
+  //           description: dataSet.description,
+  //           activityId: activity.id,
+  //           dueAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+  //           input: {
+  //             dataSetId: dataSet.id,
+  //             dataSetName: dataSet.name
+  //           },
+  //           assignees
+  //         }
+  //         context.state = {
+  //           ...context.state,
+  //           domain,
+  //           tx
+  //         }
+  //         await issue(activityInstance, context)
+  //       } else {
+  //         throw new Error(
+  //           `Assignees not set. So Data Collect Activity for ${dataSet.name}($dataSet.id) could not be issued.`
+  //         )
+  //       }
+  //     } else {
+  //       throw new Error(`Data Collect Activity is not installed.`)
+  //     }
+  //   })
+  //   context.status = 200
+  // })
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

package/server/service/index.ts

@@ -0,0 +1,44 @@
+/* EXPORT ENTITY TYPES */
+export * from './process-thread/process-thread'
+export * from './process-instance/process-instance'
+export * from './process/process'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as ProcessThreadEntities,
+  resolvers as ProcessThreadResolvers,
+  subscribers as ProcessThreadSubscribers
+} from './process-thread'
+import {
+  entities as ProcessInstanceEntities,
+  resolvers as ProcessInstanceResolvers,
+  subscribers as ProcessInstanceSubscribers
+} from './process-instance'
+import {
+  entities as ProcessEntities,
+  resolvers as ProcessResolvers,
+  subscribers as ProcessSubscribers
+} from './process'
+
+export const entities = [
+  /* ENTITIES */
+  ...ProcessThreadEntities,
+  ...ProcessInstanceEntities,
+  ...ProcessEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...ProcessThreadSubscribers,
+  ...ProcessInstanceSubscribers,
+  ...ProcessSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...ProcessThreadResolvers,
+    ...ProcessInstanceResolvers,
+    ...ProcessResolvers
+  ]
+}

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

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Process } from './process'
+import { ProcessHistory } from './process-history'
+
+@EventSubscriber()
+export class ProcessHistoryEntitySubscriber extends HistoryEntitySubscriber<Process, ProcessHistory> {
+  public get entity() {
+    return Process
+  }
+
+  public get historyEntity() {
+    return ProcessHistory
+  }
+}

package/server/service/process/index.ts

@@ -0,0 +1,9 @@
+import { Process } from './process'
+import { ProcessHistory } from './process-history'
+import { ProcessMutation } from './process-mutation'
+import { ProcessQuery } from './process-query'
+import { ProcessHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [Process, ProcessHistory]
+export const resolvers = [ProcessQuery, ProcessMutation]
+export const subscribers = [ProcessHistoryEntitySubscriber]