@event-driven-io/emmett-esdb 0.43.0-beta.2 → 0.43.0-beta.21

package/dist/index.js

@@ -1,1381 +1,395 @@
-// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var EmmettError = class _EmmettError extends Error {
-  static Codes = {
-    ValidationError: 400,
-    IllegalStateError: 403,
-    NotFoundError: 404,
-    ConcurrencyError: 412,
-    InternalServerError: 500
-  };
-  errorCode;
-  constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _EmmettError.Codes.InternalServerError;
-    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
-    super(message);
-    this.errorCode = errorCode;
-    Object.setPrototypeOf(this, _EmmettError.prototype);
-  }
-  static mapFrom(error) {
-    if (_EmmettError.isInstanceOf(error)) {
-      return error;
-    }
-    return new _EmmettError({
-      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : _EmmettError.Codes.InternalServerError,
-      message: error.message ?? "An unknown error occurred"
-    });
-  }
-  static isInstanceOf(error, errorCode) {
-    return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
-  }
-};
-var ConcurrencyError = class _ConcurrencyError extends EmmettError {
-  constructor(current, expected, message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: message ?? `Expected version ${expected.toString()} does not match current ${current?.toString()}`
-    });
-    this.current = current;
-    this.expected = expected;
-    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
-  }
-};
-var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError extends EmmettError {
-  constructor(message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: message ?? `Expected document state does not match current one!`
-    });
-    Object.setPrototypeOf(this, _ConcurrencyInMemoryDatabaseError.prototype);
-  }
-};
-
-// ../emmett/dist/index.js
-import { v4 as uuid4 } from "uuid";
-import { v7 as uuid } from "uuid";
-import retry from "async-retry";
-import { v7 as uuid2 } from "uuid";
-import { v4 as uuid3 } from "uuid";
-import { v7 as uuid5 } from "uuid";
-var emmettPrefix = "emt";
-var defaultTag = `${emmettPrefix}:default`;
-var unknownTag = `${emmettPrefix}:unknown`;
-var STREAM_EXISTS = "STREAM_EXISTS";
-var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
-var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
-var matchesExpectedVersion = (current, expected, defaultVersion) => {
-  if (expected === NO_CONCURRENCY_CHECK) return true;
-  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
-  if (expected == STREAM_EXISTS) return current !== defaultVersion;
-  return current === expected;
-};
-var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
-  expected ??= NO_CONCURRENCY_CHECK;
-  if (!matchesExpectedVersion(current, expected, defaultVersion))
-    throw new ExpectedVersionConflictError(current, expected);
-};
-var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
-  constructor(current, expected) {
-    super(current?.toString(), expected?.toString());
-    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
-  }
-};
-var isPrimitive = (value) => {
-  const type = typeof value;
-  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
-};
-var compareArrays = (left, right) => {
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let i = 0; i < left.length; i++) {
-    const leftHas = i in left;
-    const rightHas = i in right;
-    if (leftHas !== rightHas) return false;
-    if (leftHas && !deepEquals(left[i], right[i])) return false;
-  }
-  return true;
-};
-var compareDates = (left, right) => {
-  return left.getTime() === right.getTime();
-};
-var compareRegExps = (left, right) => {
-  return left.toString() === right.toString();
-};
-var compareErrors = (left, right) => {
-  if (left.message !== right.message || left.name !== right.name) {
-    return false;
-  }
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) return false;
-  const rightKeySet = new Set(rightKeys);
-  for (const key of leftKeys) {
-    if (!rightKeySet.has(key)) return false;
-    if (!deepEquals(left[key], right[key])) return false;
-  }
-  return true;
-};
-var compareMaps = (left, right) => {
-  if (left.size !== right.size) return false;
-  for (const [key, value] of left) {
-    if (isPrimitive(key)) {
-      if (!right.has(key) || !deepEquals(value, right.get(key))) {
-        return false;
-      }
-    } else {
-      let found = false;
-      for (const [rightKey, rightValue] of right) {
-        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) return false;
-    }
-  }
-  return true;
-};
-var compareSets = (left, right) => {
-  if (left.size !== right.size) return false;
-  for (const leftItem of left) {
-    if (isPrimitive(leftItem)) {
-      if (!right.has(leftItem)) return false;
-    } else {
-      let found = false;
-      for (const rightItem of right) {
-        if (deepEquals(leftItem, rightItem)) {
-          found = true;
-          break;
-        }
-      }
-      if (!found) return false;
-    }
-  }
-  return true;
-};
-var compareArrayBuffers = (left, right) => {
-  if (left.byteLength !== right.byteLength) return false;
-  const leftView = new Uint8Array(left);
-  const rightView = new Uint8Array(right);
-  for (let i = 0; i < leftView.length; i++) {
-    if (leftView[i] !== rightView[i]) return false;
-  }
-  return true;
-};
-var compareTypedArrays = (left, right) => {
-  if (left.constructor !== right.constructor) return false;
-  if (left.byteLength !== right.byteLength) return false;
-  const leftArray = new Uint8Array(
-    left.buffer,
-    left.byteOffset,
-    left.byteLength
-  );
-  const rightArray = new Uint8Array(
-    right.buffer,
-    right.byteOffset,
-    right.byteLength
-  );
-  for (let i = 0; i < leftArray.length; i++) {
-    if (leftArray[i] !== rightArray[i]) return false;
-  }
-  return true;
-};
-var compareObjects = (left, right) => {
-  const keys1 = Object.keys(left);
-  const keys2 = Object.keys(right);
-  if (keys1.length !== keys2.length) {
-    return false;
-  }
-  for (const key of keys1) {
-    if (left[key] instanceof Function && right[key] instanceof Function) {
-      continue;
-    }
-    const isEqual = deepEquals(left[key], right[key]);
-    if (!isEqual) {
-      return false;
-    }
-  }
-  return true;
-};
-var getType = (value) => {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const primitiveType = typeof value;
-  if (primitiveType !== "object") return primitiveType;
-  if (Array.isArray(value)) return "array";
-  if (value instanceof Boolean) return "boxed-boolean";
-  if (value instanceof Number) return "boxed-number";
-  if (value instanceof String) return "boxed-string";
-  if (value instanceof Date) return "date";
-  if (value instanceof RegExp) return "regexp";
-  if (value instanceof Error) return "error";
-  if (value instanceof Map) return "map";
-  if (value instanceof Set) return "set";
-  if (value instanceof ArrayBuffer) return "arraybuffer";
-  if (value instanceof DataView) return "dataview";
-  if (value instanceof WeakMap) return "weakmap";
-  if (value instanceof WeakSet) return "weakset";
-  if (ArrayBuffer.isView(value)) return "typedarray";
-  return "object";
-};
-var deepEquals = (left, right) => {
-  if (left === right) return true;
-  if (isEquatable(left)) {
-    return left.equals(right);
-  }
-  const leftType = getType(left);
-  const rightType = getType(right);
-  if (leftType !== rightType) return false;
-  switch (leftType) {
-    case "null":
-    case "undefined":
-    case "boolean":
-    case "number":
-    case "bigint":
-    case "string":
-    case "symbol":
-    case "function":
-      return left === right;
-    case "array":
-      return compareArrays(left, right);
-    case "date":
-      return compareDates(left, right);
-    case "regexp":
-      return compareRegExps(left, right);
-    case "error":
-      return compareErrors(left, right);
-    case "map":
-      return compareMaps(
-        left,
-        right
-      );
-    case "set":
-      return compareSets(left, right);
-    case "arraybuffer":
-      return compareArrayBuffers(left, right);
-    case "dataview":
-    case "weakmap":
-    case "weakset":
-      return false;
-    case "typedarray":
-      return compareTypedArrays(
-        left,
-        right
-      );
-    case "boxed-boolean":
-      return left.valueOf() === right.valueOf();
-    case "boxed-number":
-      return left.valueOf() === right.valueOf();
-    case "boxed-string":
-      return left.valueOf() === right.valueOf();
-    case "object":
-      return compareObjects(
-        left,
-        right
-      );
-    default:
-      return false;
-  }
-};
-var isEquatable = (left) => {
-  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
-};
-var toNormalizedString = (value) => value.toString().padStart(19, "0");
-var bigInt = {
-  toNormalizedString
-};
-var ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
-  }
-};
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      options?.map ? options.map(value) : value,
-      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (_, v) => typeof v === "bigint" ? v.toString() : v
-    );
-  },
-  parse: (text, options) => {
-    const parsed = JSON.parse(text, options?.reviver);
-    if (options?.typeCheck && !options?.typeCheck(parsed))
-      throw new ParseError(text);
-    return options?.map ? options.map(parsed) : parsed;
-  }
-};
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return retry(
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (opts?.shouldRetryResult && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONParser.stringify(result)}`
-          );
-        }
-        return result;
-      } catch (error) {
-        if (opts?.shouldRetryError && !opts.shouldRetryError(error)) {
-          bail(error);
-          return void 0;
-        }
-        throw error;
-      }
-    },
-    opts ?? { retries: 0 }
-  );
-};
-var onShutdown = (handler) => {
-  const signals = ["SIGTERM", "SIGINT"];
-  if (typeof process !== "undefined" && typeof process.on === "function") {
-    for (const signal of signals) {
-      process.on(signal, handler);
-    }
-    return () => {
-      for (const signal of signals) {
-        process.off(signal, handler);
-      }
-    };
-  }
-  const deno = globalThis.Deno;
-  if (deno && typeof deno.addSignalListener === "function") {
-    for (const signal of signals) {
-      deno.addSignalListener(signal, handler);
-    }
-    return () => {
-      for (const signal of signals) {
-        deno.removeSignalListener(signal, handler);
-      }
-    };
-  }
-  return () => {
-  };
-};
-var textEncoder = new TextEncoder();
-var isGeneralExpectedDocumentVersion = (version) => {
-  return version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
-};
-var expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
-var operationResult = (result, options) => {
-  const operationResult2 = {
-    ...result,
-    acknowledged: true,
-    successful: result.successful,
-    assertSuccessful: (errorMessage) => {
-      const { successful } = result;
-      const { operationName, collectionName } = options;
-      if (!successful)
-        throw new ConcurrencyInMemoryDatabaseError(
-          errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONParser.stringify(result)}!`
-        );
-    }
-  };
-  if (options.errors?.throwOnOperationFailures)
-    operationResult2.assertSuccessful();
-  return operationResult2;
-};
-var getInMemoryDatabase = () => {
-  const storage = /* @__PURE__ */ new Map();
-  return {
-    collection: (collectionName, collectionOptions = {}) => {
-      const ensureCollectionCreated = () => {
-        if (!storage.has(collectionName)) storage.set(collectionName, []);
-      };
-      const errors = collectionOptions.errors;
-      const collection = {
-        collectionName,
-        insertOne: async (document) => {
-          ensureCollectionCreated();
-          const _id = document._id ?? uuid();
-          const _version = document._version ?? 1n;
-          const existing = await collection.findOne((c) => c._id === _id);
-          if (existing) {
-            return operationResult(
-              {
-                successful: false,
-                insertedId: null,
-                nextExpectedVersion: _version
-              },
-              { operationName: "insertOne", collectionName, errors }
-            );
-          }
-          const documentsInCollection = storage.get(collectionName);
-          const newDocument = { ...document, _id, _version };
-          const newCollection = [...documentsInCollection, newDocument];
-          storage.set(collectionName, newCollection);
-          return operationResult(
-            {
-              successful: true,
-              insertedId: _id,
-              nextExpectedVersion: _version
-            },
-            { operationName: "insertOne", collectionName, errors }
-          );
-        },
-        findOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          const firstOne = filteredDocuments?.[0] ?? null;
-          return Promise.resolve(firstOne);
-        },
-        find: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          return Promise.resolve(filteredDocuments);
-        },
-        deleteOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          if (predicate) {
-            const foundIndex = documentsInCollection.findIndex(
-              (doc) => predicate(doc)
-            );
-            if (foundIndex === -1) {
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: false,
-                    matchedCount: 0,
-                    deletedCount: 0
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            } else {
-              const newCollection2 = documentsInCollection.toSpliced(
-                foundIndex,
-                1
-              );
-              storage.set(collectionName, newCollection2);
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: true,
-                    matchedCount: 1,
-                    deletedCount: 1
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            }
-          }
-          const newCollection = documentsInCollection.slice(1);
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                matchedCount: 1,
-                deletedCount: 1
-              },
-              { operationName: "deleteOne", collectionName, errors }
-            )
-          );
-        },
-        replaceOne: (predicate, document, options) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const firstIndex = documentsInCollection.findIndex(
-            (doc) => predicate(doc)
-          );
-          if (firstIndex === void 0 || firstIndex === -1) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 0,
-                  modifiedCount: 0,
-                  nextExpectedVersion: 0n
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const existing = documentsInCollection[firstIndex];
-          if (typeof options?.expectedVersion === "bigint" && existing._version !== options.expectedVersion) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 1,
-                  modifiedCount: 0,
-                  nextExpectedVersion: existing._version
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const newVersion = existing._version + 1n;
-          const newCollection = documentsInCollection.with(firstIndex, {
-            _id: existing._id,
-            ...document,
-            _version: newVersion
-          });
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                modifiedCount: 1,
-                matchedCount: firstIndex,
-                nextExpectedVersion: newVersion
-              },
-              { operationName: "replaceOne", collectionName, errors }
-            )
-          );
-        },
-        handle: async (id, handle, options) => {
-          const { expectedVersion: version, ...operationOptions } = options ?? {};
-          ensureCollectionCreated();
-          const existing = await collection.findOne(({ _id }) => _id === id);
-          const expectedVersion = expectedVersionValue(version);
-          if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion !== null && existing._version !== expectedVersion) {
-            return operationResult(
-              {
-                successful: false,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          }
-          const result = handle(existing !== null ? { ...existing } : null);
-          if (deepEquals(existing, result))
-            return operationResult(
-              {
-                successful: true,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          if (!existing && result) {
-            const newDoc = { ...result, _id: id };
-            const insertResult = await collection.insertOne({
-              ...newDoc,
-              _id: id
-            });
-            return {
-              ...insertResult,
-              document: {
-                ...newDoc,
-                _version: insertResult.nextExpectedVersion
-              }
-            };
-          }
-          if (existing && !result) {
-            const deleteResult = await collection.deleteOne(
-              ({ _id }) => id === _id
-            );
-            return { ...deleteResult, document: null };
-          }
-          if (existing && result) {
-            const replaceResult = await collection.replaceOne(
-              ({ _id }) => id === _id,
-              result,
-              {
-                ...operationOptions,
-                expectedVersion: expectedVersion ?? "DOCUMENT_EXISTS"
-              }
-            );
-            return {
-              ...replaceResult,
-              document: {
-                ...result,
-                _version: replaceResult.nextExpectedVersion
-              }
-            };
-          }
-          return operationResult(
-            {
-              successful: true,
-              document: existing
-            },
-            { operationName: "handle", collectionName, errors }
-          );
-        }
-      };
-      return collection;
-    }
-  };
-};
-var getCheckpoint = (message2) => {
-  return message2.metadata.checkpoint;
-};
-var wasMessageHandled = (message2, checkpoint) => {
-  const messageCheckpoint = getCheckpoint(message2);
-  return messageCheckpoint !== null && messageCheckpoint !== void 0 && checkpoint !== null && checkpoint !== void 0 && messageCheckpoint <= checkpoint;
-};
-var MessageProcessorType = {
-  PROJECTOR: "projector",
-  REACTOR: "reactor"
-};
-var defaultProcessingMessageProcessingScope = (handler, partialContext) => handler(partialContext);
-var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
-var parseBigIntProcessorCheckpoint = (value) => BigInt(value);
-var defaultProcessorVersion = 1;
-var defaultProcessorPartition = defaultTag;
-var getProcessorInstanceId = (processorId) => `${processorId}:${uuid2()}`;
-var getProjectorId = (options) => `emt:processor:projector:${options.projectionName}`;
-var reactor = (options) => {
-  const {
-    checkpoints,
-    processorId,
-    processorInstanceId: instanceId = getProcessorInstanceId(processorId),
-    type = MessageProcessorType.REACTOR,
-    version = defaultProcessorVersion,
-    partition = defaultProcessorPartition,
-    hooks = {},
-    processingScope = defaultProcessingMessageProcessingScope,
-    startFrom,
-    canHandle,
-    stopAfter
-  } = options;
-  const eachMessage = "eachMessage" in options && options.eachMessage ? options.eachMessage : () => Promise.resolve();
-  let isInitiated = false;
-  let isActive = false;
-  let lastCheckpoint = null;
-  let closeSignal = null;
-  const init = async (initOptions) => {
-    if (isInitiated) return;
-    if (hooks.onInit === void 0) {
-      isInitiated = true;
-      return;
-    }
-    return await processingScope(async (context) => {
-      await hooks.onInit(context);
-      isInitiated = true;
-    }, initOptions);
-  };
-  const close = async (closeOptions) => {
-    isActive = false;
-    if (closeSignal) {
-      closeSignal();
-      closeSignal = null;
-    }
-    if (hooks.onClose) {
-      await processingScope(hooks.onClose, closeOptions);
-    }
-  };
-  return {
-    // TODO: Consider whether not make it optional or add URN prefix
-    id: processorId,
-    instanceId,
-    type,
-    canHandle,
-    init,
-    start: async (startOptions) => {
-      if (isActive) return;
-      await init(startOptions);
-      isActive = true;
-      closeSignal = onShutdown(() => close({}));
-      if (lastCheckpoint !== null)
-        return {
-          lastCheckpoint
-        };
-      return await processingScope(async (context) => {
-        if (hooks.onStart) {
-          await hooks.onStart(context);
-        }
-        if (startFrom && startFrom !== "CURRENT") return startFrom;
-        if (checkpoints) {
-          const readResult = await checkpoints?.read(
-            {
-              processorId,
-              partition
-            },
-            { ...startOptions, ...context }
-          );
-          lastCheckpoint = readResult.lastCheckpoint;
-        }
-        if (lastCheckpoint === null) return "BEGINNING";
-        return {
-          lastCheckpoint
-        };
-      }, startOptions);
-    },
-    close,
-    get isActive() {
-      return isActive;
-    },
-    handle: async (messages, partialContext) => {
-      if (!isActive) return Promise.resolve();
-      return await processingScope(async (context) => {
-        let result = void 0;
-        for (const message2 of messages) {
-          if (wasMessageHandled(message2, lastCheckpoint)) continue;
-          const upcasted = upcastRecordedMessage(
-            // TODO: Make it smarter
-            message2,
-            options.messageOptions?.schema?.versioning
-          );
-          if (canHandle !== void 0 && !canHandle.includes(upcasted.type))
-            continue;
-          const messageProcessingResult = await eachMessage(upcasted, context);
-          if (checkpoints) {
-            const storeCheckpointResult = await checkpoints.store(
-              {
-                processorId,
-                version,
-                message: upcasted,
-                lastCheckpoint,
-                partition
-              },
-              context
-            );
-            if (storeCheckpointResult.success) {
-              lastCheckpoint = storeCheckpointResult.newCheckpoint;
-            }
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-            isActive = false;
-            result = messageProcessingResult;
-            break;
-          }
-          if (stopAfter && stopAfter(upcasted)) {
-            isActive = false;
-            result = { type: "STOP", reason: "Stop condition reached" };
-            break;
-          }
-          if (messageProcessingResult && messageProcessingResult.type === "SKIP")
-            continue;
-        }
-        return result;
-      }, partialContext);
-    }
-  };
-};
-var projector = (options) => {
-  const {
-    projection: projection2,
-    processorId = getProjectorId({
-      projectionName: projection2.name ?? "unknown"
-    }),
-    ...rest
-  } = options;
-  return reactor({
-    ...rest,
-    type: MessageProcessorType.PROJECTOR,
-    canHandle: projection2.canHandle,
-    processorId,
-    messageOptions: options.projection.eventsOptions,
-    hooks: {
-      onInit: options.hooks?.onInit,
-      onStart: options.truncateOnStart && options.projection.truncate || options.hooks?.onStart ? async (context) => {
-        if (options.truncateOnStart && options.projection.truncate)
-          await options.projection.truncate(context);
-        if (options.hooks?.onStart) await options.hooks?.onStart(context);
-      } : void 0,
-      onClose: options.hooks?.onClose
-    },
-    eachMessage: async (event2, context) => projection2.handle([event2], context)
-  });
-};
-var inMemoryCheckpointer = () => {
-  return {
-    read: async ({ processorId }, { database }) => {
-      const checkpoint = await database.collection("emt_processor_checkpoints").findOne((d) => d._id === processorId);
-      return Promise.resolve({
-        lastCheckpoint: checkpoint?.lastCheckpoint ?? null
-      });
-    },
-    store: async (context, { database }) => {
-      const { message: message2, processorId, lastCheckpoint } = context;
-      const checkpoints = database.collection(
-        "emt_processor_checkpoints"
-      );
-      const checkpoint = await checkpoints.findOne(
-        (d) => d._id === processorId
-      );
-      const currentPosition = checkpoint?.lastCheckpoint ?? null;
-      const newCheckpoint = getCheckpoint(message2);
-      if (currentPosition && (currentPosition === newCheckpoint || currentPosition !== lastCheckpoint)) {
-        return {
-          success: false,
-          reason: currentPosition === newCheckpoint ? "IGNORED" : newCheckpoint !== null && currentPosition > newCheckpoint ? "CURRENT_AHEAD" : "MISMATCH"
-        };
-      }
-      await checkpoints.handle(processorId, (existing) => ({
-        ...existing ?? {},
-        _id: processorId,
-        lastCheckpoint: newCheckpoint
-      }));
-      return { success: true, newCheckpoint };
-    }
-  };
-};
-var inMemoryProcessingScope = (options) => {
-  const processorDatabase = options.database;
-  const processingScope = (handler, partialContext) => {
-    const database = processorDatabase ?? partialContext?.database;
-    if (!database)
-      throw new EmmettError(
-        `InMemory processor '${options.processorId}' is missing database. Ensure that you passed it through options`
-      );
-    return handler({ ...partialContext, database });
-  };
-  return processingScope;
-};
-var inMemoryProjector = (options) => {
-  const database = options.connectionOptions?.database ?? getInMemoryDatabase();
-  const hooks = {
-    onInit: options.hooks?.onInit,
-    onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose ? async (context) => {
-      if (options.hooks?.onClose) await options.hooks?.onClose(context);
-    } : void 0
-  };
-  const processor = projector({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: options.processorId ?? `projection:${options.projection.name}`
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
-};
-var inMemoryReactor = (options) => {
-  const database = options.connectionOptions?.database ?? getInMemoryDatabase();
-  const hooks = {
-    onInit: options.hooks?.onInit,
-    onStart: options.hooks?.onStart,
-    onClose: options.hooks?.onClose
-  };
-  const processor = reactor({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: options.processorId
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.downcast)
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.downcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.upcast)
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-
-// src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
-import {
-  EventStoreDBClient
-} from "@eventstore/db-client";
-import { v7 as uuid6 } from "uuid";
+import { EmmettError, ExpectedVersionConflictError, JSONSerializer, NO_CONCURRENCY_CHECK, STREAM_DOES_NOT_EXIST, STREAM_EXISTS, assertExpectedVersionMatchesCurrent, asyncAwaiter, asyncRetry, bigIntProcessorCheckpoint, downcastRecordedMessages, getCheckpoint, inMemoryProjector, inMemoryReactor, isString, parseBigIntProcessorCheckpoint, upcastRecordedMessage } from "@event-driven-io/emmett";
+import { ANY, END, EventStoreDBClient, NO_STREAM, START, STREAM_EXISTS as STREAM_EXISTS$1, StreamNotFoundError, WrongExpectedVersionError, excludeSystemEvents, jsonEvent } from "@eventstore/db-client";
+import { v7 } from "uuid";
+import { Transform, Writable, pipeline } from "stream";
 
-// src/eventStore/consumers/subscriptions/index.ts
-import {
-  END,
-  excludeSystemEvents,
-  START
-} from "@eventstore/db-client";
-import { pipeline, Transform, Writable } from "stream";
-
-// src/eventStore/eventstoreDBEventStore.ts
-import {
-  ANY,
-  STREAM_EXISTS as ESDB_STREAM_EXISTS,
-  NO_STREAM,
-  StreamNotFoundError,
-  WrongExpectedVersionError,
-  jsonEvent
-} from "@eventstore/db-client";
-var toEventStoreDBReadOptions = (options) => {
-  return options ? {
-    fromRevision: "from" in options ? options.from : void 0,
-    maxCount: "maxCount" in options ? options.maxCount : "to" in options ? options.to : void 0
-  } : void 0;
-};
-var EventStoreDBEventStoreDefaultStreamVersion = -1n;
-var getEventStoreDBEventStore = (eventStore) => {
-  return {
-    async aggregateStream(streamName, options) {
-      const { evolve, initialState, read } = options;
-      const expectedStreamVersion = read?.expectedStreamVersion;
-      let state = initialState();
-      let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
-      let lastEventGlobalPosition = void 0;
-      try {
-        for await (const resolvedEvent of eventStore.readStream(
-          streamName,
-          toEventStoreDBReadOptions(options.read)
-        )) {
-          const { event } = resolvedEvent;
-          if (!event) continue;
-          state = evolve(
-            state,
-            upcastRecordedMessage(
-              mapFromESDBEvent(resolvedEvent),
-              options?.read?.schema?.versioning
-            )
-          );
-          currentStreamVersion = event.revision;
-          lastEventGlobalPosition = event.position?.commit;
-        }
-        assertExpectedVersionMatchesCurrent(
-          currentStreamVersion,
-          expectedStreamVersion,
-          EventStoreDBEventStoreDefaultStreamVersion
-        );
-        return lastEventGlobalPosition ? {
-          currentStreamVersion,
-          lastEventGlobalPosition,
-          state,
-          streamExists: true
-        } : {
-          currentStreamVersion,
-          state,
-          streamExists: false
-        };
-      } catch (error) {
-        if (error instanceof StreamNotFoundError) {
-          return {
-            currentStreamVersion,
-            state,
-            streamExists: false
-          };
-        }
-        throw error;
-      }
-    },
-    readStream: async (streamName, options) => {
-      const events = [];
-      let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
-      try {
-        for await (const resolvedEvent of eventStore.readStream(
-          streamName,
-          toEventStoreDBReadOptions(options)
-        )) {
-          const { event } = resolvedEvent;
-          if (!event) continue;
-          events.push(
-            upcastRecordedMessage(
-              mapFromESDBEvent(resolvedEvent),
-              options?.schema?.versioning
-            )
-          );
-          currentStreamVersion = event.revision;
-        }
-        return {
-          currentStreamVersion,
-          events,
-          streamExists: true
-        };
-      } catch (error) {
-        if (error instanceof StreamNotFoundError) {
-          return {
-            currentStreamVersion,
-            events: [],
-            streamExists: false
-          };
-        }
-        throw error;
-      }
-    },
-    appendToStream: async (streamName, events, options) => {
-      try {
-        const eventsToStore = downcastRecordedMessages(
-          events,
-          options?.schema?.versioning
-        );
-        const serializedEvents = eventsToStore.map(jsonEvent);
-        const expectedRevision = toExpectedRevision(
-          options?.expectedStreamVersion
-        );
-        const appendResult = await eventStore.appendToStream(
-          streamName,
-          serializedEvents,
-          {
-            expectedRevision
-          }
-        );
-        return {
-          nextExpectedStreamVersion: appendResult.nextExpectedRevision,
-          lastEventGlobalPosition: appendResult.position.commit,
-          createdNewStream: appendResult.nextExpectedRevision >= BigInt(serializedEvents.length)
-        };
-      } catch (error) {
-        if (error instanceof WrongExpectedVersionError) {
-          throw new ExpectedVersionConflictError(
-            BigInt(error.actualVersion),
-            toExpectedVersion(error.expectedVersion)
-          );
-        }
-        throw error;
-      }
-    },
-    consumer: (options) => eventStoreDBEventStoreConsumer({
-      ...options ?? {},
-      client: eventStore
-    }),
-    streamExists: async (streamName) => {
-      try {
-        for await (const resolvedEvent of eventStore.readStream(streamName)) {
-          const { event } = resolvedEvent;
-          if (!event) continue;
-          return true;
-        }
-        return false;
-      } catch (error) {
-        if (error instanceof StreamNotFoundError) {
-          return false;
-        }
-        throw error;
-      }
-    }
-    //streamEvents: streamEvents(eventStore),
-  };
-};
-var getESDBCheckpoint = (resolvedEvent, from) => {
-  return !from || from?.stream === $all ? resolvedEvent.link?.position?.commit ?? resolvedEvent.event?.position?.commit : resolvedEvent.link?.revision ?? resolvedEvent.event.revision;
-};
-var mapFromESDBEvent = (resolvedEvent, from) => {
-  const event = resolvedEvent.event;
-  return {
-    type: event.type,
-    data: event.data,
-    metadata: {
-      ...event.metadata ?? {},
-      eventId: event.id,
-      streamName: event.streamId,
-      streamPosition: event.revision,
-      globalPosition: event.position.commit,
-      checkpoint: bigIntProcessorCheckpoint(
-        getESDBCheckpoint(resolvedEvent, from)
-      )
-    }
-  };
-};
-var toExpectedRevision = (expected) => {
-  if (expected === void 0) return ANY;
-  if (expected === NO_CONCURRENCY_CHECK) return ANY;
-  if (expected == STREAM_DOES_NOT_EXIST) return NO_STREAM;
-  if (expected == STREAM_EXISTS) return ESDB_STREAM_EXISTS;
-  return expected;
-};
-var toExpectedVersion = (expected) => {
-  if (expected === void 0) return NO_CONCURRENCY_CHECK;
-  if (expected === ANY) return NO_CONCURRENCY_CHECK;
-  if (expected == NO_STREAM) return STREAM_DOES_NOT_EXIST;
-  if (expected == ESDB_STREAM_EXISTS) return STREAM_EXISTS;
-  return expected;
+//#region src/eventStore/eventstoreDBEventStore.ts
+const toEventStoreDBReadOptions = (options) => {
+	return options ? {
+		fromRevision: "from" in options ? options.from : void 0,
+		maxCount: "maxCount" in options ? options.maxCount : "to" in options ? options.to : void 0
+	} : void 0;
+};
+const EventStoreDBEventStoreDefaultStreamVersion = -1n;
+const getEventStoreDBEventStore = (eventStore) => {
+	return {
+		async aggregateStream(streamName, options) {
+			const { evolve, initialState, read } = options;
+			const expectedStreamVersion = read?.expectedStreamVersion;
+			let state = initialState();
+			let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
+			let lastCheckpoint = void 0;
+			try {
+				for await (const resolvedEvent of eventStore.readStream(streamName, toEventStoreDBReadOptions(options.read))) {
+					const { event } = resolvedEvent;
+					if (!event) continue;
+					state = evolve(state, upcastRecordedMessage(mapFromESDBEvent(resolvedEvent), options?.read?.schema?.versioning));
+					currentStreamVersion = event.revision;
+					lastCheckpoint = event.position?.commit;
+				}
+				assertExpectedVersionMatchesCurrent(currentStreamVersion, expectedStreamVersion, EventStoreDBEventStoreDefaultStreamVersion);
+				return lastCheckpoint ? {
+					currentStreamVersion,
+					lastEventGlobalPosition: bigIntProcessorCheckpoint(lastCheckpoint),
+					state,
+					streamExists: true
+				} : {
+					currentStreamVersion,
+					state,
+					streamExists: false
+				};
+			} catch (error) {
+				if (error instanceof StreamNotFoundError) return {
+					currentStreamVersion,
+					state,
+					streamExists: false
+				};
+				throw error;
+			}
+		},
+		readStream: async (streamName, options) => {
+			const events = [];
+			let currentStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
+			try {
+				for await (const resolvedEvent of eventStore.readStream(streamName, toEventStoreDBReadOptions(options))) {
+					const { event } = resolvedEvent;
+					if (!event) continue;
+					events.push(upcastRecordedMessage(mapFromESDBEvent(resolvedEvent), options?.schema?.versioning));
+					currentStreamVersion = event.revision;
+				}
+				return {
+					currentStreamVersion,
+					events,
+					streamExists: true
+				};
+			} catch (error) {
+				if (error instanceof StreamNotFoundError) return {
+					currentStreamVersion,
+					events: [],
+					streamExists: false
+				};
+				throw error;
+			}
+		},
+		appendToStream: async (streamName, events, options) => {
+			try {
+				const serializedEvents = downcastRecordedMessages(events, options?.schema?.versioning).map(jsonEvent);
+				const expectedRevision = toExpectedRevision(options?.expectedStreamVersion);
+				const appendResult = await eventStore.appendToStream(streamName, serializedEvents, { expectedRevision });
+				return {
+					nextExpectedStreamVersion: appendResult.nextExpectedRevision,
+					lastEventGlobalPosition: bigIntProcessorCheckpoint(appendResult.position.commit),
+					createdNewStream: appendResult.nextExpectedRevision >= BigInt(serializedEvents.length)
+				};
+			} catch (error) {
+				if (error instanceof WrongExpectedVersionError) throw new ExpectedVersionConflictError(BigInt(error.actualVersion), toExpectedVersion(error.expectedVersion));
+				throw error;
+			}
+		},
+		consumer: (options) => eventStoreDBEventStoreConsumer({
+			...options ?? {},
+			client: eventStore
+		}),
+		streamExists: async (streamName) => {
+			try {
+				for await (const resolvedEvent of eventStore.readStream(streamName)) {
+					const { event } = resolvedEvent;
+					if (!event) continue;
+					return true;
+				}
+				return false;
+			} catch (error) {
+				if (error instanceof StreamNotFoundError) return false;
+				throw error;
+			}
+		}
+	};
+};
+const getESDBCheckpoint = (resolvedEvent, from) => {
+	return !from || from?.stream === "$all" ? resolvedEvent.link?.position?.commit ?? resolvedEvent.event?.position?.commit : resolvedEvent.link?.revision ?? resolvedEvent.event.revision;
+};
+const mapFromESDBEvent = (resolvedEvent, from) => {
+	const event = resolvedEvent.event;
+	return {
+		type: event.type,
+		data: event.data,
+		metadata: {
+			...event.metadata ?? {},
+			eventId: event.id,
+			streamName: event.streamId,
+			streamPosition: event.revision,
+			globalPosition: bigIntProcessorCheckpoint(event.position.commit),
+			checkpoint: bigIntProcessorCheckpoint(getESDBCheckpoint(resolvedEvent, from))
+		}
+	};
+};
+const toExpectedRevision = (expected) => {
+	if (expected === void 0) return ANY;
+	if (expected === NO_CONCURRENCY_CHECK) return ANY;
+	if (expected == STREAM_DOES_NOT_EXIST) return NO_STREAM;
+	if (expected == STREAM_EXISTS) return STREAM_EXISTS$1;
+	return expected;
+};
+const toExpectedVersion = (expected) => {
+	if (expected === void 0) return NO_CONCURRENCY_CHECK;
+	if (expected === ANY) return NO_CONCURRENCY_CHECK;
+	if (expected == NO_STREAM) return STREAM_DOES_NOT_EXIST;
+	if (expected == STREAM_EXISTS$1) return STREAM_EXISTS;
+	return expected;
 };
 
-// src/eventStore/consumers/subscriptions/index.ts
-var DefaultEventStoreDBEventStoreProcessorBatchSize = 100;
-var DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = 50;
-var toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? START : startFrom === "END" ? END : {
-  prepare: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint),
-  commit: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint)
-};
-var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? START : startFrom === "END" ? END : parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint);
-var subscribe = (client, from, options) => from == void 0 || from.stream == $all ? client.subscribeToAll({
-  ...from?.options ?? {},
-  fromPosition: toGlobalPosition(options.startFrom),
-  filter: excludeSystemEvents()
+//#endregion
+//#region src/eventStore/consumers/subscriptions/index.ts
+const DefaultEventStoreDBEventStoreProcessorBatchSize = 100;
+const DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = 50;
+const toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? START : startFrom === "END" ? END : {
+	prepare: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint),
+	commit: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint)
+};
+const toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? START : startFrom === "END" ? END : parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint);
+const subscribe = (client, from, options) => from == void 0 || from.stream == "$all" ? client.subscribeToAll({
+	...from?.options ?? {},
+	fromPosition: toGlobalPosition(options.startFrom),
+	filter: excludeSystemEvents()
 }) : client.subscribeToStream(from.stream, {
-  ...from.options ?? {},
-  fromRevision: toStreamPosition(options.startFrom)
+	...from.options ?? {},
+	fromRevision: toStreamPosition(options.startFrom)
 });
