Process: Use previous step context in the same transition (#9877)

Signed-off-by: Denis Bykhov <bykhov.denis@gmail.com>

Author: BykhovDenis

server-plugins/process-resources/src/functions.ts

@@ -25,7 +25,8 @@ import core, {
   Ref,
   Relation,
   splitMixinUpdate,
-  Tx
+  Tx,
+  TxProcessor
 } from '@hcengineering/core'
 import process, {
   Execution,
@@ -36,7 +37,7 @@ import process, {
   processError,
   ProcessToDo
 } from '@hcengineering/process'
-import { ExecuteResult, ProcessControl } from '@hcengineering/server-process'
+import { ExecuteResult, ProcessControl, SuccessExecutionContext } from '@hcengineering/server-process'
 import time, { ToDoPriority } from '@hcengineering/time'
 
 export async function CheckToDoDone (
@@ -122,9 +123,19 @@ export async function AddRelation (
     docA,
     docB
   }
-  const res: Tx[] = [control.client.txFactory.createTxCreateDoc(core.class.Relation, core.space.Workspace, data, _id)]
+  const resTx = control.client.txFactory.createTxCreateDoc(core.class.Relation, core.space.Workspace, data, _id)
+  const res: Tx[] = [resTx]
   const rollback: Tx[] = [control.client.txFactory.createTxRemoveDoc(core.class.Relation, core.space.Workspace, _id)]
-  return { txes: res, rollback, context: _id }
+  return {
+    txes: res,
+    rollback,
+    context: [
+      {
+        _id,
+        value: TxProcessor.createDoc2Doc(resTx, true)
+      }
+    ]
+  }
 }
 
 export async function UpdateCard (
@@ -189,19 +200,29 @@ export async function AddTag (
   const { _id, props } = params
   if (_id === undefined) throw processError(process.error.RequiredParamsNotProvided, { params: '_id' })
   const res: Tx[] = []
-  const context: Ref<Card>[] = [execution.card]
   const _process = control.client.getModel().findObject(execution.process)
   if (_process === undefined) throw processError(process.error.ObjectNotFound, { _id: execution.process })
-  res.push(
-    control.client.txFactory.createTxMixin(
-      execution.card,
-      _process.masterTag,
-      core.space.Workspace,
-      _id as Ref<Tag>,
-      props
-    )
+  const tx = control.client.txFactory.createTxMixin(
+    execution.card,
+    _process.masterTag,
+    core.space.Workspace,
+    _id as Ref<Tag>,
+    props
   )
-  return { txes: res, rollback: undefined, context }
+  res.push(tx)
+  const card = control.cache.get(execution.card)
+  const cardWithMixin =
+    card !== undefined ? TxProcessor.updateMixin4Doc(control.client.getHierarchy().clone(card), tx) : undefined
+  return {
+    txes: res,
+    rollback: undefined,
+    context: [
+      {
+        _id: execution.card,
+        value: cardWithMixin
+      }
+    ]
+  }
 }
 
 export async function RunSubProcess (
@@ -215,7 +236,7 @@ export async function RunSubProcess (
   const target = control.client.getModel().findObject(processId)
   if (target === undefined) throw processError(process.error.ObjectNotFound, { _id: processId })
   const res: Tx[] = []
-  const resultContext: Ref<Execution>[] = []
+  const resultContext: SuccessExecutionContext[] = []
   for (const _card of Array.isArray(card) ? card : [card]) {
     if (target.parallelExecutionForbidden === true) {
       const currentExecution = await control.client.findAll(process.class.Execution, {
@@ -233,24 +254,27 @@ export async function RunSubProcess (
       .findAllSync(process.class.Transition, { process: target._id, from: null })[0]
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const context = params.context ?? ({} as ExecutionContext)
-    const id = generateId<Execution>()
-    res.push(
-      control.client.txFactory.createTxCreateDoc(
-        process.class.Execution,
-        core.space.Workspace,
-        {
-          process: processId,
-          currentState: initTransition.to,
-          card: _card,
-          context,
-          status: ExecutionStatus.Active,
-          rollback: [],
-          parentId: execution._id
-        },
-        id
-      )
+    const _id = generateId<Execution>()
+    const tx = control.client.txFactory.createTxCreateDoc(
+      process.class.Execution,
+      core.space.Workspace,
+      {
+        process: processId,
+        currentState: initTransition.to,
+        card: _card,
+        context,
+        status: ExecutionStatus.Active,
+        rollback: [],
+        parentId: execution._id
+      },
+      _id
     )
-    resultContext.push(id)
+
+    res.push(tx)
+    resultContext.push({
+      _id,
+      value: TxProcessor.createDoc2Doc(tx, true)
+    })
   }
   return { txes: res, rollback: undefined, context: resultContext }
 }
@@ -270,30 +294,38 @@ export async function CreateToDo (
   const res: Tx[] = []
   const rollback: Tx[] = []
   const id = generateId<ProcessToDo>()
-  res.push(
-    control.client.txFactory.createTxCreateDoc(
-      process.class.ProcessToDo,
-      time.space.ToDos,
-      {
-        attachedTo: execution.card,
-        attachedToClass: cardPlugin.class.Card,
-        collection: 'todos',
-        workslots: 0,
-        execution: execution._id,
-        title: params.title,
-        user: params.user,
-        description: params.description ?? '',
-        dueDate: params.dueDate,
-        priority: params.priority ?? ToDoPriority.NoPriority,
-        visibility: 'public',
-        doneOn: null,
-        rank: '',
-        withRollback: params.withRollback ?? false
-      },
-      id
-    )
+  const tx = control.client.txFactory.createTxCreateDoc(
+    process.class.ProcessToDo,
+    time.space.ToDos,
+    {
+      attachedTo: execution.card,
+      attachedToClass: cardPlugin.class.Card,
+      collection: 'todos',
+      workslots: 0,
+      execution: execution._id,
+      title: params.title,
+      user: params.user,
+      description: params.description ?? '',
+      dueDate: params.dueDate,
+      priority: params.priority ?? ToDoPriority.NoPriority,
+      visibility: 'public',
+      doneOn: null,
+      rank: '',
+      withRollback: params.withRollback ?? false
+    },
+    id
   )
-  return { txes: res, rollback, context: id }
+  res.push(tx)
+  return {
+    txes: res,
+    rollback,
+    context: [
+      {
+        _id: id,
+        value: TxProcessor.createDoc2Doc(tx, true)
+      }
+    ]
+  }
 }
 
 export async function CreateCard (
@@ -313,9 +345,19 @@ export async function CreateCard (
     title,
     ...attrs
   } as any
-  const res: Tx[] = [control.client.txFactory.createTxCreateDoc(_class as Ref<MasterTag>, execution.space, data, _id)]
+  const tx = control.client.txFactory.createTxCreateDoc(_class as Ref<MasterTag>, execution.space, data, _id)
+  const res: Tx[] = [tx]
   const rollback: Tx[] = [control.client.txFactory.createTxRemoveDoc(_class as Ref<MasterTag>, execution.space, _id)]
-  return { txes: res, rollback, context: _id }
+  return {
+    txes: res,
+    rollback,
+    context: [
+      {
+        _id,
+        value: TxProcessor.createDoc2Doc(tx, true)
+      }
+    ]
+  }
 }
 
 function isEmpty (value: any): boolean {

server-plugins/process-resources/src/utils.ts

@@ -275,7 +275,8 @@ async function getExecutionContextValue (
   if (userContext !== undefined) {
     if (context.key === '' || context.key === '_id') return userContext
     if (processContext !== undefined) {
-      const contextVal = await control.client.findOne(processContext?._class, { _id: userContext })
+      const contextVal =
+        control.cache.get(userContext) ?? (await control.client.findOne(processContext?._class, { _id: userContext }))
       if (contextVal !== undefined) {
         const val = getValue(control, execution, context.key, contextVal)
         return val

server-plugins/process/src/types.ts

@@ -13,7 +13,12 @@ export type ExecuteResult = SuccessExecutionResult | ExecutionError
 export interface SuccessExecutionResult {
   txes: Tx[]
   rollback: Tx[] | undefined
-  context: any | null
+  context: SuccessExecutionContext[] | null
+}
+
+export interface SuccessExecutionContext {
+  _id: string
+  value: any
 }
 
 export type TransformFunc = (

services/process/src/main.ts

@@ -449,7 +449,11 @@ async function executeAction<T extends Doc> (
     const f = await getResource(impl.func)
     const res = await f(params, execution, control)
     if (!isError(res) && action.context?._id != null && res.context != null) {
-      execution.context[action.context._id] = res.context
+      execution.context[action.context._id] =
+        res.context.length === 1 ? res.context[0]._id : res.context.map((it) => it._id)
+      for (const ctx of res.context) {
+        control.cache.set(ctx._id, ctx.value)
+      }
     }
     return res
   } catch (err) {