@restatedev/restate-sdk 0.7.3-worker → 0.8.1

package/src/types/errors.ts

@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { ErrorMessage, Failure } from "../generated/proto/protocol";
+import { formatMessageAsJson } from "../utils/utils";
+import { FailureWithTerminal } from "../generated/proto/javascript";
+import * as p from "./protocol";
+
+export enum ErrorCodes {
+  /**
+   *  Not an error; returned on success.
+   *  HTTP 200
+   */
+  OK = 0,
+  /**
+   * The operation was cancelled, typically by the caller.
+   * HTTP 408
+   */
+  CANCELLED = 1,
+  /**
+   * Unknown error. For example, this error may be returned when a
+   * Status value received from another address space belongs to an error
+   * space that is not known in this address space. Also errors raised by APIs
+   * that do  not return enough error information may be converted to this
+   * error.
+   * HTTP 500
+   */
+  UNKNOWN = 2,
+  /**
+   * The client specified an invalid argument. Note that
+   * this differs from FAILED_PRECONDITION. INVALID_ARGUMENT indicates
+   * arguments that are problematic regardless of the state of the system
+   * (e.g., a malformed file name).
+   * HTTP 400
+   */
+  INVALID_ARGUMENT = 3,
+  /**
+   * The deadline expired before the operation could
+   * complete. For operations that change the state of the system, this error
+   * may be returned even if the operation has completed successfully. For
+   * example, a successful response from a server could have been delayed
+   * long.
+   * HTTP 408
+   */
+  DEADLINE_EXCEEDED = 4,
+  /**
+   * Some requested entity (e.g., file or directory) was not
+   * found. Note to server developers: if a request is denied for an entire
+   * class of users, such as gradual feature rollout or undocumented
+   * allowlist, NOT_FOUND may be used. If a request is denied for some users
+   * within a class of users, such as user-based access control,
+   * PERMISSION_DENIED must be used.
+   * HTTP 404
+   */
+  NOT_FOUND = 5,
+  /**
+   * The entity that a client attempted to create (e.g., file
+   * or directory) already exists.
+   * HTTP 409
+   */
+  ALREADY_EXISTS = 6,
+  /**
+   * The caller does not have permission to execute the
+   * specified operation. PERMISSION_DENIED must not be used for rejections
+   * caused by exhausting some resource (use RESOURCE_EXHAUSTED instead for
+   * those errors). PERMISSION_DENIED must not be used if the caller can not
+   * be identified (use UNAUTHENTICATED instead for those errors). This error
+   * code does not imply the request is valid or the requested entity exists
+   * or satisfies other pre-conditions.
+   * HTTP 403
+   */
+  PERMISSION_DENIED = 7,
+  /**
+   * Some resource has been exhausted, perhaps a per-user
+   * quota, or perhaps the entire file system is out of space.
+   * HTTP 413
+   */
+  RESOURCE_EXHAUSTED = 8,
+  /**
+   * The operation was rejected because the system is
+   * not in a state required for the operation's execution. For example, the
+   * directory to be deleted is non-empty, an rmdir operation is applied to a
+   * non-directory, etc. Service implementors can use the following guidelines
+   * to decide between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE: (a) Use
+   * UNAVAILABLE if the client can retry just the failing call. (b) Use
+   * ABORTED if the client should retry at a higher level (e.g., when a
+   * client-specified test-and-set fails, indicating the client should restart
+   * a read-modify-write sequence). (c) Use FAILED_PRECONDITION if the client
+   * should not retry until the system state has been explicitly fixed. E.g.,
+   * if an "rmdir" fails because the directory is non-empty,
+   * FAILED_PRECONDITION should be returned since the client should not retry
+   * unless the files are deleted from the directory.
+   * HTTP 412
+   */
+  FAILED_PRECONDITION = 9,
+  /**
+   * The operation was aborted, typically due to a concurrency issue
+   * such as a sequencer check failure or transaction abort. See the
+   * guidelines above for deciding between FAILED_PRECONDITION, ABORTED, and
+   * UNAVAILABLE.
+   * HTTP 409
+   */
+  ABORTED = 10,
+  /**
+   * The operation was attempted past the valid range. E.g.,
+   * seeking or reading past end-of-file. Unlike INVALID_ARGUMENT, this error
+   * indicates a problem that may be fixed if the system state changes. For
+   * example, a 32-bit file system will generate INVALID_ARGUMENT if asked to
+   * read at an offset that is not in the range [0,2^32-1], but it will
+   * generate OUT_OF_RANGE if asked to read from an offset past the current
+   * file size. There is a fair bit of overlap between FAILED_PRECONDITION and
+   * OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)
+   * when it applies so that callers who are iterating through a space can
+   * easily look for an OUT_OF_RANGE error to detect when they are done.
+   * HTTP 400
+   */
+  OUT_OF_RANGE = 11,
+  /**
+   * The operation is not implemented or is not
+   * supported/enabled in this service.
+   * HTTP 501
+   */
+  UNIMPLEMENTED = 12,
+  /**
+   * Internal errors. This means that some invariants expected by
+   * the underlying system have been broken. This error code is reserved for
+   * serious errors.
+   * HTTP 500
+   */
+  INTERNAL = 13,
+  /**
+   * The service is currently unavailable. This is most likely a
+   * transient condition, which can be corrected by retrying with a backoff.
+   * Note that it is not always safe to retry non-idempotent operations.
+   * HTTP 503
+   */
+  UNAVAILABLE = 14,
+  /**
+   * Unrecoverable data loss or corruption.
+   * HTTP 500
+   */
+  DATA_LOSS = 15,
+  /**
+   * The request does not have valid authentication
+   * credentials for the operation.
+   * HTTP 401
+   */
+  UNAUTHENTICATED = 16,
+}
+export enum RestateErrorCodes {
+  JOURNAL_MISMATCH = 32,
+  PROTOCOL_VIOLATION = 33,
+}
+
+export function ensureError(e: unknown): Error {
+  if (e instanceof Error) {
+    return e;
+  }
+
+  let msg;
+  try {
+    msg = JSON.stringify(e);
+  } catch (x) {
+    msg = "(no JSON representation)";
+  }
+
+  return new Error("Non-Error value: " + msg);
+}
+
+export class RestateError extends Error {
+  public readonly code: number;
+
+  constructor(message: string, options?: { errorCode?: number; cause?: any }) {
+    super(message, { cause: options?.cause });
+    this.code = options?.errorCode ?? ErrorCodes.INTERNAL;
+  }
+
+  public toFailure(): Failure {
+    return Failure.create({
+      code: this.code,
+      message: this.message,
+    });
+  }
+}
+
+// Does not lead to Restate retries
+// Leads to an output message with a failure defined
+export class TerminalError extends RestateError {
+  constructor(message: string, options?: { errorCode?: number; cause?: any }) {
+    super(message, options);
+  }
+}
+
+export class TimeoutError extends TerminalError {
+  constructor() {
+    super("Timeout occurred", { errorCode: ErrorCodes.DEADLINE_EXCEEDED });
+  }
+}
+
+// Leads to Restate retries
+export class RetryableError extends RestateError {
+  constructor(message: string, options?: { errorCode?: number; cause?: any }) {
+    super(message, options);
+  }
+
+  public static internal(message: string) {
+    return new RetryableError(message);
+  }
+
+  public static journalMismatch(
+    journalIndex: number,
+    actualEntry: {
+      messageType: bigint;
+      message: p.ProtocolMessage | Uint8Array;
+    },
+    expectedEntry: {
+      messageType: bigint;
+      message: p.ProtocolMessage | Uint8Array;
+    }
+  ) {
+    const msg = `Journal mismatch: Replayed journal entries did not correspond to the user code. The user code has to be deterministic!
+        The journal entry at position ${journalIndex} was:
+        - In the user code: type: ${
+          expectedEntry.messageType
+        }, message:${formatMessageAsJson(expectedEntry.message)}
+        - In the replayed messages: type: ${
+          actualEntry.messageType
+        }, message: ${formatMessageAsJson(actualEntry.message)}`;
+    return new RetryableError(msg, {
+      errorCode: RestateErrorCodes.JOURNAL_MISMATCH,
+    });
+  }
+
+  public static protocolViolation(message: string) {
+    return new RetryableError(message, {
+      errorCode: RestateErrorCodes.PROTOCOL_VIOLATION,
+    });
+  }
+
+  public static apiViolation(message: string) {
+    return new RetryableError(`API violation: ${message}`, {
+      errorCode: ErrorCodes.INTERNAL,
+    });
+  }
+}
+
+export function errorToFailure(err: Error): Failure {
+  return err instanceof RestateError
+    ? err.toFailure()
+    : Failure.create({
+        code: ErrorCodes.INTERNAL,
+        message: err.message,
+      });
+}
+
+export function errorToFailureWithTerminal(err: Error): FailureWithTerminal {
+  const failure = errorToFailure(err);
+  return FailureWithTerminal.create({
+    failure,
+    terminal: err instanceof TerminalError,
+  });
+}
+
+export function failureToTerminalError(failure: Failure): TerminalError {
+  return failureToError(failure, true) as TerminalError;
+}
+
+export function failureToError(
+  failure: Failure,
+  terminalError: boolean
+): Error {
+  const errorMessage = failure.message ?? "(missing error message)";
+  const errorCode = failure.code ?? ErrorCodes.INTERNAL;
+
+  return terminalError
+    ? new TerminalError(errorMessage, { errorCode })
+    : new RestateError(errorMessage, { errorCode });
+}
+
+export function errorToErrorMessage(err: Error): ErrorMessage {
+  const code = err instanceof RestateError ? err.code : ErrorCodes.INTERNAL;
+
+  return ErrorMessage.create({
+    code: code,
+    message: err.message,
+  });
+}

