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

package/dist/index.js

@@ -1,1240 +1,251 @@
-// src/index.ts
 import "express-async-errors";
-
-// src/application.ts
 import express, { Router } from "express";
-import "express-async-errors";
 import http from "http";
-
-// ../emmett/dist/chunk-AZDDB5SF.js
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var EmmettError = class _EmmettError extends Error {
-  static Codes = {
-    ValidationError: 400,
-    IllegalStateError: 403,
-    NotFoundError: 404,
-    ConcurrencyError: 412,
-    InternalServerError: 500
-  };
-  errorCode;
-  constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _EmmettError.Codes.InternalServerError;
-    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
-    super(message);
-    this.errorCode = errorCode;
-    Object.setPrototypeOf(this, _EmmettError.prototype);
-  }
-  static mapFrom(error) {
-    if (_EmmettError.isInstanceOf(error)) {
-      return error;
-    }
-    return new _EmmettError({
-      errorCode: "errorCode" in error && error.errorCode !== void 0 && error.errorCode !== null ? error.errorCode : _EmmettError.Codes.InternalServerError,
-      message: error.message ?? "An unknown error occurred"
-    });
-  }
-  static isInstanceOf(error, errorCode) {
-    return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
-  }
-};
-var ConcurrencyError = class _ConcurrencyError extends EmmettError {
-  constructor(current, expected, message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: message ?? `Expected version ${expected.toString()} does not match current ${current?.toString()}`
-    });
-    this.current = current;
-    this.expected = expected;
-    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
-  }
-};
-var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError extends EmmettError {
-  constructor(message) {
-    super({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: message ?? `Expected document state does not match current one!`
-    });
-    Object.setPrototypeOf(this, _ConcurrencyInMemoryDatabaseError.prototype);
-  }
-};
-
-// ../emmett/dist/index.js
-import { v4 as uuid5 } from "uuid";
-import { v7 as uuid2 } from "uuid";
-import { v7 as uuid } from "uuid";
-import retry from "async-retry";
-import { v7 as uuid3 } from "uuid";
-import { v4 as uuid4 } from "uuid";
-import { v7 as uuid6 } 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 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(context?.source ?? value.toString());
-    } catch {
-      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 {
-        }
-      }
-    }
-  }
-  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(
-  opts?.replacer,
-  opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0,
-  opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0
-);
-var JSONReviver = (opts) => composeJSONRevivers(
-  opts?.reviver,
-  opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0,
-  opts?.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) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer)
-});
-var textEncoder = new TextEncoder();
-var isGeneralExpectedDocumentVersion = (version) => {
-  return version === "DOCUMENT_DOES_NOT_EXIST" || version === "DOCUMENT_EXISTS" || version === "NO_CONCURRENCY_CHECK";
-};
-var expectedVersionValue = (version) => version === void 0 || isGeneralExpectedDocumentVersion(version) ? null : version;
-var operationResult = (result, options) => {
-  const operationResult2 = {
-    ...result,
-    acknowledged: true,
-    successful: result.successful,
-    assertSuccessful: (errorMessage) => {
-      const { successful } = result;
-      const { operationName, collectionName } = options;
-      if (!successful)
-        throw new ConcurrencyInMemoryDatabaseError(
-          errorMessage ?? `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`
-        );
-    }
-  };
-  if (options.errors?.throwOnOperationFailures)
-    operationResult2.assertSuccessful();
-  return operationResult2;
-};
-var getInMemoryDatabase = () => {
-  const storage = /* @__PURE__ */ new Map();
-  return {
-    collection: (collectionName, collectionOptions = {}) => {
-      const ensureCollectionCreated = () => {
-        if (!storage.has(collectionName)) storage.set(collectionName, []);
-      };
-      const errors = collectionOptions.errors;
-      const collection = {
-        collectionName,
-        insertOne: async (document) => {
-          ensureCollectionCreated();
-          const _id = document._id ?? uuid2();
-          const _version = document._version ?? 1n;
-          const existing = await collection.findOne((c) => c._id === _id);
-          if (existing) {
-            return operationResult(
-              {
-                successful: false,
-                insertedId: null,
-                nextExpectedVersion: _version
-              },
-              { operationName: "insertOne", collectionName, errors }
-            );
-          }
-          const documentsInCollection = storage.get(collectionName);
-          const newDocument = { ...document, _id, _version };
-          const newCollection = [...documentsInCollection, newDocument];
-          storage.set(collectionName, newCollection);
-          return operationResult(
-            {
-              successful: true,
-              insertedId: _id,
-              nextExpectedVersion: _version
-            },
-            { operationName: "insertOne", collectionName, errors }
-          );
-        },
-        findOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          const firstOne = filteredDocuments?.[0] ?? null;
-          return Promise.resolve(firstOne);
-        },
-        find: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const filteredDocuments = predicate ? documentsInCollection?.filter((doc) => predicate(doc)) : documentsInCollection;
-          return Promise.resolve(filteredDocuments);
-        },
-        deleteOne: (predicate) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          if (predicate) {
-            const foundIndex = documentsInCollection.findIndex(
-              (doc) => predicate(doc)
-            );
-            if (foundIndex === -1) {
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: false,
-                    matchedCount: 0,
-                    deletedCount: 0
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            } else {
-              const newCollection2 = documentsInCollection.toSpliced(
-                foundIndex,
-                1
-              );
-              storage.set(collectionName, newCollection2);
-              return Promise.resolve(
-                operationResult(
-                  {
-                    successful: true,
-                    matchedCount: 1,
-                    deletedCount: 1
-                  },
-                  { operationName: "deleteOne", collectionName, errors }
-                )
-              );
-            }
-          }
-          const newCollection = documentsInCollection.slice(1);
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                matchedCount: 1,
-                deletedCount: 1
-              },
-              { operationName: "deleteOne", collectionName, errors }
-            )
-          );
-        },
-        replaceOne: (predicate, document, options) => {
-          ensureCollectionCreated();
-          const documentsInCollection = storage.get(collectionName);
-          const firstIndex = documentsInCollection.findIndex(
-            (doc) => predicate(doc)
-          );
-          if (firstIndex === void 0 || firstIndex === -1) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 0,
-                  modifiedCount: 0,
-                  nextExpectedVersion: 0n
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const existing = documentsInCollection[firstIndex];
-          if (typeof options?.expectedVersion === "bigint" && existing._version !== options.expectedVersion) {
-            return Promise.resolve(
-              operationResult(
-                {
-                  successful: false,
-                  matchedCount: 1,
-                  modifiedCount: 0,
-                  nextExpectedVersion: existing._version
-                },
-                { operationName: "replaceOne", collectionName, errors }
-              )
-            );
-          }
-          const newVersion = existing._version + 1n;
-          const newCollection = documentsInCollection.with(firstIndex, {
-            _id: existing._id,
-            ...document,
-            _version: newVersion
-          });
-          storage.set(collectionName, newCollection);
-          return Promise.resolve(
-            operationResult(
-              {
-                successful: true,
-                modifiedCount: 1,
-                matchedCount: firstIndex,
-                nextExpectedVersion: newVersion
-              },
-              { operationName: "replaceOne", collectionName, errors }
-            )
-          );
-        },
-        handle: async (id, handle, options) => {
-          const { expectedVersion: version, ...operationOptions } = options ?? {};
-          ensureCollectionCreated();
-          const existing = await collection.findOne(({ _id }) => _id === id);
-          const expectedVersion = expectedVersionValue(version);
-          if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion !== null && existing._version !== expectedVersion) {
-            return operationResult(
-              {
-                successful: false,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          }
-          const result = handle(existing !== null ? { ...existing } : null);
-          if (deepEquals(existing, result))
-            return operationResult(
-              {
-                successful: true,
-                document: existing
-              },
-              { operationName: "handle", collectionName, errors }
-            );
-          if (!existing && result) {
-            const newDoc = { ...result, _id: id };
-            const insertResult = await collection.insertOne({
-              ...newDoc,
-              _id: id
-            });
-            return {
-              ...insertResult,
-              document: {
-                ...newDoc,
-                _version: insertResult.nextExpectedVersion
-              }
-            };
-          }
-          if (existing && !result) {
-            const deleteResult = await collection.deleteOne(
-              ({ _id }) => id === _id
-            );
-            return { ...deleteResult, document: null };
-          }
-          if (existing && result) {
-            const replaceResult = await collection.replaceOne(
-              ({ _id }) => id === _id,
-              result,
-              {
-                ...operationOptions,
-                expectedVersion: expectedVersion ?? "DOCUMENT_EXISTS"
-              }
-            );
-            return {
-              ...replaceResult,
-              document: {
-                ...result,
-                _version: replaceResult.nextExpectedVersion
-              }
-            };
-          }
-          return operationResult(
-            {
-              successful: true,
-              document: existing
-            },
-            { operationName: "handle", collectionName, errors }
-          );
-        }
-      };
-      return collection;
-    }
-  };
-};
-var bigIntProcessorCheckpoint = (value) => bigInt.toNormalizedString(value);
-var handleInMemoryProjections = async (options) => {
-  const { projections: projections2, events, database, eventStore } = options;
-  const eventTypes = events.map((e) => e.type);
-  const relevantProjections = projections2.filter(
-    (p) => p.canHandle.some((type) => eventTypes.includes(type))
-  );
-  for (const projection2 of relevantProjections) {
-    await projection2.handle(events, {
-      eventStore,
-      database
-    });
-  }
-};
-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?");
-};
-var assertMatches = (actual, expected, message2) => {
-  if (!isSubset(actual, expected))
-    throw new AssertionError(
-      message2 ?? `subObj:
-${JSONSerializer.serialize(expected)}
-is not subset of
-${JSONSerializer.serialize(actual)}`
-    );
-};
-function assertOk(obj, message2) {
-  if (!obj) throw new AssertionError(message2 ?? `Condition is not truthy`);
-}
-function assertEqual(expected, actual, message2) {
-  if (expected !== actual)
-    throw new AssertionError(
-      `${message2 ?? "Objects are not equal"}:
-Expected: ${JSONSerializer.serialize(expected)}
-Actual: ${JSONSerializer.serialize(actual)}`
-    );
-}
-var WrapEventStore = (eventStore) => {
-  const appendedEvents = /* @__PURE__ */ new Map();
-  const wrapped = {
-    ...eventStore,
-    aggregateStream(streamName, options) {
-      return eventStore.aggregateStream(streamName, options);
-    },
-    async readStream(streamName, options) {
-      return await eventStore.readStream(
-        streamName,
-        options
-      );
-    },
-    appendToStream: async (streamName, events, options) => {
-      const result = await eventStore.appendToStream(
-        streamName,
-        events,
-        options
-      );
-      const currentStream = appendedEvents.get(streamName) ?? [streamName, []];
-      appendedEvents.set(streamName, [
-        streamName,
-        [...currentStream[1], ...events]
-      ]);
-      return result;
-    },
-    appendedEvents,
-    setup: async (streamName, events) => {
-      return eventStore.appendToStream(streamName, events);
-    }
-    // streamEvents: (): ReadableStream<
-    //   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-    //   ReadEvent<Event, ReadEventMetadataType> | GlobalSubscriptionEvent
-    // > => {
-    //   return eventStore.streamEvents();
-    // },
-  };
-  return wrapped;
-};
-var downcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.downcast)
-    return recordedMessage;
-  const downcasted = options.downcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: downcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in downcasted ? downcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var downcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.downcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
-  );
-};
-var upcastRecordedMessage = (recordedMessage, options) => {
-  if (!options?.upcast)
-    return recordedMessage;
-  const upcasted = options.upcast(
-    recordedMessage
-  );
-  return {
-    ...recordedMessage,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    data: upcasted.data,
-    ..."metadata" in recordedMessage || "metadata" in upcasted ? {
-      metadata: {
-        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
-        ..."metadata" in upcasted ? upcasted.metadata : {}
-      }
-    } : {}
-  };
-};
-var upcastRecordedMessages = (recordedMessages, options) => {
-  if (!options?.upcast)
-    return recordedMessages;
-  return recordedMessages.map(
-    (recordedMessage) => upcastRecordedMessage(recordedMessage, options)
-  );
-};
-var InMemoryEventStoreDefaultStreamVersion = 0n;
-var getInMemoryEventStore = (eventStoreOptions) => {
-  const streams = /* @__PURE__ */ new Map();
-  const getAllEventsCount = () => {
-    return Array.from(streams.values()).map((s) => s.length).reduce((p, c) => p + c, 0);
-  };
-  const database = eventStoreOptions?.database || getInMemoryDatabase();
-  const inlineProjections2 = (eventStoreOptions?.projections ?? []).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
-  const eventStore = {
-    database,
-    async aggregateStream(streamName, options) {
-      const { evolve, initialState, read } = options;
-      const result = await this.readStream(
-        streamName,
-        read
-      );
-      const events = result?.events ?? [];
-      const state = events.reduce((s, e) => evolve(s, e), initialState());
-      return {
-        currentStreamVersion: BigInt(events.length),
-        state,
-        streamExists: result.streamExists
-      };
-    },
-    readStream: (streamName, readOptions) => {
-      const events = streams.get(streamName);
-      const currentStreamVersion = events ? BigInt(events.length) : InMemoryEventStoreDefaultStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        readOptions?.expectedStreamVersion,
-        InMemoryEventStoreDefaultStreamVersion
-      );
-      const from = Number(readOptions?.from ?? 0);
-      const to = Number(
-        readOptions?.to ?? (readOptions?.maxCount ? (readOptions.from ?? 0n) + readOptions.maxCount : events?.length ?? 1)
-      );
-      const resultEvents = events !== void 0 && events.length > 0 ? upcastRecordedMessages(
-        events.slice(from, to),
-        readOptions?.schema?.versioning
-      ) : [];
-      const result = {
-        currentStreamVersion,
-        events: resultEvents,
-        streamExists: events !== void 0 && events.length > 0
-      };
-      return Promise.resolve(result);
-    },
-    appendToStream: async (streamName, events, options) => {
-      const currentEvents = streams.get(streamName) ?? [];
-      const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
-      assertExpectedVersionMatchesCurrent(
-        currentStreamVersion,
-        options?.expectedStreamVersion,
-        InMemoryEventStoreDefaultStreamVersion
-      );
-      const newEvents = events.map((event2, index) => {
-        const globalPosition = BigInt(getAllEventsCount() + index + 1);
-        const metadata = {
-          streamName,
-          messageId: uuid5(),
-          streamPosition: BigInt(currentEvents.length + index + 1),
-          globalPosition,
-          checkpoint: bigIntProcessorCheckpoint(globalPosition)
-        };
-        return {
-          ...event2,
-          kind: event2.kind ?? "Event",
-          metadata: {
-            ..."metadata" in event2 ? event2.metadata ?? {} : {},
-            ...metadata
-          }
-        };
-      });
-      const positionOfLastEventInTheStream = BigInt(
-        newEvents.slice(-1)[0].metadata.streamPosition
-      );
-      streams.set(streamName, [
-        ...currentEvents,
-        ...downcastRecordedMessages(newEvents, options?.schema?.versioning)
-      ]);
-      if (inlineProjections2.length > 0) {
-        await handleInMemoryProjections({
-          projections: inlineProjections2,
-          events: newEvents,
-          database: eventStore.database,
-          eventStore
-        });
-      }
-      const result = {
-        nextExpectedStreamVersion: positionOfLastEventInTheStream,
-        createdNewStream: currentStreamVersion === InMemoryEventStoreDefaultStreamVersion
-      };
-      await tryPublishMessagesAfterCommit(
-        newEvents,
-        eventStoreOptions?.hooks
-      );
-      return result;
-    },
-    streamExists: (streamName) => {
-      const events = streams.get(streamName);
-      return Promise.resolve(events !== void 0 && events.length > 0);
-    }
-  };
-  return eventStore;
-};
-
-// src/middlewares/problemDetailsMiddleware.ts
+import { EmmettError, WrapEventStore, assertEqual, assertFails, assertMatches, getInMemoryEventStore, isNumber } from "@event-driven-io/emmett";
 import { ProblemDocument } from "http-problem-details";
