@temporalio/common 1.1.0 → 1.4.0

package/src/internal-non-workflow/codec-helpers.ts

@@ -0,0 +1,348 @@
+import { Payload } from '../interfaces';
+import { arrayFromPayloads, fromPayloadsAtIndex, toPayloads } from '../converter/payload-converter';
+import { PayloadConverterError } from '../errors';
+import { PayloadCodec } from '../converter/payload-codec';
+import { ProtoFailure, TemporalFailure } from '../failure';
+import { LoadedDataConverter } from '../converter/data-converter';
+import { DecodedPayload, DecodedProtoFailure, EncodedPayload, EncodedProtoFailure } from './codec-types';
+
+/**
+ * Decode through each codec, starting with the last codec.
+ */
+export async function decode(codecs: PayloadCodec[], payloads: Payload[]): Promise<DecodedPayload[]> {
+  for (let i = codecs.length - 1; i >= 0; i--) {
+    payloads = await codecs[i].decode(payloads);
+  }
+  return payloads as DecodedPayload[];
+}
+
+/**
+ * Encode through each codec, starting with the first codec.
+ */
+export async function encode(codecs: PayloadCodec[], payloads: Payload[]): Promise<EncodedPayload[]> {
+  for (let i = 0; i < codecs.length; i++) {
+    payloads = await codecs[i].encode(payloads);
+  }
+  return payloads as EncodedPayload[];
+}
+
+/** Run {@link PayloadCodec.encode} on `payloads` */
+export async function encodeOptional(
+  codecs: PayloadCodec[],
+  payloads: Payload[] | null | undefined
+): Promise<EncodedPayload[] | null | undefined> {
+  if (payloads == null) return payloads;
+  return await encode(codecs, payloads);
+}
+
+/** Run {@link PayloadCodec.decode} on `payloads` */
+export async function decodeOptional(
+  codecs: PayloadCodec[],
+  payloads: Payload[] | null | undefined
+): Promise<DecodedPayload[] | null | undefined> {
+  if (payloads == null) return payloads;
+  return await decode(codecs, payloads);
+}
+
+async function encodeSingle(codecs: PayloadCodec[], payload: Payload): Promise<EncodedPayload> {
+  const encodedPayloads = await encode(codecs, [payload]);
+  return encodedPayloads[0] as EncodedPayload;
+}
+
+async function decodeSingle(codecs: PayloadCodec[], payload: Payload): Promise<DecodedPayload> {
+  const [decodedPayload] = await decode(codecs, [payload]);
+  return decodedPayload;
+}
+
+/** Run {@link PayloadCodec.encode} on a single Payload */
+export async function encodeOptionalSingle(
+  codecs: PayloadCodec[],
+  payload: Payload | null | undefined
+): Promise<EncodedPayload | null | undefined> {
+  if (payload == null) return payload;
+  return await encodeSingle(codecs, payload);
+}
+
+/** Run {@link PayloadCodec.decode} on a single Payload */
+export async function decodeOptionalSingle(
+  codecs: PayloadCodec[],
+  payload: Payload | null | undefined
+): Promise<DecodedPayload | null | undefined> {
+  if (payload == null) return payload;
+  return await decodeSingle(codecs, payload);
+}
+
+/**
+ * Run {@link PayloadConverter.toPayload} on value, and then encode it.
+ */
+export async function encodeToPayload(converter: LoadedDataConverter, value: unknown): Promise<Payload> {
+  const { payloadConverter, payloadCodecs } = converter;
+  return await encodeSingle(payloadCodecs, payloadConverter.toPayload(value));
+}
+
+/**
+ * Decode `payloads` and then return {@link arrayFromPayloads}`.
+ */
+export async function decodeArrayFromPayloads(
+  converter: LoadedDataConverter,
+  payloads?: Payload[] | null
+): Promise<unknown[]> {
+  const { payloadConverter, payloadCodecs } = converter;
+  return arrayFromPayloads(payloadConverter, await decodeOptional(payloadCodecs, payloads));
+}
+
+/**
+ * Decode `payloads` and then return {@link fromPayloadsAtIndex}.
+ */
+export async function decodeFromPayloadsAtIndex<T>(
+  converter: LoadedDataConverter,
+  index: number,
+  payloads?: Payload[] | null
+): Promise<T> {
+  const { payloadConverter, payloadCodecs } = converter;
+  return await fromPayloadsAtIndex(payloadConverter, index, await decodeOptional(payloadCodecs, payloads));
+}
+
+/**
+ * Run {@link decodeFailure} and then return {@link failureToError}.
+ */
+export async function decodeOptionalFailureToOptionalError(
+  converter: LoadedDataConverter,
+  failure: ProtoFailure | undefined | null
+): Promise<TemporalFailure | undefined> {
+  const { failureConverter, payloadCodecs } = converter;
+  return failure ? failureConverter.failureToError(await decodeFailure(payloadCodecs, failure)) : undefined;
+}
+
+export async function decodeOptionalMap(
+  codecs: PayloadCodec[],
+  payloads: Record<string, Payload> | null | undefined
+): Promise<Record<string, DecodedPayload> | null | undefined> {
+  if (payloads == null) return payloads;
+  return Object.fromEntries(
+    await Promise.all(Object.entries(payloads).map(async ([k, v]) => [k, await decode(codecs, [v])]))
+  );
+}
+
+/**
+ * Run {@link PayloadConverter.toPayload} on values, and then encode them.
+ */
+export async function encodeToPayloads(
+  converter: LoadedDataConverter,
+  ...values: unknown[]
+): Promise<Payload[] | undefined> {
+  const { payloadConverter, payloadCodecs } = converter;
+  if (values.length === 0) {
+    return undefined;
+  }
+  const payloads = toPayloads(payloadConverter, ...values);
+  return payloads ? await encode(payloadCodecs, payloads) : undefined;
+}
+
+/**
+ * Run {@link PayloadCodec.decode} and then {@link PayloadConverter.fromPayload} on values in `map`.
+ */
+export async function decodeMapFromPayloads<K extends string>(
+  converter: LoadedDataConverter,
+  map: Record<K, Payload> | null | undefined
+): Promise<Record<K, unknown> | undefined> {
+  if (!map) return undefined;
+  const { payloadConverter, payloadCodecs } = converter;
+  return Object.fromEntries(
+    await Promise.all(
+      Object.entries(map).map(async ([k, payload]): Promise<[K, unknown]> => {
+        const [decodedPayload] = await decode(payloadCodecs, [payload as Payload]);
+        const value = payloadConverter.fromPayload(decodedPayload);
+        return [k as K, value];
+      })
+    )
+  ) as Record<K, unknown>;
+}
+
+/** Run {@link PayloadCodec.encode} on all values in `map` */
+export async function encodeMap<K extends string>(
+  codecs: PayloadCodec[],
+  map: Record<K, Payload> | null | undefined
+): Promise<Record<K, EncodedPayload> | null | undefined> {
+  if (map === null) return null;
+  if (map === undefined) return undefined;
+  return Object.fromEntries(
+    await Promise.all(
+      Object.entries(map).map(async ([k, payload]): Promise<[K, EncodedPayload]> => {
+        return [k as K, await encodeSingle(codecs, payload as Payload)];
+      })
+    )
+  ) as Record<K, EncodedPayload>;
+}
+
+/**
+ * Run {@link PayloadConverter.toPayload} and then {@link PayloadCodec.encode} on values in `map`.
+ */
+export async function encodeMapToPayloads<K extends string>(
+  converter: LoadedDataConverter,
+  map: Record<K, unknown>
+): Promise<Record<K, Payload>> {
+  const { payloadConverter, payloadCodecs } = converter;
+  return Object.fromEntries(
+    await Promise.all(
+      Object.entries(map).map(async ([k, v]): Promise<[K, Payload]> => {
+        const payload = payloadConverter.toPayload(v);
+        if (payload === undefined) throw new PayloadConverterError(`Failed to encode entry: ${k}: ${v}`);
+        const [encodedPayload] = await encode(payloadCodecs, [payload]);
+        return [k as K, encodedPayload];
+      })
+    )
+  ) as Record<K, Payload>;
+}
+
+/**
+ * Run {@link errorToFailure} on `error`, and then {@link encodeFailure}.
+ */
+export async function encodeErrorToFailure(dataConverter: LoadedDataConverter, error: unknown): Promise<ProtoFailure> {
+  const { failureConverter, payloadCodecs } = dataConverter;
+  return await encodeFailure(payloadCodecs, failureConverter.errorToFailure(error));
+}
+
+/**
+ * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
+ */
+export async function encodeFailure(codecs: PayloadCodec[], failure: ProtoFailure): Promise<EncodedProtoFailure> {
+  return {
+    ...failure,
+    encodedAttributes: failure.encodedAttributes ? (await encode(codecs, [failure.encodedAttributes]))[0] : undefined,
+    cause: failure.cause ? await encodeFailure(codecs, failure.cause) : null,
+    applicationFailureInfo: failure.applicationFailureInfo
+      ? {
+          ...failure.applicationFailureInfo,
+          details: failure.applicationFailureInfo.details
+            ? {
+                payloads: await encode(codecs, failure.applicationFailureInfo.details.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    timeoutFailureInfo: failure.timeoutFailureInfo
+      ? {
+          ...failure.timeoutFailureInfo,
+          lastHeartbeatDetails: failure.timeoutFailureInfo.lastHeartbeatDetails
+            ? {
+                payloads: await encode(codecs, failure.timeoutFailureInfo.lastHeartbeatDetails.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    canceledFailureInfo: failure.canceledFailureInfo
+      ? {
+          ...failure.canceledFailureInfo,
+          details: failure.canceledFailureInfo.details
+            ? {
+                payloads: await encode(codecs, failure.canceledFailureInfo.details.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    resetWorkflowFailureInfo: failure.resetWorkflowFailureInfo
+      ? {
+          ...failure.resetWorkflowFailureInfo,
+          lastHeartbeatDetails: failure.resetWorkflowFailureInfo.lastHeartbeatDetails
+            ? {
+                payloads: await encode(codecs, failure.resetWorkflowFailureInfo.lastHeartbeatDetails.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+  };
+}
+
+/**
+ * Return a new {@link ProtoFailure} with `codec.decode()` run on all the {@link Payload}s.
+ */
+export async function decodeFailure(codecs: PayloadCodec[], failure: ProtoFailure): Promise<DecodedProtoFailure> {
+  return {
+    ...failure,
+    encodedAttributes: failure.encodedAttributes ? (await decode(codecs, [failure.encodedAttributes]))[0] : undefined,
+    cause: failure.cause ? await decodeFailure(codecs, failure.cause) : null,
+    applicationFailureInfo: failure.applicationFailureInfo
+      ? {
+          ...failure.applicationFailureInfo,
+          details: failure.applicationFailureInfo.details
+            ? {
+                payloads: await decode(codecs, failure.applicationFailureInfo.details.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    timeoutFailureInfo: failure.timeoutFailureInfo
+      ? {
+          ...failure.timeoutFailureInfo,
+          lastHeartbeatDetails: failure.timeoutFailureInfo.lastHeartbeatDetails
+            ? {
+                payloads: await decode(codecs, failure.timeoutFailureInfo.lastHeartbeatDetails.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    canceledFailureInfo: failure.canceledFailureInfo
+      ? {
+          ...failure.canceledFailureInfo,
+          details: failure.canceledFailureInfo.details
+            ? {
+                payloads: await decode(codecs, failure.canceledFailureInfo.details.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+    resetWorkflowFailureInfo: failure.resetWorkflowFailureInfo
+      ? {
+          ...failure.resetWorkflowFailureInfo,
+          lastHeartbeatDetails: failure.resetWorkflowFailureInfo.lastHeartbeatDetails
+            ? {
+                payloads: await decode(codecs, failure.resetWorkflowFailureInfo.lastHeartbeatDetails.payloads ?? []),
+              }
+            : undefined,
+        }
+      : undefined,
+  };
+}
+
+/**
+ * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
+ */
+export async function encodeOptionalFailure(
+  codecs: PayloadCodec[],
+  failure: ProtoFailure | null | undefined
+): Promise<EncodedProtoFailure | null | undefined> {
+  if (failure == null) return failure;
+  return await encodeFailure(codecs, failure);
+}
+
+/**
+ * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
+ */
+export async function decodeOptionalFailure(
+  codecs: PayloadCodec[],
+  failure: ProtoFailure | null | undefined
+): Promise<DecodedProtoFailure | null | undefined> {
+  if (failure == null) return failure;
+  return await decodeFailure(codecs, failure);
+}
+
+/**
+ * Mark all values in the map as encoded.
+ * Use this for headers, which we don't encode.
+ */
+export function noopEncodeMap<K extends string>(
+  map: Record<K, Payload> | null | undefined
+): Record<K, EncodedPayload> | null | undefined {
+  return map as Record<K, EncodedPayload> | null | undefined;
+}
+
+/**
+ * Mark all values in the map as decoded.
+ * Use this for headers, which we don't encode.
+ */
+export function noopDecodeMap<K extends string>(
+  map: Record<K, Payload> | null | undefined
+): Record<K, DecodedPayload> | null | undefined {
+  return map as Record<K, DecodedPayload> | null | undefined;
+}

package/src/internal-non-workflow/codec-types.ts

@@ -0,0 +1,34 @@
+import type { Payload } from '../interfaces';
+import type { ProtoFailure } from '../failure';
+
+export interface EncodedPayload extends Payload {
+  encoded: true;
+}
+
+export interface DecodedPayload extends Payload {
+  decoded: true;
+}
+
+/** Replace `Payload`s with `EncodedPayload`s */
+export type Encoded<T> = ReplaceNested<T, Payload, EncodedPayload>;
+
+/** Replace `Payload`s with `DecodedPayload`s */
+export type Decoded<T> = ReplaceNested<T, Payload, DecodedPayload>;
+
+export type EncodedProtoFailure = Encoded<ProtoFailure>;
+export type DecodedProtoFailure = Decoded<ProtoFailure>;
+
+/** An object T with any nested values of type ToReplace replaced with ReplaceWith */
+export type ReplaceNested<T, ToReplace, ReplaceWith> = T extends (...args: any[]) => any
+  ? T
+  : [keyof T] extends [never]
+  ? T
+  : T extends { [k: string]: ToReplace }
+  ? {
+      [P in keyof T]: ReplaceNested<T[P], ToReplace, ReplaceWith>;
+    }
+  : T extends ToReplace
+  ? ReplaceWith | Exclude<T, ToReplace>
+  : {
+      [P in keyof T]: ReplaceNested<T[P], ToReplace, ReplaceWith>;
+    };

package/src/internal-non-workflow/data-converter-helpers.ts

@@ -0,0 +1,81 @@
+import { PayloadConverter } from '../converter/payload-converter';
+import { DataConverter, defaultFailureConverter, LoadedDataConverter } from '../converter/data-converter';
+import { FailureConverter } from '../converter/failure-converter';
+import { defaultPayloadConverter } from '../converter/payload-converter';
+import { errorCode, hasOwnProperty, isRecord } from '../type-helpers';
+import { ValueError } from '../errors';
+
+const isValidPayloadConverter = (converter: unknown): converter is PayloadConverter =>
+  typeof converter === 'object' &&
+  converter !== null &&
+  ['toPayload', 'fromPayload'].every((method) => typeof (converter as Record<string, unknown>)[method] === 'function');
+
+const isValidFailureConverter = (converter: unknown): converter is FailureConverter =>
+  typeof converter === 'object' &&
+  converter !== null &&
+  ['errorToFailure', 'failureToError'].every(
+    (method) => typeof (converter as Record<string, unknown>)[method] === 'function'
+  );
+
+function requireConverter<T>(path: string, type: string, validator: (converter: unknown) => converter is T): T {
+  let module;
+  try {
+    module = require(path); // eslint-disable-line @typescript-eslint/no-var-requires
+  } catch (error) {
+    if (errorCode(error) === 'MODULE_NOT_FOUND') {
+      throw new ValueError(`Could not find a file at the specified ${type}Path: '${path}'.`);
+    }
+    throw error;
+  }
+
+  if (isRecord(module) && hasOwnProperty(module, type)) {
+    const converter = module[type];
+    if (validator(converter)) {
+      return converter;
+    } else {
+      throw new ValueError(
+        `payloadConverter export at ${path} must be an object with toPayload and fromPayload methods`
+      );
+    }
+  } else {
+    throw new ValueError(`Module ${path} does not have a \`payloadConverter\` named export`);
+  }
+}
+
+/**
+ * If {@link DataConverter.payloadConverterPath} is specified, `require()` it and validate that the module has a `payloadConverter` named export.
+ * If not, use {@link defaultPayloadConverter}.
+ * If {@link DataConverter.payloadCodecs} is unspecified, use an empty array.
+ */
+export function loadDataConverter(dataConverter?: DataConverter): LoadedDataConverter {
+  let payloadConverter: PayloadConverter = defaultPayloadConverter;
+  if (dataConverter?.payloadConverterPath) {
+    payloadConverter = requireConverter(
+      dataConverter.payloadConverterPath,
+      'payloadConverter',
+      isValidPayloadConverter
+    );
+  }
+  let failureConverter: FailureConverter = defaultFailureConverter;
+  if (dataConverter?.failureConverterPath) {
+    failureConverter = requireConverter(
+      dataConverter.failureConverterPath,
+      'failureConverter',
+      isValidFailureConverter
+    );
+  }
+  return {
+    payloadConverter,
+    failureConverter,
+    payloadCodecs: dataConverter?.payloadCodecs ?? [],
+  };
+}
+
+/**
+ * Returns true if the converter is already "loaded"
+ */
+export function isLoadedDataConverter(
+  dataConverter?: DataConverter | LoadedDataConverter
+): dataConverter is LoadedDataConverter {
+  return isRecord(dataConverter) && hasOwnProperty(dataConverter, 'payloadConverter');
+}

package/src/internal-non-workflow/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Internal SDK library: users should usually use other packages instead. Not included in Workflow bundle.
+ *
+ * @module
+ */
+export * from './codec-helpers';
+export * from './codec-types';
+export * from './data-converter-helpers';
+export * from './tls-config';
+export * from './utils';

package/src/internal-non-workflow/tls-config.ts

@@ -0,0 +1,35 @@
+/** TLS configuration options. */
+export interface TLSConfig {
+  /**
+   * Overrides the target name used for SSL host name checking.
+   * If this attribute is not specified, the name used for SSL host name checking will be the host from {@link ServerOptions.url}.
+   * This _should_ be used for testing only.
+   */
+  serverNameOverride?: string;
+  /**
+   * Root CA certificate used by the server. If not set, and the server's
+   * cert is issued by someone the operating system trusts, verification will still work (ex: Cloud offering).
+   */
+  serverRootCACertificate?: Buffer;
+  /** Sets the client certificate and key for connecting with mTLS */
+  clientCertPair?: {
+    /** The certificate for this client */
+    crt: Buffer;
+    /** The private key for this client */
+    key: Buffer;
+  };
+}
+
+/**
+ * TLS configuration.
+ * Pass a falsy value to use a non-encrypted connection or `true` or `{}` to
+ * connect with TLS without any customization.
+ */
+export type TLSConfigOption = TLSConfig | boolean | null;
+
+/**
+ * Normalize {@link TLSConfigOption} by turning false and null to undefined and true to and empty object
+ */
+export function normalizeTlsConfig(tls?: TLSConfigOption): TLSConfig | undefined {
+  return typeof tls === 'object' ? (tls === null ? undefined : tls) : tls ? {} : undefined;
+}

package/src/internal-non-workflow/utils.ts

@@ -0,0 +1,6 @@
+/**
+ * Helper to prevent undefined and null values overriding defaults when merging maps
+ */
+export function filterNullAndUndefined<T extends Record<string, any>>(obj: T): T {
+  return Object.fromEntries(Object.entries(obj).filter(([_k, v]) => v != null)) as any;
+}

package/src/otel.ts

@@ -1,6 +1,6 @@
 import * as otel from '@opentelemetry/api';
-import { Headers } from '@temporalio/internal-workflow-common';
-import { defaultPayloadConverter } from './converter/payload-converters';
+import { Headers } from './interceptors';
+import { defaultPayloadConverter } from './converter/payload-converter';
 
 /** Default trace header for opentelemetry interceptors */
 export const TRACE_HEADER = '_tracer-data';

package/src/retry-policy.ts

@@ -0,0 +1,101 @@
+import type { temporal } from '@temporalio/proto';
+import { ValueError } from './errors';
+import { msOptionalToNumber, msOptionalToTs, msToNumber, msToTs, optionalTsToMs } from './time';
+
+/**
+ * Options for retrying Workflows and Activities
+ */
+export interface RetryPolicy {
+  /**
+   * Coefficient used to calculate the next retry interval.
+   * The next retry interval is previous interval multiplied by this coefficient.
+   * @minimum 1
+   * @default 2
+   */
+  backoffCoefficient?: number;
+  /**
+   * Interval of the first retry.
+   * If coefficient is 1 then it is used for all retries
+   * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
+   * @default 1 second
+   */
+  initialInterval?: string | number;
+  /**
+   * Maximum number of attempts. When exceeded, retries stop (even if {@link ActivityOptions.scheduleToCloseTimeout}
+   * hasn't been reached).
+   *
+   * @default Infinity
+   */
+  maximumAttempts?: number;
+  /**
+   * Maximum interval between retries.
+   * Exponential backoff leads to interval increase.
+   * This value is the cap of the increase.
+   *
+   * @default 100x of {@link initialInterval}
+   * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
+   */
+  maximumInterval?: string | number;
+
+  /**
+   * List of application failures types to not retry.
+   */
+  nonRetryableErrorTypes?: string[];
+}
+
+/**
+ * Turn a TS RetryPolicy into a proto compatible RetryPolicy
+ */
+export function compileRetryPolicy(retryPolicy: RetryPolicy): temporal.api.common.v1.IRetryPolicy {
+  if (retryPolicy.backoffCoefficient != null && retryPolicy.backoffCoefficient <= 0) {
+    throw new ValueError('RetryPolicy.backoffCoefficient must be greater than 0');
+  }
+  if (retryPolicy.maximumAttempts != null) {
+    if (retryPolicy.maximumAttempts === Number.POSITIVE_INFINITY) {
+      // drop field (Infinity is the default)
+      const { maximumAttempts: _, ...without } = retryPolicy;
+      retryPolicy = without;
+    } else if (retryPolicy.maximumAttempts <= 0) {
+      throw new ValueError('RetryPolicy.maximumAttempts must be a positive integer');
+    } else if (!Number.isInteger(retryPolicy.maximumAttempts)) {
+      throw new ValueError('RetryPolicy.maximumAttempts must be an integer');
+    }
+  }
+  const maximumInterval = msOptionalToNumber(retryPolicy.maximumInterval);
+  const initialInterval = msToNumber(retryPolicy.initialInterval ?? 1000);
+  if (maximumInterval === 0) {
+    throw new ValueError('RetryPolicy.maximumInterval cannot be 0');
+  }
+  if (initialInterval === 0) {
+    throw new ValueError('RetryPolicy.initialInterval cannot be 0');
+  }
+  if (maximumInterval != null && maximumInterval < initialInterval) {
+    throw new ValueError('RetryPolicy.maximumInterval cannot be less than its initialInterval');
+  }
+  return {
+    maximumAttempts: retryPolicy.maximumAttempts,
+    initialInterval: msToTs(initialInterval),
+    maximumInterval: msOptionalToTs(maximumInterval),
+    backoffCoefficient: retryPolicy.backoffCoefficient,
+    nonRetryableErrorTypes: retryPolicy.nonRetryableErrorTypes,
+  };
+}
+
+/**
+ * Turn a proto compatible RetryPolicy into a TS RetryPolicy
+ */
+export function decompileRetryPolicy(
+  retryPolicy?: temporal.api.common.v1.IRetryPolicy | null
+): RetryPolicy | undefined {
+  if (!retryPolicy) {
+    return undefined;
+  }
+
+  return {
+    backoffCoefficient: retryPolicy.backoffCoefficient ?? undefined,
+    maximumAttempts: retryPolicy.maximumAttempts ?? undefined,
+    maximumInterval: optionalTsToMs(retryPolicy.maximumInterval),
+    initialInterval: optionalTsToMs(retryPolicy.initialInterval),
+    nonRetryableErrorTypes: retryPolicy.nonRetryableErrorTypes ?? undefined,
+  };
+}