package/src/types/grpc.ts

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+
+import { Context } from "../context";
+import { FileDescriptorProto } from "ts-proto-descriptors";
+
+export class GrpcServiceMethod<I, O> {
+  constructor(
+    readonly name: string, // the gRPC name as defined in the .proto file
+    readonly localName: string, // the method name as defined in the class.
+    readonly keyedContext: boolean, // If the method expects a keyed context
+    readonly localFn: (instance: unknown, input: I) => Promise<O>, // the actual function
+    readonly inputDecoder: (buf: Uint8Array) => I, // the protobuf decoder
+    readonly outputEncoder: (output: O) => Uint8Array // protobuf encoder
+  ) {}
+}
+
+export class GrpcService {
+  constructor(
+    readonly name: string,
+    readonly packge: string,
+    readonly impl: object,
+    readonly methods: Array<GrpcServiceMethod<unknown, unknown>>
+  ) {}
+}
+
+export class HostedGrpcServiceMethod<I, O> {
+  constructor(
+    readonly instance: unknown,
+    readonly pkg: string,
+    readonly service: string,
+    readonly method: GrpcServiceMethod<I, O>
+  ) {}
+
+  // The end of an invoke is either a response (Uint8Array) or a SuspensionMessage
+  async invoke(context: Context, inBytes: Uint8Array): Promise<Uint8Array> {
+    const instanceWithContext = setContext(this.instance, context);
+    const input = this.method.inputDecoder(inBytes);
+    const result: O = await this.method.localFn(instanceWithContext, input);
+    return this.method.outputEncoder(result);
+  }
+}
+
+function setContext<T>(instance: T, context: Context): T {
+  // creates a *new*, per call object that shares all the properties that @instance has
+  // except '$$restate' which is a unique, per call pointer to a restate context.
+  //
+  // The following line create a new object, that its prototype is @instance.
+  // and that object has a $$restate property.
+  const wrapper = Object.create(instance as object, {
+    $$restate: { value: context },
+  });
+  return wrapper as T;
+}
+
+//
+// The following definitions are equivalent to the ones
+// generated by the protoc ts plugin.
+// we use them to traverse the FileDescriptor
+//
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type ProtoMetaMessageOptions = {
+  options?: { [key: string]: any };
+  fields?: { [key: string]: { [key: string]: any } };
+  oneof?: { [key: string]: { [key: string]: any } };
+  nested?: { [key: string]: ProtoMetaMessageOptions };
+};
+
+export interface ProtoMetadata {
+  fileDescriptor: FileDescriptorProto;
+  references: { [key: string]: any };
+  dependencies?: ProtoMetadata[];
+  options?: {
+    options?: { [key: string]: any };
+    services?: {
+      [key: string]: {
+        options?: { [key: string]: any };
+        methods?: { [key: string]: { [key: string]: any } };
+      };
+    };
+    messages?: { [key: string]: ProtoMetaMessageOptions };
+    enums?: {
+      [key: string]: {
+        options?: { [key: string]: any };
+        values?: { [key: string]: { [key: string]: any } };
+      };
+    };
+  };
+}

