@temporalio/common 1.8.0 → 1.8.2

package/lib/type-helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertNever = exports.errorCode = exports.errorMessage = exports.hasOwnProperties = exports.hasOwnProperty = exports.isRecord = exports.checkExtends = void 0;
+exports.SymbolBasedInstanceOfError = exports.assertNever = exports.errorCode = exports.errorMessage = exports.isAbortError = exports.isError = exports.hasOwnProperties = exports.hasOwnProperty = exports.isRecord = exports.checkExtends = void 0;
 /** Verify that an type _Copy extends _Orig */
 function checkExtends() {
     // noop, just type check
@@ -10,7 +10,6 @@ function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
 exports.isRecord = isRecord;
-// ts-prune-ignore-next
 function hasOwnProperty(record, prop) {
     return prop in record;
 }
@@ -19,26 +18,38 @@ function hasOwnProperties(record, props) {
     return props.every((prop) => prop in record);
 }
 exports.hasOwnProperties = hasOwnProperties;
+function isError(error) {
+    return (isRecord(error) &&
+        typeof error.name === 'string' &&
+        typeof error.message === 'string' &&
+        (error.stack == null || typeof error.stack === 'string'));
+}
+exports.isError = isError;
+function isAbortError(error) {
+    return isError(error) && error.name === 'AbortError';
+}
+exports.isAbortError = isAbortError;
 /**
  * Get `error.message` (or `undefined` if not present)
  */
 function errorMessage(error) {
-    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;
 }
 exports.errorMessage = errorMessage;
+function isErrorWithCode(error) {
+    return isRecord(error) && typeof error.code === 'string';
+}
 /**
  * Get `error.code` (or `undefined` if not present)
  */
 function errorCode(error) {
-    if (typeof error === 'object' &&
-        error.code !== undefined &&
-        typeof error.code === 'string') {
+    if (isErrorWithCode(error)) {
         return error.code;
     }
     return undefined;
@@ -51,4 +62,54 @@ function assertNever(msg, x) {
     throw new TypeError(msg + ': ' + x);
 }
 exports.assertNever = assertNever;
+/**
+ * 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.
+ */
+function SymbolBasedInstanceOfError(markerName) {
+    return (clazz) => {
+        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 (error) {
+                if (this === clazz) {
+                    return isRecord(error) && error[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
+                }
+            },
+        });
+    };
+}
+exports.SymbolBasedInstanceOfError = SymbolBasedInstanceOfError;
 //# sourceMappingURL=type-helpers.js.map

package/lib/type-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-helpers.js","sourceRoot":"","sources":["../src/type-helpers.ts"],"names":[],"mappings":";;;AAYA,8CAA8C;AAC9C,SAAgB,YAAY;IAC1B,wBAAwB;AAC1B,CAAC;AAFD,oCAEC;AAID,SAAgB,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAFD,4BAEC;AAED,uBAAuB;AACvB,SAAgB,cAAc,CAC5B,MAAS,EACT,IAAO;IAEP,OAAO,IAAI,IAAI,MAAM,CAAC;AACxB,CAAC;AALD,wCAKC;AAED,SAAgB,gBAAgB,CAC9B,MAAS,EACT,KAAU;IAEV,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,MAAM,CAAC,CAAC;AAC/C,CAAC;AALD,4CAKC;AAED;;GAEG;AACH,SAAgB,YAAY,CAAC,KAAc;IACzC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,OAAO,KAAK,CAAC;KACd;IACD,IAAI,KAAK,YAAY,KAAK,EAAE;QAC1B,OAAO,KAAK,CAAC,OAAO,CAAC;KACtB;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AARD,oCAQC;AAKD;;GAEG;AACH,SAAgB,SAAS,CAAC,KAAc;IACtC,IACE,OAAO,KAAK,KAAK,QAAQ;QACxB,KAAuB,CAAC,IAAI,KAAK,SAAS;QAC3C,OAAQ,KAAuB,CAAC,IAAI,KAAK,QAAQ,EACjD;QACA,OAAQ,KAAuB,CAAC,IAAI,CAAC;KACtC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAVD,8BAUC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,GAAW,EAAE,CAAQ;IAC/C,MAAM,IAAI,SAAS,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;AACtC,CAAC;AAFD,kCAEC"}
+{"version":3,"file":"type-helpers.js","sourceRoot":"","sources":["../src/type-helpers.ts"],"names":[],"mappings":"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"}

package/lib/versioning-intent.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Indicates whether the user intends certain commands to be run on a compatible worker Build Id
+ * version or not.
+ *
+ * `COMPATIBLE` indicates that the command should run on a worker with compatible version if
+ * possible. It may not be possible if the target task queue does not also have knowledge of the
+ * current worker's Build Id.
+ *
+ * `DEFAULT` indicates that the command should run on the target task queue's current
+ * overall-default Build Id.
+ *
+ * Where this type is accepted optionally, an unset value indicates that the SDK should choose the
+ * most sensible default behavior for the type of command, accounting for whether the command will
+ * be run on the same task queue as the current worker.
+ *
+ * @experimental
+ */
+export type VersioningIntent = 'COMPATIBLE' | 'DEFAULT';

package/lib/versioning-intent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=versioning-intent.js.map

package/lib/versioning-intent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioning-intent.js","sourceRoot":"","sources":["../src/versioning-intent.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/common",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "Common library for code that's used across the Client, Worker, and/or Workflow",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
@@ -13,7 +13,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.4.1",
-    "@temporalio/proto": "1.8.0",
+    "@temporalio/proto": "1.8.2",
     "long": "^5.2.0",
     "ms": "^3.0.0-canary.1",
     "proto3-json-serializer": "^1.0.3",
@@ -35,5 +35,5 @@
     "src",
     "lib"
   ],
-  "gitHead": "17d16e4dca39513470dd4b6e30d9af06dafd00d6"
+  "gitHead": "d85bf54da757741b438f8d39a0e7265b80d4f0d6"
 }

