Expose root execution info

packages/client/src/helpers.ts

@@ -78,6 +78,12 @@ export async function executionInfoFromRaw<T>(
           runId: raw.parentExecution.runId!,
         }
       : undefined,
+    rootExecution: raw.rootExecution
+      ? {
+          workflowId: raw.rootExecution.workflowId!,
+          runId: raw.rootExecution.runId!,
+        }
+      : undefined,
     raw: rawDataToEmbed,
   };
 }

packages/client/src/types.ts

@@ -51,6 +51,7 @@ export interface WorkflowExecutionInfo {
   searchAttributes: SearchAttributes; // eslint-disable-line deprecation/deprecation
   typedSearchAttributes: TypedSearchAttributes;
   parentExecution?: Required<proto.temporal.api.common.v1.IWorkflowExecution>;
+  rootExecution?: Required<proto.temporal.api.common.v1.IWorkflowExecution>;
   raw: RawWorkflowExecutionInfo;
 }
 

packages/test/src/test-integration-workflows.ts

@@ -24,7 +24,7 @@ import { activityStartedSignal } from './workflows/definitions';
 import * as workflows from './workflows';
 import { Context, createLocalTestEnvironment, helpers, makeTestFunction } from './helpers-integration';
 import { overrideSdkInternalFlag } from './mock-internal-flags';
-import { asSdkLoggerSink, loadHistory, RUN_TIME_SKIPPING_TESTS } from './helpers';
+import { asSdkLoggerSink, loadHistory, RUN_TIME_SKIPPING_TESTS, waitUntil } from './helpers';
 
 const test = makeTestFunction({
   workflowsPath: __filename,
@@ -1337,3 +1337,55 @@ test('can register search attributes to dev server', async (t) => {
   t.deepEqual(desc.searchAttributes, { 'new-search-attr': [12] }); // eslint-disable-line deprecation/deprecation
   await env.teardown();
 });
+
+export async function ChildWorkflowInfo(): Promise<workflow.RootWorkflowInfo | undefined> {
+  let blocked = true;
+  workflow.setHandler(unblockSignal, () => {
+    blocked = false;
+  });
+  await workflow.condition(() => !blocked);
+  return workflow.workflowInfo().root;
+}
+
+export async function WithChildWorkflow(childWfId: string): Promise<workflow.RootWorkflowInfo | undefined> {
+  return await workflow.executeChild(ChildWorkflowInfo, {
+    workflowId: childWfId,
+  });
+}
+
+test('root execution is exposed', async (t) => {
+  const { createWorker, startWorkflow } = helpers(t);
+  const worker = await createWorker();
+
+  await worker.runUntil(async () => {
+    const childWfId = 'child-wf-id';
+    const handle = await startWorkflow(WithChildWorkflow, {
+      args: [childWfId],
+    });
+
+    const childHandle = t.context.env.client.workflow.getHandle(childWfId);
+    const childStarted = async (): Promise<boolean> => {
+      try {
+        await childHandle.describe();
+        return true;
+      } catch (e) {
+        if (e instanceof workflow.WorkflowNotFoundError) {
+          return false;
+        } else {
+          throw e;
+        }
+      }
+    };
+    await waitUntil(childStarted, 5000);
+    const childDesc = await childHandle.describe();
+    const parentDesc = await handle.describe();
+
+    t.true(childDesc.rootExecution?.workflowId === parentDesc.workflowId);
+    t.true(childDesc.rootExecution?.runId === parentDesc.runId);
+
+    await childHandle.signal(unblockSignal);
+    const childWfInfoRoot = await handle.result();
+    t.true(childWfInfoRoot?.workflowId === parentDesc.workflowId);
+    t.true(childWfInfoRoot?.runId === parentDesc.runId);
+  });
+});

packages/test/src/test-schedules.ts

@@ -773,7 +773,7 @@ if (RUN_INTEGRATION_TESTS) {
         const exists =
           desc.typedSearchAttributes.getAll().find((pair) => pair.key.name === attributeName) !== undefined;
         return exists === shouldExist;
-      }, 300);
+      }, 5000);
       return await handle.describe();
     };
 

