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

package/dist/index.js

@@ -1,1121 +1,521 @@
-// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var isErrorConstructor = (expect) => {
-  return typeof expect === "function" && expect.prototype && // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  expect.prototype.constructor === expect;
-};
-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);
-  }
-};
-
-// ../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";
-async function tryPublishMessagesAfterCommit(messages, options, context) {
-  if (options?.onAfterCommit === void 0) return false;
-  try {
-    await options?.onAfterCommit(messages, context);
-    return true;
-  } catch (error) {
-    console.error(`Error in on after commit hook`, error);
-    return false;
-  }
-}
-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 hasDuplicates = (array, predicate) => {
-  const mapped = array.map(predicate);
-  const uniqueValues = new Set(mapped);
-  return uniqueValues.size < mapped.length;
-};
-var getDuplicates = (array, predicate) => {
-  const map = /* @__PURE__ */ new Map();
-  for (let i = 0; i < array.length; i++) {
-    const item = array[i];
-    const key = predicate(item, i, array);
-    if (!map.has(key)) {
-      map.set(key, []);
-    }
-    map.get(key).push(item);
-  }
-  return Array.from(map.values()).filter((group) => group.length > 1).flat();
-};
-var merge = (array, item, where, onExisting, onNotFound = () => void 0) => {
-  let wasFound = false;
-  const result = array.map((p) => {
-    if (!where(p)) return p;
-    wasFound = true;
-    return onExisting(p);
-  }).filter((p) => p !== void 0).map((p) => {
-    if (!p) throw Error("That should not happen");
-    return p;
-  });
-  if (!wasFound) {
-    const result2 = onNotFound();
-    if (result2 !== void 0) return [...array, item];
-  }
-  return result;
-};
-var arrayUtils = {
-  merge,
-  hasDuplicates,
-  getDuplicates
-};
-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 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 textEncoder = new TextEncoder();
-var AssertionError = class extends Error {
-  constructor(message2) {
-    super(message2);
-  }
-};
-var isSubset = (superObj, subObj) => {
-  const sup = superObj;
-  const sub = subObj;
-  assertOk(sup);
-  assertOk(sub);
-  return Object.keys(sub).every((ele) => {
-    if (sub[ele] !== null && typeof sub[ele] == "object") {
-      return isSubset(sup[ele], sub[ele]);
-    }
-    return sub[ele] === sup[ele];
-  });
-};
-var assertFails = (message2) => {
-  throw new AssertionError(message2 ?? "That should not ever happened, right?");
-};
-function assertTrue(condition, message2) {
-  if (condition !== true)
-    throw new AssertionError(message2 ?? `Condition is false`);
-}
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
-}
-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 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 : {}
-      }
-    } : {}
-  };
-};
-var upcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.upcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => upcastRecordedMessage(recordedMessage, options)
-  );
-};
-var filterProjections = (type, projections2) => {
-  const inlineProjections2 = projections2.filter((projection2) => projection2.type === type).map(({ projection: projection2 }) => projection2);
-  const duplicateRegistrations = arrayUtils.getDuplicates(
-    inlineProjections2,
-    (proj) => proj.name
-  );
-  if (duplicateRegistrations.length > 0) {
-    throw new EmmettError(`You cannot register multiple projections with the same name (or without the name).
-      Ensure that:
-      ${JSONParser.stringify(duplicateRegistrations)}
-      have different names`);
-  }
-  return inlineProjections2;
-};
-var inlineProjections = (definitions) => definitions.map((definition) => ({
-  type: "inline",
-  projection: definition
-}));
-var asyncProjections = (definitions) => definitions.map((definition) => ({
-  type: "inline",
-  projection: definition
-}));
-var projections = {
-  inline: inlineProjections,
-  async: asyncProjections
-};
-
-// src/eventStore/mongoDBEventStore.ts
-import {
-  MongoClient as MongoClient2
-} from "mongodb";
-import { v4 as uuid6 } from "uuid";
+import { AssertionError, ExpectedVersionConflictError, assertExpectedVersionMatchesCurrent, assertFails, assertTrue, deepEquals, downcastRecordedMessage, filterProjections, isErrorConstructor, isSubset, noopScope, projections, tryPublishMessagesAfterCommit, upcastRecordedMessages } from "@event-driven-io/emmett";
+import { MongoClient } from "mongodb";
+import { v4 } from "uuid";
 
