Special behaviour for temporal prefixes

packages/common/src/reserved.ts

@@ -0,0 +1,24 @@
+export const TEMPORAL_RESERVED_PREFIX = '__temporal_';
+export const STACK_TRACE_RESERVED_PREFIX = '__stack_trace';
+export const ENHANCED_STACK_TRACE_RESERVED_PREFIX = '__enhanced_stack_trace';
+
+export const reservedPrefixes = [
+  TEMPORAL_RESERVED_PREFIX,
+  STACK_TRACE_RESERVED_PREFIX,
+  ENHANCED_STACK_TRACE_RESERVED_PREFIX,
+];
+
+export function throwIfReservedName(type: string, name: string): void {
+  const prefix = isReservedName(name);
+  if (prefix) {
+    throw Error(`Cannot register ${type} name: '${name}', with reserved prefix: '${prefix}'`);
+  }
+}
+
+export function isReservedName(name: string): string | undefined {
+  for (const prefix of reservedPrefixes) {
+    if (name.startsWith(prefix)) {
+      return prefix;
+    }
+  }
+}

packages/test/src/test-integration-split-two.ts

@@ -14,7 +14,16 @@ import {
 import { msToNumber, tsToMs } from '@temporalio/common/lib/time';
 import { decode as payloadDecode, decodeFromPayloadsAtIndex } from '@temporalio/common/lib/internal-non-workflow';
 
-import { condition, defineQuery, defineSignal, setDefaultQueryHandler, setHandler, sleep } from '@temporalio/workflow';
+import {
+  condition,
+  defineQuery,
+  defineSignal,
+  defineUpdate,
+  setDefaultQueryHandler,
+  setHandler,
+  sleep,
+} from '@temporalio/workflow';
+import { reservedPrefixes } from '@temporalio/common/lib/reserved';
 import { configurableHelpers, createTestWorkflowBundle } from './helpers-integration';
 import * as activities from './activities';
 import * as workflows from './workflows';
@@ -751,3 +760,90 @@ test('default query handler is not used if requested query exists', configMacro,
     t.deepEqual(result, { name: definedQuery.name, args });
   });
 });
+
+test('Cannot register activities using reserved prefixes', configMacro, async (t, config) => {
+  const { createWorkerWithDefaults } = config;
+
+  for (const prefix of reservedPrefixes) {
+    const activityName = prefix + '_test';
+    await t.throwsAsync(
+      createWorkerWithDefaults(t, {
+        activities: { [activityName]: () => {} },
+      }),
+      {
+        instanceOf: Error,
+        message: `Cannot register activity name: '${activityName}', with reserved prefix: '${prefix}'`,
+      }
+    );
+  }
+});
+
+test('Cannot register task queues using reserved prefixes', configMacro, async (t, config) => {
+  const { createWorkerWithDefaults } = config;
+
+  for (const prefix of reservedPrefixes) {
+    const taskQueue = prefix + '_test';
+
+    await t.throwsAsync(
+      createWorkerWithDefaults(t, {
+        taskQueue,
+      }),
+      {
+        instanceOf: Error,
+        message: `Cannot register task queue name: '${taskQueue}', with reserved prefix: '${prefix}'`,
+      }
+    );
+  }
+});
+
+interface HandlerError {
+  name: string;
+  message: string;
+}
+
+export async function workflowBadPrefixHandler(prefix: string): Promise<HandlerError[]> {
+  // Re-package errors, default payload converter has trouble converting native errors (no 'data' field).
+  const expectedErrors: HandlerError[] = [];
+  try {
+    setHandler(defineSignal(prefix + '_signal'), () => {});
+  } catch (e) {
+    if (e instanceof Error) {
+      expectedErrors.push({ name: e.name, message: e.message });
+    }
+  }
+  try {
+    setHandler(defineUpdate(prefix + '_update'), () => {});
+  } catch (e) {
+    if (e instanceof Error) {
+      expectedErrors.push({ name: e.name, message: e.message });
+    }
+  }
+  try {
+    setHandler(defineQuery(prefix + '_query'), () => {});
+  } catch (e) {
+    if (e instanceof Error) {
+      expectedErrors.push({ name: e.name, message: e.message });
+    }
+  }
+  return expectedErrors;
+}
+
+test('Workflow failure if define signals/updates/queries with reserved prefixes', configMacro, async (t, config) => {
+  const { env, createWorkerWithDefaults } = config;
+  const { executeWorkflow } = configurableHelpers(t, t.context.workflowBundle, env);
+  const worker = await createWorkerWithDefaults(t);
+  await worker.runUntil(async () => {
+    const prefix = reservedPrefixes[0];
+    // for (const prefix of reservedPrefixes) {
+    const result = await executeWorkflow(workflowBadPrefixHandler, {
+      args: [prefix],
+    });
+    console.log('result', result);
+    t.deepEqual(result, [
+      { name: 'Error', message: `Cannot register signal name: '${prefix}_signal', with reserved prefix: '${prefix}'` },
+      { name: 'Error', message: `Cannot register update name: '${prefix}_update', with reserved prefix: '${prefix}'` },
+      { name: 'Error', message: `Cannot register query name: '${prefix}_query', with reserved prefix: '${prefix}'` },
+    ]);
+    // }
+  });
+});

