@temporalio/common 1.8.1 → 1.8.3

package/src/type-helpers.ts

@@ -21,7 +21,6 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
 
-// ts-prune-ignore-next
 export function hasOwnProperty<X extends Record<string, unknown>, Y extends PropertyKey>(
   record: X,
   prop: Y
@@ -36,15 +35,27 @@ export function hasOwnProperties<X extends Record<string, unknown>, Y extends Pr
   return props.every((prop) => prop in record);
 }
 
+export function isError(error: unknown): error is Error {
+  return (
+    isRecord(error) &&
+    typeof error.name === 'string' &&
+    typeof error.message === 'string' &&
+    (error.stack == null || typeof error.stack === 'string')
+  );
+}
+
+export function isAbortError(error: unknown): error is Error & { name: 'AbortError' } {
+  return isError(error) && error.name === 'AbortError';
+}
+
 /**
  * Get `error.message` (or `undefined` if not present)
  */
 export function errorMessage(error: unknown): string | undefined {
-  if (typeof error === 'string') {
-    return error;
-  }
-  if (error instanceof Error) {
+  if (isError(error)) {
     return error.message;
+  } else if (typeof error === 'string') {
+    return error;
   }
   return undefined;
 }
@@ -52,16 +63,17 @@ export function errorMessage(error: unknown): string | undefined {
 interface ErrorWithCode {
   code: string;
 }
+
+function isErrorWithCode(error: unknown): error is ErrorWithCode {
+  return isRecord(error) && typeof error.code === 'string';
+}
+
 /**
  * Get `error.code` (or `undefined` if not present)
  */
 export function errorCode(error: unknown): string | undefined {
-  if (
-    typeof error === 'object' &&
-    (error as ErrorWithCode).code !== undefined &&
-    typeof (error as ErrorWithCode).code === 'string'
-  ) {
-    return (error as ErrorWithCode).code;
+  if (isErrorWithCode(error)) {
+    return error.code;
   }
 
   return undefined;
@@ -73,3 +85,58 @@ export function errorCode(error: unknown): string | undefined {
 export function assertNever(msg: string, x: never): never {
   throw new TypeError(msg + ': ' + x);
 }
+
+export type Class<E extends Error> = {
+  new (...args: any[]): E;
+  prototype: E;
+};
+
+/**
+ * A decorator to be used on error classes. It adds the 'name' property AND provides a custom
+ * 'instanceof' handler that works correctly across execution contexts.
+ *
+ * ### Details ###
+ *
+ * According to the EcmaScript's spec, the default behavior of JavaScript's `x instanceof Y` operator is to walk up the
+ * prototype chain of object 'x', checking if any constructor in that hierarchy is _exactly the same object_ as the
+ * constructor function 'Y'.
+ *
+ * Unfortunately, it happens in various situations that different constructor function objects get created for what
+ * appears to be the very same class. This leads to surprising behavior where `instanceof` returns false though it is
+ * known that the object is indeed an instance of that class. One particular case where this happens is when constructor
+ * 'Y' belongs to a different realm than the constuctor with which 'x' was instantiated. Another case is when two copies
+ * of the same library gets loaded in the same realm.
+ *
+ * In practice, this tends to cause issues when crossing the workflow-sandboxing boundary (since Node's vm module
+ * really creates new execution realms), as well as when running tests using Jest (see https://github.com/jestjs/jest/issues/2549
+ * for some details on that one).
+ *
+ * This function injects a custom 'instanceof' handler into the prototype of 'clazz', which is both cross-realm safe and
+ * cross-copies-of-the-same-lib safe. It works by adding a special symbol property to the prototype of 'clazz', and then
+ * checking for the presence of that symbol.
+ */
+export function SymbolBasedInstanceOfError<E extends Error>(markerName: string): (clazz: Class<E>) => void {
+  return (clazz: Class<E>): void => {
+    const marker = Symbol.for(`__temporal_is${markerName}`);
+
+    Object.defineProperty(clazz.prototype, 'name', { value: markerName, enumerable: true });
+    Object.defineProperty(clazz.prototype, marker, { value: true, enumerable: false });
+    Object.defineProperty(clazz, Symbol.hasInstance, {
+      // eslint-disable-next-line object-shorthand
+      value: function (this: any, error: object): boolean {
+        if (this === clazz) {
+          return isRecord(error) && (error as any)[marker] === true;
+        } else {
+          // 'this' must be a _subclass_ of clazz that doesn't redefined [Symbol.hasInstance], so that it inherited
+          // from clazz's [Symbol.hasInstance]. If we don't handle this particular situation, then
+          // `x instanceof SubclassOfParent` would return true for any instance of 'Parent', which is clearly wrong.
+          //
+          // Ideally, it'd be preferable to avoid this case entirely, by making sure that all subclasses of 'clazz'
+          // redefine [Symbol.hasInstance], but we can't enforce that. We therefore fallback to the default instanceof
+          // behavior (which is NOT cross-realm safe).
+          return this.prototype.isPrototypeOf(error); // eslint-disable-line no-prototype-builtins
+        }
+      },
+    });
+  };
+}

package/src/versioning-intent-enum.ts

@@ -0,0 +1,32 @@
+import type { coresdk } from '@temporalio/proto';
+import type { VersioningIntent as VersioningIntentString } from './versioning-intent';
+import { assertNever, checkExtends } from './type-helpers';
+
+// Avoid importing the proto implementation to reduce workflow bundle size
+// Copied from coresdk.common.VersioningIntent
+/**
+ * Protobuf enum representation of {@link VersioningIntentString}.
+ *
+ * @experimental
+ */
+export enum VersioningIntent {
+  UNSPECIFIED = 0,
+  COMPATIBLE = 1,
+  DEFAULT = 2,
+}
+
+checkExtends<coresdk.common.VersioningIntent, VersioningIntent>();
+checkExtends<VersioningIntent, coresdk.common.VersioningIntent>();
+
+export function versioningIntentToProto(intent: VersioningIntentString | undefined): VersioningIntent {
+  switch (intent) {
+    case 'DEFAULT':
+      return VersioningIntent.DEFAULT;
+    case 'COMPATIBLE':
+      return VersioningIntent.COMPATIBLE;
+    case undefined:
+      return VersioningIntent.UNSPECIFIED;
+    default:
+      assertNever('Unexpected VersioningIntent', intent);
+  }
+}

package/src/workflow-options.ts

@@ -52,7 +52,7 @@ export interface BaseWorkflowOptions {
    *
    * *Note: A Workflow can never be started with a Workflow Id of a Running Workflow.*
    *
-   * @default {@link WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY}
+   * @default {@link WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE}
    */
   workflowIdReusePolicy?: WorkflowIdReusePolicy;