-// src/eventStore/projections/mongoDBInlineProjection.ts
-var MongoDBDefaultInlineProjectionName = "_default";
-var handleInlineProjections = async (options) => {
-  const {
-    events,
-    projections: allProjections,
-    updates: update,
-    streamId,
-    collection,
-    readModels
-  } = options;
-  const eventTypes = events.map((e) => e.type);
-  const projections2 = allProjections.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  for (const projection of projections2) {
-    await projection.handle(events, {
-      document: readModels[projection.name] ?? null,
-      streamId,
-      collection,
-      updates: update
-    });
-  }
-};
-var mongoDBInlineProjection = (options) => {
-  const projectionName = options.name ?? MongoDBDefaultInlineProjectionName;
-  const schemaVersion = options.schemaVersion ?? 1;
-  return {
-    name: projectionName,
-    canHandle: options.canHandle,
-    handle: async (events, { document, updates, streamId }) => {
-      if (events.length === 0) return;
-      let state = "initialState" in options ? document ?? options.initialState() : document;
-      for (const event of events) {
-        state = await options.evolve(
-          state,
-          event
-        );
-      }
-      const metadata = {
-        streamId,
-        name: projectionName,
-        schemaVersion,
-        streamPosition: events[events.length - 1].metadata.streamPosition
-      };
-      updates.$set[`projections.${projectionName}`] = state !== null ? {
-        ...state,
-        _metadata: metadata
-      } : null;
-    }
-  };
+//#region src/eventStore/projections/mongoDBInlineProjection.ts
+const MongoDBDefaultInlineProjectionName = "_default";
+const handleInlineProjections = async (options) => {
+	const { events, projections: allProjections, updates: update, streamId, collection, readModels } = options;
+	const eventTypes = events.map((e) => e.type);
+	const projections = allProjections.filter((p) => p.canHandle.some((type) => eventTypes.includes(type)));
+	for (const projection of projections) await projection.handle(events, {
+		document: readModels[projection.name] ?? null,
+		streamId,
+		collection,
+		updates: update,
+		observabilityScope: noopScope
+	});
+};
+const mongoDBInlineProjection = (options) => {
+	const projectionName = options.name ?? "_default";
+	const schemaVersion = options.schemaVersion ?? 1;
+	return {
+		name: projectionName,
+		canHandle: options.canHandle,
+		handle: async (events, { document, updates, streamId }) => {
+			if (events.length === 0) return;
+			let state = "initialState" in options ? document ?? options.initialState() : document;
+			for (const event of events) state = await options.evolve(state, event);
+			const metadata = {
+				streamId,
+				name: projectionName,
+				schemaVersion,
+				streamPosition: events[events.length - 1].metadata.streamPosition
+			};
+			updates.$set[`projections.${projectionName}`] = state !== null ? {
+				...state,
+				_metadata: metadata
+			} : null;
+		}
+	};
 };
 
-// src/eventStore/projections/mongoDBInlineProjectionSpec.ts
-import { MongoClient } from "mongodb";
-var MongoDBInlineProjectionSpec = {
-  for: (options) => {
-    {
-      const { projection, ...connectionOptions } = options;
-      return (givenStream) => {
-        const { streamName, events: givenEvents } = givenStream;
-        return {
-          when: (events) => {
-            const allEvents = [...givenEvents, ...events];
-            const run = (eventStore) => eventStore.appendToStream(streamName, allEvents);
-            return {
-              then: async (assert, message) => {
-                const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(
-                  connectionOptions.connectionString,
-                  connectionOptions.clientOptions
-                );
-                const eventStore = getMongoDBEventStore({
-                  projections: projections.inline([projection]),
-                  client
-                });
-                try {
-                  await run(eventStore);
-                  const succeeded = await assert({ eventStore, streamName });
-                  if (succeeded !== void 0 && succeeded === false)
-                    assertFails(
-                      message ?? "Projection specification didn't match the criteria"
-                    );
-                } finally {
-                  await client.close();
-                }
-              },
-              thenThrows: async (...args) => {
-                const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(
-                  connectionOptions.connectionString,
-                  connectionOptions.clientOptions
-                );
-                const eventStore = getMongoDBEventStore({
-                  projections: projections.inline([projection]),
-                  client
-                });
-                try {
-                  await run(eventStore);
-                  throw new AssertionError("Handler did not fail as expected");
-                } catch (error) {
-                  if (error instanceof AssertionError) throw error;
-                  if (args.length === 0) return;
-                  if (!isErrorConstructor(args[0])) {
-                    assertTrue(
-                      args[0](error),
-                      `Error didn't match the error condition: ${error?.toString()}`
-                    );
-                    return;
-                  }
-                  assertTrue(
-                    error instanceof args[0],
-                    `Caught error is not an instance of the expected type: ${error?.toString()}`
-                  );
-                  if (args[1]) {
-                    assertTrue(
-                      args[1](error),
-                      `Error didn't match the error condition: ${error?.toString()}`
-                    );
-                  }
-                } finally {
-                  await client.close();
-                }
-              }
-            };
-          }
-        };
-      };
-    }
-  }
-};
-var eventInStream = (streamName, event) => ({
-  streamName,
-  events: [event]
+//#endregion
+//#region src/eventStore/projections/mongoDBInlineProjectionSpec.ts
+const MongoDBInlineProjectionSpec = { for: (options) => {
+	{
+		const { projection, ...connectionOptions } = options;
+		return (givenStream) => {
+			const { streamName, events: givenEvents } = givenStream;
+			return { when: (events) => {
+				const allEvents = [...givenEvents, ...events];
+				const run = (eventStore) => eventStore.appendToStream(streamName, allEvents);
+				return {
+					then: async (assert, message) => {
+						const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(connectionOptions.connectionString, connectionOptions.clientOptions);
+						const eventStore = getMongoDBEventStore({
+							projections: projections.inline([projection]),
+							client
+						});
+						try {
+							await run(eventStore);
+							const succeeded = await assert({
+								eventStore,
+								streamName
+							});
+							if (succeeded !== void 0 && succeeded === false) assertFails(message ?? "Projection specification didn't match the criteria");
+						} finally {
+							await client.close();
+						}
+					},
+					thenThrows: async (...args) => {
+						const client = "client" in connectionOptions && connectionOptions.client ? connectionOptions.client : new MongoClient(connectionOptions.connectionString, connectionOptions.clientOptions);
+						const eventStore = getMongoDBEventStore({
+							projections: projections.inline([projection]),
+							client
+						});
+						try {
+							await run(eventStore);
+							throw new AssertionError("Handler did not fail as expected");
+						} catch (error) {
+							if (error instanceof AssertionError) throw error;
+							if (args.length === 0) return;
+							if (!isErrorConstructor(args[0])) {
+								assertTrue(args[0](error), `Error didn't match the error condition: ${error?.toString()}`);
+								return;
+							}
+							assertTrue(error instanceof args[0], `Caught error is not an instance of the expected type: ${error?.toString()}`);
+							if (args[1]) assertTrue(args[1](error), `Error didn't match the error condition: ${error?.toString()}`);
+						} finally {
+							await client.close();
+						}
+					}
+				};
+			} };
+		};
+	}
+} };
+const eventInStream = (streamName, event) => ({
+	streamName,
+	events: [event]
 });
-var eventsInStream = (streamName, events) => ({
-  streamName,
-  events
+const eventsInStream = (streamName, events) => ({
+	streamName,
+	events
 });
-var expectReadModelToMatch = async (options) => {
-  const { streamName, projectionName, eventStore, match } = options;
-  const readModel = await eventStore.projections.inline.findOne({
-    streamName,
-    projectionName
-  });
-  return match(readModel);
-};
-var expectInlineReadModelWithName = (projectionName) => ({
-  toHave: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
-    eventStore,
-    streamName,
-    projectionName,
-    match: (readModel) => isSubset(readModel, expected)
-  }),
-  toDeepEquals: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
-    eventStore,
-    streamName,
-    projectionName,
-    match: (readModel) => deepEquals(readModel, expected)
-  }),
-  toMatch: (match) => ({ eventStore, streamName }) => expectReadModelToMatch({
-    eventStore,
-    streamName,
-    projectionName,
-    match
-  }),
-  notToExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
-    eventStore,
-    streamName,
-    projectionName,
-    match: (readModel) => readModel === null
-  }),
-  toExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
-    eventStore,
-    streamName,
-    projectionName,
-    match: (readModel) => readModel !== null
-  })
+const expectReadModelToMatch = async (options) => {
+	const { streamName, projectionName, eventStore, match } = options;
+	return match(await eventStore.projections.inline.findOne({
+		streamName,
+		projectionName
+	}));
+};
+const expectInlineReadModelWithName = (projectionName) => ({
+	toHave: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
+		eventStore,
+		streamName,
+		projectionName,
+		match: (readModel) => isSubset(readModel, expected)
+	}),
+	toDeepEquals: (expected) => ({ eventStore, streamName }) => expectReadModelToMatch({
+		eventStore,
+		streamName,
+		projectionName,
+		match: (readModel) => deepEquals(readModel, expected)
+	}),
+	toMatch: (match) => ({ eventStore, streamName }) => expectReadModelToMatch({
+		eventStore,
+		streamName,
+		projectionName,
+		match
+	}),
+	notToExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
+		eventStore,
+		streamName,
+		projectionName,
+		match: (readModel) => readModel === null
+	}),
+	toExist: () => ({ eventStore, streamName }) => expectReadModelToMatch({
+		eventStore,
+		streamName,
+		projectionName,
+		match: (readModel) => readModel !== null
+	})
 });
