@temporalio/common 0.17.2 → 0.19.0-rc.1

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

@@ -0,0 +1,49 @@
+import { isRecord } from '@temporalio/internal-workflow-common';
+
+/**
+ * Create a version of `root` with non-nested namespaces to match the generated types.
+ * For more information, see:
+ * https://github.com/temporalio/sdk-typescript/blob/main/docs/protobuf-libraries.md#current-solution
+ * @param root Generated by `pbjs -t json-module -w commonjs -o json-module.js *.proto`
+ * @returns A new patched `root`
+ */
+export function patchProtobufRoot<T extends Record<string, unknown>>(root: T): T {
+  return _patchProtobufRoot(root);
+}
+
+function _patchProtobufRoot<T extends Record<string, unknown>>(root: T, name?: string): T {
+  const newRoot = new (root.constructor as any)(isNamespace(root) ? name : {});
+  for (const key in root) {
+    newRoot[key] = root[key];
+  }
+
+  if (isRecord(root.nested)) {
+    for (const typeOrNamespace in root.nested) {
+      const value = root.nested[typeOrNamespace];
+      if (typeOrNamespace in root && !(isType(root[typeOrNamespace]) || isNamespace(root[typeOrNamespace]))) {
+        console.log(
+          `patchRoot warning: overriding property '${typeOrNamespace}' that is used by protobufjs with the '${typeOrNamespace}' protobuf namespace. This may result in protobufjs not working property.`
+        );
+      }
+
+      if (isNamespace(value)) {
+        newRoot[typeOrNamespace] = _patchProtobufRoot(value, typeOrNamespace);
+      } else if (isType(value)) {
+        newRoot[typeOrNamespace] = value;
+      }
+    }
+  }
+
+  return newRoot;
+}
+
+type Type = Record<string, unknown>;
+type Namespace = { nested: Record<string, unknown> };
+
+function isType(value: unknown): value is Type {
+  return isRecord(value) && value.constructor.name === 'Type';
+}
+
+function isNamespace(value: unknown): value is Namespace {
+  return isRecord(value) && value.constructor.name === 'Namespace';
+}

package/src/converter/payload-codec.ts

@@ -0,0 +1,30 @@
+import { Payload } from './types';
+
+/**
+ * `PayloadCodec` is an optional step that happens between the wire and the {@link PayloadConverter}:
+ *
+ * Temporal Server <--> Wire <--> `PayloadCodec` <--> `PayloadConverter` <--> User code
+ *
+ * Implement this to transform an array of {@link Payload}s to/from the format sent over the wire and stored by Temporal Server.
+ * Common transformations are encryption and compression.
+ */
+export interface PayloadCodec {
+  /**
+   * Encode an array of {@link Payload}s for sending over the wire.
+   * @param payloads May have length 0.
+   */
+  encode(payloads: Payload[]): Promise<Payload[]>;
+
+  /**
+   * Decode an array of {@link Payload}s received from the wire.
+   */
+  decode(payloads: Payload[]): Promise<Payload[]>;
+}
+
+/**
+ * No-op implementation of {@link PayloadCodec}.
+ */
+export const defaultPayloadCodec = {
+  encode: async (payloads: Payload[]): Promise<Payload[]> => payloads,
+  decode: async (payloads: Payload[]): Promise<Payload[]> => payloads,
+};

package/src/converter/payload-converter.ts