packages/test/src/test-workflows.ts

@@ -20,6 +20,12 @@ import { VMWorkflow, VMWorkflowCreator } from '@temporalio/worker/lib/workflow/v
 import { SdkFlag, SdkFlags } from '@temporalio/workflow/lib/flags';
 import { ReusableVMWorkflow, ReusableVMWorkflowCreator } from '@temporalio/worker/lib/workflow/reusable-vm';
 import { parseWorkflowCode } from '@temporalio/worker/lib/worker';
+import {
+  ENHANCED_STACK_TRACE_RESERVED_PREFIX,
+  reservedPrefixes,
+  STACK_TRACE_RESERVED_PREFIX,
+  TEMPORAL_RESERVED_PREFIX,
+} from '@temporalio/common/lib/reserved';
 import * as activityFunctions from './activities';
 import { cleanStackTrace, REUSE_V8_CONTEXT, u8 } from './helpers';
 import { ProcessedSignal } from './workflows';
@@ -2528,3 +2534,83 @@ test('Signals/Updates/Activities/Timers - Trace promises completion order - 1.11
     );
   }
 });
+
+test('Default query handler fail activations with reserved names - workflowWithDefaultHandlers', async (t) => {
+  const { workflowType } = t.context;
+
+  await activate(t, makeActivation(undefined, makeInitializeWorkflowJob(workflowType)));
+
+  for (const prefix of reservedPrefixes) {
+    const completion = await activate(t, makeActivation(undefined, makeQueryWorkflowJob('1', prefix + '_query')));
+
+    compareCompletion(t, completion, {
+      failed: {
+        failure: {
+          ...completion.failed?.failure,
+          // We only care about the error message.
+          message: `Cannot register query name: '${prefix}_query', with reserved prefix: '${prefix}'`,
+        },
+      },
+    });
+  }
+});
+
+test('Default signal handler fail activations with temporal prefix - workflowWithDefaultHandlers', async (t) => {
+  const { workflowType } = t.context;
+
+  await activate(t, makeActivation(undefined, makeInitializeWorkflowJob(workflowType)));
+  const signalName = TEMPORAL_RESERVED_PREFIX + '_signal';
+  const job = makeSignalWorkflowJob(signalName, []);
+
+  const completion = await activate(t, makeActivation(undefined, job));
+
+  compareCompletion(t, completion, {
+    failed: {
+      failure: {
+        ...completion.failed?.failure,
+        // We only care about the error message.
+        message: `Cannot register signal name: '${signalName}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`,
+      },
+    },
+  });
+});
+
+test('Default signal handler fail activations with stack trace prefix - workflowWithDefaultHandlers', async (t) => {
+  const { workflowType } = t.context;
+
+  await activate(t, makeActivation(undefined, makeInitializeWorkflowJob(workflowType)));
+  const signalName = STACK_TRACE_RESERVED_PREFIX + '_signal';
+  const job = makeSignalWorkflowJob(signalName, []);
+
+  const completion = await activate(t, makeActivation(undefined, job));
+
+  compareCompletion(t, completion, {
+    failed: {
+      failure: {
+        ...completion.failed?.failure,
+        // We only care about the error message.
+        message: `Cannot register signal name: '${signalName}', with reserved prefix: '${STACK_TRACE_RESERVED_PREFIX}'`,
+      },
+    },
+  });
+});
+
+test('Default signal handler fail activations with enhanced stack trace prefix - workflowWithDefaultHandlers', async (t) => {
+  const { workflowType } = t.context;
+
+  await activate(t, makeActivation(undefined, makeInitializeWorkflowJob(workflowType)));
+  const signalName = ENHANCED_STACK_TRACE_RESERVED_PREFIX + '_signal';
+  const job = makeSignalWorkflowJob(signalName, []);
+
+  const completion = await activate(t, makeActivation(undefined, job));
+
+  compareCompletion(t, completion, {
+    failed: {
+      failure: {
+        ...completion.failed?.failure,
+        // We only care about the error message.
+        message: `Cannot register signal name: '${signalName}', with reserved prefix: '${ENHANCED_STACK_TRACE_RESERVED_PREFIX}'`,
+      },
+    },
+  });
+});

