interaqt 2.0.0 → 2.0.2

package/agent/agentspace/knowledge/usage/05-interactions.md

@@ -629,8 +629,12 @@ const User = Entity.create({
           StateTransfer.create({
             current: NameUpdatedState,
             next: NameUpdatedState,
-            trigger: UpdateUserProfile,
-            computeTarget: (event) => ({ id: event.payload.userId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: UpdateUserProfile.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.userId })
           })
         ],
         initialState: NameUpdatedState
@@ -645,8 +649,12 @@ const User = Entity.create({
           StateTransfer.create({
             current: BioUpdatedState,
             next: BioUpdatedState,
-            trigger: UpdateUserProfile,
-            computeTarget: (event) => ({ id: event.payload.userId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: UpdateUserProfile.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.userId })
           })
         ],
         initialState: BioUpdatedState
@@ -704,20 +712,32 @@ const Post = Entity.create({
           StateTransfer.create({
             current: draftState,
             next: publishedState,
-            trigger: PublishPost,
-            computeTarget: (event) => ({ id: event.payload.postId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: PublishPost.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.postId })
           }),
           StateTransfer.create({
             current: publishedState,
             next: deletedState,
-            trigger: DeletePost,
-            computeTarget: (event) => ({ id: event.payload.postId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: DeletePost.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.postId })
           }),
           StateTransfer.create({
             current: draftState,
             next: deletedState,
-            trigger: DeletePost,
-            computeTarget: (event) => ({ id: event.payload.postId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: DeletePost.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.postId })
           })
         ]
       })
@@ -821,26 +841,42 @@ const Order = Entity.create({
           StateTransfer.create({
             current: pendingState,
             next: confirmedState,
-            trigger: ConfirmPayment,
-            computeTarget: (event) => ({ id: event.payload.orderId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ConfirmPayment.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
           }),
           StateTransfer.create({
             current: confirmedState,
             next: shippedState,
-            trigger: ShipOrder,
-            computeTarget: (event) => ({ id: event.payload.orderId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ShipOrder.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
           }),
           StateTransfer.create({
             current: shippedState,
             next: deliveredState,
-            trigger: ConfirmDelivery,
-            computeTarget: (event) => ({ id: event.payload.orderId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ConfirmDelivery.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
           }),
           StateTransfer.create({
             current: pendingState,
             next: cancelledState,
-            trigger: CancelOrder,
-            computeTarget: (event) => ({ id: event.payload.orderId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: CancelOrder.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
           })
         ]
       })
@@ -1130,14 +1166,22 @@ const OrderStateMachine = StateMachine.create({
     StateTransfer.create({
       current: PendingState,
       next: PaidState,
-      trigger: PayOrder,
-      computeTarget: (event) => ({ id: event.payload.orderId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: PayOrder.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.orderId })
     }),
     StateTransfer.create({
       current: PaidState,
       next: ShippedState,
-      trigger: ShipOrder,
-      computeTarget: (event) => ({ id: event.payload.orderId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: ShipOrder.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.orderId })
     })
   ]
 });
@@ -1300,6 +1344,7 @@ const Order = Entity.create({
       computation: Every.create({
         record: OrderItemRelation,
         relationDirection: 'source',
+        attributeQuery: ['quantity', ['product', { attributeQuery: ['stock'] }]],  // Required when callback reads fields
         callback: function(orderItem) {
           // Check if each order item has sufficient product inventory
           return orderItem.product.stock >= orderItem.quantity;

package/agent/agentspace/knowledge/usage/08-activities.md

@@ -1,5 +1,15 @@
 # How to Use Activities for Process Management
 
+> **⚠️ Maintenance note (2026-07-09)**: parts of this guide are outdated. The REAL Activity API is:
+> `Activity.create({ name, interactions, transfers, groups? })` with `Transfer.create({ name, source, target })`,
+> where `source`/`target` are Interaction / ActivityGroup instances. **There is no string-based
+> `Transfer.create({ from, to, interaction, condition })` form** — examples below using that shape are
+> historical sketches and do not run. Activities are dispatched through `ActivityManager`:
+> compile with `new ActivityManager(activities).getOutput()`, pass the output entities/relations/eventSources
+> to the Controller, then `controller.dispatch(controller.findEventSourceByName('ActivityName:interactionName'), { user, activityId? })`.
+> For a runnable end-to-end example see `agent/agentspace/knowledge/usage/13-testing.md` §12.2.2
+> and `tests/runtime/activity.spec.ts`. A full rewrite of this guide is tracked as follow-up work.
+
 Activities are the core mechanism in interaqt for managing complex business processes. They allow you to define multi-step, multi-role business processes and control the execution order and conditions of processes through a state machine model.
 
 ## Understanding Activity Concepts

package/agent/agentspace/knowledge/usage/09-filtered-entities.md

@@ -373,6 +373,7 @@ const User = Entity.create({
       defaultValue: () => 0,
       computation: WeightedSummation.create({
         record: UserPublishedPosts,
+        attributeQuery: [['target', { attributeQuery: ['viewCount'] }]],  // Required when callback reads fields
         callback: (relation) => ({
           weight: 1,
           value: relation.target.viewCount

package/agent/agentspace/knowledge/usage/13-testing.md

@@ -26,7 +26,8 @@ storage.create('Entity', data)                       // ✅ Create record
 
 ```typescript
 import { describe, test, expect, beforeEach } from 'vitest'
-import { Controller, MonoSystem, KlassByName, PGLiteDB, MatchExp } from 'interaqt'
+import { Controller, MonoSystem, KlassByName, MatchExp } from 'interaqt'
+import { PGLiteDB } from 'interaqt/drivers'
 import { entities, relations, interactions, activities } from '../backend'
 // If you need UUID, install and import it:
 // npm install uuid @types/uuid
@@ -574,121 +575,72 @@ describe('User Interactions', () => {
 
 ### 12.2.2 Activity Testing
 
+An Activity is an ordered composition of Interactions (`Activity.create({ name, interactions, transfers })`, with `Transfer.create({ name, source, target })` connecting them — NOT StateNode/StateTransfer, which belong to StateMachine). Use `ActivityManager` to compile activities into dispatchable event sources named `activityName:interactionName`, and drive them through `controller.dispatch`:
+
 ```typescript
 // tests/activities/approvalProcess.spec.ts
+import {
+  Activity, ActivityManager, Transfer, Interaction, Action,
+  Controller, MonoSystem, KlassByName
+} from 'interaqt';
+import { PGLiteDB } from '@drivers';
+
 describe('Approval Process Activity', () => {
   test('should handle complete approval workflow', async () => {
     const system = new MonoSystem(new PGLiteDB());
-    
-    // Create request entity
-    const requestEntity = Entity.create({
-      name: 'Request',
-      properties: [
-        Property.create({ name: 'title', type: 'string' }),
-        Property.create({ name: 'status', type: 'string' }),
-        Property.create({ name: 'submitterId', type: 'string' })
-      ]
-    });
-    
-    // Create activity states
-    const submittedState = StateNode.create({ name: 'submitted' });
-    const reviewingState = StateNode.create({ name: 'reviewing' });
-    const approvedState = StateNode.create({ name: 'approved' });
-    const rejectedState = StateNode.create({ name: 'rejected' });
-    
-    // Create interactions
-    const submitInteraction = Interaction.create({
+    system.conceptClass = KlassByName;
+
+    // 1. Declare the interactions of the workflow
+    const submit = Interaction.create({
       name: 'submit',
       action: Action.create({ name: 'submit' })
     });
-    
-    const approveInteraction = Interaction.create({
+    const approve = Interaction.create({
       name: 'approve',
       action: Action.create({ name: 'approve' })
     });
-    
-    const rejectInteraction = Interaction.create({
-      name: 'reject',
-      action: Action.create({ name: 'reject' })
-    });
-    
-    // Create state transfers
-    const submitTransfer = StateTransfer.create({
-      trigger: submitInteraction,
-      current: submittedState,
-      next: reviewingState
-    });
-    
-    const approveTransfer = StateTransfer.create({
-      trigger: approveInteraction,
-      current: reviewingState,
-      next: approvedState
-    });
-    
-    const rejectTransfer = StateTransfer.create({
-      trigger: rejectInteraction,
-      current: reviewingState,
-      next: rejectedState
-    });
-    
-    // Create activity
+
+    // 2. Compose them into an activity: submit → approve
     const approvalActivity = Activity.create({
       name: 'ApprovalProcess',
-      states: [submittedState, reviewingState, approvedState, rejectedState],
-      transfers: [submitTransfer, approveTransfer, rejectTransfer],
-      initialState: submittedState
+      interactions: [submit, approve],
+      transfers: [
+        Transfer.create({ name: 'submitToApprove', source: submit, target: approve })
+      ]
     });
-    
+
+    // 3. ActivityManager compiles the activity into event sources / records
+    const activityManager = new ActivityManager([approvalActivity]);
+    const activityOutput = activityManager.getOutput();
+
     const controller = new Controller({
       system,
-      entities: [requestEntity],
-      relations: [],
-      activities: [approvalActivity],  // activities
-      interactions: [submitInteraction, approveInteraction, rejectInteraction],  // interactions
-      dict: []
+      entities: [...activityOutput.entities],
+      relations: [...activityOutput.relations],
+      eventSources: [...activityOutput.eventSources]
     });
     await controller.setup(true);
-    
-    // Create request
-    const request = await system.storage.create('Request', {
-      title: 'Test Request',
-      status: 'submitted',
-      submitterId: 'user123'
-    });
-    
-    // Execute submit interaction
-    await controller.callInteraction(submitInteraction.name, {
-      user: { id: 'user123' },  // Add user object
-      payload: {
-        requestId: request.id
-      }
-    });
-    
-    // Verify state transition
-    let updatedRequest = await system.storage.findOne(
-      'Request',
-      MatchExp.atom({ key: 'id', value: ['=', request.id] }),
-      undefined,
-      ['id', 'title', 'status', 'submitterId']  // Specify fields
-    );
-    expect(updatedRequest.status).toBe('reviewing');
-    
-    // Execute approve interaction
-    await controller.callInteraction(approveInteraction.name, {
-      user: { id: 'admin-user' },  // Add user object
-      payload: {
-        requestId: request.id
-      }
-    });
-    
-    // Verify final state
-    updatedRequest = await system.storage.findOne(
-      'Request',
-      MatchExp.atom({ key: 'id', value: ['=', request.id] }),
-      undefined,
-      ['id', 'title', 'status', 'submitterId']  // Specify fields
-    );
-    expect(updatedRequest.status).toBe('approved');
+
+    const submitES = controller.findEventSourceByName('ApprovalProcess:submit')!;
+    const approveES = controller.findEventSourceByName('ApprovalProcess:approve')!;
+
+    // 4. The head interaction creates the activity instance
+    const res1 = await controller.dispatch(submitES, { user: { id: 'user123' } });
+    expect(res1.error).toBeUndefined();
+    const activityId = res1.context!.activityId as string;
+
+    // 5. Subsequent interactions must carry the activityId
+    const res2 = await controller.dispatch(approveES, { user: { id: 'admin-user' }, activityId });
+    expect(res2.error).toBeUndefined();
+
+    // 6. The activity is complete: no further interaction is available
+    const res3 = await controller.dispatch(approveES, { user: { id: 'admin-user' }, activityId });
+    expect(res3.error).toBeDefined();
+
+    // 7. Verify the activity state directly
+    const activityCall = activityManager.getActivityCallByName('ApprovalProcess')!;
+    const state = await activityCall.getState(controller, activityId);
+    expect(state.current).toBeUndefined();  // undefined = completed
   });
 });
 ```
@@ -724,7 +676,8 @@ Permission testing is an important component of interaqt application testing, re
 
 ```typescript
 import { describe, test, expect, beforeEach } from 'vitest';
-import { Controller, MonoSystem, KlassByName, PGLiteDB } from 'interaqt';
+import { Controller, MonoSystem, KlassByName } from 'interaqt';
+import { PGLiteDB } from 'interaqt/drivers';
 
 describe('Permission Testing', () => {
   let system: MonoSystem;

package/agent/agentspace/knowledge/usage/14-api-reference.md

@@ -299,6 +299,7 @@ const userTotalScore = Property.create({
     defaultValue: () => 0,  // Must provide default value
     computation: WeightedSummation.create({
         record: UserScoreRelation,
+        attributeQuery: ['multiplier', 'points'],  // Required when callback reads fields
         callback: function(scoreRecord) {
             return {
                 weight: scoreRecord.multiplier || 1,
@@ -311,6 +312,7 @@ const userTotalScore = Property.create({
 // Global weighted summation
 const globalWeightedScore = WeightedSummation.create({
     record: ScoreRecord,
+    attributeQuery: ['difficulty', 'score'],  // Required when callback reads fields
     callback: function(record) {
         return {
             weight: record.difficulty,
@@ -460,6 +462,7 @@ const completedAllRequired = Property.create({
     defaultValue: () => false,  // Must provide default value
     computation: Every.create({
         record: UserCourseRelation,
+        attributeQuery: ['status'],  // Required when callback reads fields
         callback: function(courseRelation) {
             return courseRelation.status === 'completed'
         },
@@ -491,6 +494,7 @@ const hasPendingTasks = Property.create({
     defaultValue: () => false,  // Must provide default value
     computation: Any.create({
         record: UserTaskRelation,
+        attributeQuery: ['status'],  // Required when callback reads fields
         callback: function(taskRelation) {
             return taskRelation.status === 'pending'
         }
@@ -530,6 +534,7 @@ Custom callbacks may be replayed after retryable transaction failures. Do not pe
 
 **Incremental planning**
 - If `incrementalCompute` or `incrementalPatchCompute` is provided, the computation must also provide `incrementalDataDeps` or `planIncremental`.
+- Mutation event snapshot shapes differ by type: `create` events carry the written fields in `record` (`oldRecord` is `undefined`); `update` events carry **only the changed fields** (+ `id`) in `record` and the full pre-update snapshot in `oldRecord`; `delete` events carry the full deleted snapshot in `record` (`oldRecord` is `undefined`). For updates, reconstruct the full new state with `{ ...mutationEvent.oldRecord, ...mutationEvent.record }` or re-fetch the record — reading unchanged fields off `mutationEvent.record` yields `undefined`.
 - `incrementalDataDeps: string[]` lists exactly which `dataDeps` keys should be resolved for the incremental callback; use `[]` when none are needed.
 - `planIncremental(event, record, context)` is the advanced form. Return `{ type: 'incremental', dataDepKeys, needsLastValue? }`, `{ type: 'fullRecompute', reason }`, or `{ type: 'skip', reason }`.
 - Incremental callbacks receive only planned partial `dataDeps`; the runtime no longer resolves all `dataDeps` before incremental execution.
@@ -621,7 +626,11 @@ const OrderStateMachine = StateMachine.create({
         StateTransfer.create({
             current: pendingState,
             next: confirmedState,
-            trigger: ConfirmOrderInteraction
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ConfirmOrderInteraction.name }
+            }
         })
     ],
     initialState: pendingState
@@ -927,23 +936,31 @@ StateTransfer.create(config: StateTransferConfig): KlassInstance<typeof StateTra
 ```
 
 **Parameters**
-- `config.trigger` (any, required): Trigger for the state transfer (usually an Interaction)
+- `config.trigger` (RecordMutationEventPattern, required): Pattern matched against record mutation events: `{ recordName, type, keys?, record?, oldRecord? }`. For interaction-triggered transfers use `{ recordName: InteractionEventEntity.name, type: 'create', record: { interactionName: SomeInteraction.name } }`. `keys` uses subset semantics (fires when the update touched all listed fields)
 - `config.current` (StateNode, required): Current state node
 - `config.next` (StateNode, required): Next state node
-- `config.computeTarget` (function, optional): Function to dynamically compute the target state
+- `config.computeTarget` (function, optional for global-level, **required for property-level** state machines): Maps a matched mutation event to the record(s) whose property should transition, e.g. `(event) => ({ id: event.record.payload.id })`
 
 **Examples**
 ```typescript
 // Simple state transfer
 const approveTransfer = StateTransfer.create({
-    trigger: ApproveInteraction,
+    trigger: {
+      recordName: InteractionEventEntity.name,
+      type: 'create',
+      record: { interactionName: ApproveInteraction.name }
+    },
     current: pendingState,
     next: approvedState
 });
 
 // State transfer with dynamic target computation
 const conditionalTransfer = StateTransfer.create({
-    trigger: ProcessInteraction,
+    trigger: {
+      recordName: InteractionEventEntity.name,
+      type: 'create',
+      record: { interactionName: ProcessInteraction.name }
+    },
     current: pendingState,
     next: approvedState, // Default next state
     computeTarget: (context) => {

package/agent/agentspace/knowledge/usage/15-entity-crud-patterns.md

@@ -363,14 +363,22 @@ const ArticleStatusStateMachine = StateMachine.create({
     StateTransfer.create({
       current: ActiveState,
       next: DeletedState,
-      trigger: DeleteArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     }),
     StateTransfer.create({
       current: DeletedState,
       next: ActiveState,
-      trigger: RestoreArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: RestoreArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     })
   ]
 });
@@ -418,14 +426,22 @@ const Article = Entity.create({
             StateTransfer.create({
               current: activeState,
               next: deletedState,
-              trigger: DeleteArticle,
-              computeTarget: (event) => ({ id: event.payload.articleId })
+              trigger: {
+                recordName: InteractionEventEntity.name,
+                type: 'create',
+                record: { interactionName: DeleteArticle.name }
+              },
+              computeTarget: (event) => ({ id: event.record.payload.articleId })
             }),
             StateTransfer.create({
               current: deletedState,
               next: activeState,
-              trigger: RestoreArticle,
-              computeTarget: (event) => ({ id: event.payload.articleId })
+              trigger: {
+                recordName: InteractionEventEntity.name,
+                type: 'create',
+                record: { interactionName: RestoreArticle.name }
+              },
+              computeTarget: (event) => ({ id: event.record.payload.articleId })
             })
           ],
           initialState: activeState
@@ -476,11 +492,15 @@ deletionProperty.computation = StateMachine.create({
   initialState: NON_DELETED_STATE,
   transfers: [
     StateTransfer.create({
-      trigger: DeleteArticle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteArticle.name }
+      },
       current: NON_DELETED_STATE,
       next: DELETED_STATE,
       computeTarget: function(event) {
-        return { id: event.payload.articleId };
+        return { id: event.record.payload.articleId };
       }
     })
   ]
@@ -611,14 +631,22 @@ const ArticlePublishStateMachine = StateMachine.create({
     StateTransfer.create({
       current: DraftState,
       next: PublishedState,
-      trigger: PublishArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: PublishArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     }),
     StateTransfer.create({
       current: PublishedState,
       next: DraftState,
-      trigger: UnpublishArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: UnpublishArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     })
   ]
 });
@@ -722,8 +750,12 @@ const TimestampStateMachine = StateMachine.create({
     StateTransfer.create({
       current: TimestampState,
       next: TimestampState,
-      trigger: RecordActivity,
-      computeTarget: (event) => ({ id: event.payload.entityId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: RecordActivity.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.entityId })
     })
   ]
 });
@@ -767,7 +799,11 @@ const User = Entity.create({
           StateTransfer.create({
             current: activeState,
             next: activeState,
-            trigger: UserActivityInteraction,
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: UserActivityInteraction.name }
+            },
             computeTarget: (event) => ({ id: event.user.id })
           })
         ],
@@ -801,8 +837,12 @@ const Article = Entity.create({
           StateTransfer.create({
             current: modifiedState,
             next: modifiedState,
-            trigger: UpdateArticleInteraction,
-            computeTarget: (event) => ({ id: event.payload.articleId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: UpdateArticleInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.articleId })
           })
         ],
         initialState: modifiedState
@@ -834,8 +874,12 @@ const Sensor = Entity.create({
           StateTransfer.create({
             current: triggeredState,
             next: triggeredState,
-            trigger: SensorTriggerInteraction,
-            computeTarget: (event) => ({ id: event.payload.sensorId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: SensorTriggerInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.sensorId })
           })
         ],
         initialState: triggeredState
@@ -896,7 +940,11 @@ Property.create({
       StateTransfer.create({
         current: activeState,
         next: activeState,
-        trigger: UserActivityInteraction,
+        trigger: {
+          recordName: InteractionEventEntity.name,
+          type: 'create',
+          record: { interactionName: UserActivityInteraction.name }
+        },
         computeTarget: (event) => ({ id: event.user.id })
       })
     ]
@@ -925,6 +973,7 @@ const User = Entity.create({
       computation: Count.create({
         record: UserArticleRelation,
         direction: 'target',
+        attributeQuery: [['source', { attributeQuery: ['status'] }]],  // Required when callback reads fields
         callback: (relation) => relation.source.status !== 'deleted'
       })
     })
@@ -1033,20 +1082,32 @@ const ArticleLifecycleStateMachine = StateMachine.create({
     StateTransfer.create({
       current: DraftState,
       next: PublishedState,
-      trigger: PublishArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: PublishArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     }),
     StateTransfer.create({
       current: PublishedState,
       next: DeletedState,
-      trigger: DeleteArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     }),
     StateTransfer.create({
       current: DraftState,
       next: DeletedState,
-      trigger: DeleteArticle,
-      computeTarget: (event) => ({ id: event.payload.articleId })
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteArticle.name }
+      },
+      computeTarget: (event) => ({ id: event.record.payload.articleId })
     })
   ]
 });