feat: Improve activity registration and proxy types (#742)

Co-authored-by: Loren ☺️ <251288+lorensr@users.noreply.github.com>

Author: bergundy

packages/activity/src/index.ts

@@ -30,7 +30,11 @@ import { msToNumber } from '@temporalio/internal-workflow-common';
 import { AbortSignal } from 'abort-controller';
 import { AsyncLocalStorage } from 'async_hooks';
 export { CancelledFailure } from '@temporalio/common';
-export { ActivityFunction, ActivityInterface } from '@temporalio/internal-workflow-common';
+export {
+  ActivityFunction,
+  ActivityInterface, // eslint-disable-line deprecation/deprecation
+  UntypedActivities,
+} from '@temporalio/internal-workflow-common';
 export * from '@temporalio/internal-workflow-common/lib/errors';
 
 /**

packages/internal-workflow-common/src/activity-options.ts

@@ -144,12 +144,3 @@ export interface LocalActivityOptions {
    */
   cancellationType?: coresdk.workflow_commands.ActivityCancellationType;
 }
-
-export interface ActivityFunction<P extends any[], R> {
-  (...args: P): Promise<R>;
-}
-
-/**
- * Mapping of Activity name to function
- */
-export type ActivityInterface = Record<string, ActivityFunction<any[], any>>;

packages/internal-workflow-common/src/interfaces.ts

@@ -47,3 +47,18 @@ export type WorkflowResultType<W extends Workflow> = ReturnType<W> extends Promi
  */
 export type SearchAttributes = Record<string, SearchAttributeValue | undefined>;
 export type SearchAttributeValue = string[] | number[] | boolean[] | Date[];
+
+export interface ActivityFunction<P extends any[] = any[], R = any> {
+  (...args: P): Promise<R>;
+}
+
+/**
+ * Mapping of Activity name to function
+ * @deprecated not required anymore, for untyped activities use {@link UntypedActivities}
+ */
+export type ActivityInterface = Record<string, ActivityFunction>;
+
+/**
+ * Mapping of Activity name to function
+ */
+export type UntypedActivities = Record<string, ActivityFunction>;

packages/test/src/activities/async-completer.ts

@@ -1,7 +1,7 @@
 import { Observer } from 'rxjs';
-import { ActivityInterface, CompleteAsyncError, Context, Info } from '@temporalio/activity';
+import { CompleteAsyncError, Context, Info } from '@temporalio/activity';
 
