@temporalio/common 0.23.0 → 1.0.0

package/src/converter/search-attribute-payload-converter.ts

@@ -0,0 +1,71 @@
+import { IllegalStateError, ValueError } from '@temporalio/internal-workflow-common';
+import { PayloadConverter } from './payload-converter';
+import { JsonPayloadConverter } from './json-payload-converter';
+import { Payload, str } from './types';
+
+const jsonConverter = new JsonPayloadConverter();
+const validNonDateTypes = ['string', 'number', 'boolean'];
+
+/**
+ * Converts Search Attribute values using JsonPayloadConverter
+ */
+export class SearchAttributePayloadConverter implements PayloadConverter {
+  public toPayload(values: unknown): Payload {
+    if (!(values instanceof Array)) {
+      throw new ValueError(`SearchAttribute value must be an array`);
+    }
+
+    if (values.length > 0) {
+      const firstValue = values[0];
+      const firstType = typeof firstValue;
+      if (firstType === 'object') {
+        for (const idx in values) {
+          const value = values[idx];
+          if (!(value instanceof Date)) {
+            throw new ValueError(
+              `SearchAttribute values must arrays of strings, numbers, booleans, or Dates. The value ${value} at index ${idx} is of type ${typeof value}`
+            );
+          }
+        }
+      } else {
+        if (!validNonDateTypes.includes(firstType)) {
+          throw new ValueError(`SearchAttribute array values must be: string | number | boolean | Date`);
+        }
+
+        for (const idx in values) {
+          const value = values[idx];
+          if (typeof value !== firstType) {
+            throw new ValueError(
+              `All SearchAttribute array values must be of the same type. The first value ${firstValue} of type ${firstType} doesn't match value ${value} of type ${typeof value} at index ${idx}`
+            );
+          }
+        }
+      }
+    }
+
+    // JSON.stringify takes care of converting Dates to ISO strings
+    const ret = jsonConverter.toPayload(values);
+    if (ret === undefined) {
+      throw new IllegalStateError('Could not convert search attributes to payloads');
+    }
+    return ret;
+  }
+
+  /**
+   * Datetime Search Attribute values are converted to `Date`s
+   */
+  public fromPayload<T>(payload: Payload): T {
+    if (payload.metadata === undefined || payload.metadata === null) {
+      throw new ValueError('Missing payload metadata');
+    }
+
+    const value = jsonConverter.fromPayload(payload);
+    let arrayWrappedValue = value instanceof Array ? value : [value];
+
+    const searchAttributeType = str(payload.metadata.type);
+    if (searchAttributeType === 'Datetime') {
+      arrayWrappedValue = arrayWrappedValue.map((dateString) => new Date(dateString));
+    }
+    return arrayWrappedValue as unknown as T;
+  }
+}

package/src/converter/types.ts

@@ -1,7 +1,6 @@
-import type { coresdk } from '@temporalio/proto';
 import { TextDecoder, TextEncoder } from './encoding';
 