-var problemDetailsMiddleware = (mapError) => (error, request, response, _next) => {
-  let problemDetails;
-  if (mapError) problemDetails = mapError(error, request);
-  problemDetails = problemDetails ?? defaultErrorToProblemDetailsMapping(error);
-  sendProblem(response, problemDetails.status, { problem: problemDetails });
-};
-var defaultErrorToProblemDetailsMapping = (error) => {
-  let statusCode = 500;
-  if ("errorCode" in error && isNumber(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) {
-    statusCode = error.errorCode;
-  }
-  return new ProblemDocument({
-    detail: error.message,
-    status: statusCode
-  });
-};
+import supertest from "supertest";
+import assert from "assert";
 
-// src/application.ts
-var getApplication = (options) => {
-  const app = express();
-  const {
-    apis,
-    mapError,
-    enableDefaultExpressEtag,
-    disableJsonMiddleware,
-    disableUrlEncodingMiddleware,
-    disableProblemDetailsMiddleware
-  } = options;
-  const router = Router();
-  app.set("etag", enableDefaultExpressEtag ?? false);
-  if (!disableJsonMiddleware) app.use(express.json());
-  if (!disableUrlEncodingMiddleware)
-    app.use(
-      express.urlencoded({
-        extended: true
-      })
-    );
-  for (const api of apis) {
-    api(router);
-  }
-  app.use(router);
-  if (!disableProblemDetailsMiddleware)
-    app.use(problemDetailsMiddleware(mapError));
-  return app;
-};
-var startAPI = (app, options = { port: 3e3 }) => {
-  const { port } = options;
-  const server = http.createServer(app);
-  server.on("listening", () => {
-    console.info("server up listening");
-  });
-  return server.listen(port);
+//#region src/middlewares/problemDetailsMiddleware.ts
+const problemDetailsMiddleware = (mapError) => (error, request, response, _next) => {
+	let problemDetails;
+	if (mapError) problemDetails = mapError(error, request);
+	problemDetails = problemDetails ?? defaultErrorToProblemDetailsMapping(error);
+	sendProblem(response, problemDetails.status, { problem: problemDetails });
+};
+const defaultErrorToProblemDetailsMapping = (error) => {
+	let statusCode = 500;
+	if ("errorCode" in error && isNumber(error.errorCode) && error.errorCode >= 100 && error.errorCode < 600) statusCode = error.errorCode;
+	return new ProblemDocument({
+		detail: error.message,
+		status: statusCode
+	});
 };
 
-// src/etag.ts
-var HeaderNames = {
-  IF_MATCH: "if-match",
-  IF_NOT_MATCH: "if-not-match",
-  ETag: "etag"
+//#endregion
+//#region src/application.ts
+const getApplication = (options) => {
+	const app = express();
+	const { apis, mapError, enableDefaultExpressEtag, disableJsonMiddleware, disableUrlEncodingMiddleware, disableProblemDetailsMiddleware } = options;
+	const router = Router();
+	app.set("etag", enableDefaultExpressEtag ?? false);
+	if (!disableJsonMiddleware) app.use(express.json());
+	if (!disableUrlEncodingMiddleware) app.use(express.urlencoded({ extended: true }));
+	for (const api of apis) api(router);
+	app.use(router);
+	if (!disableProblemDetailsMiddleware) app.use(problemDetailsMiddleware(mapError));
+	return app;
+};
+const startAPI = (app, options = { port: 3e3 }) => {
+	const { port } = options;
+	const server = http.createServer(app);
+	server.on("listening", () => {
+		console.info("server up listening");
+	});
+	return server.listen(port);
 };
-var WeakETagRegex = /W\/"(-?\d+.*)"/;
-var ETagErrors = /* @__PURE__ */ ((ETagErrors2) => {
-  ETagErrors2["WRONG_WEAK_ETAG_FORMAT"] = "WRONG_WEAK_ETAG_FORMAT";
-  ETagErrors2["MISSING_IF_MATCH_HEADER"] = "MISSING_IF_MATCH_HEADER";
-  ETagErrors2["MISSING_IF_NOT_MATCH_HEADER"] = "MISSING_IF_NOT_MATCH_HEADER";
-  return ETagErrors2;
-})(ETagErrors || {});
-var isWeakETag = (etag) => {
-  return WeakETagRegex.test(etag);
-};
-var getWeakETagValue = (etag) => {
-  const result = WeakETagRegex.exec(etag);
-  if (result === null || result.length === 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "WRONG_WEAK_ETAG_FORMAT" /* WRONG_WEAK_ETAG_FORMAT */
-    });
-  }
-  return result[1];
-};
-var toWeakETag = (value) => {
-  return `W/"${value}"`;
-};
-var getETagFromIfMatch = (request) => {
-  const etag = request.headers[HeaderNames.IF_MATCH];
-  if (etag === void 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "MISSING_IF_MATCH_HEADER" /* MISSING_IF_MATCH_HEADER */
-    });
-  }
-  return etag;
-};
-var getETagFromIfNotMatch = (request) => {
-  const etag = request.headers[HeaderNames.IF_NOT_MATCH];
-  if (etag === void 0) {
-    throw new EmmettError({
-      errorCode: EmmettError.Codes.ConcurrencyError,
-      message: "MISSING_IF_NOT_MATCH_HEADER" /* MISSING_IF_NOT_MATCH_HEADER */
-    });
-  }
-  return Array.isArray(etag) ? etag[0] : etag;
-};
-var setETag = (response, etag) => {
-  response.setHeader(HeaderNames.ETag, etag);
-};
-var getETagValueFromIfMatch = (request) => {
-  const eTagValue = getETagFromIfMatch(request);
-  return isWeakETag(eTagValue) ? getWeakETagValue(eTagValue) : eTagValue;
+
+//#endregion
+//#region src/etag.ts
+const HeaderNames = {
+	IF_MATCH: "if-match",
+	IF_NOT_MATCH: "if-not-match",
+	ETag: "etag"
+};
+const WeakETagRegex = /W\/"(-?\d+.*)"/;
+let ETagErrors = /* @__PURE__ */ function(ETagErrors) {
+	ETagErrors["WRONG_WEAK_ETAG_FORMAT"] = "WRONG_WEAK_ETAG_FORMAT";
+	ETagErrors["MISSING_IF_MATCH_HEADER"] = "MISSING_IF_MATCH_HEADER";
+	ETagErrors["MISSING_IF_NOT_MATCH_HEADER"] = "MISSING_IF_NOT_MATCH_HEADER";
+	return ETagErrors;
+}({});
+const isWeakETag = (etag) => {
+	return WeakETagRegex.test(etag);
+};
+const getWeakETagValue = (etag) => {
+	const result = WeakETagRegex.exec(etag);
+	if (result === null || result.length === 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "WRONG_WEAK_ETAG_FORMAT"
+	});
+	return result[1];
+};
+const toWeakETag = (value) => {
+	return `W/"${value}"`;
+};
+const getETagFromIfMatch = (request) => {
+	const etag = request.headers[HeaderNames.IF_MATCH];
+	if (etag === void 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "MISSING_IF_MATCH_HEADER"
+	});
+	return etag;
+};
+const getETagFromIfNotMatch = (request) => {
+	const etag = request.headers[HeaderNames.IF_NOT_MATCH];
+	if (etag === void 0) throw new EmmettError({
+		errorCode: EmmettError.Codes.ConcurrencyError,
+		message: "MISSING_IF_NOT_MATCH_HEADER"
+	});
+	return Array.isArray(etag) ? etag[0] : etag;
+};
+const setETag = (response, etag) => {
+	response.setHeader(HeaderNames.ETag, etag);
+};
+const getETagValueFromIfMatch = (request) => {
+	const eTagValue = getETagFromIfMatch(request);
+	return isWeakETag(eTagValue) ? getWeakETagValue(eTagValue) : eTagValue;
 };
 
