@temporalio/common 1.3.0 → 1.4.0

package/src/failure.ts

@@ -1,6 +1,5 @@
-import { checkExtends, hasOwnProperties, isRecord } from '@temporalio/internal-workflow-common';
 import type { temporal } from '@temporalio/proto';
-import { arrayFromPayloads, fromPayloadsAtIndex, PayloadConverter, toPayloads } from './converter/payload-converter';
+import { checkExtends, isRecord } from './type-helpers';
 
 export const FAILURE_SOURCE = 'TypeScriptSDK';
 export type ProtoFailure = temporal.api.failure.v1.IFailure;
@@ -263,153 +262,6 @@ export class ChildWorkflowFailure extends TemporalFailure {
   }
 }
 
-/**
- * Converts an error to a Failure proto message if defined or returns undefined
- */
-export function optionalErrorToOptionalFailure(
-  err: unknown,
-  payloadConverter: PayloadConverter
-): ProtoFailure | undefined {
-  return err ? errorToFailure(err, payloadConverter) : undefined;
-}
-
-/**
- * Stack traces will be cutoff when on of these patterns is matched
- */
-const CUTOFF_STACK_PATTERNS = [
-  /** Activity execution */
-  /\s+at Activity\.execute \(.*[\\/]worker[\\/](?:src|lib)[\\/]activity\.[jt]s:\d+:\d+\)/,
-  /** Workflow activation */
-  /\s+at Activator\.\S+NextHandler \(.*[\\/]workflow[\\/](?:src|lib)[\\/]internals\.[jt]s:\d+:\d+\)/,
-  /** Workflow run anything in context */
-  /\s+at Script\.runInContext \((?:node:vm|vm\.js):\d+:\d+\)/,
-];
-
-/**
- * Cuts out the framework part of a stack trace, leaving only user code entries
- */
-export function cutoffStackTrace(stack?: string): string {
-  const lines = (stack ?? '').split(/\r?\n/);
-  const acc = Array<string>();
-  lineLoop: for (const line of lines) {
-    for (const pattern of CUTOFF_STACK_PATTERNS) {
-      if (pattern.test(line)) break lineLoop;
-    }
-    acc.push(line);
-  }
-  return acc.join('\n');
-}
-
-/**
- * Converts a caught error to a Failure proto message
- */
-export function errorToFailure(err: unknown, payloadConverter: PayloadConverter): ProtoFailure {
-  if (err instanceof TemporalFailure) {
-    if (err.failure) return err.failure;
-
-    const base = {
-      message: err.message,
-      stackTrace: cutoffStackTrace(err.stack),
-      cause: optionalErrorToOptionalFailure(err.cause, payloadConverter),
-      source: FAILURE_SOURCE,
-    };
-    if (err instanceof ActivityFailure) {
-      return {
-        ...base,
-        activityFailureInfo: {
-          ...err,
-          activityType: { name: err.activityType },
-        },
-      };
-    }
-    if (err instanceof ChildWorkflowFailure) {
-      return {
-        ...base,
-        childWorkflowExecutionFailureInfo: {
-          ...err,
-          workflowExecution: err.execution,
-          workflowType: { name: err.workflowType },
-        },
-      };
-    }
-    if (err instanceof ApplicationFailure) {
-      return {
-        ...base,
-        applicationFailureInfo: {
-          type: err.type,
-          nonRetryable: err.nonRetryable,
-          details:
-            err.details && err.details.length ? { payloads: toPayloads(payloadConverter, ...err.details) } : undefined,
-        },
-      };
-    }
-    if (err instanceof CancelledFailure) {
-      return {
-        ...base,
-        canceledFailureInfo: {
-          details:
-            err.details && err.details.length ? { payloads: toPayloads(payloadConverter, ...err.details) } : undefined,
-        },
-      };
-    }
-    if (err instanceof TimeoutFailure) {
-      return {
-        ...base,
-        timeoutFailureInfo: {
-          timeoutType: err.timeoutType,
-          lastHeartbeatDetails: err.lastHeartbeatDetails
-            ? { payloads: toPayloads(payloadConverter, err.lastHeartbeatDetails) }
-            : undefined,
-        },
-      };
-    }
-    if (err instanceof TerminatedFailure) {
-      return {
-        ...base,
-        terminatedFailureInfo: {},
-      };
-    }
-    if (err instanceof ServerFailure) {
-      return {
-        ...base,
-        serverFailureInfo: { nonRetryable: err.nonRetryable },
-      };
-    }
-    // Just a TemporalFailure
-    return base;
-  }
-
-  const base = {
-    source: FAILURE_SOURCE,
-  };
-
-  if (isRecord(err) && hasOwnProperties(err, ['message', 'stack'])) {
-    return {
-      ...base,
-      message: String(err.message) ?? '',
-      stackTrace: cutoffStackTrace(String(err.stack)),
-      cause: optionalErrorToOptionalFailure(err.cause, payloadConverter),
-    };
-  }
-
-  const recommendation = ` [A non-Error value was thrown from your code. We recommend throwing Error objects so that we can provide a stack trace]`;
-
-  if (typeof err === 'string') {
-    return { ...base, message: err + recommendation };
-  }
-  if (typeof err === 'object') {
-    let message = '';
-    try {
-      message = JSON.stringify(err);
-    } catch (_err) {
-      message = String(err);
-    }
-    return { ...base, message: message + recommendation };
-  }
-
-  return { ...base, message: String(err) + recommendation };
-}
-
 /**
  * If `error` is already an `ApplicationFailure`, returns `error`.
  *
@@ -445,108 +297,6 @@ export function ensureTemporalFailure(err: unknown): TemporalFailure {
   return ensureApplicationFailure(err);
 }
 
-/**
- * Converts a Failure proto message to a JS Error object if defined or returns undefined.
- */
-export function optionalFailureToOptionalError(
-  failure: ProtoFailure | undefined | null,
-  payloadConverter: PayloadConverter
-): TemporalFailure | undefined {
-  return failure ? failureToError(failure, payloadConverter) : undefined;
-}
-
-/**
- * Converts a Failure proto message to a JS Error object.
- *
- * Does not set common properties, that is done in {@link failureToError}.
- */
-export function failureToErrorInner(failure: ProtoFailure, payloadConverter: PayloadConverter): TemporalFailure {
-  if (failure.applicationFailureInfo) {
-    return new ApplicationFailure(
-      failure.message ?? undefined,
-      failure.applicationFailureInfo.type,
-      Boolean(failure.applicationFailureInfo.nonRetryable),
-      arrayFromPayloads(payloadConverter, failure.applicationFailureInfo.details?.payloads),
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.serverFailureInfo) {
-    return new ServerFailure(
-      failure.message ?? undefined,
-      Boolean(failure.serverFailureInfo.nonRetryable),
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.timeoutFailureInfo) {
-    return new TimeoutFailure(
-      failure.message ?? undefined,
-      fromPayloadsAtIndex(payloadConverter, 0, failure.timeoutFailureInfo.lastHeartbeatDetails?.payloads),
-      failure.timeoutFailureInfo.timeoutType ?? TimeoutType.TIMEOUT_TYPE_UNSPECIFIED
-    );
-  }
-  if (failure.terminatedFailureInfo) {
-    return new TerminatedFailure(
-      failure.message ?? undefined,
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.canceledFailureInfo) {
-    return new CancelledFailure(
-      failure.message ?? undefined,
-      arrayFromPayloads(payloadConverter, failure.canceledFailureInfo.details?.payloads),
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.resetWorkflowFailureInfo) {
-    return new ApplicationFailure(
-      failure.message ?? undefined,
-      'ResetWorkflow',
-      false,
-      arrayFromPayloads(payloadConverter, failure.resetWorkflowFailureInfo.lastHeartbeatDetails?.payloads),
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.childWorkflowExecutionFailureInfo) {
-    const { namespace, workflowType, workflowExecution, retryState } = failure.childWorkflowExecutionFailureInfo;
-    if (!(workflowType?.name && workflowExecution)) {
-      throw new TypeError('Missing attributes on childWorkflowExecutionFailureInfo');
-    }
-    return new ChildWorkflowFailure(
-      namespace ?? undefined,
-      workflowExecution,
-      workflowType.name,
-      retryState ?? RetryState.RETRY_STATE_UNSPECIFIED,
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  if (failure.activityFailureInfo) {
-    if (!failure.activityFailureInfo.activityType?.name) {
-      throw new TypeError('Missing activityType?.name on activityFailureInfo');
-    }
-    return new ActivityFailure(
-      failure.activityFailureInfo.activityType.name,
-      failure.activityFailureInfo.activityId ?? undefined,
-      failure.activityFailureInfo.retryState ?? RetryState.RETRY_STATE_UNSPECIFIED,
-      failure.activityFailureInfo.identity ?? undefined,
-      optionalFailureToOptionalError(failure.cause, payloadConverter)
-    );
-  }
-  return new TemporalFailure(
-    failure.message ?? undefined,
-    optionalFailureToOptionalError(failure.cause, payloadConverter)
-  );
-}
-
-/**
- * Converts a Failure proto message to a JS Error object.
- */
-export function failureToError(failure: ProtoFailure, payloadConverter: PayloadConverter): TemporalFailure {
-  const err = failureToErrorInner(failure, payloadConverter);
-  err.stack = failure.stackTrace ?? '';
-  err.failure = failure;
-  return err;
-}
-
 /**
  * Get the root cause message of given `error`.
  *

package/src/index.ts

@@ -3,16 +3,42 @@
  *
  * @module
  */
-export { Headers, Next, RetryPolicy } from '@temporalio/internal-workflow-common';
-export * from '@temporalio/internal-workflow-common/lib/activity-options';
-export * from '@temporalio/internal-workflow-common/lib/errors';
-export * from '@temporalio/internal-workflow-common/lib/interfaces';
-export * from '@temporalio/internal-workflow-common/lib/time';
-export * from '@temporalio/internal-workflow-common/lib/workflow-options';
+export { Headers, Next } from './interceptors';
+
+export * from './activity-options';
 export * from './converter/data-converter';
+export * from './converter/failure-converter';
 export * from './converter/payload-codec';
 export * from './converter/payload-converter';
-export * from './converter/payload-converters';
-export * from './converter/json-payload-converter';
 export * from './converter/types';
+export * from './errors';
 export * from './failure';
+export * from './failure';
+export * from './interfaces';
+export * from './retry-policy';
+export { Timestamp } from './time';
+export * from './workflow-options';
+export * from './workflow-handle';
+export * from './deprecated-time';
+
+import * as encoding from './encoding';
+
+/**
+ * Encode a UTF-8 string into a Uint8Array
+ *
+ * @hidden
+ * @deprecated - meant for internal use only
+ */
+export function u8(s: string): Uint8Array {
+  return encoding.encode(s);
+}
+
+/**
+ * Decode a Uint8Array into a UTF-8 string
+ *
+ * @hidden
+ * @deprecated - meant for internal use only
+ */
+export function str(arr: Uint8Array): string {
+  return encoding.decode(arr);
+}

package/src/interceptors.ts

@@ -0,0 +1,32 @@
+import { AnyFunc, OmitLastParam } from './type-helpers';
+import { Payload } from './interfaces';
+
+/**
+ * Type of the next function for a given interceptor function
+ *
+ * Called from an interceptor to continue the interception chain
+ */
+export type Next<IF, FN extends keyof IF> = Required<IF>[FN] extends AnyFunc ? OmitLastParam<Required<IF>[FN]> : never;
+
+/** Headers are just a mapping of header name to Payload */
+export type Headers = Record<string, Payload>;
+
+/**
+ * Composes all interceptor methods into a single function
+ *
+ * @param interceptors a list of interceptors
+ * @param method the name of the interceptor method to compose
+ * @param next the original function to be executed at the end of the interception chain
+ */
+export function composeInterceptors<I, M extends keyof I>(interceptors: I[], method: M, next: Next<I, M>): Next<I, M> {
+  for (let i = interceptors.length - 1; i >= 0; --i) {
+    const interceptor = interceptors[i];
+    if (interceptor[method] !== undefined) {
+      const prev = next;
+      // We loose type safety here because Typescript can't deduce that interceptor[method] is a function that returns
+      // the same type as Next<I, M>
+      next = ((input: any) => (interceptor[method] as any)(input, prev)) as any;
+    }
+  }
+  return next;
+}

package/src/interfaces.ts

@@ -0,0 +1,64 @@
+import type { temporal } from '@temporalio/proto';
+
+export type Payload = temporal.api.common.v1.IPayload;
+
+/** Type that can be returned from a Workflow `execute` function */
+export type WorkflowReturnType = Promise<any>;
+export type WorkflowSignalType = (...args: any[]) => Promise<void> | void;
+export type WorkflowQueryType = (...args: any[]) => any;
+
+/**
+ * Broad Workflow function definition, specific Workflows will typically use a narrower type definition, e.g:
+ * ```ts
+ * export async function myWorkflow(arg1: number, arg2: string): Promise<string>;
+ * ```
+ */
+export type Workflow = (...args: any[]) => WorkflowReturnType;
+
+/**
+ * An interface representing a Workflow signal definition, as returned from {@link defineSignal}
+ *
+ * @remarks `_Args` can be used for parameter type inference in handler functions and *WorkflowHandle methods.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface SignalDefinition<_Args extends any[] = []> {
+  type: 'signal';
+  name: string;
+}
+
+/**
+ * An interface representing a Workflow query definition as returned from {@link defineQuery}
+ *
+ * @remarks `_Args` and `_Ret` can be used for parameter type inference in handler functions and *WorkflowHandle methods.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface QueryDefinition<_Ret, _Args extends any[] = []> {
+  type: 'query';
+  name: string;
+}
+
+/** Get the "unwrapped" return type (without Promise) of the execute handler from Workflow type `W` */
+export type WorkflowResultType<W extends Workflow> = ReturnType<W> extends Promise<infer R> ? R : never;
+
+/**
+ * If another SDK creates a Search Attribute that's not an array, we wrap it in an array.
+ *
+ * Dates are serialized as ISO strings.
+ */
+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>;