-export type Payload = coresdk.common.IPayload;
+export { Payload } from '@temporalio/internal-workflow-common';
 
 /**
  * Transform an *ascii* string into a Uint8Array

package/src/failure.ts

@@ -1,7 +1,6 @@
 import { checkExtends, hasOwnProperties, isRecord } from '@temporalio/internal-workflow-common';
 import type { temporal } from '@temporalio/proto';
-import { arrayFromPayloads, fromPayloadsAtIndex, toPayloads } from './converter/payload-converter';
-import { WrappedPayloadConverter } from './converter/wrapped-payload-converter';
+import { PayloadConverter, arrayFromPayloads, fromPayloadsAtIndex, toPayloads } from './converter/payload-converter';
 
 export const FAILURE_SOURCE = 'TypeScriptSDK';
 export type ProtoFailure = temporal.api.failure.v1.IFailure;
@@ -71,27 +70,28 @@ export class ServerFailure extends TemporalFailure {
 }
 
 /**
- * Application failure is used to communicate application specific failures between Workflows and
- * Activities.
+ * `ApplicationFailure`s are used to communicate application-specific failures in Workflows and Activities.
  *
- * Throw this exception to have full control over type and details if the exception delivered to
- * the caller workflow or client.
+ * The {@link type} property is matched against {@link RetryPolicy.nonRetryableErrorTypes} to determine if an instance
+ * of this error is retryable. Another way to avoid retrying is by setting the {@link nonRetryable} flag to `true`.
  *
- * Any unhandled exception which doesn't extend {@link TemporalFailure} is converted to an
- * instance of this class before being returned to a caller.
+ * In Workflows, if you throw a non-`ApplicationFailure`, the Workflow Task will fail and be retried. If you throw an
+ * `ApplicationFailure`, the Workflow Execution will fail.
  *
- * The {@link type} property is used by {@link temporal.common.RetryOptions} to determine if
- * an instance of this exception is non retryable. Another way to avoid retrying an exception of
- * this type is by setting {@link nonRetryable} flag to `true`.
+ * In Activities, you can either throw an `ApplicationFailure` or another `Error` to fail the Activity Task. In the
+ * latter case, the `Error` will be converted to an `ApplicationFailure`. If the
+ * {@link https://docs.temporal.io/concepts/what-is-an-activity-execution | Activity Execution} fails, the
+ * `ApplicationFailure` from the last Activity Task will be the `cause` of the {@link ActivityFailure} thrown in the
+ * Workflow.
  *
- * The conversion of an exception that doesn't extend {@link TemporalFailure} to an
- * ApplicationFailure is done as following:
+ * The conversion of an error that doesn't extend {@link TemporalFailure} to an `ApplicationFailure` is done as
+ * following:
  *
- * - type is set to the exception full type name.
- * - message is set to the exception message
- * - nonRetryable is set to false
- * - details are set to null
- * - stack trace is copied from the original exception
+ * - `type` is set to `error.constructor?.name ?? error.name`
+ * - `message` is set to `error.message`
+ * - `nonRetryable` is set to false
+ * - `details` are set to null
+ * - stack trace is copied from the original error
  */
 export class ApplicationFailure extends TemporalFailure {
   public readonly name: string = 'ApplicationFailure';
@@ -107,29 +107,26 @@ export class ApplicationFailure extends TemporalFailure {
   }
 
   /**
-   * New ApplicationFailure with {@link nonRetryable} flag set to false. Note that this
-   * exception still can be not retried by the service if its type is included into doNotRetry
-   * property of the correspondent retry policy.
+   * Get a new `ApplicationFailure` with the {@link nonRetryable} flag set to false. Note that this error will still
+   * not be retried if its `type` is included in {@link RetryPolicy.nonRetryableErrorTypes}.
    *
-   * @param message optional error message
-   * @param type optional error type that is used by {@link RetryOptions.nonRetryableErrorTypes}.
-   * @param details optional details about the failure. They are serialized using the same approach
-   *     as arguments and results.
+   * @param message Optional error message
+   * @param type Optional error type (used by {@link RetryPolicy.nonRetryableErrorTypes})
+   * @param details Optional details about the failure. Serialized by the Worker's {@link PayloadConverter}.
    */
   public static retryable(message: string | undefined, type?: string, ...details: unknown[]): ApplicationFailure {
     return new this(message, type ?? 'Error', false, details);
   }
 
   /**
-   * New ApplicationFailure with {@link nonRetryable} flag set to true.
+   * Get a new `ApplicationFailure` with the {@link nonRetryable} flag set to true.
    *
-   * It means that this exception is not going to be retried even if it is not included into
-   * retry policy doNotRetry list.
+   * When thrown from an Activity or Workflow, the Activity or Workflow will not be retried (even if `type` is not
+   * listed in {@link RetryPolicy.nonRetryableErrorTypes}).
    *
-   * @param message optional error message
-   * @param type optional error type
-   * @param details optional details about the failure. They are serialized using the same approach
-   *     as arguments and results.
+   * @param message Optional error message
+   * @param type Optional error type
+   * @param details Optional details about the failure. Serialized by the Worker's {@link PayloadConverter}.
    */
   public static nonRetryable(message: string | undefined, type?: string, ...details: unknown[]): ApplicationFailure {
     return new this(message, type ?? 'Error', true, details);
@@ -137,7 +134,11 @@ export class ApplicationFailure extends TemporalFailure {
 }
 
 /**
- * Used as the cause for when a Workflow or Activity has been cancelled
+ * This error is thrown when Cancellation has been requested. To allow Cancellation to happen, let it propagate. To
+ * ignore Cancellation, catch it and continue executing. Note that Cancellation can only be requested a single time, so
+ * your Workflow/Activity Execution will not receive further Cancellation requests.
+ *
+ * When a Workflow or Activity has been successfully cancelled, a `CancelledFailure` will be the `cause`.
  */
 export class CancelledFailure extends TemporalFailure {
   public readonly name: string = 'CancelledFailure';
@@ -148,7 +149,7 @@ export class CancelledFailure extends TemporalFailure {
 }
 
 /**
- * Used as the cause for when a Workflow has been terminated
+ * Used as the `cause` when a Workflow has been terminated
  */
 export class TerminatedFailure extends TemporalFailure {
   public readonly name: string = 'TerminatedFailure';
@@ -174,12 +175,14 @@ export class TimeoutFailure extends TemporalFailure {
 }
 
 /**
- * Contains information about an activity failure. Always contains the original reason for the
- * failure as its cause. For example if an activity timed out the cause is {@link TimeoutFailure}.
+ * Contains information about an Activity failure. Always contains the original reason for the failure as its `cause`.
+ * For example, if an Activity timed out, the cause will be a {@link TimeoutFailure}.
  *
  * This exception is expected to be thrown only by the framework code.
  */
 export class ActivityFailure extends TemporalFailure {
+  public readonly name: string = 'ActivityFailure';
+
   public constructor(
     public readonly activityType: string,
     public readonly activityId: string | undefined,
@@ -192,12 +195,14 @@ export class ActivityFailure extends TemporalFailure {
 }
 
 /**
- * Contains information about an child workflow failure. Always contains the original reason for the
- * failure as its cause. For example if a child workflow was terminated the cause is {@link TerminatedFailure}.
+ * Contains information about a Child Workflow failure. Always contains the reason for the failure as its {@link cause}.
+ * For example, if the Child was Terminated, the `cause` is a {@link TerminatedFailure}.
  *
  * This exception is expected to be thrown only by the framework code.
  */
 export class ChildWorkflowFailure extends TemporalFailure {
+  public readonly name: string = 'ChildWorkflowFailure';
+
   public constructor(
     public readonly namespace: string | undefined,
     public readonly execution: WorkflowExecution,
@@ -214,7 +219,7 @@ export class ChildWorkflowFailure extends TemporalFailure {
  */
 export function optionalErrorToOptionalFailure(
   err: unknown,
-  payloadConverter: WrappedPayloadConverter
+  payloadConverter: PayloadConverter
 ): ProtoFailure | undefined {
   return err ? errorToFailure(err, payloadConverter) : undefined;
 }
@@ -226,9 +231,9 @@ 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 \(webpack-internal:\/\/\/.*\/internals\.[jt]s:\d+:\d+\)/,
+  /\s+at Activator\.\S+NextHandler \(.*[\\/]workflow[\\/](?:src|lib)[\\/]internals\.[jt]s:\d+:\d+\)/,
   /** Workflow run anything in context */
-  /\s+at Script\.runInContext/,
+  /\s+at Script\.runInContext \((?:node:vm|vm\.js):\d+:\d+\)/,
 ];
 
 /**
@@ -249,7 +254,7 @@ export function cutoffStackTrace(stack?: string): string {
 /**
  * Converts a caught error to a Failure proto message
  */
-export function errorToFailure(err: unknown, payloadConverter: WrappedPayloadConverter): ProtoFailure {
+export function errorToFailure(err: unknown, payloadConverter: PayloadConverter): ProtoFailure {
   if (err instanceof TemporalFailure) {
     if (err.failure) return err.failure;
 
@@ -338,27 +343,38 @@ export function errorToFailure(err: unknown, payloadConverter: WrappedPayloadCon
     };
   }
 
-  const recommendation = ` [A non-Error value was thrown from your code. We recommend throwing Error objects so that we can provide a stack trace.]`;
+  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: JSON.stringify(err) + recommendation };
+  return { ...base, message: String(err) + recommendation };
 }
 
 /**
  * If `err` is an Error it is turned into an `ApplicationFailure`.
  *
- * If `err` was already a `TemporalFailure`, returns the original error.
+ * If `err` was already a `ApplicationFailure`, returns the original error.
  *
  * Otherwise returns an `ApplicationFailure` with `String(err)` as the message.
  */
-export function ensureTemporalFailure(err: unknown): TemporalFailure {
-  if (err instanceof TemporalFailure) {
+export function ensureApplicationFailure(err: unknown): ApplicationFailure {
+  if (err instanceof ApplicationFailure) {
     return err;
-  } else if (err instanceof Error) {
-    const failure = new ApplicationFailure(err.message, err.name, false);
+  }
+  if (err instanceof Error) {
+    const name = err.constructor?.name ?? err.name;
+    const failure = new ApplicationFailure(err.message, name, false);
     failure.stack = err.stack;
     return failure;
   } else {
@@ -368,12 +384,26 @@ export function ensureTemporalFailure(err: unknown): TemporalFailure {
   }
 }
 
+/**
+ * If `err` is an Error it is turned into an `ApplicationFailure`.
+ *
+ * If `err` was already a `TemporalFailure`, returns the original error.
+ *
+ * Otherwise returns an `ApplicationFailure` with `String(err)` as the message.
+ */
+export function ensureTemporalFailure(err: unknown): TemporalFailure {
+  if (err instanceof TemporalFailure) {
+    return err;
+  }
+  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: WrappedPayloadConverter
+  payloadConverter: PayloadConverter
 ): TemporalFailure | undefined {
   return failure ? failureToError(failure, payloadConverter) : undefined;
 }
@@ -383,7 +413,7 @@ export function optionalFailureToOptionalError(
  *
  * Does not set common properties, that is done in {@link failureToError}.
  */
-export function failureToErrorInner(failure: ProtoFailure, payloadConverter: WrappedPayloadConverter): TemporalFailure {
+export function failureToErrorInner(failure: ProtoFailure, payloadConverter: PayloadConverter): TemporalFailure {
   if (failure.applicationFailureInfo) {
     return new ApplicationFailure(
       failure.message ?? undefined,
@@ -463,7 +493,7 @@ export function failureToErrorInner(failure: ProtoFailure, payloadConverter: Wra
 /**
  * Converts a Failure proto message to a JS Error object.
  */
-export function failureToError(failure: ProtoFailure, payloadConverter: WrappedPayloadConverter): TemporalFailure {
+export function failureToError(failure: ProtoFailure, payloadConverter: PayloadConverter): TemporalFailure {
   const err = failureToErrorInner(failure, payloadConverter);
   err.stack = failure.stackTrace ?? '';
   err.failure = failure;
@@ -471,20 +501,20 @@ export function failureToError(failure: ProtoFailure, payloadConverter: WrappedP
 }
 
 /**
- * Get the root cause (string) of given error `err`.
+ * Get the root cause message of given `error`.
  *
- * In case `err` is a {@link TemporalFailure}, recurse the cause chain and return the root's message.
- * Otherwise, return `err.message`.
+ * In case `error` is a {@link TemporalFailure}, recurse the `cause` chain and return the root `cause.message`.
+ * Otherwise, return `error.message`.
  */
-export function rootCause(err: unknown): string | undefined {
-  if (err instanceof TemporalFailure) {
-    return err.cause ? rootCause(err.cause) : err.message;
+export function rootCause(error: unknown): string | undefined {
+  if (error instanceof TemporalFailure) {
+    return error.cause ? rootCause(error.cause) : error.message;
   }
-  if (err instanceof Error) {
-    return err.message;
+  if (error instanceof Error) {
+    return error.message;
   }
-  if (typeof err === 'string') {
-    return err;
+  if (typeof error === 'string') {
+    return error;
   }
   return undefined;
 }

package/src/index.ts

@@ -13,5 +13,6 @@ export * from './converter/data-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 './failure';

package/src/otel.ts

@@ -0,0 +1,63 @@
+import * as otel from '@opentelemetry/api';
+import { Headers } from '@temporalio/internal-workflow-common';
+import { defaultPayloadConverter } from './converter/payload-converters';
+
+/** Default trace header for opentelemetry interceptors */
+export const TRACE_HEADER = '_tracer-data';
+/** As in workflow run id */
+export const RUN_ID_ATTR_KEY = 'run_id';
+/** For a workflow or activity task */
+export const TASK_TOKEN_ATTR_KEY = 'task_token';
+/** Number of jobs in a workflow activation */
+export const NUM_JOBS_ATTR_KEY = 'num_jobs';
+
+const payloadConverter = defaultPayloadConverter;
+
+/**
+ * If found, return an otel Context deserialized from the provided headers
+ */
+export async function extractContextFromHeaders(headers: Headers): Promise<otel.Context | undefined> {
+  const encodedSpanContext = headers[TRACE_HEADER];
+  if (encodedSpanContext === undefined) {
+    return undefined;
+  }
+  const textMap: Record<string, string> = payloadConverter.fromPayload(encodedSpanContext);
+  return otel.propagation.extract(otel.context.active(), textMap, otel.defaultTextMapGetter);
+}
+
+/**
+ * If found, return an otel SpanContext deserialized from the provided headers
+ */
+export async function extractSpanContextFromHeaders(headers: Headers): Promise<otel.SpanContext | undefined> {
+  const context = await extractContextFromHeaders(headers);
+  if (context === undefined) {
+    return undefined;
+  }
+
+  return otel.trace.getSpanContext(context);
+}
+
+/**
+ * Given headers, return new headers with the current otel context inserted
+ */
+export async function headersWithContext(headers: Headers): Promise<Headers> {
+  const carrier = {};
+  otel.propagation.inject(otel.context.active(), carrier, otel.defaultTextMapSetter);
+  return { ...headers, [TRACE_HEADER]: payloadConverter.toPayload(carrier) };
+}
+
+/**
+ * Link a span to an maybe-existing span context
+ */
+export function linkSpans(fromSpan: otel.Span, toContext?: otel.SpanContext): void {
+  if (toContext !== undefined) {
+    // TODO: I have to go around typescript because otel api 😢
+    //  See https://github.com/open-telemetry/opentelemetry-js-api/issues/124
+    const links = (fromSpan as any).links;
+    if (links === undefined) {
+      (fromSpan as any).links = [{ context: toContext }];
+    } else {
+      links.push({ context: toContext });
+    }
+  }
+}

package/src/proto-utils.ts

@@ -0,0 +1,103 @@
+import proto from '@temporalio/proto';
+import { fromProto3JSON, toProto3JSON } from 'proto3-json-serializer';
+import { patchProtobufRoot } from '@temporalio/proto/lib/patch-protobuf-root';
+
+export type History = proto.temporal.api.history.v1.IHistory;
+export type Payload = proto.temporal.api.common.v1.IPayload;
+
+// Cast to any because the generated proto module types are missing the lookupType method
+const patched = patchProtobufRoot(proto) as any;
+const historyType = patched.lookupType('temporal.api.history.v1.History');
+const payloadType = patched.lookupType('temporal.api.common.v1.Payload');
+
+function pascalCaseToConstantCase(s: string) {
+  return s.replace(/[^\b][A-Z]/g, (m) => `${m[0]}_${m[1]}`).toUpperCase();
+}
+
+function fixEnumValue<O extends Record<string, any>>(obj: O, attr: keyof O, prefix: string) {
+  return (
+    obj[attr] && {
+      [attr]: `${prefix}_${pascalCaseToConstantCase(obj[attr])}`,
+    }
+  );
+}
+
+function fixHistoryEvent(e: Record<string, any>) {
+  const type = Object.keys(e).find((k) => k.endsWith('EventAttributes'));
+  if (!type) {
+    throw new TypeError(`Missing attributes in history event: ${JSON.stringify(e)}`);
+  }
+
+  return {
+    ...e,
+    ...fixEnumValue(e, 'eventType', 'EVENT_TYPE'),
+    [type]: {
+      ...e[type],
+      ...(e[type].taskQueue && {
+        taskQueue: { ...e[type].taskQueue, ...fixEnumValue(e[type].taskQueue, 'kind', 'TASK_QUEUE_KIND') },
+      }),
+      ...fixEnumValue(e[type], 'parentClosePolicy', 'PARENT_CLOSE_POLICY'),
+      ...fixEnumValue(e[type], 'workflowIdReusePolicy', 'WORKFLOW_ID_REUSE_POLICY'),
+      ...fixEnumValue(e[type], 'initiator', 'CONTINUE_AS_NEW_INITIATOR'),
+      ...fixEnumValue(e[type], 'retryState', 'RETRY_STATE'),
+      ...(e[type].childWorkflowExecutionFailureInfo && {
+        childWorkflowExecutionFailureInfo: {
+          ...e[type].childWorkflowExecutionFailureInfo,
+          ...fixEnumValue(e[type].childWorkflowExecutionFailureInfo, 'retryState', 'RETRY_STATE'),
+        },
+      }),
+    },
+  };
+}
+
+function fixHistory(h: Record<string, any>) {
+  return {
+    events: h.events.map(fixHistoryEvent),
+  };
+}
+
+/**
+ * Convert a proto JSON representation of History to a valid History object
+ */
+export function historyFromJSON(history: unknown): History {
+  if (typeof history !== 'object' || history == null || !Array.isArray((history as any).events)) {
+    throw new TypeError('Invalid history, expected an object with an array of events');
+  }
+  const loaded = fromProto3JSON(historyType, fixHistory(history));
+  if (loaded === null) {
+    throw new TypeError('Invalid history');
+  }
+  return loaded as any;
+}
+
+/**
+ * JSON representation of Temporal's {@link Payload} protobuf object
+ */
+export interface JSONPayload {
+  /**
+   * Mapping of key to base64 encoded value
+   */
+  metadata?: Record<string, string> | null;
+  /**
+   * base64 encoded value
+   */
+  data?: string | null;
+}
+
+/**
+ * Convert from protobuf payload to JSON
+ */
+export function payloadToJSON(payload: Payload): JSONPayload {
+  return toProto3JSON(patched.temporal.api.common.v1.Payload.create(payload)) as any;
+}
+
+/**
+ * Convert from JSON to protobuf payload
+ */
+export function JSONToPayload(json: JSONPayload): Payload {
+  const loaded = fromProto3JSON(payloadType, json as any);
+  if (loaded === null) {
+    throw new TypeError('Invalid payload');
+  }
+  return loaded as any;
+}

package/src/protobufs.ts

@@ -1,6 +1,6 @@
 /**
  * Entry point for classes and utilities related to using
- * [Protobufs](https://docs.temporal.io/docs/typescript/data-converters#protobufs) for serialization.
+ * {@link https://docs.temporal.io/typescript/data-converters#protobufs | Protobufs} for serialization.
  *
  * Import from `@temporalio/common/lib/protobufs`, for example:
  *
@@ -12,4 +12,4 @@
 
 // Don't export from index, so we save space in Workflow bundles of users who don't use Protobufs
 export * from './converter/protobuf-payload-converters';
-export * from './converter/patch-protobuf-root';
+export { patchProtobufRoot } from '@temporalio/proto/lib/patch-protobuf-root';

package/lib/converter/patch-protobuf-root.d.ts

@@ -1 +0,0 @@
-export { patchProtobufRoot } from '@temporalio/proto/lib/patch-protobuf-root';

package/lib/converter/patch-protobuf-root.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchProtobufRoot = void 0;
-var patch_protobuf_root_1 = require("@temporalio/proto/lib/patch-protobuf-root");
-Object.defineProperty(exports, "patchProtobufRoot", { enumerable: true, get: function () { return patch_protobuf_root_1.patchProtobufRoot; } });
-//# sourceMappingURL=patch-protobuf-root.js.map

package/lib/converter/patch-protobuf-root.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"patch-protobuf-root.js","sourceRoot":"","sources":["../../src/converter/patch-protobuf-root.ts"],"names":[],"mappings":";;;AAAA,iFAA8E;AAArE,wHAAA,iBAAiB,OAAA"}

package/lib/converter/wrapped-payload-converter.d.ts

@@ -1,12 +0,0 @@
-import { PayloadConverter } from './payload-converter';
-import { Payload } from './types';
-/**
- * When we call {@link PayloadConverter.toPayload}, we want it to either throw or return a Payload, so we wrap Payload
- * Converters with this class before using them.
- */
-export declare class WrappedPayloadConverter implements PayloadConverter {
-    private readonly payloadConverter;
-    constructor(payloadConverter: PayloadConverter);
-    toPayload(value: unknown): Payload;
-    fromPayload<T>(payload: Payload): T;
-}

package/lib/converter/wrapped-payload-converter.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WrappedPayloadConverter = void 0;
-const internal_workflow_common_1 = require("@temporalio/internal-workflow-common");
-/**
- * When we call {@link PayloadConverter.toPayload}, we want it to either throw or return a Payload, so we wrap Payload
- * Converters with this class before using them.
- */
-class WrappedPayloadConverter {
-    constructor(payloadConverter) {
-        this.payloadConverter = payloadConverter;
-    }
-    toPayload(value) {
-        const result = this.payloadConverter.toPayload(value);
-        if (!isPayload(result)) {
-            throw new internal_workflow_common_1.ValueError(`The Payload Converter method ${Object.getPrototypeOf(this.payloadConverter).constructor.name}.toPayload must return a Payload. Received \`${result}\` of type \`${typeof result}\` when trying to convert \`${value}\` of type \`${typeof value}\`.`);
-        }
-        return result;
-    }
-    fromPayload(payload) {
-        return this.payloadConverter.fromPayload(payload);
-    }
-}
-exports.WrappedPayloadConverter = WrappedPayloadConverter;
-function isPayload(payload) {
-    return (0, internal_workflow_common_1.isRecord)(payload) && ((0, internal_workflow_common_1.hasOwnProperty)(payload, 'metadata') || (0, internal_workflow_common_1.hasOwnProperty)(payload, 'data'));
-}
-//# sourceMappingURL=wrapped-payload-converter.js.map

package/lib/converter/wrapped-payload-converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrapped-payload-converter.js","sourceRoot":"","sources":["../../src/converter/wrapped-payload-converter.ts"],"names":[],"mappings":";;;AAAA,mFAA4F;AAI5F;;;GAGG;AACH,MAAa,uBAAuB;IAClC,YAA6B,gBAAkC;QAAlC,qBAAgB,GAAhB,gBAAgB,CAAkB;IAAG,CAAC;IAE5D,SAAS,CAAC,KAAc;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YACtB,MAAM,IAAI,qCAAU,CAClB,gCACE,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,IAC3D,gDAAgD,MAAM,gBAAgB,OAAO,MAAM,+BAA+B,KAAK,gBAAgB,OAAO,KAAK,KAAK,CACzJ,CAAC;SACH;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,WAAW,CAAI,OAAgB;QACpC,OAAO,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;CACF;AAlBD,0DAkBC;AAED,SAAS,SAAS,CAAC,OAAgB;IACjC,OAAO,IAAA,mCAAQ,EAAC,OAAO,CAAC,IAAI,CAAC,IAAA,yCAAc,EAAC,OAAO,EAAE,UAAU,CAAC,IAAI,IAAA,yCAAc,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AACvG,CAAC"}

package/src/converter/patch-protobuf-root.ts

@@ -1 +0,0 @@
-export { patchProtobufRoot } from '@temporalio/proto/lib/patch-protobuf-root';