feat(workflow): add upsert memo command

packages/test/src/integration-tests-old.ts

@@ -677,6 +677,20 @@ export function runIntegrationTests(codec?: PayloadCodec): void {
     );
   });
 
+  test('Workflow can upsert memo', async (t) => {
+    const { client } = t.context;
+    const workflow = await client.start(workflows.upsertAndReadMemo, {
+      taskQueue: 'test',
+      workflowId: uuid4(),
+      args: [{ note2: 'bar' }],
+    });
+    const result = await workflow.result();
+    t.deepEqual(result, {
+      note: 'foo',
+      note2: 'bar',
+    });
+  });
+
   test('Workflow can read WorkflowInfo', async (t) => {
     const { client } = t.context;
     const workflowId = uuid4();

packages/test/src/test-sinks.ts

@@ -432,6 +432,44 @@ if (RUN_INTEGRATION_TESTS) {
     ]);
   });
 
+  test('Sink functions contains upserted memo', async (t) => {
+    const taskQueue = `${__filename}-${t.title}`;
+
+    const recordedMessages = Array<{ message: string; memo: Record<string, unknown> | undefined }>();
+    const sinks = asSdkLoggerSink(async (info, message, _attrs) => {
+      recordedMessages.push({
+        message,
+        memo: info.memo,
+      });
+    });
+
+    const client = new WorkflowClient();
+
+    const worker = await Worker.create({
+      ...defaultOptions,
+      taskQueue,
+      sinks,
+    });
+    await worker.runUntil(
+      client.execute(workflows.upsertAndReadMemo, {
+        taskQueue,
+        workflowId: uuid4(),
+        args: [{ note: 'foo' }],
+      })
+    );
+
+    t.deepEqual(recordedMessages, [
+      {
+        message: 'Workflow started',
+        memo: undefined,
+      },
+      {
+        message: 'Workflow completed',
+        memo: { note: 'foo' },
+      },
+    ]);
+  });
+
   test('Core issue 589', async (t) => {
     const taskQueue = `${__filename}-${t.title}`;
 

packages/test/src/workflows/index.ts

@@ -96,3 +96,4 @@ export * from './upsert-and-read-search-attributes';
 export * from './url-whatwg';
 export * from './wait-on-user';
 export * from './workflow-cancellation-scenarios';
+export * from './upsert-and-read-memo';

packages/test/src/workflows/upsert-and-read-memo.ts

@@ -0,0 +1,6 @@
+import { upsertMemo, workflowInfo } from '@temporalio/workflow';
+
+export async function upsertAndReadMemo(memo: Record<string, unknown>): Promise<Record<string, unknown> | undefined> {
+  upsertMemo(memo);
+  return workflowInfo().memo;
+}

packages/workflow/src/workflow.ts

@@ -1368,6 +1368,56 @@ export function upsertSearchAttributes(searchAttributes: SearchAttributes): void
   });
 }
 
+/**
+ * Updates this Workflow's Memo by merging the provided `memo` with the existing Memo,
+ * `workflowInfo().memo`.
+ *
+ * For example, this Workflow code:
+ *
+ * ```ts
+ * upsertMemo({
+ *   key1: value,
+ * });
+ * upsertMemo({
+ *   key2: value,
+ * });
+ * ```
+ *
+ * would result in the Workflow having these Memo:
+ *
+ * ```ts
+ * {
+ *   key1: value,
+ *   key2: value,
+ * }
+ * ```
+ *
+ * @param memo The Record to merge. Use a value of `null` to clear a key from the Memo.
+ */
+export function upsertMemo(memo: Record<string, unknown>): void {
+  const activator = assertInWorkflowContext('Workflow.upsertMemo(...) may only be used from a Workflow Execution.');
+
+  if (memo == null) {
+    throw new Error('memo must be a non-null Record');
+  }
+
+  activator.pushCommand({
+    modifyWorkflowProperties: {
+      upsertedMemo: mapToPayloads(activator.payloadConverter, memo),
+    },
+  });
+
+  activator.mutateWorkflowInfo((info: WorkflowInfo): WorkflowInfo => {
+    return {
+      ...info,
+      memo: {
+        ...info.memo,
+        ...memo,
+      },
+    };
+  });
+}
+
 export const stackTraceQuery = defineQuery<string>('__stack_trace');
 export const enhancedStackTraceQuery = defineQuery<EnhancedStackTrace>('__enhanced_stack_trace');
 export const workflowMetadataQuery = defineQuery<temporal.api.sdk.v1.IWorkflowMetadata>('__temporal_workflow_metadata');