packages/test/src/test-sinks.ts

@@ -117,6 +117,7 @@ if (RUN_INTEGRATION_TESTS) {
       lastResult: undefined,
       memo: {},
       parent: undefined,
+      root: undefined,
       searchAttributes: {},
       // FIXME: consider rehydrating the class before passing to sink functions or
       // create a variant of WorkflowInfo that corresponds to what we actually get in sinks.

packages/test/src/test-typed-search-attributes.ts

@@ -135,7 +135,7 @@ if (test?.serial?.before) {
         Object.keys(untypedKeys).every((key) => key in resp.customAttributes) &&
         Object.keys(typedKeys).every((key) => key in resp.customAttributes)
       );
-    }, 300);
+    }, 5000);
   });
 }
 

packages/worker/src/utils.ts

@@ -1,5 +1,5 @@
-import type { coresdk } from '@temporalio/proto';
-import { IllegalStateError, ParentWorkflowInfo } from '@temporalio/workflow';
+import type { coresdk, temporal } from '@temporalio/proto';
+import { IllegalStateError, ParentWorkflowInfo, RootWorkflowInfo } from '@temporalio/workflow';
 
 export const MiB = 1024 ** 2;
 
@@ -28,3 +28,19 @@ export function convertToParentWorkflowType(
     namespace: parent.namespace,
   };
 }
+
+export function convertToRootWorkflowType(
+  root: temporal.api.common.v1.IWorkflowExecution | null | undefined
+): RootWorkflowInfo | undefined {
+  if (root == null) {
+    return undefined;
+  }
+  if (!root.workflowId || !root.runId) {
+    throw new IllegalStateError('Root workflow execution is missing a field that should be defined');
+  }
+
+  return {
+    workflowId: root.workflowId,
+    runId: root.runId,
+  };
+}

packages/worker/src/worker.ts

@@ -70,7 +70,7 @@ import {
 } from './replay';
 import { History, Runtime } from './runtime';
 import { CloseableGroupedObservable, closeableGroupBy, mapWithState, mergeMapWithState } from './rxutils';
-import { byteArrayToBuffer, convertToParentWorkflowType } from './utils';
+import { byteArrayToBuffer, convertToParentWorkflowType, convertToRootWorkflowType } from './utils';
 import {
   CompiledWorkerOptions,
   CompiledWorkerOptionsWithBuildId,
@@ -1258,6 +1258,7 @@ export class Worker {
       randomnessSeed,
       workflowType,
       parentWorkflowInfo,
+      rootWorkflow,
       workflowExecutionTimeout,
       workflowRunTimeout,
       workflowTaskTimeout,
@@ -1279,6 +1280,7 @@ export class Worker {
       searchAttributes: {},
       typedSearchAttributes: new TypedSearchAttributes(),
       parent: convertToParentWorkflowType(parentWorkflowInfo),
+      root: convertToRootWorkflowType(rootWorkflow),
       taskQueue: this.options.taskQueue,
       namespace: this.options.namespace,
       firstExecutionRunId,

packages/workflow/src/index.ts

@@ -96,6 +96,7 @@ export {
   StackTraceFileSlice,
   ParentClosePolicy,
   ParentWorkflowInfo,
+  RootWorkflowInfo,
   StackTraceSDKInfo,
   StackTrace,
   UnsafeWorkflowInfo,

packages/workflow/src/interfaces.ts

@@ -62,6 +62,11 @@ export interface WorkflowInfo {
    */
   readonly parent?: ParentWorkflowInfo;
 
+  /**
+   * Root Workflow info
+   */
+  readonly root?: RootWorkflowInfo;
+
   /**
    * Result from the previous Run (present if this is a Cron Workflow or was Continued As New).
    *
@@ -223,6 +228,11 @@ export interface ParentWorkflowInfo {
   namespace: string;
 }
 
+export interface RootWorkflowInfo {
+  workflowId: string;
+  runId: string;
+}
+
 /**
  * Not an actual error, used by the Workflow runtime to abort execution when {@link continueAsNew} is called
  */