@@ -1,142 +1,162 @@
-import { ValueError } from '../errors';
-import { u8, str, Payload, encodingTypes, encodingKeys, METADATA_ENCODING_KEY } from './types';
+import { PayloadConverterError, ValueError } from '@temporalio/internal-workflow-common';
+import {
+  BinaryPayloadConverter,
+  JsonPayloadConverter,
+  PayloadConverterWithEncoding,
+  UndefinedPayloadConverter,
+} from './payload-converters';
+import { METADATA_ENCODING_KEY, Payload, str } from './types';
 
 /**
- * Used by the framework to serialize/deserialize method parameters that need to be sent over the
- * wire.
+ * Used by the framework to serialize/deserialize parameters and return values.
  *
- * @author fateev
+ * This is called inside the [Workflow isolate](https://docs.temporal.io/docs/typescript/determinism).
+ * To write async code or use Node APIs (or use packages that use Node APIs), use a {@link PayloadCodec}.
  */
 export interface PayloadConverter {
-  encodingType: string;
-
   /**
-   * TODO: Fix comment in https://github.com/temporalio/sdk-java/blob/85593dbfa99bddcdf54c7196d2b73eeb23e94e9e/temporal-sdk/src/main/java/io/temporal/common/converter/DataConverter.java#L46
-   * Implements conversion of value to payload
-   *
-   * @param value JS value to convert.
-   * @return converted value
-   * @throws DataConverterException if conversion of the value passed as parameter failed for any
-   *     reason.
+   * Converts a value to a {@link Payload}.
+   * @param value The value to convert. Example values include the Workflow args sent by the client and the values returned by a Workflow or Activity.
    */
-  toData(value: unknown): Promise<Payload | undefined>;
+  toPayload<T>(value: T): Payload | undefined;
 
   /**
-   * Implements conversion of payload to value.
-   *
-   * @param content Serialized value to convert to a JS value.
-   * @return converted JS value
-   * @throws DataConverterException if conversion of the data passed as parameter failed for any
-   *     reason.
+   * Converts a {@link Payload} back to a value.
    */
-  fromData<T>(content: Payload): Promise<T>;
+  fromPayload<T>(payload: Payload): T;
+}
+
+export class CompositePayloadConverter implements PayloadConverter {
+  readonly converters: PayloadConverterWithEncoding[];
+  readonly converterByEncoding: Map<string, PayloadConverterWithEncoding> = new Map();
+
+  constructor(...converters: PayloadConverterWithEncoding[]) {
+    this.converters = converters;
+    for (const converter of converters) {
+      this.converterByEncoding.set(converter.encodingType, converter);
+    }
+  }
 
   /**
-   * Synchronous version of {@link toData}, used in the Workflow runtime because
-   * the async version limits the functionality of the runtime.
-   *
-   * Implements conversion of value to payload
+   * Tries to run `.toPayload(value)` on each converter in the order provided at construction.
+   * Returns the first successful result, or `undefined` if there is no converter that can handle the value.
    *
-   * @param value JS value to convert.
-   * @return converted value
-   * @throws DataConverterException if conversion of the value passed as parameter failed for any
-   *     reason.
+   * @throws UnsupportedJsonTypeError
    */
-  toDataSync(value: unknown): Payload | undefined;
+  public toPayload<T>(value: T): Payload | undefined {
+    for (const converter of this.converters) {
+      const result = converter.toPayload(value);
+      if (result !== undefined) {
+        return result;
+      }
+    }
+    return undefined;
+  }
 
   /**
-   * Synchronous version of {@link fromData}, used in the Workflow runtime because
-   * the async version limits the functionality of the runtime.
-   *
-   * Implements conversion of payload to value.
-   *
-   * @param content Serialized value to convert to a JS value.
-   * @return converted JS value
-   * @throws DataConverterException if conversion of the data passed as parameter failed for any
-   *     reason.
+   * Run {@link PayloadConverterWithEncoding.fromPayload} based on the {@link encodingTypes | encoding type} of the {@link Payload}.
    */
-  fromDataSync<T>(content: Payload): T;
-}
-
-export abstract class AsyncFacadePayloadConverter implements PayloadConverter {
-  abstract encodingType: string;
-  abstract toDataSync(value: unknown): Payload | undefined;
-  abstract fromDataSync<T>(content: Payload): T;
-
-  public async toData(value: unknown): Promise<Payload | undefined> {
-    return this.toDataSync(value);
+  public fromPayload<T>(payload: Payload): T {
+    if (payload.metadata === undefined || payload.metadata === null) {
+      throw new ValueError('Missing payload metadata');
+    }
+    const encoding = str(payload.metadata[METADATA_ENCODING_KEY]);
+    const converter = this.converterByEncoding.get(encoding);
+    if (converter === undefined) {
+      throw new ValueError(`Unknown encoding: ${encoding}`);
+    }
+    return converter.fromPayload(payload);
   }
+}
 
-  public async fromData<T>(content: Payload): Promise<T> {
-    return this.fromDataSync(content);
+/**
+ * Tries to convert `value` to a {@link Payload}. Throws if conversion fails.
+ *
+ * @throws {@link PayloadConverterError}
+ */
+export function toPayload(converter: PayloadConverter, value: unknown): Payload {
+  const payload = converter.toPayload(value);
+  if (payload === undefined) {
+    throw new PayloadConverterError(`Failed to convert value: ${value}`);
   }
+  return payload;
 }
 
 /**
- * Converts between JS undefined and NULL Payload
+ * Implements conversion of a list of values.
+ *
+ * @param converter
+ * @param values JS values to convert to Payloads
+ * @return converted values
+ * @throws PayloadConverterError if conversion of the value passed as parameter failed for any
+ *     reason.
  */
-export class UndefinedPayloadConverter extends AsyncFacadePayloadConverter {
-  public encodingType = encodingTypes.METADATA_ENCODING_NULL;
-
-  public toDataSync(value: unknown): Payload | undefined {
-    if (value !== undefined) return undefined; // Can't encode
-    return {
-      metadata: {
-        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_NULL,
-      },
-    };
+export function toPayloads(converter: PayloadConverter, ...values: unknown[]): Payload[] | undefined {
+  if (values.length === 0) {
+    return undefined;
   }
 
-  public fromDataSync<T>(_content: Payload): T {
-    return undefined as any; // Just return undefined
-  }
+  return values.map((value) => toPayload(converter, value));
 }
 
 /**
- * Converts between non-undefined values and serialized JSON Payload
+ * Run {@link PayloadConverter.toPayload} on each value in the map.
+ *
+ * @throws {@link PayloadConverterError} if conversion of any value in the map fails
  */
-export class JsonPayloadConverter extends AsyncFacadePayloadConverter {
-  public encodingType = encodingTypes.METADATA_ENCODING_JSON;
-
-  public toDataSync(value: unknown): Payload | undefined {
-    if (value === undefined) return undefined; // Should be encoded with the UndefinedPayloadConverter
-    return {
-      metadata: {
-        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_JSON,
-      },
-      data: u8(JSON.stringify(value)),
-    };
-  }
+export function mapToPayloads<K extends string>(converter: PayloadConverter, map: Record<K, any>): Record<K, Payload> {
+  return Object.fromEntries(
+    Object.entries(map).map(([k, v]): [K, Payload] => [k as K, toPayload(converter, v)])
+  ) as Record<K, Payload>;
+}
 
-  public fromDataSync<T>(content: Payload): T {
-    if (content.data === undefined || content.data === null) {
-      throw new ValueError('Got payload with no data');
-    }
-    return JSON.parse(str(content.data));
+/**
+ * Implements conversion of an array of values of different types. Useful for deserializing
+ * arguments of function invocations.
+ *
+ * @param converter
+ * @param index index of the value in the payloads
+ * @param payloads serialized value to convert to JS values.
+ * @return converted JS value
+ * @throws {@link PayloadConverterError} if conversion of the data passed as parameter failed for any
+ *     reason.
+ */
+export function fromPayloadsAtIndex<T>(converter: PayloadConverter, index: number, payloads?: Payload[] | null): T {
+  // To make adding arguments a backwards compatible change
+  if (payloads === undefined || payloads === null || index >= payloads.length) {
+    return undefined as any;
   }
+  return converter.fromPayload(payloads[index]);
 }
 
 /**
- * Converts between binary data types and RAW Payload
+ * Run {@link PayloadConverter.fromPayload} on each value in the array.
  */
-export class BinaryPayloadConverter extends AsyncFacadePayloadConverter {
-  public encodingType = encodingTypes.METADATA_ENCODING_RAW;
-
-  public toDataSync(value: unknown): Payload | undefined {
-    // TODO: support any DataView or ArrayBuffer?
-    if (!(value instanceof Uint8Array)) {
-      return undefined;
-    }
-    return {
-      metadata: {
-        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_RAW,
-      },
-      data: value,
-    };
+export function arrayFromPayloads(converter: PayloadConverter, payloads?: Payload[] | null): unknown[] {
+  if (!payloads) {
+    return [];
   }
+  return payloads.map((payload: Payload) => converter.fromPayload(payload));
+}
 
-  public fromDataSync<T>(content: Payload): T {
-    // TODO: support any DataView or ArrayBuffer?
-    return content.data as any;
+export class DefaultPayloadConverter extends CompositePayloadConverter {
+  // Match the order used in other SDKs, but exclude Protobuf converters so that the code, including
+  // `proto3-json-serializer`, doesn't take space in Workflow bundles that don't use Protobufs. To use Protobufs, use
+  // {@link DefaultPayloadConverterWithProtobufs}.
+  //
+  // Go SDK:
+  // https://github.com/temporalio/sdk-go/blob/5e5645f0c550dcf717c095ae32c76a7087d2e985/converter/default_data_converter.go#L28
+  constructor() {
+    super(new UndefinedPayloadConverter(), new BinaryPayloadConverter(), new JsonPayloadConverter());
   }
 }
+
+/**
+ * The default {@link PayloadConverter} used by the SDK.
+ * Supports `Uint8Array` and JSON serializables (so if [`JSON.stringify(yourArgOrRetval)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#description) works, the default payload converter will work).
+ *
+ * To also support Protobufs, create a custom payload converter with {@link DefaultPayloadConverter}:
+ *
+ * `const myConverter = new DefaultPayloadConverter({ protobufRoot })`
+ */
+export const defaultPayloadConverter = new DefaultPayloadConverter();

package/src/converter/payload-converters.ts

@@ -0,0 +1,89 @@
+import { errorMessage, UnsupportedJsonTypeError, ValueError } from '@temporalio/internal-workflow-common';
+import { PayloadConverter } from './payload-converter';
+import { encodingKeys, EncodingType, encodingTypes, METADATA_ENCODING_KEY, Payload, str, u8 } from './types';
+
+export interface PayloadConverterWithEncoding extends PayloadConverter {
+  readonly encodingType: EncodingType;
+}
+
+/**
+ * Converts between JS undefined and NULL Payload
+ */
+export class UndefinedPayloadConverter implements PayloadConverterWithEncoding {
+  public encodingType = encodingTypes.METADATA_ENCODING_NULL;
+
+  public toPayload(value: unknown): Payload | undefined {
+    if (value !== undefined) return undefined; // Can't encode
+    return {
+      metadata: {
+        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_NULL,
+      },
+    };
+  }
+
+  public fromPayload<T>(_content: Payload): T {
+    return undefined as any; // Just return undefined
+  }
+}
+
+/**
+ * Converts between non-undefined values and serialized JSON Payload
+ *
+ * @throws UnsupportedJsonTypeError
+ */
+export class JsonPayloadConverter implements PayloadConverterWithEncoding {
+  public encodingType = encodingTypes.METADATA_ENCODING_JSON;
+
+  public toPayload(value: unknown): Payload | undefined {
+    if (value === undefined) return undefined;
+
+    let json;
+    try {
+      json = JSON.stringify(value);
+    } catch (e) {
+      throw new UnsupportedJsonTypeError(
+        `Can't run JSON.stringify on this value: ${value}. Either convert it (or its properties) to JSON-serializable values (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#description ), or use a custom data converter: https://docs.temporal.io/docs/typescript/data-converters . JSON.stringify error message: ${errorMessage(
+          e
+        )}`,
+        e as Error
+      );
+    }
+
+    return {
+      metadata: {
+        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_JSON,
+      },
+      data: u8(json),
+    };
+  }
+
+  public fromPayload<T>(content: Payload): T {
+    if (content.data === undefined || content.data === null) {
+      throw new ValueError('Got payload with no data');
+    }
+    return JSON.parse(str(content.data));
+  }
+}
+
+/**
+ * Converts between binary data types and RAW Payload
+ */
+export class BinaryPayloadConverter implements PayloadConverterWithEncoding {
+  public encodingType = encodingTypes.METADATA_ENCODING_RAW;
+
+  public toPayload(value: unknown): Payload | undefined {
+    // TODO: support any DataView or ArrayBuffer?
+    if (!(value instanceof Uint8Array)) return undefined;
+    return {
+      metadata: {
+        [METADATA_ENCODING_KEY]: encodingKeys.METADATA_ENCODING_RAW,
+      },
+      data: value,
+    };
+  }
+
+  public fromPayload<T>(content: Payload): T {
+    // TODO: support any DataView or ArrayBuffer?
+    return content.data as any;
+  }
+}

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

@@ -0,0 +1,192 @@
+import {
+  errorMessage,
+  hasOwnProperties,
+  hasOwnProperty,
+  isRecord,
+  PayloadConverterError,
+  ValueError,
+} from '@temporalio/internal-workflow-common';
+import * as protoJsonSerializer from 'proto3-json-serializer';
+import type { Message, Namespace, Root, Type } from 'protobufjs';
+import { CompositePayloadConverter } from './payload-converter';
+import {
+  BinaryPayloadConverter,
+  JsonPayloadConverter,
+  PayloadConverterWithEncoding,
+  UndefinedPayloadConverter,
+} from './payload-converters';
+import {
+  EncodingType,
+  encodingTypes,
+  METADATA_ENCODING_KEY,
+  METADATA_MESSAGE_TYPE_KEY,
+  Payload,
+  str,
+  u8,
+} from './types';
+
+abstract class ProtobufPayloadConverter implements PayloadConverterWithEncoding {
+  protected readonly root: Root | undefined;
+  public abstract encodingType: EncodingType;
+
+  public abstract toPayload<T>(value: T): Payload | undefined;
+  public abstract fromPayload<T>(payload: Payload): T;
+
+  // Don't use type Root here because root.d.ts doesn't export Root, so users would have to type assert
+  constructor(root?: unknown) {
+    if (root) {
+      if (!isRoot(root)) {
+        throw new TypeError('root must be an instance of a protobufjs Root');
+      }
+
+      this.root = root;
+    }
+  }
+
+  protected validatePayload(content: Payload): { messageType: Type; data: Uint8Array } {
+    if (content.data === undefined || content.data === null) {
+      throw new ValueError('Got payload with no data');
+    }
+    if (!content.metadata || !(METADATA_MESSAGE_TYPE_KEY in content.metadata)) {
+      throw new ValueError(`Got protobuf payload without metadata.${METADATA_MESSAGE_TYPE_KEY}`);
+    }
+    if (!this.root) {
+      throw new PayloadConverterError('Unable to deserialize protobuf message without `root` being provided');
+    }
+
+    const messageTypeName = str(content.metadata[METADATA_MESSAGE_TYPE_KEY]);
+    let messageType;
+    try {
+      messageType = this.root.lookupType(messageTypeName);
+    } catch (e) {
+      if (errorMessage(e)?.includes('no such type')) {
+        throw new PayloadConverterError(
+          `Got a \`${messageTypeName}\` protobuf message but cannot find corresponding message class in \`root\``
+        );
+      }
+
+      throw e;
+    }
+
+    return { messageType, data: content.data };
+  }
+
+  protected constructPayload({ messageTypeName, message }: { messageTypeName: string; message: Uint8Array }): Payload {
+    return {
+      metadata: {
+        [METADATA_ENCODING_KEY]: u8(this.encodingType),
+        [METADATA_MESSAGE_TYPE_KEY]: u8(messageTypeName),
+      },
+      data: message,
+    };
+  }
+}
+
+/**
+ * Converts between protobufjs Message instances and serialized Protobuf Payload
+ */
+export class ProtobufBinaryPayloadConverter extends ProtobufPayloadConverter {
+  public encodingType = encodingTypes.METADATA_ENCODING_PROTOBUF;
+
+  /**
+   * @param root The value returned from {@link patchProtobufRoot}
+   */
+  constructor(root?: unknown) {
+    super(root);
+  }
+
+  public toPayload(value: unknown): Payload | undefined {
+    if (!isProtobufMessage(value)) return undefined;
+
+    return this.constructPayload({
+      messageTypeName: getNamespacedTypeName(value.$type),
+      message: value.$type.encode(value).finish(),
+    });
+  }
+
+  public fromPayload<T>(content: Payload): T {
+    const { messageType, data } = this.validatePayload(content);
+    return messageType.decode(data) as unknown as T;
+  }
+}
+
+/**
+ * Converts between protobufjs Message instances and serialized JSON Payload
+ */
+export class ProtobufJsonPayloadConverter extends ProtobufPayloadConverter {
+  public encodingType = encodingTypes.METADATA_ENCODING_PROTOBUF_JSON;
+
+  /**
+   * @param root The value returned from {@link patchProtobufRoot}
+   */
+  constructor(root?: unknown) {
+    super(root);
+  }
+
+  public toPayload(value: unknown): Payload | undefined {
+    if (!isProtobufMessage(value)) return undefined;
+
+    const jsonValue = protoJsonSerializer.toProto3JSON(value);
+
+    return this.constructPayload({
+      messageTypeName: getNamespacedTypeName(value.$type),
+      message: u8(JSON.stringify(jsonValue)),
+    });
+  }
+
+  public fromPayload<T>(content: Payload): T {
+    const { messageType, data } = this.validatePayload(content);
+    return protoJsonSerializer.fromProto3JSON(messageType, JSON.parse(str(data))) as unknown as T;
+  }
+}
+
+function isProtobufType(type: unknown): type is Type {
+  return (
+    isRecord(type) &&
+    type.constructor.name === 'Type' &&
+    hasOwnProperties(type, ['parent', 'name', 'create', 'encode', 'decode']) &&
+    typeof type.name === 'string' &&
+    typeof type.create === 'function' &&
+    typeof type.encode === 'function' &&
+    typeof type.decode === 'function'
+  );
+}
+
+function isProtobufMessage(value: unknown): value is Message {
+  return isRecord(value) && hasOwnProperty(value, '$type') && isProtobufType(value.$type);
+}
+
+function getNamespacedTypeName(node: Type | Namespace): string {
+  if (node.parent && !isRoot(node.parent)) {
+    return getNamespacedTypeName(node.parent) + '.' + node.name;
+  } else {
+    return node.name;
+  }
+}
+
+function isRoot(root: unknown): root is Root {
+  return isRecord(root) && root.constructor.name === 'Root';
+}
+
+export interface DefaultPayloadConverterWithProtobufsOptions {
+  /**
+   * The `root` provided to {@link ProtobufJsonPayloadConverter} and {@link ProtobufBinaryPayloadConverter}
+   */
+  protobufRoot: Record<string, unknown>;
+}
+
+export class DefaultPayloadConverterWithProtobufs extends CompositePayloadConverter {
+  // Match the order used in other SDKs.
+  //
+  // Go SDK:
+  // https://github.com/temporalio/sdk-go/blob/5e5645f0c550dcf717c095ae32c76a7087d2e985/converter/default_data_converter.go#L28
+  constructor({ protobufRoot }: DefaultPayloadConverterWithProtobufsOptions) {
+    super(
+      new UndefinedPayloadConverter(),
+      new BinaryPayloadConverter(),
+      new ProtobufJsonPayloadConverter(protobufRoot),
+      new ProtobufBinaryPayloadConverter(protobufRoot),
+      new JsonPayloadConverter()
+    );
+  }
+}

package/src/converter/types.ts

@@ -1,5 +1,5 @@
 import type * as iface from '@temporalio/proto/lib/coresdk';
-import { TextEncoder, TextDecoder } from '../encoding';
+import { TextEncoder, TextDecoder } from './encoding';
 
 export type Payload = iface.coresdk.common.IPayload;
 
@@ -22,6 +22,7 @@ export const encodingTypes = {
   METADATA_ENCODING_PROTOBUF_JSON: 'json/protobuf',
   METADATA_ENCODING_PROTOBUF: 'binary/protobuf',
 } as const;
+export type EncodingType = typeof encodingTypes[keyof typeof encodingTypes];
 
 export const encodingKeys = {
   METADATA_ENCODING_NULL: u8(encodingTypes.METADATA_ENCODING_NULL),
@@ -30,3 +31,5 @@ export const encodingKeys = {
   METADATA_ENCODING_PROTOBUF_JSON: u8(encodingTypes.METADATA_ENCODING_PROTOBUF_JSON),
   METADATA_ENCODING_PROTOBUF: u8(encodingTypes.METADATA_ENCODING_PROTOBUF),
 } as const;
+
+export const METADATA_MESSAGE_TYPE_KEY = 'messageType';