packages/test/src/workflows/index.ts

@@ -89,3 +89,4 @@ export * from './upsert-and-read-search-attributes';
 export * from './wait-on-user';
 export * from './workflow-cancellation-scenarios';
 export * from './upsert-and-read-memo';
+export * from './workflow-with-default-handlers';

packages/test/src/workflows/workflow-with-default-handlers.ts

@@ -0,0 +1,16 @@
+import {
+  condition,
+  defineSignal,
+  setDefaultQueryHandler,
+  setDefaultSignalHandler,
+  setHandler,
+} from '@temporalio/workflow';
+
+export async function workflowWithDefaultHandlers(): Promise<void> {
+  const complete = true;
+  setDefaultQueryHandler(() => {});
+  setDefaultSignalHandler(() => {});
+  setHandler(defineSignal('completeSignal'), () => {});
+
+  await condition(() => complete);
+}

packages/worker/src/worker-options.ts

@@ -8,6 +8,7 @@ import { LoggerSinks } from '@temporalio/workflow';
 import { Context } from '@temporalio/activity';
 import { checkExtends } from '@temporalio/common/lib/type-helpers';
 import { WorkerOptions as NativeWorkerOptions, WorkerTuner as NativeWorkerTuner } from '@temporalio/core-bridge';
+import { throwIfReservedName } from '@temporalio/common/lib/reserved';
 import { ActivityInboundLogInterceptor } from './activity-log-interceptor';
 import { NativeConnection } from './connection';
 import { CompiledWorkerInterceptors, WorkerInterceptors } from './interceptors';
@@ -822,6 +823,9 @@ export function compileWorkerOptions(rawOpts: WorkerOptions, logger: Logger): Co
   }
 
   const activities = new Map(Object.entries(opts.activities ?? {}).filter(([_, v]) => typeof v === 'function'));