-var expectInlineReadModel = {
-  withName: (name) => expectInlineReadModelWithName(name),
-  ...expectInlineReadModelWithName(MongoDBDefaultInlineProjectionName)
+const expectInlineReadModel = {
+	withName: (name) => expectInlineReadModelWithName(name),
+	...expectInlineReadModelWithName(MongoDBDefaultInlineProjectionName)
 };
 
-// src/eventStore/storage/mongoDBEventStoreStorage.ts
-var DefaultMongoDBEventStoreStorageOptions = "COLLECTION_PER_STREAM_TYPE";
-var DefaultMongoDBEventStoreCollectionName = "emt:streams";
-var resolveCollectionAndDatabase = (streamType, options) => {
-  if (options === "SINGLE_COLLECTION" || typeof options === "object" && options.type === "SINGLE_COLLECTION") {
-    return {
-      collectionName: typeof options === "object" ? options.collectionName ?? DefaultMongoDBEventStoreCollectionName : DefaultMongoDBEventStoreCollectionName,
-      databaseName: typeof options === "object" ? options.databaseName : void 0
-    };
-  } else if (options === "COLLECTION_PER_STREAM_TYPE" || typeof options === "object" && options.type === "COLLECTION_PER_STREAM_TYPE") {
-    return {
-      collectionName: toStreamCollectionName(streamType),
-      databaseName: typeof options === "object" ? options.databaseName : void 0
-    };
-  } else {
-    const result = options.collectionFor(streamType);
-    return {
-      collectionName: typeof result === "object" ? result.collectionName : result,
-      databaseName: typeof result === "object" ? result.databaseName ?? options.databaseName : options.databaseName
-    };
-  }
-};
-var getDB = async (options) => {
-  const { dbsCache, databaseName, getConnectedClient } = options;
-  const safeDbName = databaseName ?? "___default";
-  let db = dbsCache.get(safeDbName);
-  if (!db) {
-    const connectedClient = await getConnectedClient();
-    db = connectedClient.db(databaseName);
-    dbsCache.set(safeDbName, db);
-  }
-  return db;
-};
-var collectionFor = async (options) => {
-  const { collectionName, db, streamCollections } = options;
-  let collection = streamCollections.get(collectionName);
-  if (!collection) {
-    collection = db.collection(collectionName);
-    await collection.createIndex({ streamName: 1 }, { unique: true });
-    streamCollections.set(
-      collectionName,
-      collection
-    );
-  }
-  return collection;
-};
-var mongoDBEventStoreStorage = (options) => {
-  const dbsCache = /* @__PURE__ */ new Map();
-  const streamCollections = /* @__PURE__ */ new Map();
-  const storageOptions = options.storage ?? DefaultMongoDBEventStoreStorageOptions;
-  const { getConnectedClient } = options;
-  return {
-    collectionFor: async (streamType) => {
-      const { collectionName, databaseName } = resolveCollectionAndDatabase(
-        streamType,
-        storageOptions
-      );
-      let collection = streamCollections.get(collectionName);
-      if (!collection) {
-        const db = await getDB({ databaseName, dbsCache, getConnectedClient });
-        collection = await collectionFor({
-          collectionName,
-          streamCollections,
-          db
-        });
-      }
-      return collection;
-    }
-  };
+//#endregion
+//#region src/eventStore/storage/mongoDBEventStoreStorage.ts
+const DefaultMongoDBEventStoreStorageOptions = "COLLECTION_PER_STREAM_TYPE";
+const DefaultMongoDBEventStoreCollectionName = "emt:streams";
+const resolveCollectionAndDatabase = (streamType, options) => {
+	if (options === "SINGLE_COLLECTION" || typeof options === "object" && options.type === "SINGLE_COLLECTION") return {
+		collectionName: typeof options === "object" ? options.collectionName ?? "emt:streams" : DefaultMongoDBEventStoreCollectionName,
+		databaseName: typeof options === "object" ? options.databaseName : void 0
+	};
+	else if (options === "COLLECTION_PER_STREAM_TYPE" || typeof options === "object" && options.type === "COLLECTION_PER_STREAM_TYPE") return {
+		collectionName: toStreamCollectionName(streamType),
+		databaseName: typeof options === "object" ? options.databaseName : void 0
+	};
+	else {
+		const result = options.collectionFor(streamType);
+		return {
+			collectionName: typeof result === "object" ? result.collectionName : result,
+			databaseName: typeof result === "object" ? result.databaseName ?? options.databaseName : options.databaseName
+		};
+	}
+};
+const getDB = async (options) => {
+	const { dbsCache, databaseName, getConnectedClient } = options;
+	const safeDbName = databaseName ?? "___default";
+	let db = dbsCache.get(safeDbName);
+	if (!db) {
+		db = (await getConnectedClient()).db(databaseName);
+		dbsCache.set(safeDbName, db);
+	}
+	return db;
+};
+const collectionFor = async (options) => {
+	const { collectionName, db, streamCollections } = options;
+	let collection = streamCollections.get(collectionName);
+	if (!collection) {
+		collection = db.collection(collectionName);
+		await collection.createIndex({ streamName: 1 }, { unique: true });
+		streamCollections.set(collectionName, collection);
+	}
+	return collection;
+};
+const mongoDBEventStoreStorage = (options) => {
+	const dbsCache = /* @__PURE__ */ new Map();
+	const streamCollections = /* @__PURE__ */ new Map();
+	const storageOptions = options.storage ?? "COLLECTION_PER_STREAM_TYPE";
+	const { getConnectedClient } = options;
+	return { collectionFor: async (streamType) => {
+		const { collectionName, databaseName } = resolveCollectionAndDatabase(streamType, storageOptions);
+		let collection = streamCollections.get(collectionName);
+		if (!collection) collection = await collectionFor({
+			collectionName,
+			streamCollections,
+			db: await getDB({
+				databaseName,
+				dbsCache,
+				getConnectedClient
+			})
+		});
+		return collection;
+	} };
 };
 
-// src/eventStore/mongoDBEventStore.ts
-var MongoDBEventStoreDefaultStreamVersion = 0n;
+//#endregion
+//#region src/eventStore/mongoDBEventStore.ts
+const MongoDBEventStoreDefaultStreamVersion = 0n;
 var MongoDBEventStoreImplementation = class {
-  client;
-  inlineProjections;
-  shouldManageClientLifetime;
-  isClosed = false;
-  storage;
-  options;
-  projections;
-  constructor(options) {
-    this.options = options;
-    this.client = "client" in options && options.client ? options.client : new MongoClient2(options.connectionString, options.clientOptions);
-    this.shouldManageClientLifetime = !("client" in options);
-    this.storage = mongoDBEventStoreStorage({
-      storage: options.storage,
-      getConnectedClient: () => this.getConnectedClient()
-    });
-    this.inlineProjections = filterProjections(
-      "inline",
-      options.projections ?? []
-    );
-    this.projections = {
-      inline: {
-        findOne: this.findOneInlineProjection.bind(this),
-        find: this.findInlineProjection.bind(this),
-        count: this.countInlineProjection.bind(this)
-      }
-    };
-  }
-  async readStream(streamName, options) {
-    const { streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = options?.expectedStreamVersion;
-    const collection = await this.storage.collectionFor(streamType);
-    const filter = {
-      streamName: { $eq: streamName }
-    };
-    const eventsSliceArr = [];
-    if (options && "from" in options) {
-      eventsSliceArr.push(Number(options.from));
-    } else {
-      eventsSliceArr.push(0);
-    }
-    if (options && "to" in options) {
-      eventsSliceArr.push(Number(options.to));
-    }
-    const eventsSlice = eventsSliceArr.length > 1 ? { $slice: eventsSliceArr } : 1;
-    const stream = await collection.findOne(filter, {
-      useBigInt64: true,
-      projection: {
-        metadata: 1,
-        messages: eventsSlice
-      }
-    });
-    if (!stream) {
-      return {
-        events: [],
-        currentStreamVersion: MongoDBEventStoreDefaultStreamVersion,
-        streamExists: false
-      };
-    }
-    assertExpectedVersionMatchesCurrent(
-      stream.metadata.streamPosition,
-      expectedStreamVersion,
-      MongoDBEventStoreDefaultStreamVersion
-    );
-    const events = upcastRecordedMessages(
-      stream.messages,
-      options?.schema?.versioning
-    );
-    return {
-      events,
-      currentStreamVersion: stream.metadata.streamPosition,
-      streamExists: true
-    };
-  }
-  async aggregateStream(streamName, options) {
-    const stream = await this.readStream(
-      streamName,
-      options?.read
-    );
-    const { evolve, initialState } = options;
-    const state = stream.events.reduce(evolve, initialState());
-    return {
-      state,
-      currentStreamVersion: stream.currentStreamVersion,
-      streamExists: stream.streamExists
-    };
-  }
-  async appendToStream(streamName, events, options) {
-    const { streamId, streamType } = fromStreamName(streamName);
-    const expectedStreamVersion = options?.expectedStreamVersion;
-    const collection = await this.storage.collectionFor(streamType);
-    const stream = await collection.findOne(
-      { streamName: { $eq: streamName } },
-      {
-        useBigInt64: true,
-        projection: {
-          "metadata.streamPosition": 1,
-          projections: 1
-        }
-      }
-    );
-    const currentStreamVersion = stream?.metadata.streamPosition ?? MongoDBEventStoreDefaultStreamVersion;
-    assertExpectedVersionMatchesCurrent(
-      currentStreamVersion,
-      expectedStreamVersion,
-      MongoDBEventStoreDefaultStreamVersion
-    );
-    let streamOffset = currentStreamVersion;
-    const eventsToAppend = events.map((event) => {
-      const metadata = {
-        messageId: uuid6(),
-        streamName,
-        streamPosition: ++streamOffset
-      };
-      return downcastRecordedMessage(
-        {
-          type: event.type,
-          data: event.data,
-          metadata: {
-            ...metadata,
-            ..."metadata" in event ? event.metadata ?? {} : {}
-          }
-        },
-        options?.schema?.versioning
-      );
-    });
-    const now = /* @__PURE__ */ new Date();
-    const updates = {
-      $push: { messages: { $each: eventsToAppend } },
-      $set: {
-        "metadata.updatedAt": now,
-        "metadata.streamPosition": currentStreamVersion + BigInt(events.length)
-      },
-      $setOnInsert: {
-        streamName,
-        "metadata.streamId": streamId,
-        "metadata.streamType": streamType,
-        "metadata.createdAt": now
-      }
-    };
-    if (this.inlineProjections) {
-      await handleInlineProjections({
-        readModels: stream?.projections ?? {},
-        streamId,
-        events: eventsToAppend,
-        projections: this.inlineProjections,
-        collection,
-        updates,
-        client: {}
-      });
-    }
-    const updatedStream = await collection.updateOne(
-      {
-        streamName: { $eq: streamName },
-        "metadata.streamPosition": currentStreamVersion
-      },
-      updates,
-      { useBigInt64: true, upsert: true }
-    );
-    if (!updatedStream) {
-      throw new ExpectedVersionConflictError(
-        currentStreamVersion,
-        options?.expectedStreamVersion ?? 0n
-      );
-    }
-    await tryPublishMessagesAfterCommit(
-      eventsToAppend,
-      this.options.hooks
-      // {
-      // TODO: same context as InlineProjectionHandlerContext for mongodb?
-      // },
-    );
-    return {
-      nextExpectedStreamVersion: currentStreamVersion + BigInt(eventsToAppend.length),
-      createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
-    };
-  }
-  async streamExists(streamName) {
-    const { streamType } = fromStreamName(streamName);
-    const collection = await this.storage.collectionFor(streamType);
-    const filter = {
-      streamName: { $eq: streamName }
-    };
-    const count = await collection.countDocuments(filter, {
-      useBigInt64: true,
-      limit: 1
-    });
-    return Boolean(count > 0);
-  }
-  collectionFor = async (streamType) => {
-    return this.storage.collectionFor(streamType);
-  };
-  /**
-   * Gracefully cleans up managed resources by the MongoDBEventStore.
-   * It closes MongoDB client created for the provided connection string
-   * through event store options.
-   *
-   * @memberof Closeable
-   */
-  close = () => {
-    if (this.isClosed) return Promise.resolve();
-    this.isClosed = true;
-    if (!this.shouldManageClientLifetime) return Promise.resolve();
-    return this.client.close();
-  };
-  async findOneInlineProjection(streamFilter, projectionQuery) {
-    const { projectionName, streamName, streamType } = parseSingleProjectionQueryStreamFilter(streamFilter);
-    const collection = await this.storage.collectionFor(streamType);
-    const query = prependMongoFilterWithProjectionPrefix(projectionQuery, `projections.${projectionName}`);
-    const filters = [
-      { [`projections.${projectionName}`]: { $exists: true } }
-    ];
-    if (query) {
-      filters.push(query);
-    }
-    if (streamName) {
-      filters.push({ streamName: { $eq: streamName } });
-    }
-    const result = await collection.findOne(
-      { $and: filters },
-      {
-        useBigInt64: true,
-        projection: { [`projections.${projectionName}`]: 1 }
-      }
-    );
-    return result?.projections?.[projectionName] ?? null;
-  }
-  async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
-    const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
-    if (!parsedStreamFilter) return [];
-    const { projectionName, streamNames, streamType } = parsedStreamFilter;
-    const collection = await this.storage.collectionFor(streamType);
-    const prefix = `projections.${projectionName}`;
-    const projectionFilter = prependMongoFilterWithProjectionPrefix(projectionQuery, prefix);
-    const filters = [
-      { [`projections.${projectionName}`]: { $ne: null } }
-    ];
-    if (projectionFilter) {
-      filters.push(projectionFilter);
-    }
-    if (streamNames) {
-      filters.push({ streamName: { $in: streamNames } });
-    }
-    let query = collection.find(
-      { $and: filters },
-      {
-        useBigInt64: true,
-        projection: { [`projections.${projectionName}`]: 1 }
-      }
-    );
-    if (queryOptions?.skip) {
-      query = query.skip(queryOptions.skip);
-    }
-    if (queryOptions?.limit) {
-      query = query.limit(queryOptions.limit);
-    }
-    if (queryOptions?.sort) {
-      const sort = prependMongoFilterWithProjectionPrefix(
-        queryOptions.sort,
-        prefix
-      );
-      query = query.sort(sort);
-    }
-    const streams = await query.toArray();
-    return streams.map((s) => s.projections[projectionName]).filter((p) => !!p);
-  }
-  async countInlineProjection(streamFilter, projectionQuery) {
-    const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
-    if (!parsedStreamFilter) return 0;
-    const { projectionName, streamNames, streamType } = parsedStreamFilter;
-    const collection = await this.storage.collectionFor(streamType);
-    const prefix = `projections.${projectionName}`;
-    const projectionFilter = prependMongoFilterWithProjectionPrefix(projectionQuery, prefix);
-    const filters = [
-      { [`projections.${projectionName}`]: { $ne: null } }
-    ];
-    if (projectionFilter) {
-      filters.push(projectionFilter);
-    }
-    if (streamNames) {
-      filters.push({ streamName: { $in: streamNames } });
-    }
-    const total = await collection.countDocuments({ $and: filters });
-    return total;
-  }
-  getConnectedClient = async () => {
-    if (!this.isClosed) await this.client.connect();
-    return this.client;
-  };
+	client;
+	inlineProjections;
+	shouldManageClientLifetime;
+	isClosed = false;
+	storage;
+	options;
+	projections;
+	constructor(options) {
+		this.options = options;
+		this.client = "client" in options && options.client ? options.client : new MongoClient(options.connectionString, options.clientOptions);
+		this.shouldManageClientLifetime = !("client" in options);
+		this.storage = mongoDBEventStoreStorage({
+			storage: options.storage,
+			getConnectedClient: () => this.getConnectedClient()
+		});
+		this.inlineProjections = filterProjections("inline", options.projections ?? []);
+		this.projections = { inline: {
+			findOne: this.findOneInlineProjection.bind(this),
+			find: this.findInlineProjection.bind(this),
+			count: this.countInlineProjection.bind(this)
+		} };
+	}
+	async readStream(streamName, options) {
+		const { streamType } = fromStreamName(streamName);
+		const expectedStreamVersion = options?.expectedStreamVersion;
+		const collection = await this.storage.collectionFor(streamType);
+		const filter = { streamName: { $eq: streamName } };
+		const eventsSliceArr = [];
+		if (options && "from" in options) eventsSliceArr.push(Number(options.from));
+		else eventsSliceArr.push(0);
+		if (options && "to" in options) eventsSliceArr.push(Number(options.to));
+		const eventsSlice = eventsSliceArr.length > 1 ? { $slice: eventsSliceArr } : 1;
+		const stream = await collection.findOne(filter, {
+			useBigInt64: true,
+			projection: {
+				metadata: 1,
+				messages: eventsSlice
+			}
+		});
+		if (!stream) return {
+			events: [],
+			currentStreamVersion: MongoDBEventStoreDefaultStreamVersion,
+			streamExists: false
+		};
+		assertExpectedVersionMatchesCurrent(stream.metadata.streamPosition, expectedStreamVersion, MongoDBEventStoreDefaultStreamVersion);
+		return {
+			events: upcastRecordedMessages(stream.messages, options?.schema?.versioning),
+			currentStreamVersion: stream.metadata.streamPosition,
+			streamExists: true
+		};
+	}
+	async aggregateStream(streamName, options) {
+		const stream = await this.readStream(streamName, options?.read);
+		const { evolve, initialState } = options;
+		return {
+			state: stream.events.reduce(evolve, initialState()),
+			currentStreamVersion: stream.currentStreamVersion,
+			streamExists: stream.streamExists
+		};
+	}
+	async appendToStream(streamName, events, options) {
+		const { streamId, streamType } = fromStreamName(streamName);
+		const expectedStreamVersion = options?.expectedStreamVersion;
+		const collection = await this.storage.collectionFor(streamType);
+		const stream = await collection.findOne({ streamName: { $eq: streamName } }, {
+			useBigInt64: true,
+			projection: {
+				"metadata.streamPosition": 1,
+				projections: 1
+			}
+		});
+		const currentStreamVersion = stream?.metadata.streamPosition ?? 0n;
+		assertExpectedVersionMatchesCurrent(currentStreamVersion, expectedStreamVersion, MongoDBEventStoreDefaultStreamVersion);
+		let streamOffset = currentStreamVersion;
+		const eventsToAppend = events.map((event) => {
+			const metadata = {
+				messageId: v4(),
+				streamName,
+				streamPosition: ++streamOffset
+			};
+			return downcastRecordedMessage({
+				type: event.type,
+				data: event.data,
+				metadata: {
+					...metadata,
+					..."metadata" in event ? event.metadata ?? {} : {}
+				}
+			}, options?.schema?.versioning);
+		});
+		const now = /* @__PURE__ */ new Date();
+		const updates = {
+			$push: { messages: { $each: eventsToAppend } },
+			$set: {
+				"metadata.updatedAt": now,
+				"metadata.streamPosition": currentStreamVersion + BigInt(events.length)
+			},
+			$setOnInsert: {
+				streamName,
+				"metadata.streamId": streamId,
+				"metadata.streamType": streamType,
+				"metadata.createdAt": now
+			}
+		};
+		if (this.inlineProjections) await handleInlineProjections({
+			readModels: stream?.projections ?? {},
+			streamId,
+			events: eventsToAppend,
+			projections: this.inlineProjections,
+			collection,
+			updates,
+			client: {}
+		});
+		if (!await collection.updateOne({
+			streamName: { $eq: streamName },
+			"metadata.streamPosition": currentStreamVersion
+		}, updates, {
+			useBigInt64: true,
+			upsert: true
+		})) throw new ExpectedVersionConflictError(currentStreamVersion, options?.expectedStreamVersion ?? 0n);
+		await tryPublishMessagesAfterCommit(eventsToAppend, this.options.hooks);
+		return {
+			nextExpectedStreamVersion: currentStreamVersion + BigInt(eventsToAppend.length),
+			createdNewStream: currentStreamVersion === MongoDBEventStoreDefaultStreamVersion
+		};
+	}
+	async streamExists(streamName) {
+		const { streamType } = fromStreamName(streamName);
+		const collection = await this.storage.collectionFor(streamType);
+		const filter = { streamName: { $eq: streamName } };
+		const count = await collection.countDocuments(filter, {
+			useBigInt64: true,
+			limit: 1
+		});
+		return Boolean(count > 0);
+	}
+	collectionFor = async (streamType) => {
+		return this.storage.collectionFor(streamType);
+	};
+	/**
+	* Gracefully cleans up managed resources by the MongoDBEventStore.
+	* It closes MongoDB client created for the provided connection string
+	* through event store options.
+	*
+	* @memberof Closeable
+	*/
+	close = () => {
+		if (this.isClosed) return Promise.resolve();
+		this.isClosed = true;
+		if (!this.shouldManageClientLifetime) return Promise.resolve();
+		return this.client.close();
+	};
+	async findOneInlineProjection(streamFilter, projectionQuery) {
+		const { projectionName, streamName, streamType } = parseSingleProjectionQueryStreamFilter(streamFilter);
+		const collection = await this.storage.collectionFor(streamType);
+		const query = prependMongoFilterWithProjectionPrefix(projectionQuery, `projections.${projectionName}`);
+		const filters = [{ [`projections.${projectionName}`]: { $exists: true } }];
+		if (query) filters.push(query);
+		if (streamName) filters.push({ streamName: { $eq: streamName } });
+		return (await collection.findOne({ $and: filters }, {
+			useBigInt64: true,
+			projection: { [`projections.${projectionName}`]: 1 }
+		}))?.projections?.[projectionName] ?? null;
+	}
+	async findInlineProjection(streamFilter, projectionQuery, queryOptions) {
+		const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
+		if (!parsedStreamFilter) return [];
+		const { projectionName, streamNames, streamType } = parsedStreamFilter;
+		const collection = await this.storage.collectionFor(streamType);
+		const prefix = `projections.${projectionName}`;
+		const projectionFilter = prependMongoFilterWithProjectionPrefix(projectionQuery, prefix);
+		const filters = [{ [`projections.${projectionName}`]: { $ne: null } }];
+		if (projectionFilter) filters.push(projectionFilter);
+		if (streamNames) filters.push({ streamName: { $in: streamNames } });
+		let query = collection.find({ $and: filters }, {
+			useBigInt64: true,
+			projection: { [`projections.${projectionName}`]: 1 }
+		});
+		if (queryOptions?.skip) query = query.skip(queryOptions.skip);
+		if (queryOptions?.limit) query = query.limit(queryOptions.limit);
+		if (queryOptions?.sort) {
+			const sort = prependMongoFilterWithProjectionPrefix(queryOptions.sort, prefix);
+			query = query.sort(sort);
+		}
+		return (await query.toArray()).map((s) => s.projections[projectionName]).filter((p) => !!p);
+	}
+	async countInlineProjection(streamFilter, projectionQuery) {
+		const parsedStreamFilter = parseMultiProjectionQueryStreamFilter(streamFilter);
+		if (!parsedStreamFilter) return 0;
+		const { projectionName, streamNames, streamType } = parsedStreamFilter;
+		const collection = await this.storage.collectionFor(streamType);
+		const projectionFilter = prependMongoFilterWithProjectionPrefix(projectionQuery, `projections.${projectionName}`);
+		const filters = [{ [`projections.${projectionName}`]: { $ne: null } }];
+		if (projectionFilter) filters.push(projectionFilter);
+		if (streamNames) filters.push({ streamName: { $in: streamNames } });
+		return await collection.countDocuments({ $and: filters });
+	}
+	getConnectedClient = async () => {
+		if (!this.isClosed) await this.client.connect();
+		return this.client;
+	};
 };
 function parseSingleProjectionQueryStreamFilter(streamFilter) {
-  const projectionName = streamFilter.projectionName ?? MongoDBDefaultInlineProjectionName;
-  if ("streamName" in streamFilter) {
-    const { streamType } = fromStreamName(streamFilter.streamName);
-    return {
-      projectionName,
-      streamName: streamFilter.streamName,
-      streamType
-    };
-  }
-  if (streamFilter.streamId) {
-    const streamName = toStreamName(
-      streamFilter.streamType,
-      streamFilter.streamId
-    );
-    return {
-      projectionName,
-      streamName,
-      streamType: streamFilter.streamType
-    };
-  }
-  return {
-    projectionName,
-    streamType: streamFilter.streamType
-  };
+	const projectionName = streamFilter.projectionName ?? "_default";
+	if ("streamName" in streamFilter) {
+		const { streamType } = fromStreamName(streamFilter.streamName);
+		return {
+			projectionName,
+			streamName: streamFilter.streamName,
+			streamType
+		};
+	}
+	if (streamFilter.streamId) return {
+		projectionName,
+		streamName: toStreamName(streamFilter.streamType, streamFilter.streamId),
+		streamType: streamFilter.streamType
+	};
+	return {
+		projectionName,
+		streamType: streamFilter.streamType
+	};
 }
 function parseMultiProjectionQueryStreamFilter(streamFilter) {
-  const projectionName = streamFilter.projectionName ?? MongoDBDefaultInlineProjectionName;
-  if ("streamNames" in streamFilter) {
-    if (streamFilter.streamNames.length == 0) return null;
-    const { streamType } = fromStreamName(streamFilter.streamNames[0]);
-    return {
-      projectionName,
-      streamNames: streamFilter.streamNames,
-      streamType
-    };
-  }
-  if (streamFilter.streamIds && streamFilter.streamIds.length > 0) {
-    const streamNames = streamFilter.streamIds.map(
-      (id) => toStreamName(streamFilter.streamType, id)
-    );
-    return {
-      projectionName,
-      streamNames,
-      streamType: streamFilter.streamType
-    };
-  }
-  return {
-    projectionName,
-    streamType: streamFilter.streamType
-  };
+	const projectionName = streamFilter.projectionName ?? "_default";
+	if ("streamNames" in streamFilter) {
+		if (streamFilter.streamNames.length == 0) return null;
+		const { streamType } = fromStreamName(streamFilter.streamNames[0]);
+		return {
+			projectionName,
+			streamNames: streamFilter.streamNames,
+			streamType
+		};
+	}
+	if (streamFilter.streamIds && streamFilter.streamIds.length > 0) return {
+		projectionName,
+		streamNames: streamFilter.streamIds.map((id) => toStreamName(streamFilter.streamType, id)),
+		streamType: streamFilter.streamType
+	};
+	return {
+		projectionName,
+		streamType: streamFilter.streamType
+	};
 }
+/**
+* Prepends `prefix` to all object keys that don't start with a '$'
+*/
 function prependMongoFilterWithProjectionPrefix(obj, prefix) {
-  if (typeof obj !== "object" || obj === null || obj === void 0) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    for (let i = 0; i < obj.length; i++) {
-      obj[i] = prependMongoFilterWithProjectionPrefix(obj[i], prefix);
-    }
-    return obj;
-  }
-  for (const key in obj) {
-    const k = addProjectionPrefixToMongoKey(key, prefix);
-    if (k !== key) {
-      obj[k] = obj[key];
-      delete obj[key];
-    }
-    obj[k] = prependMongoFilterWithProjectionPrefix(obj[k], prefix);
-  }
-  return obj;
+	if (typeof obj !== "object" || obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) {
+		for (let i = 0; i < obj.length; i++) obj[i] = prependMongoFilterWithProjectionPrefix(obj[i], prefix);
+		return obj;
+	}
+	for (const key in obj) {
+		const k = addProjectionPrefixToMongoKey(key, prefix);
+		if (k !== key) {
+			obj[k] = obj[key];
+			delete obj[key];
+		}
+		obj[k] = prependMongoFilterWithProjectionPrefix(obj[k], prefix);
+	}
+	return obj;
 }
 function addProjectionPrefixToMongoKey(key, prefix) {
-  if (key[0] === "$") {
-    return key;
-  }
-  return `${prefix}${key.length > 0 ? "." : ""}${key}`;
+	if (key[0] === "$") return key;
+	return `${prefix}${key.length > 0 ? "." : ""}${key}`;
 }
 function getMongoDBEventStore(options) {
-  const impl = new MongoDBEventStoreImplementation(options);
-  if ("client" in options && "close" in impl) {
-    delete impl.close;
-  }
-  return impl;
+	const impl = new MongoDBEventStoreImplementation(options);
+	if ("client" in options && "close" in impl) delete impl.close;
+	return impl;
 }
+/**
+* Accepts a `streamType` (the type/category of the event stream) and an `streamId`
+* (the individual entity/object or aggregate ID) and combines them to a singular
+* `streamName` which can be used in `EventStore`.
+*/
 function toStreamName(streamType, streamId) {
-  return `${streamType}:${streamId}`;
+	return `${streamType}:${streamId}`;
 }
+/**
+* Accepts a fully formatted `streamName` and returns the broken down
+* `streamType` and `streamId`.
+*/
 function fromStreamName(streamName) {
-  const parts = streamName.split(":");
-  return {
-    streamType: parts[0],
-    streamId: parts[1]
-  };
+	const parts = streamName.split(":");
+	return {
+		streamType: parts[0],
+		streamId: parts[1]
+	};
 }
+/**
+* Accepts a `streamType` (the type/category of the event stream)
+* and combines them to a `collectionName` which can be used in `EventStore`.
+*/
 function toStreamCollectionName(streamType) {
-  return `emt:${streamType}`;
+	return `emt:${streamType}`;
 }
+/**
+* Accepts a fully formatted `streamCollectionName` and returns the parsed `streamType`.
+*/
 function fromStreamCollectionName(streamCollectionName) {
-  const parts = streamCollectionName.split(":");
-  return {
-    streamType: parts[1]
-  };
+	return { streamType: streamCollectionName.split(":")[1] };
 }
-export {
-  DefaultMongoDBEventStoreCollectionName,
-  DefaultMongoDBEventStoreStorageOptions,
-  MongoDBDefaultInlineProjectionName,
-  MongoDBEventStoreDefaultStreamVersion,
-  MongoDBInlineProjectionSpec,
-  eventInStream,
-  eventsInStream,
-  expectInlineReadModel,
-  fromStreamCollectionName,
-  fromStreamName,
-  getMongoDBEventStore,
-  handleInlineProjections,
-  mongoDBEventStoreStorage,
-  mongoDBInlineProjection,
-  prependMongoFilterWithProjectionPrefix,
-  toStreamCollectionName,
-  toStreamName
-};
+
+//#endregion
+export { DefaultMongoDBEventStoreCollectionName, DefaultMongoDBEventStoreStorageOptions, MongoDBDefaultInlineProjectionName, MongoDBEventStoreDefaultStreamVersion, MongoDBInlineProjectionSpec, eventInStream, eventsInStream, expectInlineReadModel, fromStreamCollectionName, fromStreamName, getMongoDBEventStore, handleInlineProjections, mongoDBEventStoreStorage, mongoDBInlineProjection, prependMongoFilterWithProjectionPrefix, toStreamCollectionName, toStreamName };
 //# sourceMappingURL=index.js.map