package/src/types/protocol.ts

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+
+import {
+  SideEffectEntryMessage,
+  CombinatorEntryMessage,
+} from "../generated/proto/javascript";
+import {
+  AwakeableEntryMessage,
+  BackgroundInvokeEntryMessage,
+  ClearStateEntryMessage,
+  ClearAllStateEntryMessage,
+  CompleteAwakeableEntryMessage,
+  CompletionMessage,
+  EntryAckMessage,
+  ErrorMessage,
+  EndMessage,
+  GetStateEntryMessage,
+  GetStateKeysEntryMessage,
+  InvokeEntryMessage,
+  OutputStreamEntryMessage,
+  PollInputStreamEntryMessage,
+  SetStateEntryMessage,
+  SleepEntryMessage,
+  StartMessage,
+  SuspensionMessage,
+} from "../generated/proto/protocol";
+
+// Re-export the protobuf messages.
+export {
+  AwakeableEntryMessage,
+  BackgroundInvokeEntryMessage,
+  ClearStateEntryMessage,
+  ClearAllStateEntryMessage,
+  CompleteAwakeableEntryMessage,
+  CompletionMessage,
+  ErrorMessage,
+  EndMessage,
+  GetStateEntryMessage,
+  GetStateKeysEntryMessage,
+  InvokeEntryMessage,
+  OutputStreamEntryMessage,
+  PollInputStreamEntryMessage,
+  SetStateEntryMessage,
+  SleepEntryMessage,
+  StartMessage,
+  SuspensionMessage,
+  EntryAckMessage,
+} from "../generated/proto/protocol";
+
+// Export the protocol message types as defined by the restate protocol.
+export const START_MESSAGE_TYPE = 0x0000n;
+export const COMPLETION_MESSAGE_TYPE = 0x0001n;
+export const SUSPENSION_MESSAGE_TYPE = 0x0002n;
+export const ERROR_MESSAGE_TYPE = 0x0003n;
+export const ENTRY_ACK_MESSAGE_TYPE = 0x0004n;
+export const END_MESSAGE_TYPE = 0x0005n;
+export const POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE = 0x0400n;
+export const OUTPUT_STREAM_ENTRY_MESSAGE_TYPE = 0x0401n;
+export const GET_STATE_ENTRY_MESSAGE_TYPE = 0x0800n;
+export const SET_STATE_ENTRY_MESSAGE_TYPE = 0x0801n;
+export const CLEAR_STATE_ENTRY_MESSAGE_TYPE = 0x0802n;
+export const CLEAR_ALL_STATE_ENTRY_MESSAGE_TYPE = 0x0803n;
+export const GET_STATE_KEYS_ENTRY_MESSAGE_TYPE = 0x0804n;
+export const SLEEP_ENTRY_MESSAGE_TYPE = 0x0c00n;
+export const INVOKE_ENTRY_MESSAGE_TYPE = 0x0c01n;
+export const BACKGROUND_INVOKE_ENTRY_MESSAGE_TYPE = 0x0c02n;
+export const AWAKEABLE_ENTRY_MESSAGE_TYPE = 0x0c03n;
+export const COMPLETE_AWAKEABLE_ENTRY_MESSAGE_TYPE = 0x0c04n;
+
+export const AWAKEABLE_IDENTIFIER_PREFIX = "prom_1";
+
+// Export the custom message types
+// Side effects are custom messages because the runtime does not need to inspect them
+export const SIDE_EFFECT_ENTRY_MESSAGE_TYPE = 0xfc01n;
+export const COMBINATOR_ENTRY_MESSAGE = 0xfc02n;
+
+// Restate DuplexStream
+
+// Message types in the protocol.
+// Custom message types (per SDK) such as side effect entry message should not be included here.
+export const KNOWN_MESSAGE_TYPES = new Set([
+  START_MESSAGE_TYPE,
+  COMPLETION_MESSAGE_TYPE,
+  SUSPENSION_MESSAGE_TYPE,
+  ERROR_MESSAGE_TYPE,
+  ENTRY_ACK_MESSAGE_TYPE,
+  END_MESSAGE_TYPE,
+  POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE,
+  OUTPUT_STREAM_ENTRY_MESSAGE_TYPE,
+  GET_STATE_ENTRY_MESSAGE_TYPE,
+  GET_STATE_KEYS_ENTRY_MESSAGE_TYPE,
+  SET_STATE_ENTRY_MESSAGE_TYPE,
+  CLEAR_STATE_ENTRY_MESSAGE_TYPE,
+  CLEAR_ALL_STATE_ENTRY_MESSAGE_TYPE,
+  SLEEP_ENTRY_MESSAGE_TYPE,
+  INVOKE_ENTRY_MESSAGE_TYPE,
+  BACKGROUND_INVOKE_ENTRY_MESSAGE_TYPE,
+  AWAKEABLE_ENTRY_MESSAGE_TYPE,
+  COMPLETE_AWAKEABLE_ENTRY_MESSAGE_TYPE,
+  SIDE_EFFECT_ENTRY_MESSAGE_TYPE,
+  COMBINATOR_ENTRY_MESSAGE,
+]);
+
+const PROTOBUF_MESSAGE_NAME_BY_TYPE = new Map<bigint, string>([
+  [START_MESSAGE_TYPE, "StartMessage"],
+  [COMPLETION_MESSAGE_TYPE, "CompletionMessage"],
+  [SUSPENSION_MESSAGE_TYPE, "SuspensionMessage"],
+  [ERROR_MESSAGE_TYPE, "ErrorMessage"],
+  [ENTRY_ACK_MESSAGE_TYPE, "EntryAckMessage"],
+  [END_MESSAGE_TYPE, "EndMessage"],
+  [POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE, "PollInputStreamEntryMessage"],
+  [OUTPUT_STREAM_ENTRY_MESSAGE_TYPE, "OutputStreamEntryMessage"],
+  [GET_STATE_ENTRY_MESSAGE_TYPE, "GetStateEntryMessage"],
+  [GET_STATE_KEYS_ENTRY_MESSAGE_TYPE, "GetStateKeysEntryMessage"],
+  [SET_STATE_ENTRY_MESSAGE_TYPE, "SetStateEntryMessage"],
+  [CLEAR_STATE_ENTRY_MESSAGE_TYPE, "ClearStateEntryMessage"],
+  [CLEAR_ALL_STATE_ENTRY_MESSAGE_TYPE, "ClearAllStateEntryMessage"],
+  [SLEEP_ENTRY_MESSAGE_TYPE, "SleepEntryMessage"],
+  [INVOKE_ENTRY_MESSAGE_TYPE, "InvokeEntryMessage"],
+  [BACKGROUND_INVOKE_ENTRY_MESSAGE_TYPE, "BackgroundInvokeEntryMessage"],
+  [AWAKEABLE_ENTRY_MESSAGE_TYPE, "AwakeableEntryMessage"],
+  [COMPLETE_AWAKEABLE_ENTRY_MESSAGE_TYPE, "CompleteAwakeableEntryMessage"],
+  [SIDE_EFFECT_ENTRY_MESSAGE_TYPE, "SideEffectEntryMessage"],
+  [COMBINATOR_ENTRY_MESSAGE, "CombinatorEntryMessage"],
+]);
+
+export function formatMessageType(messageType: bigint) {
+  return (
+    PROTOBUF_MESSAGE_NAME_BY_TYPE.get(messageType) || messageType.toString()
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const PROTOBUF_MESSAGES: Array<[bigint, any]> = [
+  [START_MESSAGE_TYPE, StartMessage],
+  [COMPLETION_MESSAGE_TYPE, CompletionMessage],
+  [SUSPENSION_MESSAGE_TYPE, SuspensionMessage],
+  [ERROR_MESSAGE_TYPE, ErrorMessage],
+  [ENTRY_ACK_MESSAGE_TYPE, EntryAckMessage],
+  [END_MESSAGE_TYPE, EndMessage],
+  [POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE, PollInputStreamEntryMessage],
+  [OUTPUT_STREAM_ENTRY_MESSAGE_TYPE, OutputStreamEntryMessage],
+  [GET_STATE_ENTRY_MESSAGE_TYPE, GetStateEntryMessage],
+  [GET_STATE_KEYS_ENTRY_MESSAGE_TYPE, GetStateKeysEntryMessage],
+  [SET_STATE_ENTRY_MESSAGE_TYPE, SetStateEntryMessage],
+  [CLEAR_STATE_ENTRY_MESSAGE_TYPE, ClearStateEntryMessage],
+  [CLEAR_ALL_STATE_ENTRY_MESSAGE_TYPE, ClearAllStateEntryMessage],
+  [SLEEP_ENTRY_MESSAGE_TYPE, SleepEntryMessage],
+  [INVOKE_ENTRY_MESSAGE_TYPE, InvokeEntryMessage],
+  [BACKGROUND_INVOKE_ENTRY_MESSAGE_TYPE, BackgroundInvokeEntryMessage],
+  [AWAKEABLE_ENTRY_MESSAGE_TYPE, AwakeableEntryMessage],
+  [COMPLETE_AWAKEABLE_ENTRY_MESSAGE_TYPE, CompleteAwakeableEntryMessage],
+  [SIDE_EFFECT_ENTRY_MESSAGE_TYPE, SideEffectEntryMessage],
+  [COMBINATOR_ENTRY_MESSAGE, CombinatorEntryMessage],
+];
+
+export const PROTOBUF_MESSAGE_BY_TYPE = new Map(PROTOBUF_MESSAGES);
+
+export type ProtocolMessage =
+  | StartMessage
+  | CompletionMessage
+  | SuspensionMessage
+  | ErrorMessage
+  | EntryAckMessage
+  | EndMessage
+  | PollInputStreamEntryMessage
+  | OutputStreamEntryMessage
+  | GetStateEntryMessage
+  | GetStateKeysEntryMessage
+  | SetStateEntryMessage
+  | ClearStateEntryMessage
+  | ClearAllStateEntryMessage
+  | SleepEntryMessage
+  | InvokeEntryMessage
+  | BackgroundInvokeEntryMessage
+  | AwakeableEntryMessage
+  | CompleteAwakeableEntryMessage
+  | SideEffectEntryMessage
+  | CombinatorEntryMessage;
+
+// These message types will trigger sending a suspension message from the runtime
+// for each of the protocol modes
+export const SUSPENSION_TRIGGERS: bigint[] = [
+  INVOKE_ENTRY_MESSAGE_TYPE,
+  GET_STATE_ENTRY_MESSAGE_TYPE,
+  GET_STATE_KEYS_ENTRY_MESSAGE_TYPE,
+  AWAKEABLE_ENTRY_MESSAGE_TYPE,
+  SLEEP_ENTRY_MESSAGE_TYPE,
+  COMBINATOR_ENTRY_MESSAGE,
+  // We need it because of the ack
+  SIDE_EFFECT_ENTRY_MESSAGE_TYPE,
+];