-var isDatabaseUnavailableError = (error) => error instanceof Error && "type" in error && error.type === "unavailable" && "code" in error && error.code === 14;
-var EventStoreDBResubscribeDefaultOptions = {
-  forever: true,
-  minTimeout: 100,
-  factor: 1.5,
-  shouldRetryError: (error) => !isDatabaseUnavailableError(error)
+const isDatabaseUnavailableError = (error) => error instanceof Error && "type" in error && error.type === "unavailable" && "code" in error && error.code === 14;
+const EventStoreDBResubscribeDefaultOptions = {
+	forever: true,
+	minTimeout: 100,
+	factor: 1.5,
+	shouldRetryError: (error) => !isDatabaseUnavailableError(error)
 };
 var SubscriptionSequentialHandler = class extends Transform {
-  options;
-  from;
-  isRunning;
-  constructor(options) {
-    super({ objectMode: true, ...options });
-    this.options = options;
-    this.from = options.from;
-    this.isRunning = true;
-  }
-  async _transform(resolvedEvent, _encoding, callback) {
-    try {
-      if (!this.isRunning || !resolvedEvent.event) {
-        callback();
-        return;
-      }
-      const message = mapFromESDBEvent(resolvedEvent, this.from);
-      const messageCheckpoint = getCheckpoint(message);
-      const result = await this.options.eachBatch([message]);
-      if (result && result.type === "STOP") {
-        this.isRunning = false;
-        if (!result.error) this.push(messageCheckpoint);
-        this.push(result);
-        this.push(null);
-        callback();
-        return;
-      }
-      this.push(messageCheckpoint);
-      callback();
-    } catch (error) {
-      callback(error);
-    }
-  }
-};
-var eventStoreDBSubscription = ({
-  client,
-  from,
-  batchSize,
-  eachBatch,
-  resilience
-}) => {
-  let isRunning = false;
-  let start;
-  let processor;
-  let subscription;
-  const resubscribeOptions = resilience?.resubscribeOptions ?? {
-    ...EventStoreDBResubscribeDefaultOptions,
-    shouldRetryResult: () => isRunning,
-    shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
-  };
-  const stopSubscription = (callback) => {
-    isRunning = false;
-    if (processor) processor.isRunning = false;
-    return subscription.unsubscribe().then(() => {
-      subscription.destroy();
-    }).catch((err) => console.error("Error during unsubscribe.%s", err)).finally(callback ?? (() => {
-    }));
-  };
-  const pipeMessages = (options) => {
-    let retry2 = 0;
-    return asyncRetry(
-      () => new Promise((resolve, reject) => {
-        if (!isRunning) {
-          resolve();
-          return;
-        }
-        console.info(
-          `Starting subscription. ${retry2++} retries. From: ${JSONParser.stringify(from ?? "$all")}, Start from: ${JSONParser.stringify(
-            options.startFrom
-          )}`
-        );
-        subscription = subscribe(client, from, options);
-        processor = new SubscriptionSequentialHandler({
-          client,
-          from,
-          batchSize,
-          eachBatch,
-          resilience
-        });
-        const handler = new class extends Writable {
-          async _write(result, _encoding, done) {
-            if (!isRunning) return;
-            if (isString(result)) {
-              options.startFrom = {
-                lastCheckpoint: result
-              };
-              done();
-              return;
-            }
-            if (result && result.type === "STOP" && result.error) {
-              console.error(
-                `Subscription stopped with error code: ${result.error.errorCode}, message: ${result.error.message}.`
-              );
-            }
-            await stopSubscription();
-            done();
-          }
-        }({ objectMode: true });
-        pipeline(
-          subscription,
-          processor,
-          handler,
-          async (error) => {
-            console.info(`Stopping subscription.`);
-            await stopSubscription(() => {
-              if (!error) {
-                console.info("Subscription ended successfully.");
-                resolve();
-                return;
-              }
-              console.error(
-                `Received error: ${JSONParser.stringify(error)}.`
-              );
-              reject(error);
-            });
-          }
-        );
-      }),
-      resubscribeOptions
-    );
-  };
-  return {
-    get isRunning() {
-      return isRunning;
-    },
-    start: (options) => {
-      if (isRunning) return start;
-      start = (async () => {
-        isRunning = true;
-        return pipeMessages(options);
-      })();
-      return start;
-    },
-    stop: async () => {
-      if (!isRunning) return start ? await start : Promise.resolve();
-      await stopSubscription();
-      await start;
-    }
-  };
-};
-var zipEventStoreDBEventStoreMessageBatchPullerStartFrom = (options) => {
-  if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING"))
-    return "BEGINNING";
-  if (options.every((o) => o === "END")) return "END";
-  return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
+	options;
+	from;
+	isRunning;
+	constructor(options) {
+		super({
+			objectMode: true,
+			...options
+		});
+		this.options = options;
+		this.from = options.from;
+		this.isRunning = true;
+	}
+	async _transform(resolvedEvent, _encoding, callback) {
+		try {
+			if (!this.isRunning || !resolvedEvent.event) {
+				callback();
+				return;
+			}
+			const message = mapFromESDBEvent(resolvedEvent, this.from);
+			const messageCheckpoint = getCheckpoint(message);
+			const result = await this.options.eachBatch([message]);
+			if (result && result.type === "STOP") {
+				this.isRunning = false;
+				if (!result.error) this.push(messageCheckpoint);
+				this.push(result);
+				this.push(null);
+				callback();
+				return;
+			}
+			this.push(messageCheckpoint);
+			callback();
+		} catch (error) {
+			callback(error);
+		}
+	}
+};
+const eventStoreDBSubscription = ({ client, from, batchSize, eachBatch, resilience }) => {
+	let isRunning = false;
+	let start;
+	let processor;
+	let subscription;
+	const resubscribeOptions = resilience?.resubscribeOptions ?? {
+		...EventStoreDBResubscribeDefaultOptions,
+		shouldRetryResult: () => isRunning,
+		shouldRetryError: (error) => isRunning && EventStoreDBResubscribeDefaultOptions.shouldRetryError(error)
+	};
+	const stopSubscription = (callback) => {
+		isRunning = false;
+		if (processor) processor.isRunning = false;
+		return subscription.unsubscribe().then(() => {
+			subscription.destroy();
+		}).catch((err) => console.error("Error during unsubscribe.%s", err)).finally(callback ?? (() => {}));
+	};
+	const pipeMessages = (options) => {
+		let retry = 0;
+		return asyncRetry(() => new Promise((resolve, reject) => {
+			if (!isRunning) {
+				resolve();
+				return;
+			}
+			console.info(`Starting subscription. ${retry++} retries. From: ${JSONSerializer.serialize(from ?? "$all")}, Start from: ${JSONSerializer.serialize(options.startFrom)}`);
+			subscription = subscribe(client, from, options);
+			subscription.once("confirmation", () => options.started?.resolve());
+			processor = new SubscriptionSequentialHandler({
+				client,
+				from,
+				batchSize,
+				eachBatch,
+				resilience
+			});
+			const handler = new class extends Writable {
+				async _write(result, _encoding, done) {
+					if (!isRunning) return;
+					if (isString(result)) {
+						options.startFrom = { lastCheckpoint: result };
+						done();
+						return;
+					}
+					if (result && result.type === "STOP" && result.error) console.error(`Subscription stopped with error code: ${result.error.errorCode}, message: ${result.error.message}.`);
+					await stopSubscription();
+					done();
+				}
+			}({ objectMode: true });
+			pipeline(subscription, processor, handler, async (error) => {
+				console.info(`Stopping subscription.`);
+				await stopSubscription(() => {
+					if (!error) {
+						console.info("Subscription ended successfully.");
+						resolve();
+						return;
+					}
+					console.error(`Received error: ${JSONSerializer.serialize(error)}.`);
+					options.started?.reject(error);
+					reject(error);
+				});
+			});
+		}), resubscribeOptions);
+	};
+	return {
+		get isRunning() {
+			return isRunning;
+		},
+		start: (options) => {
+			if (isRunning) return start;
+			start = (async () => {
+				isRunning = true;
+				return pipeMessages(options);
+			})();
+			return start;
+		},
+		stop: async () => {
+			if (!isRunning) return start ? await start : Promise.resolve();
+			await stopSubscription();
+			await start;
+		}
+	};
+};
+const zipEventStoreDBEventStoreMessageBatchPullerStartFrom = (options) => {
+	if (options.length === 0 || options.some((o) => o === void 0 || o === "BEGINNING")) return "BEGINNING";
+	if (options.every((o) => o === "END")) return "END";
+	return options.filter((o) => o !== void 0 && o !== "BEGINNING" && o !== "END").sort((a, b) => a > b ? 1 : -1)[0];
 };
 
-// src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
-var $all = "$all";
-var eventStoreDBEventStoreConsumer = (options) => {
-  let isRunning = false;
-  const { pulling } = options;
-  const processors = options.processors ?? [];
-  let start;
-  let currentSubscription;
-  const client = "client" in options && options.client ? options.client : EventStoreDBClient.connectionString(options.connectionString);
-  const eachBatch = async (messagesBatch) => {
-    const activeProcessors = processors.filter((s) => s.isActive);
-    if (activeProcessors.length === 0)
-      return {
-        type: "STOP",
-        reason: "No active processors"
-      };
-    const result = await Promise.allSettled(
-      activeProcessors.map(async (s) => {
-        return await s.handle(messagesBatch, { client });
-      })
-    );
-    const error = result.find((r) => r.status === "rejected")?.reason;
-    return result.some(
-      (r) => r.status === "fulfilled" && r.value?.type !== "STOP"
-    ) ? void 0 : {
-      type: "STOP",
-      error: error ? EmmettError.mapFrom(error) : void 0
-    };
-  };
-  const subscription = currentSubscription = eventStoreDBSubscription({
-    client,
-    from: options.from,
-    eachBatch,
-    batchSize: pulling?.batchSize ?? DefaultEventStoreDBEventStoreProcessorBatchSize,
-    resilience: options.resilience
-  });
-  const stop = async () => {
-    if (!isRunning) return;
-    isRunning = false;
-    if (currentSubscription) {
-      await currentSubscription.stop();
-      currentSubscription = void 0;
-    }
-    await start;
-  };
-  return {
-    consumerId: options.consumerId ?? uuid6(),
-    get isRunning() {
-      return isRunning;
-    },
-    processors,
-    reactor: (options2) => {
-      const processor = inMemoryReactor(options2);
-      processors.push(
-        // TODO: change that
-        processor
-      );
-      return processor;
-    },
-    projector: (options2) => {
-      const processor = inMemoryProjector(options2);
-      processors.push(
-        // TODO: change that
-        processor
-      );
-      return processor;
-    },
-    start: () => {
-      if (isRunning) return start;
-      start = (async () => {
-        if (processors.length === 0)
-          return Promise.reject(
-            new EmmettError(
-              "Cannot start consumer without at least a single processor"
-            )
-          );
-        isRunning = true;
-        const startFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom(
-          await Promise.all(processors.map((o) => o.start(client)))
-        );
-        return subscription.start({ startFrom });
-      })();
-      return start;
-    },
-    stop,
-    close: stop
-  };
-};
-export {
-  $all,
-  DefaultEventStoreDBEventStoreProcessorBatchSize,
-  DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs,
-  EventStoreDBEventStoreDefaultStreamVersion,
-  EventStoreDBResubscribeDefaultOptions,
-  eventStoreDBEventStoreConsumer,
-  eventStoreDBSubscription,
-  getEventStoreDBEventStore,
-  isDatabaseUnavailableError,
-  mapFromESDBEvent,
-  zipEventStoreDBEventStoreMessageBatchPullerStartFrom
+//#endregion
+//#region src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
+const $all = "$all";
+const eventStoreDBEventStoreConsumer = (options) => {
+	let isRunning = false;
+	let isInitialized = false;
+	const { pulling } = options;
+	const processors = options.processors ?? [];
+	let abortController = null;
+	let start;
+	let currentSubscription;
+	const startedAwaiter = asyncAwaiter();
+	const client = "client" in options && options.client ? options.client : EventStoreDBClient.connectionString(options.connectionString);
+	const eachBatch = async (messagesBatch) => {
+		const activeProcessors = processors.filter((s) => s.isActive);
+		if (activeProcessors.length === 0) return {
+			type: "STOP",
+			reason: "No active processors"
+		};
+		const result = await Promise.allSettled(activeProcessors.map(async (s) => {
+			return await s.handle(messagesBatch, { client });
+		}));
+		const error = result.find((r) => r.status === "rejected")?.reason;
+		return result.some((r) => r.status === "fulfilled" && r.value?.type !== "STOP") ? void 0 : {
+			type: "STOP",
+			error: error ? EmmettError.mapFrom(error) : void 0
+		};
+	};
+	const subscription = currentSubscription = eventStoreDBSubscription({
+		client,
+		from: options.from,
+		eachBatch,
+		batchSize: pulling?.batchSize ?? 100,
+		resilience: options.resilience
+	});
+	const init = async () => {
+		if (isInitialized) return;
+		for (const processor of processors) await processor.init({});
+		isInitialized = true;
+	};
+	const stopProcessors = () => Promise.all(processors.map((p) => p.close({})));
+	const stop = async () => {
+		if (!isRunning) return;
+		isRunning = false;
+		abortController?.abort();
+		if (currentSubscription) {
+			await currentSubscription.stop();
+			currentSubscription = void 0;
+		}
+		await start;
+		abortController = null;
+		await stopProcessors();
+	};
+	return {
+		consumerId: options.consumerId ?? v7(),
+		get isRunning() {
+			return isRunning;
+		},
+		whenStarted: () => startedAwaiter.wait,
+		processors,
+		reactor: (options) => {
+			const processor = inMemoryReactor(options);
+			processors.push(processor);
+			return processor;
+		},
+		projector: (options) => {
+			const processor = inMemoryProjector(options);
+			processors.push(processor);
+			return processor;
+		},
+		start: () => {
+			if (isRunning) return start;
+			startedAwaiter.reset();
+			if (processors.length === 0) {
+				const error = new EmmettError("Cannot start consumer without at least a single processor");
+				startedAwaiter.reject(error);
+				return Promise.reject(error);
+			}
+			isRunning = true;
+			abortController = new AbortController();
+			start = (async () => {
+				if (!isRunning) return;
+				try {
+					if (!isInitialized) await init();
+					const startFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom(await Promise.all(processors.map((o) => o.start(client))));
+					await subscription.start({
+						startFrom,
+						started: startedAwaiter
+					});
+				} catch (error) {
+					isRunning = false;
+					startedAwaiter.reject(error);
+					throw error;
+				} finally {
+					await stopProcessors();
+				}
+			})();
+			return start;
+		},
+		stop,
+		close: stop
+	};
 };
+
+//#endregion
+export { $all, DefaultEventStoreDBEventStoreProcessorBatchSize, DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs, EventStoreDBEventStoreDefaultStreamVersion, EventStoreDBResubscribeDefaultOptions, eventStoreDBEventStoreConsumer, eventStoreDBSubscription, getEventStoreDBEventStore, isDatabaseUnavailableError, mapFromESDBEvent, zipEventStoreDBEventStoreMessageBatchPullerStartFrom };
 //# sourceMappingURL=index.js.map