+  for (const activityName of activities.keys()) {
+    throwIfReservedName('activity', activityName);
+  }
   const tuner = asNativeTuner(opts.tuner, logger);
 
   return {

packages/worker/src/worker.ts

@@ -55,6 +55,7 @@ import * as native from '@temporalio/core-bridge';
 import { ShutdownError, UnexpectedError } from '@temporalio/core-bridge';
 import { coresdk, temporal } from '@temporalio/proto';
 import { type SinkCall, type WorkflowInfo } from '@temporalio/workflow';
+import { throwIfReservedName } from '@temporalio/common/lib/reserved';
 import { Activity, CancelReason, activityLogAttributes } from './activity';
 import { extractNativeClient, extractReferenceHolders, InternalNativeConnection, NativeConnection } from './connection';
 import { ActivityExecuteInput } from './interceptors';
@@ -462,6 +463,7 @@ export class Worker {
    * This method initiates a connection to the server and will throw (asynchronously) on connection failure.
    */
   public static async create(options: WorkerOptions): Promise<Worker> {
+    throwIfReservedName('task queue', options.taskQueue);
     const logger = withMetadata(Runtime.instance().logger, {
       sdkComponent: SdkComponent.worker,
       taskQueue: options.taskQueue ?? 'default',

packages/workflow/src/internals.ts

@@ -26,6 +26,12 @@ import {
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import type { coresdk, temporal } from '@temporalio/proto';
+import {
+  ENHANCED_STACK_TRACE_RESERVED_PREFIX,
+  STACK_TRACE_RESERVED_PREFIX,
+  isReservedName,
+  throwIfReservedName,
+} from '@temporalio/common/lib/reserved';
 import { alea, RNG } from './alea';
 import { RootCancellationScope } from './cancellation-scope';
 import { UpdateScope } from './update-scope';
@@ -249,7 +255,7 @@ export class Activator implements ActivationHandler {
    */
   public readonly queryHandlers = new Map<string, WorkflowQueryAnnotatedType>([
     [
-      '__stack_trace',
+      STACK_TRACE_RESERVED_PREFIX,
       {
         handler: () => {
           return this.getStackTraces()
@@ -260,7 +266,7 @@ export class Activator implements ActivationHandler {
       },
     ],
     [
-      '__enhanced_stack_trace',
+      ENHANCED_STACK_TRACE_RESERVED_PREFIX,
       {
         handler: (): EnhancedStackTrace => {
           const { sourceMap } = this;
@@ -619,6 +625,8 @@ export class Activator implements ActivationHandler {
   protected queryWorkflowNextHandler({ queryName, args }: QueryInput): Promise<unknown> {
     let fn = this.queryHandlers.get(queryName)?.handler;
     if (fn === undefined && this.defaultQueryHandler !== undefined) {
+      // Do not call default query handler with reserved query name.
+      throwIfReservedName('query', queryName);
       fn = this.defaultQueryHandler.bind(this, queryName);
     }
     // No handler or default registered, fail.
@@ -649,17 +657,28 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing query activation attributes');
     }
 
+    const queryInput = {
+      queryName: queryType,
+      args: arrayFromPayloads(this.payloadConverter, activation.arguments),
+      queryId,
+      headers: headers ?? {},
+    };
+
+    // Skip interceptors if this is an internal query.
+    if (isReservedName(queryType)) {
+      this.queryWorkflowNextHandler(queryInput).then(
+        (result) => this.completeQuery(queryId, result),
+        (reason) => this.failQuery(queryId, reason)
+      );
+      return;
+    }
+
     const execute = composeInterceptors(
       this.interceptors.inbound,
       'handleQuery',
       this.queryWorkflowNextHandler.bind(this)
     );
-    execute({
-      queryName: queryType,
-      args: arrayFromPayloads(this.payloadConverter, activation.arguments),
-      queryId,
-      headers: headers ?? {},
-    }).then(
+    execute(queryInput).then(
       (result) => this.completeQuery(queryId, result),
       (reason) => this.failQuery(queryId, reason)
     );
@@ -797,6 +816,8 @@ export class Activator implements ActivationHandler {
     if (fn) {
       return await fn(...args);
     } else if (this.defaultSignalHandler) {
+      // Do not call default signal handler with reserved signal name.
+      throwIfReservedName('signal', signalName);
       return await this.defaultSignalHandler(signalName, ...args);
     } else {
       throw new IllegalStateError(`No registered signal handler for signal: ${signalName}`);

packages/workflow/src/workflow.ts

@@ -25,6 +25,7 @@ import { versioningIntentToProto } from '@temporalio/common/lib/versioning-inten
 import { Duration, msOptionalToTs, msToNumber, msToTs, requiredTsToMs } from '@temporalio/common/lib/time';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { temporal } from '@temporalio/proto';
+import { throwIfReservedName } from '@temporalio/common/lib/reserved';
 import { CancellationScope, registerSleepImplementation } from './cancellation-scope';
 import { UpdateScope } from './update-scope';
 import {
@@ -1258,6 +1259,8 @@ export function setHandler<
   options?: QueryHandlerOptions | SignalHandlerOptions | UpdateHandlerOptions<Args>
 ): void {
   const activator = assertInWorkflowContext('Workflow.setHandler(...) may only be used from a Workflow Execution.');
+  // Cannot register handler for reserved names
+  throwIfReservedName(def.type, def.name);
   const description = options?.description;
   if (def.type === 'update') {
     if (typeof handler === 'function') {