package/src/activity-options.ts

@@ -2,6 +2,7 @@ import type { coresdk } from '@temporalio/proto';
 import { RetryPolicy } from './retry-policy';
 import { checkExtends } from './type-helpers';
 import { Duration } from './time';
+import { VersioningIntent } from './versioning-intent';
 
 // Avoid importing the proto implementation to reduce workflow bundle size
 // Copied from coresdk.workflow_commands.ActivityCancellationType
@@ -100,6 +101,14 @@ export interface ActivityOptions {
    * @default true
    */
   allowEagerDispatch?: boolean;
+
+  /**
+   * When using the Worker Versioning feature, specifies whether this Activity should run on a
+   * worker with a compatible Build Id or not. See {@link VersioningIntent}.
+   *
+   * @experimental
+   */
+  versioningIntent?: VersioningIntent;
 }
 
 /**

package/src/converter/failure-converter.ts

@@ -12,7 +12,7 @@ import {
   TimeoutFailure,
   TimeoutType,
 } from '../failure';
-import { hasOwnProperties, isRecord } from '../type-helpers';
+import { isError } from '../type-helpers';
 import { arrayFromPayloads, fromPayloadsAtIndex, PayloadConverter, toPayloads } from './payload-converter';
 
 /**
@@ -219,7 +219,7 @@ export class DefaultFailureConverter implements FailureConverter {
   }
 
   errorToFailureInner(err: unknown, payloadConverter: PayloadConverter): ProtoFailure {
-    if (TemporalFailure.is(err)) {
+    if (err instanceof TemporalFailure) {
       if (err.failure) return err.failure;
       const base = {
         message: err.message,
@@ -228,7 +228,7 @@ export class DefaultFailureConverter implements FailureConverter {
         source: FAILURE_SOURCE,
       };
 
-      if (ActivityFailure.is(err)) {
+      if (err instanceof ActivityFailure) {
         return {
           ...base,
           activityFailureInfo: {
@@ -237,7 +237,7 @@ export class DefaultFailureConverter implements FailureConverter {
           },
         };
       }
-      if (ChildWorkflowFailure.is(err)) {
+      if (err instanceof ChildWorkflowFailure) {
         return {
           ...base,
           childWorkflowExecutionFailureInfo: {
@@ -247,7 +247,7 @@ export class DefaultFailureConverter implements FailureConverter {
           },
         };
       }
-      if (ApplicationFailure.is(err)) {
+      if (err instanceof ApplicationFailure) {
         return {
           ...base,
           applicationFailureInfo: {
@@ -260,7 +260,7 @@ export class DefaultFailureConverter implements FailureConverter {
           },
         };
       }
-      if (CancelledFailure.is(err)) {
+      if (err instanceof CancelledFailure) {
         return {
           ...base,
           canceledFailureInfo: {
@@ -271,7 +271,7 @@ export class DefaultFailureConverter implements FailureConverter {
           },
         };
       }
-      if (TimeoutFailure.is(err)) {
+      if (err instanceof TimeoutFailure) {
         return {
           ...base,
           timeoutFailureInfo: {
@@ -282,13 +282,13 @@ export class DefaultFailureConverter implements FailureConverter {
           },
         };
       }
-      if (ServerFailure.is(err)) {
+      if (err instanceof ServerFailure) {
         return {
           ...base,
           serverFailureInfo: { nonRetryable: err.nonRetryable },
         };
       }
-      if (TerminatedFailure.is(err)) {
+      if (err instanceof TerminatedFailure) {
         return {
           ...base,
           terminatedFailureInfo: {},
@@ -302,12 +302,12 @@ export class DefaultFailureConverter implements FailureConverter {
       source: FAILURE_SOURCE,
     };
 
-    if (isRecord(err) && hasOwnProperties(err, ['message', 'stack'])) {
+    if (isError(err)) {
       return {
         ...base,
         message: String(err.message) ?? '',
-        stackTrace: cutoffStackTrace(String(err.stack)),
-        cause: this.optionalErrorToOptionalFailure(err.cause, payloadConverter),
+        stackTrace: cutoffStackTrace(err.stack),
+        cause: this.optionalErrorToOptionalFailure((err as any).cause, payloadConverter),
       };
     }
 

package/src/converter/payload-converter.ts

@@ -260,7 +260,7 @@ export class SearchAttributePayloadConverter implements PayloadConverter {
   validNonDateTypes = ['string', 'number', 'boolean'];
 
   public toPayload(values: unknown): Payload {
-    if (!(values instanceof Array)) {
+    if (!Array.isArray(values)) {
       throw new ValueError(`SearchAttribute value must be an array`);
     }
 
@@ -309,7 +309,7 @@ export class SearchAttributePayloadConverter implements PayloadConverter {
     }
 
     const value = this.jsonConverter.fromPayload(payload);
-    let arrayWrappedValue = value instanceof Array ? value : [value];
+    let arrayWrappedValue = Array.isArray(value) ? value : [value];
 
     const searchAttributeType = decode(payload.metadata.type);
     if (searchAttributeType === 'Datetime') {

package/src/converter/protobuf-payload-converters.ts

@@ -14,6 +14,8 @@ import {
 
 import { encodingTypes, METADATA_ENCODING_KEY, METADATA_MESSAGE_TYPE_KEY } from './types';
 
+const GLOBAL_BUFFER = globalThis.constructor.constructor('return globalThis.Buffer')();
+
 abstract class ProtobufPayloadConverter implements PayloadConverterWithEncoding {
   protected readonly root: Root | undefined;
   public abstract encodingType: string;
@@ -121,17 +123,69 @@ export class ProtobufJsonPayloadConverter extends ProtobufPayloadConverter {
       return undefined;
     }
 
-    const jsonValue = protoJsonSerializer.toProto3JSON(value);
-
-    return this.constructPayload({
-      messageTypeName: getNamespacedTypeName(value.$type),
-      message: encode(JSON.stringify(jsonValue)),
-    });
+    const hasBufferChanged = setBufferInGlobal();
+    try {
+      const jsonValue = protoJsonSerializer.toProto3JSON(value);
+
+      return this.constructPayload({
+        messageTypeName: getNamespacedTypeName(value.$type),
+        message: encode(JSON.stringify(jsonValue)),
+      });
+    } finally {
+      resetBufferInGlobal(hasBufferChanged);
+    }
   }
 
   public fromPayload<T>(content: Payload): T {
-    const { messageType, data } = this.validatePayload(content);
-    return protoJsonSerializer.fromProto3JSON(messageType, JSON.parse(decode(data))) as unknown as T;
+    const hasBufferChanged = setBufferInGlobal();
+    try {
+      const { messageType, data } = this.validatePayload(content);
+      const res = protoJsonSerializer.fromProto3JSON(messageType, JSON.parse(decode(data))) as unknown as T;
+      if (Buffer.isBuffer(res)) {
+        return new Uint8Array(res) as any;
+      }
+      replaceBuffers(res);
+      return res;
+    } finally {
+      resetBufferInGlobal(hasBufferChanged);
+    }
+  }
+}
+
+function replaceBuffers<X>(obj: X) {
+  const replaceBuffersImpl = <Y>(value: any, key: string | number, target: Y) => {
+    if (Buffer.isBuffer(value)) {
+      // Need to copy. `Buffer` manages a pool slab, internally reused when Buffer objects are GC.
+      type T = keyof typeof target;
+      target[key as T] = new Uint8Array(value) as any;
+    } else {
+      replaceBuffers(value);
+    }
+  };
+
+  if (obj != null && typeof obj === 'object') {
+    // Performance optimization for large arrays
+    if (Array.isArray(obj)) {
+      obj.forEach(replaceBuffersImpl);
+    } else {
+      for (const [key, value] of Object.entries(obj)) {
+        replaceBuffersImpl(value, key, obj);
+      }
+    }
+  }
+}
+
+function setBufferInGlobal(): boolean {
+  if (typeof globalThis.Buffer === 'undefined') {
+    globalThis.Buffer = GLOBAL_BUFFER;
+    return true;
+  }
+  return false;
+}
+
+function resetBufferInGlobal(hasChanged: boolean): void {
+  if (hasChanged) {
+    delete (globalThis as any).Buffer;
   }
 }
 

package/src/errors.ts

@@ -1,11 +1,11 @@
 import { TemporalFailure } from './failure';
+import { SymbolBasedInstanceOfError } from './type-helpers';
 
 /**
  * Thrown from code that receives a value that is unexpected or that it's unable to handle.
  */