-export interface Activities extends ActivityInterface {
+export interface Activities {
   completeAsync(): Promise<string>;
 }
 

packages/worker/src/worker-options.ts

@@ -1,6 +1,6 @@
 import { DataConverter, LoadedDataConverter } from '@temporalio/common';
 import { loadDataConverter } from '@temporalio/internal-non-workflow-common';
-import { ActivityInterface, msToNumber } from '@temporalio/internal-workflow-common';
+import { msToNumber } from '@temporalio/internal-workflow-common';
 import os from 'os';
 import { NativeConnection } from './connection';
 import { WorkerInterceptors } from './interceptors';
@@ -63,9 +63,9 @@ export interface WorkerOptions {
   taskQueue: string;
 
   /**
-   * Mapping of activity name to implementation.
+   * Mapping of activity name to implementation
    */
-  activities?: ActivityInterface;
+  activities?: object;
 
   /**
    * Path to look up workflows in, any function exported in this path will be registered as a Workflows in this Worker.

packages/worker/src/worker.ts

@@ -757,7 +757,8 @@ export class Worker {
                     );
 
                     const { activityType } = info;
-                    const fn = this.options.activities?.[activityType];
+                    // activities is of type "object" which does not support string indexes
+                    const fn = (this.options.activities as any)?.[activityType];
                     if (typeof fn !== 'function') {
                       output = {
                         type: 'result',

packages/workflow/src/index.ts

@@ -61,9 +61,10 @@ export {
 export {
   ActivityCancellationType,
   ActivityFunction,
-  ActivityInterface,
+  ActivityInterface, // eslint-disable-line deprecation/deprecation
   ActivityOptions,
   RetryPolicy,
+  UntypedActivities,
 } from '@temporalio/internal-workflow-common';
 export * from '@temporalio/internal-workflow-common/lib/errors';
 export * from '@temporalio/internal-workflow-common/lib/interfaces';

packages/workflow/src/workflow.ts

@@ -1,7 +1,6 @@
 import { mapToPayloads, searchAttributePayloadConverter, toPayloads } from '@temporalio/common';
 import {
   ActivityFunction,
-  ActivityInterface,
   ActivityOptions,
   compileRetryPolicy,
   composeInterceptors,
@@ -14,6 +13,7 @@ import {
   SearchAttributes,
   SignalDefinition,
   tsToMs,
+  UntypedActivities,
   WithWorkflowArgs,
   Workflow,
   WorkflowResultType,
@@ -117,13 +117,6 @@ export function sleep(ms: number | string): Promise<void> {
   });
 }
 
-export interface ActivityInfo {
-  name: string;
-  type: string;
-}
-
-export type InternalActivityFunction<P extends any[], R> = ActivityFunction<P, R> & ActivityInfo;
-
 function validateActivityOptions(options: ActivityOptions): void {
   if (options.scheduleToCloseTimeout === undefined && options.startToCloseTimeout === undefined) {
     throw new TypeError('Required either scheduleToCloseTimeout or startToCloseTimeout');
@@ -444,6 +437,43 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
   });
 }
 
+/**
+ * Symbol used in the return type of proxy methods to mark that an attribute on the source type is not a method.
+ *
+ * @see {@link ActivityInterfaceFor}
+ * @see {@link proxyActivities}
+ * @see {@link proxyLocalActivities}
+ */
+export const NotAnActivityMethod = Symbol.for('__TEMPORAL_NOT_AN_ACTIVITY_METHOD');
+
+/**
+ * Type helper that takes a type `T` and transforms attributes that are not {@link ActivityFunction} to
+ * {@link NotAnActivityMethod}.
+ *
+ * @example
+ *
+ * Used by {@link proxyActivities} to get this compile-time error:
+ *
+ * ```ts
+ * interface MyActivities {
+ *   valid(input: number): Promise<number>;
+ *   invalid(input: number): number;
+ * }
+ *
+ * const act = proxyActivities<MyActivities>({ startToCloseTimeout: '5m' });
+ *
+ * await act.valid(true);
+ * await act.invalid();
+ * // ^ TS complains with:
+ * // (property) invalidDefinition: typeof NotAnActivityMethod
+ * // This expression is not callable.
+ * // Type 'Symbol' has no call signatures.(2349)
+ * ```
+ */
+export type ActivityInterfaceFor<T> = {
+  [K in keyof T]: T[K] extends ActivityFunction ? T[K] : typeof NotAnActivityMethod;
+};
+
 /**
  * Configure Activity functions with given {@link ActivityOptions}.
  *
@@ -452,11 +482,9 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
  * @return a [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
  *         for which each attribute is a callable Activity function
  *
- * @typeparam A An {@link ActivityInterface} - mapping of name to function
- *
  * @example
  * ```ts
- * import { proxyActivities, ActivityInterface } from '@temporalio/workflow';
+ * import { proxyActivities } from '@temporalio/workflow';
  * import * as activities from '../activities';
  *
  * // Setup Activities from module exports
@@ -465,7 +493,7 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
  * });
  *
  * // Setup Activities from an explicit interface (e.g. when defined by another SDK)
- * interface JavaActivities extends ActivityInterface {
+ * interface JavaActivities {
  *   httpGetFromJava(url: string): Promise<string>
  *   someOtherJavaActivity(arg1: number, arg2: string): Promise<string>;
  * }
@@ -484,7 +512,7 @@ function signalWorkflowNextHandler({ seq, signalName, args, target, headers }: S
  * }
  * ```
  */
-export function proxyActivities<A extends ActivityInterface>(options: ActivityOptions): A {
+export function proxyActivities<A = UntypedActivities>(options: ActivityOptions): ActivityInterfaceFor<A> {
   if (options === undefined) {
     throw new TypeError('options must be defined');
   }
@@ -513,13 +541,11 @@ export function proxyActivities<A extends ActivityInterface>(options: ActivityOp
  * @return a [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
  *         for which each attribute is a callable Activity function
  *
- * @typeparam A An {@link ActivityInterface} - mapping of name to function
- *
  * @experimental
  *
  * See {@link proxyActivities} for examples
  */
-export function proxyLocalActivities<A extends ActivityInterface>(options: LocalActivityOptions): A {
+export function proxyLocalActivities<A = UntypedActivities>(options: LocalActivityOptions): ActivityInterfaceFor<A> {
   if (options === undefined) {
     throw new TypeError('options must be defined');
   }