-// src/handler.ts
-var on = (handle) => async (request, response, _next) => {
-  const setResponse = await Promise.resolve(handle(request));
-  return setResponse(response);
+//#endregion
+//#region src/handler.ts
+const on = (handle) => async (request, response, _next) => {
+	return (await Promise.resolve(handle(request)))(response);
 };
-var OK = (options) => (response) => {
-  send(response, 200, options);
+const OK = (options) => (response) => {
+	send(response, 200, options);
 };
-var Created = (options) => (response) => {
-  sendCreated(response, options);
+const Created = (options) => (response) => {
+	sendCreated(response, options);
 };
-var Accepted = (options) => (response) => {
-  sendAccepted(response, options);
+const Accepted = (options) => (response) => {
+	sendAccepted(response, options);
 };
-var NoContent = (options) => HttpResponse(204, options);
-var HttpResponse = (statusCode, options) => (response) => {
-  send(response, statusCode, options);
+const NoContent = (options) => HttpResponse(204, options);
+const HttpResponse = (statusCode, options) => (response) => {
+	send(response, statusCode, options);
 };
-var BadRequest = (options) => HttpProblem(400, options);
-var Forbidden = (options) => HttpProblem(403, options);
-var NotFound = (options) => HttpProblem(404, options);
-var Conflict = (options) => HttpProblem(409, options);
-var PreconditionFailed = (options) => HttpProblem(412, options);
-var HttpProblem = (statusCode, options) => (response) => {
-  sendProblem(response, statusCode, options);
+const BadRequest = (options) => HttpProblem(400, options);
+const Forbidden = (options) => HttpProblem(403, options);
+const NotFound = (options) => HttpProblem(404, options);
+const Conflict = (options) => HttpProblem(409, options);
+const PreconditionFailed = (options) => HttpProblem(412, options);
+const HttpProblem = (statusCode, options) => (response) => {
+	sendProblem(response, statusCode, options);
 };
 
-// src/responses.ts
-import { ProblemDocument as ProblemDocument2 } from "http-problem-details";
-var DefaultHttpResponseOptions = {};
-var DefaultHttpProblemResponseOptions = {
-  problemDetails: "Error occured!"
-};
-var sendCreated = (response, { eTag, ...options }) => send(response, 201, {
-  location: "url" in options ? options.url : `${response.req.url}/${options.createdId}`,
-  body: "createdId" in options ? { id: options.createdId, ...options.body ?? {} } : options.body,
-  eTag
+//#endregion
+//#region src/responses.ts
+const DefaultHttpResponseOptions = {};
+const DefaultHttpProblemResponseOptions = { problemDetails: "Error occured!" };
+const sendCreated = (response, { eTag, ...options }) => send(response, 201, {
+	location: "url" in options ? options.url : `${response.req.url}/${options.createdId}`,
+	body: "createdId" in options ? {
+		id: options.createdId,
+		...options.body ?? {}
+	} : options.body,
+	eTag
 });
-var sendAccepted = (response, options) => send(response, 202, options);
-var sendNoContent = (response, options) => send(response, 204, options);
-var send = (response, statusCode, options) => {
-  const { location, body, eTag } = options ?? DefaultHttpResponseOptions;
-  if (eTag) setETag(response, eTag);
-  if (location) response.setHeader("Location", location);
-  if (body) {
-    response.statusCode = statusCode;
-    response.send(body);
-  } else {
-    response.sendStatus(statusCode);
-  }
-};
-var sendProblem = (response, statusCode, options) => {
-  options = options ?? DefaultHttpProblemResponseOptions;
-  const { location, eTag } = options;
-  const problemDetails = "problem" in options ? options.problem : new ProblemDocument2({
-    detail: options.problemDetails,
-    status: statusCode
-  });
-  if (eTag) setETag(response, eTag);
-  if (location) response.setHeader("Location", location);
-  response.setHeader("Content-Type", "application/problem+json");
-  response.statusCode = statusCode;
-  response.json(problemDetails);
+const sendAccepted = (response, options) => send(response, 202, options);
+const sendNoContent = (response, options) => send(response, 204, options);
+const send = (response, statusCode, options) => {
+	const { location, body, eTag } = options ?? DefaultHttpResponseOptions;
+	if (eTag) setETag(response, eTag);
+	if (location) response.setHeader("Location", location);
+	if (body) {
+		response.statusCode = statusCode;
+		response.send(body);
+	} else response.sendStatus(statusCode);
+};
+const sendProblem = (response, statusCode, options) => {
+	options = options ?? DefaultHttpProblemResponseOptions;
+	const { location, eTag } = options;
+	const problemDetails = "problem" in options ? options.problem : new ProblemDocument({
+		detail: options.problemDetails,
+		status: statusCode
+	});
+	if (eTag) setETag(response, eTag);
+	if (location) response.setHeader("Location", location);
+	response.setHeader("Content-Type", "application/problem+json");
+	response.statusCode = statusCode;
+	response.json(problemDetails);
 };
 
-// src/testing/apiE2ESpecification.ts
-import supertest from "supertest";
-import assert from "assert";
-function apiE2ESpecificationFor(optionsOrGetApplication, getApplication2) {
-  const resolveApplication = () => {
-    if (typeof optionsOrGetApplication === "function" && getApplication2) {
-      const eventStore2 = optionsOrGetApplication();
-      return getApplication2(eventStore2);
-    }
-    if (typeof optionsOrGetApplication !== "object") {
-      throw new EmmettError(
-        "Invalid arguments provided to apiE2ESpecificationFor. Expected either an options object or a getEventStore function and getApplication function."
-      );
-    }
-    const eventStore = optionsOrGetApplication.getEventStore?.() ?? getInMemoryEventStore();
-    return optionsOrGetApplication.getApplication(eventStore);
-  };
-  return (...givenRequests) => {
-    const application = resolveApplication();
-    return {
-      when: (setupRequest) => {
-        const handle = async () => {
-          for (const requestFn of givenRequests) {
-            await requestFn(supertest(application));
-          }
-          return setupRequest(supertest(application));
-        };
-        return {
-          then: async (verify) => {
-            const response = await handle();
-            verify.forEach((assertion) => {
-              const succeeded = assertion(response);
-              if (succeeded === false) assert.fail();
-            });
-          }
-        };
-      }
-    };
-  };
+//#endregion
+//#region src/testing/apiE2ESpecification.ts
+function apiE2ESpecificationFor(optionsOrGetApplication, getApplication) {
+	const resolveApplication = () => {
+		if (typeof optionsOrGetApplication === "function" && getApplication) return getApplication(optionsOrGetApplication());
+		if (typeof optionsOrGetApplication !== "object") throw new EmmettError("Invalid arguments provided to apiE2ESpecificationFor. Expected either an options object or a getEventStore function and getApplication function.");
+		const eventStore = optionsOrGetApplication.getEventStore?.() ?? getInMemoryEventStore();
+		return optionsOrGetApplication.getApplication(eventStore);
+	};
+	return (...givenRequests) => {
+		const application = resolveApplication();
+		return { when: (setupRequest) => {
+			const handle = async () => {
+				for (const requestFn of givenRequests) await requestFn(supertest(application));
+				return setupRequest(supertest(application));
+			};
+			return { then: async (verify) => {
+				const response = await handle();
+				verify.forEach((assertion) => {
+					if (assertion(response) === false) assert.fail();
+				});
+			} };
+		} };
+	};
 }
-var ApiE2ESpecification = {
-  for: apiE2ESpecificationFor
-};
+const ApiE2ESpecification = { for: apiE2ESpecificationFor };
 
-// src/testing/apiSpecification.ts
-import supertest2 from "supertest";
-var existingStream = (streamId, events) => {
-  return [streamId, events];
-};
-var expect = (streamId, events) => {
-  return [streamId, events];
-};
-var expectNewEvents = (streamId, events) => {
-  return [streamId, events];
-};
-var expectResponse = (statusCode, options) => (response) => {
-  const { body, headers } = options ?? {};
-  assertEqual(statusCode, response.statusCode, "Response code doesn't match");
-  if (body) assertMatches(response.body, body);
-  if (headers) assertMatches(response.headers, headers);
-};
-var expectError = (errorCode, problemDetails) => expectResponse(
-  errorCode,
-  problemDetails ? { body: problemDetails } : void 0
-);
-function apiSpecificationFor(optionsOrGetEventStore, getApplication2) {
-  const resolveStoreAndApplication = () => {
-    if (typeof optionsOrGetEventStore === "function") {
-      const eventStore2 = WrapEventStore(optionsOrGetEventStore());
-      return { eventStore: eventStore2, application: getApplication2(eventStore2) };
-    }
-    const eventStore = WrapEventStore(optionsOrGetEventStore.getEventStore());
-    return {
-      eventStore,
-      application: optionsOrGetEventStore.getApplication(eventStore)
-    };
-  };
-  return (...givenStreams) => {
-    const { eventStore, application } = resolveStoreAndApplication();
-    return {
-      when: (setupRequest) => {
-        const handle = async () => {
-          for (const [streamName, events] of givenStreams) {
-            await eventStore.setup(streamName, events);
-          }
-          return setupRequest(supertest2(application));
-        };
-        return {
-          then: async (verify) => {
-            const response = await handle();
-            if (typeof verify === "function") {
-              const succeeded = verify(response);
-              if (succeeded === false) assertFails();
-            } else if (Array.isArray(verify)) {
-              const [first, ...rest] = verify;
-              if (typeof first === "function") {
-                const succeeded = first(response);
-                if (succeeded === false) assertFails();
-              }
-              const events = typeof first === "function" ? rest : verify;
-              assertMatches(
-                Array.from(eventStore.appendedEvents.values()),
-                events
-              );
-            }
-          }
-        };
-      }
-    };
-  };
+//#endregion
+//#region src/testing/apiSpecification.ts
+const existingStream = (streamId, events) => {
+	return [streamId, events];
+};
+const expect = (streamId, events) => {
+	return [streamId, events];
+};
+const expectNewEvents = (streamId, events) => {
+	return [streamId, events];
+};
+const expectResponse = (statusCode, options) => (response) => {
+	const { body, headers } = options ?? {};
+	assertEqual(statusCode, response.statusCode, "Response code doesn't match");
+	if (body) assertMatches(response.body, body);
+	if (headers) assertMatches(response.headers, headers);
+};
+const expectError = (errorCode, problemDetails) => expectResponse(errorCode, problemDetails ? { body: problemDetails } : void 0);
+function apiSpecificationFor(optionsOrGetEventStore, getApplication) {
+	const resolveStoreAndApplication = () => {
+		if (typeof optionsOrGetEventStore === "function") {
+			const eventStore = WrapEventStore(optionsOrGetEventStore());
+			return {
+				eventStore,
+				application: getApplication(eventStore)
+			};
+		}
+		const eventStore = WrapEventStore(optionsOrGetEventStore.getEventStore());
+		return {
+			eventStore,
+			application: optionsOrGetEventStore.getApplication(eventStore)
+		};
+	};
+	return (...givenStreams) => {
+		const { eventStore, application } = resolveStoreAndApplication();
+		return { when: (setupRequest) => {
+			const handle = async () => {
+				for (const [streamName, events] of givenStreams) await eventStore.setup(streamName, events);
+				return setupRequest(supertest(application));
+			};
+			return { then: async (verify) => {
+				const response = await handle();
+				if (typeof verify === "function") {
+					if (verify(response) === false) assertFails();
+				} else if (Array.isArray(verify)) {
+					const [first, ...rest] = verify;
+					if (typeof first === "function") {
+						if (first(response) === false) assertFails();
+					}
+					const events = typeof first === "function" ? rest : verify;
+					assertMatches(Array.from(eventStore.appendedEvents.values()), events);
+				}
+			} };
+		} };
+	};
 }
-var ApiSpecification = {
-  for: apiSpecificationFor
-};
-export {
-  Accepted,
-  ApiE2ESpecification,
-  ApiSpecification,
-  BadRequest,
-  Conflict,
-  Created,
-  DefaultHttpProblemResponseOptions,
-  DefaultHttpResponseOptions,
-  ETagErrors,
-  Forbidden,
-  HeaderNames,
-  HttpProblem,
-  HttpResponse,
-  NoContent,
-  NotFound,
-  OK,
-  PreconditionFailed,
-  WeakETagRegex,
-  existingStream,
-  expect,
-  expectError,
-  expectNewEvents,
-  expectResponse,
-  getApplication,
-  getETagFromIfMatch,
-  getETagFromIfNotMatch,
-  getETagValueFromIfMatch,
-  getWeakETagValue,
-  isWeakETag,
-  on,
-  send,
-  sendAccepted,
-  sendCreated,
-  sendNoContent,
-  sendProblem,
-  setETag,
-  startAPI,
-  toWeakETag
-};
+const ApiSpecification = { for: apiSpecificationFor };
+
+//#endregion
+export { Accepted, ApiE2ESpecification, ApiSpecification, BadRequest, Conflict, Created, DefaultHttpProblemResponseOptions, DefaultHttpResponseOptions, ETagErrors, Forbidden, HeaderNames, HttpProblem, HttpResponse, NoContent, NotFound, OK, PreconditionFailed, WeakETagRegex, existingStream, expect, expectError, expectNewEvents, expectResponse, getApplication, getETagFromIfMatch, getETagFromIfNotMatch, getETagValueFromIfMatch, getWeakETagValue, isWeakETag, on, send, sendAccepted, sendCreated, sendNoContent, sendProblem, setETag, startAPI, toWeakETag };
 //# sourceMappingURL=index.js.map