+@SymbolBasedInstanceOfError('ValueError')
 export class ValueError extends Error {
-  public readonly name: string = 'ValueError';
-
   constructor(message: string | undefined, public readonly cause?: unknown) {
     super(message ?? undefined);
   }
@@ -14,18 +14,14 @@ export class ValueError extends Error {
 /**
  * Thrown when a Payload Converter is misconfigured.
  */
-export class PayloadConverterError extends ValueError {
-  public readonly name: string = 'PayloadConverterError';
-}
+@SymbolBasedInstanceOfError('PayloadConverterError')
+export class PayloadConverterError extends ValueError {}
 
 /**
  * Used in different parts of the SDK to note that something unexpected has happened.
  */
-export class IllegalStateError extends Error {
-  public readonly name: string = 'IllegalStateError';
-}
-
-const isWorkflowExecutionAlreadyStartedError = Symbol.for('__temporal_isWorkflowExecutionAlreadyStartedError');
+@SymbolBasedInstanceOfError('IllegalStateError')
+export class IllegalStateError extends Error {}
 
 /**
  * This exception is thrown in the following cases:
@@ -35,27 +31,11 @@ const isWorkflowExecutionAlreadyStartedError = Symbol.for('__temporal_isWorkflow
  *  - There is closed Workflow in the `Completed` state with the same Workflow Id and the {@link WorkflowOptions.workflowIdReusePolicy}
  *    is `WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY`
  */
+@SymbolBasedInstanceOfError('WorkflowExecutionAlreadyStartedError')
 export class WorkflowExecutionAlreadyStartedError extends TemporalFailure {
-  public readonly name: string = 'WorkflowExecutionAlreadyStartedError';
-
   constructor(message: string, public readonly workflowId: string, public readonly workflowType: string) {
     super(message);
   }
-
-  /**
-   * Marker to determine whether an error is an instance of WorkflowExecutionAlreadyStartedError.
-   */
-  protected readonly [isWorkflowExecutionAlreadyStartedError] = true;
-
-  /**
-   * Instanceof check that works when multiple versions of @temporalio/common are installed.
-   */
-  static is(error: unknown): error is WorkflowExecutionAlreadyStartedError {
-    return (
-      error instanceof WorkflowExecutionAlreadyStartedError ||
-      (error instanceof Error && (error as any)[isWorkflowExecutionAlreadyStartedError])
-    );
-  }
 }
 
 /**
@@ -65,9 +45,8 @@ export class WorkflowExecutionAlreadyStartedError extends TemporalFailure {
  * - Workflow is closed (for some calls, e.g. `terminate`)
  * - Workflow was deleted from the Server after reaching its retention limit
  */
+@SymbolBasedInstanceOfError('WorkflowNotFoundError')
 export class WorkflowNotFoundError extends Error {
-  public readonly name: string = 'WorkflowNotFoundError';
-
   constructor(message: string, public readonly workflowId: string, public readonly runId: string | undefined) {
     super(message);
   }
@@ -76,9 +55,8 @@ export class WorkflowNotFoundError extends Error {
 /**
  * Thrown when the specified namespace is not known to Temporal Server.
  */
+@SymbolBasedInstanceOfError('NamespaceNotFoundError')
 export class NamespaceNotFoundError extends Error {
-  public readonly name: string = 'NamespaceNotFoundError';
-
   constructor(public readonly namespace: string) {
     super(`Namespace not found: '${namespace}'`);
   }