@event-driven-io/emmett-esdb 0.43.0-beta.13 → 0.43.0-beta.14

package/dist/index.cjs

@@ -1,1500 +1,406 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var EmmettError = (_class = class _EmmettError extends Error {
-  static __initStatic() {this.Codes = {
-    ValidationError: 400,
-    IllegalStateError: 403,
-    NotFoundError: 404,
-    ConcurrencyError: 412,
-    InternalServerError: 500
-  }}
-  
-  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: _nullishCoalesce(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);
-  }
-}, _class.__initStatic(), _class);
-var ConcurrencyError = class _ConcurrencyError extends EmmettError {
-  constructor(current, expected, message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
-    });
-    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: _nullishCoalesce(message, () => ( `Expected document state does not match current one!`))
-    });
-    Object.setPrototypeOf(this, _ConcurrencyInMemoryDatabaseError.prototype);
-  }
-};
-
-// ../emmett/dist/index.js
-var _uuid = require('uuid');
-
-
-var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
-
-
-
-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(_optionalChain([current, 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]), _optionalChain([expected, 'optionalAccess', _5 => _5.toString, 'call', _6 => _6()]));
-    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 bigIntReplacer = (_key, value) => {
-  return typeof value === "bigint" ? value.toString() : value;
-};
-var dateReplacer = (_key, value) => {
-  return value instanceof Date ? value.toISOString() : value;
-};
-var isFirstLetterNumeric = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57;
-};
-var isFirstLetterNumericOrMinus = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57 || c === 45;
-};
-var bigIntReviver = (_key, value, context) => {
-  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
-    try {
-      return BigInt(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _7 => _7.source]), () => ( value.toString())));
-    } catch (e) {
-      return value;
-    }
-  }
-  if (typeof value === "string" && value.length > 15) {
-    if (isFirstLetterNumericOrMinus(value)) {
-      const num = Number(value);
-      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
-        try {
-          return BigInt(value);
-        } catch (e2) {
-        }
-      }
-    }
-  }
-  return value;
-};
-var dateReviver = (_key, value) => {
-  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
-    const date = new Date(value);
-    if (!isNaN(date.getTime())) {
-      return date;
-    }
-  }
-  return value;
-};
-var composeJSONReplacers = (...replacers) => {
-  const filteredReplacers = replacers.filter((r) => r !== void 0);
-  if (filteredReplacers.length === 0) return void 0;
-  return (key, value) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredReplacers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, replacer) => replacer(key, accValue),
-      value
-    )
-  );
-};
-var composeJSONRevivers = (...revivers) => {
-  const filteredRevivers = revivers.filter((r) => r !== void 0);
-  if (filteredRevivers.length === 0) return void 0;
-  return (key, value, context) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredRevivers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, reviver) => reviver(key, accValue, context),
-      value
-    )
-  );
-};
-var JSONReplacer = (opts) => composeJSONReplacers(
-  _optionalChain([opts, 'optionalAccess', _8 => _8.replacer]),
-  _optionalChain([opts, 'optionalAccess', _9 => _9.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
-  _optionalChain([opts, 'optionalAccess', _10 => _10.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
-);
-var JSONReviver = (opts) => composeJSONRevivers(
-  _optionalChain([opts, 'optionalAccess', _11 => _11.reviver]),
-  _optionalChain([opts, 'optionalAccess', _12 => _12.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
-  _optionalChain([opts, 'optionalAccess', _13 => _13.parseDates]) === true ? JSONRevivers.date : void 0
-);
-var JSONReplacers = {
-  bigInt: bigIntReplacer,
-  date: dateReplacer
-};
-var JSONRevivers = {
-  bigInt: bigIntReviver,
-  date: dateReviver
-};
-var jsonSerializer = (options) => {
-  const defaultReplacer = JSONReplacer(options);
-  const defaultReviver = JSONReviver(options);
-  return {
-    serialize: (object, serializerOptions) => JSON.stringify(
-      object,
-      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
-    ),
-    deserialize: (payload, deserializerOptions) => JSON.parse(
-      payload,
-      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
-    )
-  };
-};
-var JSONSerializer = Object.assign(jsonSerializer(), {
-  from: (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.serialization, 'optionalAccess', _15 => _15.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _16 => _16.serialization, 'optionalAccess', _17 => _17.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _18 => _18.serialization, 'optionalAccess', _19 => _19.options])) : JSONSerializer)))
-});
-var asyncRetry = async (fn, opts) => {
-  if (opts === void 0 || opts.retries === 0) return fn();
-  return _asyncretry2.default.call(void 0, 
-    async (bail) => {
-      try {
-        const result = await fn();
-        if (_optionalChain([opts, 'optionalAccess', _20 => _20.shouldRetryResult]) && opts.shouldRetryResult(result)) {
-          throw new EmmettError(
-            `Retrying because of result: ${JSONSerializer.serialize(result)}`
-          );
-        }
-        return result;
-      } catch (error) {
-        if (_optionalChain([opts, 'optionalAccess', _21 => _21.shouldRetryError]) && !opts.shouldRetryError(error)) {
-          bail(error);
-          return void 0;
-        }
-        throw error;
-      }
-    },
-    _nullishCoalesce(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(
-          _nullishCoalesce(errorMessage, () => ( `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`))
-        );
-    }
-  };
-  if (_optionalChain([options, 'access', _22 => _22.errors, 'optionalAccess', _23 => _23.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 = _nullishCoalesce(document._id, () => ( _uuid.v7.call(void 0, )));
-          const _version = _nullishCoalesce(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 ? _optionalChain([documentsInCollection, 'optionalAccess', _24 => _24.filter, 'call', _25 => _25((doc) => predicate(doc))]) : documentsInCollection;
-          const firstOne = _nullishCoalesce(_optionalChain([filteredDocuments, 'optionalAccess', _26 => _26[0]]), () => ( null));
-          return Promise.resolve(firstOne);
-        },
-        find: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _27 => _27.filter, 'call', _28 => _28((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 _optionalChain([options, 'optionalAccess', _29 => _29.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 } = _nullishCoalesce(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: _nullishCoalesce(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}:${_uuid.v7.call(void 0, )}`;
-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 isCustomBatch = "eachBatch" in options && !!options.eachBatch;
-  const eachBatch = isCustomBatch ? options.eachBatch : async (messages, context) => {
-    let result = void 0;
-    for (let i = 0; i < messages.length; i++) {
-      const message2 = messages[i];
-      const messageProcessingResult = await options.eachMessage(
-        message2,
-        context
-      );
-      if (messageProcessingResult && messageProcessingResult.type === "STOP") {
-        result = {
-          ...messageProcessingResult,
-          lastSuccessfulMessage: messageProcessingResult.error ? messages[i - 1] : message2
-        };
-        break;
-      }
-      if (stopAfter && stopAfter(message2)) {
-        result = {
-          type: "STOP",
-          reason: "Stop condition reached",
-          lastSuccessfulMessage: message2
-        };
-        break;
-      }
-      if (messageProcessingResult && messageProcessingResult.type === "SKIP") {
-        result = {
-          ...messageProcessingResult,
-          lastSuccessfulMessage: message2
-        };
-        continue;
-      }
-    }
-    return result;
-  };
-  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(startOptions));
-      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 _optionalChain([checkpoints, 'optionalAccess', _30 => _30.read, 'call', _31 => _31(
-            {
-              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) => {
-        const messagesAboveCheckpoint = messages.filter(
-          (message2) => !wasMessageHandled(message2, lastCheckpoint)
-        );
-        const upcastedMessages = messagesAboveCheckpoint.map(
-          (message2) => upcastRecordedMessage(
-            // TODO: Make it smarter
-            message2,
-            _optionalChain([options, 'access', _32 => _32.messageOptions, 'optionalAccess', _33 => _33.schema, 'optionalAccess', _34 => _34.versioning])
-          )
-        ).filter(
-          (upcasted) => !canHandle || canHandle.includes(upcasted.type)
-        );
-        const stopMessageIndex = isCustomBatch && stopAfter ? upcastedMessages.findIndex(stopAfter) : -1;
-        const unhandledMessages = stopMessageIndex !== -1 ? upcastedMessages.slice(0, stopMessageIndex + 1) : upcastedMessages;
-        const batchResult = await eachBatch(unhandledMessages, context);
-        const messageProcessingResult = _optionalChain([batchResult, 'optionalAccess', _35 => _35.type]) === "STOP" ? batchResult : stopMessageIndex !== -1 ? {
-          type: "STOP",
-          reason: "Stop condition reached",
-          lastSuccessfulMessage: unhandledMessages[stopMessageIndex]
-        } : batchResult;
-        const isStop = messageProcessingResult && messageProcessingResult.type === "STOP";
-        const checkpointMessage = _optionalChain([messageProcessingResult, 'optionalAccess', _36 => _36.type]) === "STOP" ? messageProcessingResult.lastSuccessfulMessage : messagesAboveCheckpoint[messagesAboveCheckpoint.length - 1];
-        if (checkpointMessage && checkpoints) {
-          const storeCheckpointResult = await checkpoints.store(
-            {
-              processorId,
-              version,
-              message: checkpointMessage,
-              lastCheckpoint,
-              partition
-            },
-            context
-          );
-          if (storeCheckpointResult.success) {
-            lastCheckpoint = storeCheckpointResult.newCheckpoint;
-          }
-        }
-        if (isStop) {
-          isActive = false;
-          return messageProcessingResult;
-        }
-        return void 0;
-      }, partialContext);
-    }
-  };
-};
-var projector = (options) => {
-  const {
-    projection: projection2,
-    processorId = getProjectorId({
-      projectionName: _nullishCoalesce(projection2.name, () => ( "unknown"))
-    }),
-    ...rest
-  } = options;
-  return reactor({
-    ...rest,
-    type: MessageProcessorType.PROJECTOR,
-    canHandle: projection2.canHandle,
-    processorId,
-    messageOptions: options.projection.eventsOptions,
-    hooks: {
-      onInit: _optionalChain([options, 'access', _37 => _37.hooks, 'optionalAccess', _38 => _38.onInit]),
-      onStart: options.truncateOnStart && options.projection.truncate || _optionalChain([options, 'access', _39 => _39.hooks, 'optionalAccess', _40 => _40.onStart]) ? async (context) => {
-        if (options.truncateOnStart && options.projection.truncate)
-          await options.projection.truncate(context);
-        if (_optionalChain([options, 'access', _41 => _41.hooks, 'optionalAccess', _42 => _42.onStart])) await _optionalChain([options, 'access', _43 => _43.hooks, 'optionalAccess', _44 => _44.onStart, 'call', _45 => _45(context)]);
-      } : void 0,
-      onClose: _optionalChain([options, 'access', _46 => _46.hooks, 'optionalAccess', _47 => _47.onClose])
-    },
-    eachBatch: async (events, context) => projection2.handle(events, 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: _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _48 => _48.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 = _nullishCoalesce(_optionalChain([checkpoint, 'optionalAccess', _49 => _49.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) => ({
-        ..._nullishCoalesce(existing, () => ( {})),
-        _id: processorId,
-        lastCheckpoint: newCheckpoint
-      }));
-      return { success: true, newCheckpoint };
-    }
-  };
-};
-var inMemoryProcessingScope = (options) => {
-  const processorDatabase = options.database;
-  const processingScope = (handler, partialContext) => {
-    const database = _nullishCoalesce(processorDatabase, () => ( _optionalChain([partialContext, 'optionalAccess', _50 => _50.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 = _nullishCoalesce(_optionalChain([options, 'access', _51 => _51.connectionOptions, 'optionalAccess', _52 => _52.database]), () => ( getInMemoryDatabase()));
-  const hooks = {
-    onInit: _optionalChain([options, 'access', _53 => _53.hooks, 'optionalAccess', _54 => _54.onInit]),
-    onStart: _optionalChain([options, 'access', _55 => _55.hooks, 'optionalAccess', _56 => _56.onStart]),
-    onClose: _optionalChain([options, 'access', _57 => _57.hooks, 'optionalAccess', _58 => _58.onClose]) ? async (context) => {
-      if (_optionalChain([options, 'access', _59 => _59.hooks, 'optionalAccess', _60 => _60.onClose])) await _optionalChain([options, 'access', _61 => _61.hooks, 'optionalAccess', _62 => _62.onClose, 'call', _63 => _63(context)]);
-    } : void 0
-  };
-  const processor = projector({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: _nullishCoalesce(options.processorId, () => ( `projection:${options.projection.name}`))
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
-};
-var inMemoryReactor = (options) => {
-  const database = _nullishCoalesce(_optionalChain([options, 'access', _64 => _64.connectionOptions, 'optionalAccess', _65 => _65.database]), () => ( getInMemoryDatabase()));
-  const hooks = {
-    onInit: _optionalChain([options, 'access', _66 => _66.hooks, 'optionalAccess', _67 => _67.onInit]),
-    onStart: _optionalChain([options, 'access', _68 => _68.hooks, 'optionalAccess', _69 => _69.onStart]),
-    onClose: _optionalChain([options, 'access', _70 => _70.hooks, 'optionalAccess', _71 => _71.onClose])
-  };
-  const processor = reactor({
-    ...options,
-    hooks,
-    processingScope: inMemoryProcessingScope({
-      database,
-      processorId: options.processorId
-    }),
-    checkpoints: inMemoryCheckpointer()
-  });
-  return Object.assign(processor, { database });
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _72 => _72.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 (!_optionalChain([options, 'optionalAccess', _73 => _73.downcast]))
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!_optionalChain([options, 'optionalAccess', _74 => _74.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
-
-
-var _dbclient = require('@eventstore/db-client');
-
-
-// src/eventStore/consumers/subscriptions/index.ts
-
-
-
-
-
-var _stream = require('stream');
-
-// src/eventStore/eventstoreDBEventStore.ts
-
-
-
-
-
-
-
-
-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 = _optionalChain([read, 'optionalAccess', _75 => _75.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),
-              _optionalChain([options, 'optionalAccess', _76 => _76.read, 'optionalAccess', _77 => _77.schema, 'optionalAccess', _78 => _78.versioning])
-            )
-          );
-          currentStreamVersion = event.revision;
-          lastEventGlobalPosition = _optionalChain([event, 'access', _79 => _79.position, 'optionalAccess', _80 => _80.commit]);
-        }
-        assertExpectedVersionMatchesCurrent(
-          currentStreamVersion,
-          expectedStreamVersion,
-          EventStoreDBEventStoreDefaultStreamVersion
-        );
-        return lastEventGlobalPosition ? {
-          currentStreamVersion,
-          lastEventGlobalPosition,
-          state,
-          streamExists: true
-        } : {
-          currentStreamVersion,
-          state,
-          streamExists: false
-        };
-      } catch (error) {
-        if (error instanceof _dbclient.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),
-              _optionalChain([options, 'optionalAccess', _81 => _81.schema, 'optionalAccess', _82 => _82.versioning])
-            )
-          );
-          currentStreamVersion = event.revision;
-        }
-        return {
-          currentStreamVersion,
-          events,
-          streamExists: true
-        };
-      } catch (error) {
-        if (error instanceof _dbclient.StreamNotFoundError) {
-          return {
-            currentStreamVersion,
-            events: [],
-            streamExists: false
-          };
-        }
-        throw error;
-      }
-    },
-    appendToStream: async (streamName, events, options) => {
-      try {
-        const eventsToStore = downcastRecordedMessages(
-          events,
-          _optionalChain([options, 'optionalAccess', _83 => _83.schema, 'optionalAccess', _84 => _84.versioning])
-        );
-        const serializedEvents = eventsToStore.map(_dbclient.jsonEvent);
-        const expectedRevision = toExpectedRevision(
-          _optionalChain([options, 'optionalAccess', _85 => _85.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 _dbclient.WrongExpectedVersionError) {
-          throw new ExpectedVersionConflictError(
-            BigInt(error.actualVersion),
-            toExpectedVersion(error.expectedVersion)
-          );
-        }
-        throw error;
-      }
-    },
-    consumer: (options) => eventStoreDBEventStoreConsumer({
-      ..._nullishCoalesce(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 _dbclient.StreamNotFoundError) {
-          return false;
-        }
-        throw error;
-      }
-    }
-    //streamEvents: streamEvents(eventStore),
-  };
-};
-var getESDBCheckpoint = (resolvedEvent, from) => {
-  return !from || _optionalChain([from, 'optionalAccess', _86 => _86.stream]) === $all ? _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _87 => _87.link, 'optionalAccess', _88 => _88.position, 'optionalAccess', _89 => _89.commit]), () => ( _optionalChain([resolvedEvent, 'access', _90 => _90.event, 'optionalAccess', _91 => _91.position, 'optionalAccess', _92 => _92.commit]))) : _nullishCoalesce(_optionalChain([resolvedEvent, 'access', _93 => _93.link, 'optionalAccess', _94 => _94.revision]), () => ( resolvedEvent.event.revision));
-};
-var mapFromESDBEvent = (resolvedEvent, from) => {
-  const event = resolvedEvent.event;
-  return {
-    type: event.type,
-    data: event.data,
-    metadata: {
-      ..._nullishCoalesce(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 _dbclient.ANY;
-  if (expected === NO_CONCURRENCY_CHECK) return _dbclient.ANY;
-  if (expected == STREAM_DOES_NOT_EXIST) return _dbclient.NO_STREAM;
-  if (expected == STREAM_EXISTS) return _dbclient.STREAM_EXISTS;
-  return expected;
-};
-var toExpectedVersion = (expected) => {
-  if (expected === void 0) return NO_CONCURRENCY_CHECK;
-  if (expected === _dbclient.ANY) return NO_CONCURRENCY_CHECK;
-  if (expected == _dbclient.NO_STREAM) return STREAM_DOES_NOT_EXIST;
-  if (expected == _dbclient.STREAM_EXISTS) return STREAM_EXISTS;
-  return expected;
-};
-
-// src/eventStore/consumers/subscriptions/index.ts
-var DefaultEventStoreDBEventStoreProcessorBatchSize = 100;
-var DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = 50;
-var toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : {
-  prepare: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint),
-  commit: parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint)
-};
-var toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _dbclient.START : startFrom === "END" ? _dbclient.END : parseBigIntProcessorCheckpoint(startFrom.lastCheckpoint);
-var subscribe = (client, from, options) => from == void 0 || from.stream == $all ? client.subscribeToAll({
-  ..._nullishCoalesce(_optionalChain([from, 'optionalAccess', _95 => _95.options]), () => ( {})),
-  fromPosition: toGlobalPosition(options.startFrom),
-  filter: _dbclient.excludeSystemEvents.call(void 0, )
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _event_driven_io_emmett = require("@event-driven-io/emmett");
+let _eventstore_db_client = require("@eventstore/db-client");
+let uuid = require("uuid");
+let stream = require("stream");
+
+//#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 lastEventGlobalPosition = void 0;
+			try {
+				for await (const resolvedEvent of eventStore.readStream(streamName, toEventStoreDBReadOptions(options.read))) {
+					const { event } = resolvedEvent;
+					if (!event) continue;
+					state = evolve(state, (0, _event_driven_io_emmett.upcastRecordedMessage)(mapFromESDBEvent(resolvedEvent), options?.read?.schema?.versioning));
+					currentStreamVersion = event.revision;
+					lastEventGlobalPosition = event.position?.commit;
+				}
+				(0, _event_driven_io_emmett.assertExpectedVersionMatchesCurrent)(currentStreamVersion, expectedStreamVersion, EventStoreDBEventStoreDefaultStreamVersion);
+				return lastEventGlobalPosition ? {
+					currentStreamVersion,
+					lastEventGlobalPosition,
+					state,
+					streamExists: true
+				} : {
+					currentStreamVersion,
+					state,
+					streamExists: false
+				};
+			} catch (error) {
+				if (error instanceof _eventstore_db_client.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((0, _event_driven_io_emmett.upcastRecordedMessage)(mapFromESDBEvent(resolvedEvent), options?.schema?.versioning));
+					currentStreamVersion = event.revision;
+				}
+				return {
+					currentStreamVersion,
+					events,
+					streamExists: true
+				};
+			} catch (error) {
+				if (error instanceof _eventstore_db_client.StreamNotFoundError) return {
+					currentStreamVersion,
+					events: [],
+					streamExists: false
+				};
+				throw error;
+			}
+		},
+		appendToStream: async (streamName, events, options) => {
+			try {
+				const serializedEvents = (0, _event_driven_io_emmett.downcastRecordedMessages)(events, options?.schema?.versioning).map(_eventstore_db_client.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 _eventstore_db_client.WrongExpectedVersionError) throw new _event_driven_io_emmett.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 _eventstore_db_client.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: event.position.commit,
+			checkpoint: (0, _event_driven_io_emmett.bigIntProcessorCheckpoint)(getESDBCheckpoint(resolvedEvent, from))
+		}
+	};
+};
+const toExpectedRevision = (expected) => {
+	if (expected === void 0) return _eventstore_db_client.ANY;
+	if (expected === _event_driven_io_emmett.NO_CONCURRENCY_CHECK) return _eventstore_db_client.ANY;
+	if (expected == _event_driven_io_emmett.STREAM_DOES_NOT_EXIST) return _eventstore_db_client.NO_STREAM;
+	if (expected == _event_driven_io_emmett.STREAM_EXISTS) return _eventstore_db_client.STREAM_EXISTS;
+	return expected;
+};
+const toExpectedVersion = (expected) => {
+	if (expected === void 0) return _event_driven_io_emmett.NO_CONCURRENCY_CHECK;
+	if (expected === _eventstore_db_client.ANY) return _event_driven_io_emmett.NO_CONCURRENCY_CHECK;
+	if (expected == _eventstore_db_client.NO_STREAM) return _event_driven_io_emmett.STREAM_DOES_NOT_EXIST;
+	if (expected == _eventstore_db_client.STREAM_EXISTS) return _event_driven_io_emmett.STREAM_EXISTS;
+	return expected;
+};
+
+//#endregion
+//#region src/eventStore/consumers/subscriptions/index.ts
+const DefaultEventStoreDBEventStoreProcessorBatchSize = 100;
+const DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = 50;
+const toGlobalPosition = (startFrom) => startFrom === "BEGINNING" ? _eventstore_db_client.START : startFrom === "END" ? _eventstore_db_client.END : {
+	prepare: (0, _event_driven_io_emmett.parseBigIntProcessorCheckpoint)(startFrom.lastCheckpoint),
+	commit: (0, _event_driven_io_emmett.parseBigIntProcessorCheckpoint)(startFrom.lastCheckpoint)
+};
+const toStreamPosition = (startFrom) => startFrom === "BEGINNING" ? _eventstore_db_client.START : startFrom === "END" ? _eventstore_db_client.END : (0, _event_driven_io_emmett.parseBigIntProcessorCheckpoint)(startFrom.lastCheckpoint);
+const subscribe = (client, from, options) => from == void 0 || from.stream == "$all" ? client.subscribeToAll({
+	...from?.options ?? {},
+	fromPosition: toGlobalPosition(options.startFrom),
+	filter: (0, _eventstore_db_client.excludeSystemEvents)()
 }) : client.subscribeToStream(from.stream, {
-  ..._nullishCoalesce(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)
-};
-var SubscriptionSequentialHandler = class extends _stream.Transform {
-  
-  
-  
-  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 = _nullishCoalesce(_optionalChain([resilience, 'optionalAccess', _96 => _96.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(_nullishCoalesce(callback, () => ( (() => {
-    }))));
-  };
-  const pipeMessages = (options) => {
-    let retry2 = 0;
-    return asyncRetry(
-      () => new Promise((resolve, reject) => {
-        if (!isRunning) {
-          resolve();
-          return;
-        }
-        console.info(
-          `Starting subscription. ${retry2++} retries. From: ${JSONSerializer.serialize(_nullishCoalesce(from, () => ( "$all")))}, Start from: ${JSONSerializer.serialize(
-            options.startFrom
-          )}`
-        );
-        subscription = subscribe(client, from, options);
-        processor = new SubscriptionSequentialHandler({
-          client,
-          from,
-          batchSize,
-          eachBatch,
-          resilience
-        });
-        const handler = new class extends _stream.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 });
-        _stream.pipeline.call(void 0, 
-          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)}.`
-              );
-              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];
-};
-
-// src/eventStore/consumers/eventStoreDBEventStoreConsumer.ts
-var $all = "$all";
-var eventStoreDBEventStoreConsumer = (options) => {
-  let isRunning = false;
-  const { pulling } = options;
-  const processors = _nullishCoalesce(options.processors, () => ( []));
-  let start;
-  let currentSubscription;
-  const client = "client" in options && options.client ? options.client : _dbclient.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 = _optionalChain([result, 'access', _97 => _97.find, 'call', _98 => _98((r) => r.status === "rejected"), 'optionalAccess', _99 => _99.reason]);
-    return result.some(
-      (r) => r.status === "fulfilled" && _optionalChain([r, 'access', _100 => _100.value, 'optionalAccess', _101 => _101.type]) !== "STOP"
-    ) ? void 0 : {
-      type: "STOP",
-      error: error ? EmmettError.mapFrom(error) : void 0
-    };
-  };
-  const subscription = currentSubscription = eventStoreDBSubscription({
-    client,
-    from: options.from,
-    eachBatch,
-    batchSize: _nullishCoalesce(_optionalChain([pulling, 'optionalAccess', _102 => _102.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: _nullishCoalesce(options.consumerId, () => ( _uuid.v7.call(void 0, ))),
-    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
-  };
-};
-
-
-
-
-
-
-
-
-
-
-
-
-exports.$all = $all; exports.DefaultEventStoreDBEventStoreProcessorBatchSize = DefaultEventStoreDBEventStoreProcessorBatchSize; exports.DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs; exports.EventStoreDBEventStoreDefaultStreamVersion = EventStoreDBEventStoreDefaultStreamVersion; exports.EventStoreDBResubscribeDefaultOptions = EventStoreDBResubscribeDefaultOptions; exports.eventStoreDBEventStoreConsumer = eventStoreDBEventStoreConsumer; exports.eventStoreDBSubscription = eventStoreDBSubscription; exports.getEventStoreDBEventStore = getEventStoreDBEventStore; exports.isDatabaseUnavailableError = isDatabaseUnavailableError; exports.mapFromESDBEvent = mapFromESDBEvent; exports.zipEventStoreDBEventStoreMessageBatchPullerStartFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom;
+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 stream.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 = (0, _event_driven_io_emmett.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 (0, _event_driven_io_emmett.asyncRetry)(() => new Promise((resolve, reject) => {
+			if (!isRunning) {
+				resolve();
+				return;
+			}
+			console.info(`Starting subscription. ${retry++} retries. From: ${_event_driven_io_emmett.JSONSerializer.serialize(from ?? "$all")}, Start from: ${_event_driven_io_emmett.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 stream.Writable {
+				async _write(result, _encoding, done) {
+					if (!isRunning) return;
+					if ((0, _event_driven_io_emmett.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 });
+			(0, stream.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: ${_event_driven_io_emmett.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];
+};
+
+//#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 = (0, _event_driven_io_emmett.asyncAwaiter)();
+	const client = "client" in options && options.client ? options.client : _eventstore_db_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 ? _event_driven_io_emmett.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 ?? (0, uuid.v7)(),
+		get isRunning() {
+			return isRunning;
+		},
+		whenStarted: () => startedAwaiter.wait,
+		processors,
+		reactor: (options) => {
+			const processor = (0, _event_driven_io_emmett.inMemoryReactor)(options);
+			processors.push(processor);
+			return processor;
+		},
+		projector: (options) => {
+			const processor = (0, _event_driven_io_emmett.inMemoryProjector)(options);
+			processors.push(processor);
+			return processor;
+		},
+		start: () => {
+			if (isRunning) return start;
+			startedAwaiter.reset();
+			if (processors.length === 0) {
+				const error = new _event_driven_io_emmett.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
+exports.$all = $all;
+exports.DefaultEventStoreDBEventStoreProcessorBatchSize = DefaultEventStoreDBEventStoreProcessorBatchSize;
+exports.DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs = DefaultEventStoreDBEventStoreProcessorPullingFrequencyInMs;
+exports.EventStoreDBEventStoreDefaultStreamVersion = EventStoreDBEventStoreDefaultStreamVersion;
+exports.EventStoreDBResubscribeDefaultOptions = EventStoreDBResubscribeDefaultOptions;
+exports.eventStoreDBEventStoreConsumer = eventStoreDBEventStoreConsumer;
+exports.eventStoreDBSubscription = eventStoreDBSubscription;
+exports.getEventStoreDBEventStore = getEventStoreDBEventStore;
+exports.isDatabaseUnavailableError = isDatabaseUnavailableError;
+exports.mapFromESDBEvent = mapFromESDBEvent;
+exports.zipEventStoreDBEventStoreMessageBatchPullerStartFrom = zipEventStoreDBEventStoreMessageBatchPullerStartFrom;
 //# sourceMappingURL=index.cjs.map