@things-factory/process 8.0.0 → 9.0.0-beta.3

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

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

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

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

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

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

package/server/middlewares/index.ts

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

package/server/migrations/index.ts

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

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

@@ -1,44 +0,0 @@
-/* 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

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

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

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

@@ -1,108 +0,0 @@
-import { Field, ID, 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 } from '@things-factory/shell'
-
-import { Process, ProcessStatus } from './process'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_process_history_0',
-  (processHistory: ProcessHistory) => [processHistory.originalId, processHistory.version],
-  { unique: true }
-)
-@Index(
-  'ix_process_history_1',
-  (processHistory: ProcessHistory) => [processHistory.domain, processHistory.originalId, processHistory.version],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of Process' })
-export class ProcessHistory implements HistoryEntityInterface<Process> {
-  @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((process: Process) => process.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ProcessStatus
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  supervisoryRole?: Role
-
-  @RelationId((process: Process) => process.supervisoryRole)
-  supervisoryRoleId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((process: Process) => process.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((process: Process) => process.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/process-mutation.ts

@@ -1,210 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { Application, CallbackBase, registerSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
-
-import { Process } from './process'
-import { ProcessPatch, NewProcess } from './process-type'
-
-@Resolver(Process)
-export class ProcessMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Process, { description: 'To create new Process' })
-  async createProcess(@Arg('process') process: NewProcess, @Ctx() context: ResolverContext): Promise<Process> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Process).save({
-      ...process,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (process.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: process.thumbnail,
-            refType: Process.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Process, { description: 'To modify Process information' })
-  async updateProcess(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ProcessPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Process> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Process)
-    const process = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-      relations: ['domain', 'issuerRole', 'supervisoryRole', 'creator', 'updater']
-    })
-
-    const result = await repository.save({
-      ...process,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: Process.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Process], { description: "To modify multiple Processes' information" })
-  async updateMultipleProcess(
-    @Arg('patches', type => [ProcessPatch]) patches: ProcessPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Process[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const processRepo = tx.getRepository(Process)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await processRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: Process.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const process = await processRepo.findOne({
-          where: { id: updateRecord.id },
-          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-          relations: ['domain', 'issuerRole', 'supervisoryRole', 'creator', 'updater']
-        })
-
-        const result = await processRepo.save({
-          ...process,
-          ...updateRecord,
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: Process.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete Process' })
-  async deleteProcess(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Process).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Processes' })
-  async deleteProcesses(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Process).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple Processes' })
-  async importProcesses(
-    @Arg('processes', type => [ProcessPatch]) processes: ProcessPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      processes.map(async (process: ProcessPatch) => {
-        const createdProcess: Process = await tx.getRepository(Process).save({ domain, ...process })
-      })
-    )
-
-    return true
-  }
-}