@event-driven-io/emmett-expressjs 0.43.0-apha.2 → 0.43.0-beta.10

package/dist/index.cjs

@@ -38,38 +38,638 @@ var EmmettError = (_class = class _EmmettError extends Error {
     return typeof error === "object" && error !== null && "errorCode" in error && isNumber(error.errorCode) && (errorCode === void 0 || error.errorCode === errorCode);
   }
 }, _class.__initStatic(), _class);
+var ConcurrencyError = class _ConcurrencyError extends EmmettError {
+  constructor(current, expected, message) {
+    super({
+      errorCode: EmmettError.Codes.ConcurrencyError,
+      message: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _ => _.toString, 'call', _2 => _2()])}`))
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+var ConcurrencyInMemoryDatabaseError = class _ConcurrencyInMemoryDatabaseError extends EmmettError {
+  constructor(message) {
+    super({
+      errorCode: EmmettError.Codes.ConcurrencyError,
+      message: _nullishCoalesce(message, () => ( `Expected document state does not match current one!`))
+    });
+    Object.setPrototypeOf(this, _ConcurrencyInMemoryDatabaseError.prototype);
+  }
+};
 
 // ../emmett/dist/index.js
 var _uuid = require('uuid');
 
+
 var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
 
 
+
+async function tryPublishMessagesAfterCommit(messages, options, context) {
+  if (_optionalChain([options, 'optionalAccess', _3 => _3.onAfterCommit]) === void 0) return false;
+  try {
+    await _optionalChain([options, 'optionalAccess', _4 => _4.onAfterCommit, 'call', _5 => _5(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 ParseError = class extends Error {
-  constructor(text) {
-    super(`Cannot parse! ${text}`);
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
+};
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(_optionalChain([current, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]), _optionalChain([expected, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9()]));
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
   }
 };
-var JSONParser = {
-  stringify: (value, options) => {
-    return JSON.stringify(
-      _optionalChain([options, 'optionalAccess', _2 => _2.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, _optionalChain([options, 'optionalAccess', _3 => _3.reviver]));
-    if (_optionalChain([options, 'optionalAccess', _4 => _4.typeCheck]) && !_optionalChain([options, 'optionalAccess', _5 => _5.typeCheck, 'call', _6 => _6(parsed)]))
-      throw new ParseError(text);
-    return _optionalChain([options, 'optionalAccess', _7 => _7.map]) ? options.map(parsed) : parsed;
+var isPrimitive = (value) => {
+  const type = typeof value;
+  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
+};
+var compareArrays = (left, right) => {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i++) {
+    const leftHas = i in left;
+    const rightHas = i in right;
+    if (leftHas !== rightHas) return false;
+    if (leftHas && !deepEquals(left[i], right[i])) return false;
   }
+  return true;
+};
+var compareDates = (left, right) => {
+  return left.getTime() === right.getTime();
 };
+var compareRegExps = (left, right) => {
+  return left.toString() === right.toString();
+};
+var compareErrors = (left, right) => {
+  if (left.message !== right.message || left.name !== right.name) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  const rightKeySet = new Set(rightKeys);
+  for (const key of leftKeys) {
+    if (!rightKeySet.has(key)) return false;
+    if (!deepEquals(left[key], right[key])) return false;
+  }
+  return true;
+};
+var compareMaps = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left) {
+    if (isPrimitive(key)) {
+      if (!right.has(key) || !deepEquals(value, right.get(key))) {
+        return false;
+      }
+    } else {
+      let found = false;
+      for (const [rightKey, rightValue] of right) {
+        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareSets = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const leftItem of left) {
+    if (isPrimitive(leftItem)) {
+      if (!right.has(leftItem)) return false;
+    } else {
+      let found = false;
+      for (const rightItem of right) {
+        if (deepEquals(leftItem, rightItem)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareArrayBuffers = (left, right) => {
+  if (left.byteLength !== right.byteLength) return false;
+  const leftView = new Uint8Array(left);
+  const rightView = new Uint8Array(right);
+  for (let i = 0; i < leftView.length; i++) {
+    if (leftView[i] !== rightView[i]) return false;
+  }
+  return true;
+};
+var compareTypedArrays = (left, right) => {
+  if (left.constructor !== right.constructor) return false;
+  if (left.byteLength !== right.byteLength) return false;
+  const leftArray = new Uint8Array(
+    left.buffer,
+    left.byteOffset,
+    left.byteLength
+  );
+  const rightArray = new Uint8Array(
+    right.buffer,
+    right.byteOffset,
+    right.byteLength
+  );
+  for (let i = 0; i < leftArray.length; i++) {
+    if (leftArray[i] !== rightArray[i]) return false;
+  }
+  return true;
+};
+var compareObjects = (left, right) => {
+  const keys1 = Object.keys(left);
+  const keys2 = Object.keys(right);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (left[key] instanceof Function && right[key] instanceof Function) {
+      continue;
+    }
+    const isEqual = deepEquals(left[key], right[key]);
+    if (!isEqual) {
+      return false;
+    }
+  }
+  return true;
+};
+var getType = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitiveType = typeof value;
+  if (primitiveType !== "object") return primitiveType;
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Boolean) return "boxed-boolean";
+  if (value instanceof Number) return "boxed-number";
+  if (value instanceof String) return "boxed-string";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Error) return "error";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof ArrayBuffer) return "arraybuffer";
+  if (value instanceof DataView) return "dataview";
+  if (value instanceof WeakMap) return "weakmap";
+  if (value instanceof WeakSet) return "weakset";
+  if (ArrayBuffer.isView(value)) return "typedarray";
+  return "object";
+};
+var deepEquals = (left, right) => {
+  if (left === right) return true;
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  const leftType = getType(left);
+  const rightType = getType(right);
+  if (leftType !== rightType) return false;
+  switch (leftType) {
+    case "null":
+    case "undefined":
+    case "boolean":
+    case "number":
+    case "bigint":
+    case "string":
+    case "symbol":
+    case "function":
+      return left === right;
+    case "array":
+      return compareArrays(left, right);
+    case "date":
+      return compareDates(left, right);
+    case "regexp":
+      return compareRegExps(left, right);
+    case "error":
+      return compareErrors(left, right);
+    case "map":
+      return compareMaps(
+        left,
+        right
+      );
+    case "set":
+      return compareSets(left, right);
+    case "arraybuffer":
+      return compareArrayBuffers(left, right);
+    case "dataview":
+    case "weakmap":
+    case "weakset":
+      return false;
+    case "typedarray":
+      return compareTypedArrays(
+        left,
+        right
+      );
+    case "boxed-boolean":
+      return left.valueOf() === right.valueOf();
+    case "boxed-number":
+      return left.valueOf() === right.valueOf();
+    case "boxed-string":
+      return left.valueOf() === right.valueOf();
+    case "object":
+      return compareObjects(
+        left,
+        right
+      );
+    default:
+      return false;
+  }
+};
+var isEquatable = (left) => {
+  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+};
+var toNormalizedString = (value) => value.toString().padStart(19, "0");
+var bigInt = {
+  toNormalizedString
+};
+var bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+var dateReplacer = (_key, value) => {
+  return value instanceof Date ? value.toISOString() : value;
+};
+var isFirstLetterNumeric = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57;
+};
+var isFirstLetterNumericOrMinus = (str) => {
+  const c = str.charCodeAt(0);
+  return c >= 48 && c <= 57 || c === 45;
+};
+var bigIntReviver = (_key, value, context) => {
+  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    try {
+      return BigInt(_nullishCoalesce(_optionalChain([context, 'optionalAccess', _10 => _10.source]), () => ( value.toString())));
+    } catch (e2) {
+      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 (e3) {
+        }
+      }
+    }
+  }
+  return value;
+};
+var dateReviver = (_key, value) => {
+  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+};
+var composeJSONReplacers = (...replacers) => {
+  const filteredReplacers = replacers.filter((r) => r !== void 0);
+  if (filteredReplacers.length === 0) return void 0;
+  return (key, value) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredReplacers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, replacer) => replacer(key, accValue),
+      value
+    )
+  );
+};
+var composeJSONRevivers = (...revivers) => {
+  const filteredRevivers = revivers.filter((r) => r !== void 0);
+  if (filteredRevivers.length === 0) return void 0;
+  return (key, value, context) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    filteredRevivers.reduce(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (accValue, reviver) => reviver(key, accValue, context),
+      value
+    )
+  );
+};
+var JSONReplacer = (opts) => composeJSONReplacers(
+  _optionalChain([opts, 'optionalAccess', _11 => _11.replacer]),
+  _optionalChain([opts, 'optionalAccess', _12 => _12.failOnBigIntSerialization]) !== true ? JSONReplacers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _13 => _13.useDefaultDateSerialization]) !== true ? JSONReplacers.date : void 0
+);
+var JSONReviver = (opts) => composeJSONRevivers(
+  _optionalChain([opts, 'optionalAccess', _14 => _14.reviver]),
+  _optionalChain([opts, 'optionalAccess', _15 => _15.parseBigInts]) === true ? JSONRevivers.bigInt : void 0,
+  _optionalChain([opts, 'optionalAccess', _16 => _16.parseDates]) === true ? JSONRevivers.date : void 0
+);
+var JSONReplacers = {
+  bigInt: bigIntReplacer,
+  date: dateReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, serializerOptions) => JSON.stringify(
+      object,
+      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
+    ),
+    deserialize: (payload, deserializerOptions) => JSON.parse(
+      payload,
+      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
+    )
+  };
+};
+var JSONSerializer = Object.assign(jsonSerializer(), {
+  from: (options) => _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.serialization, 'optionalAccess', _18 => _18.serializer]), () => ( (_optionalChain([options, 'optionalAccess', _19 => _19.serialization, 'optionalAccess', _20 => _20.options]) ? jsonSerializer(_optionalChain([options, 'optionalAccess', _21 => _21.serialization, 'optionalAccess', _22 => _22.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(
+          _nullishCoalesce(errorMessage, () => ( `${operationName} on ${collectionName} failed. Expected document state does not match current one! Result: ${JSONSerializer.serialize(result)}!`))
+        );
+    }
+  };
+  if (_optionalChain([options, 'access', _23 => _23.errors, 'optionalAccess', _24 => _24.throwOnOperationFailures]))
+    operationResult2.assertSuccessful();
+  return operationResult2;
+};
+var getInMemoryDatabase = () => {
+  const storage = /* @__PURE__ */ new Map();
+  return {
+    collection: (collectionName, collectionOptions = {}) => {
+      const ensureCollectionCreated = () => {
+        if (!storage.has(collectionName)) storage.set(collectionName, []);
+      };
+      const errors = collectionOptions.errors;
+      const collection = {
+        collectionName,
+        insertOne: async (document) => {
+          ensureCollectionCreated();
+          const _id = _nullishCoalesce(document._id, () => ( _uuid.v7.call(void 0, )));
+          const _version = _nullishCoalesce(document._version, () => ( 1n));
+          const existing = await collection.findOne((c) => c._id === _id);
+          if (existing) {
+            return operationResult(
+              {
+                successful: false,
+                insertedId: null,
+                nextExpectedVersion: _version
+              },
+              { operationName: "insertOne", collectionName, errors }
+            );
+          }
+          const documentsInCollection = storage.get(collectionName);
+          const newDocument = { ...document, _id, _version };
+          const newCollection = [...documentsInCollection, newDocument];
+          storage.set(collectionName, newCollection);
+          return operationResult(
+            {
+              successful: true,
+              insertedId: _id,
+              nextExpectedVersion: _version
+            },
+            { operationName: "insertOne", collectionName, errors }
+          );
+        },
+        findOne: (predicate) => {
+          ensureCollectionCreated();
+          const documentsInCollection = storage.get(collectionName);
+          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _25 => _25.filter, 'call', _26 => _26((doc) => predicate(doc))]) : documentsInCollection;
+          const firstOne = _nullishCoalesce(_optionalChain([filteredDocuments, 'optionalAccess', _27 => _27[0]]), () => ( null));
+          return Promise.resolve(firstOne);
+        },
+        find: (predicate) => {
+          ensureCollectionCreated();
+          const documentsInCollection = storage.get(collectionName);
+          const filteredDocuments = predicate ? _optionalChain([documentsInCollection, 'optionalAccess', _28 => _28.filter, 'call', _29 => _29((doc) => predicate(doc))]) : documentsInCollection;
+          return Promise.resolve(filteredDocuments);
+        },
+        deleteOne: (predicate) => {
+          ensureCollectionCreated();
+          const documentsInCollection = storage.get(collectionName);
+          if (predicate) {
+            const foundIndex = documentsInCollection.findIndex(
+              (doc) => predicate(doc)
+            );
+            if (foundIndex === -1) {
+              return Promise.resolve(
+                operationResult(
+                  {
+                    successful: false,
+                    matchedCount: 0,
+                    deletedCount: 0
+                  },
+                  { operationName: "deleteOne", collectionName, errors }
+                )
+              );
+            } else {
+              const newCollection2 = documentsInCollection.toSpliced(
+                foundIndex,
+                1
+              );
+              storage.set(collectionName, newCollection2);
+              return Promise.resolve(
+                operationResult(
+                  {
+                    successful: true,
+                    matchedCount: 1,
+                    deletedCount: 1
+                  },
+                  { operationName: "deleteOne", collectionName, errors }
+                )
+              );
+            }
+          }
+          const newCollection = documentsInCollection.slice(1);
+          storage.set(collectionName, newCollection);
+          return Promise.resolve(
+            operationResult(
+              {
+                successful: true,
+                matchedCount: 1,
+                deletedCount: 1
+              },
+              { operationName: "deleteOne", collectionName, errors }
+            )
+          );
+        },
+        replaceOne: (predicate, document, options) => {
+          ensureCollectionCreated();
+          const documentsInCollection = storage.get(collectionName);
+          const firstIndex = documentsInCollection.findIndex(
+            (doc) => predicate(doc)
+          );
+          if (firstIndex === void 0 || firstIndex === -1) {
+            return Promise.resolve(
+              operationResult(
+                {
+                  successful: false,
+                  matchedCount: 0,
+                  modifiedCount: 0,
+                  nextExpectedVersion: 0n
+                },
+                { operationName: "replaceOne", collectionName, errors }
+              )
+            );
+          }
+          const existing = documentsInCollection[firstIndex];
+          if (typeof _optionalChain([options, 'optionalAccess', _30 => _30.expectedVersion]) === "bigint" && existing._version !== options.expectedVersion) {
+            return Promise.resolve(
+              operationResult(
+                {
+                  successful: false,
+                  matchedCount: 1,
+                  modifiedCount: 0,
+                  nextExpectedVersion: existing._version
+                },
+                { operationName: "replaceOne", collectionName, errors }
+              )
+            );
+          }
+          const newVersion = existing._version + 1n;
+          const newCollection = documentsInCollection.with(firstIndex, {
+            _id: existing._id,
+            ...document,
+            _version: newVersion
+          });
+          storage.set(collectionName, newCollection);
+          return Promise.resolve(
+            operationResult(
+              {
+                successful: true,
+                modifiedCount: 1,
+                matchedCount: firstIndex,
+                nextExpectedVersion: newVersion
+              },
+              { operationName: "replaceOne", collectionName, errors }
+            )
+          );
+        },
+        handle: async (id, handle, options) => {
+          const { expectedVersion: version, ...operationOptions } = _nullishCoalesce(options, () => ( {}));
+          ensureCollectionCreated();
+          const existing = await collection.findOne(({ _id }) => _id === id);
+          const expectedVersion = expectedVersionValue(version);
+          if (existing == null && version === "DOCUMENT_EXISTS" || existing == null && expectedVersion != null || existing != null && version === "DOCUMENT_DOES_NOT_EXIST" || existing != null && expectedVersion !== null && existing._version !== expectedVersion) {
+            return operationResult(
+              {
+                successful: false,
+                document: existing
+              },
+              { operationName: "handle", collectionName, errors }
+            );
+          }
+          const result = handle(existing !== null ? { ...existing } : null);
+          if (deepEquals(existing, result))
+            return operationResult(
+              {
+                successful: true,
+                document: existing
+              },
+              { operationName: "handle", collectionName, errors }
+            );
+          if (!existing && result) {
+            const newDoc = { ...result, _id: id };
+            const insertResult = await collection.insertOne({
+              ...newDoc,
+              _id: id
+            });
+            return {
+              ...insertResult,
+              document: {
+                ...newDoc,
+                _version: insertResult.nextExpectedVersion
+              }
+            };
+          }
+          if (existing && !result) {
+            const deleteResult = await collection.deleteOne(
+              ({ _id }) => id === _id
+            );
+            return { ...deleteResult, document: null };
+          }
+          if (existing && result) {
+            const replaceResult = await collection.replaceOne(
+              ({ _id }) => id === _id,
+              result,
+              {
+                ...operationOptions,
+                expectedVersion: _nullishCoalesce(expectedVersion, () => ( "DOCUMENT_EXISTS"))
+              }
+            );
+            return {
+              ...replaceResult,
+              document: {
+                ...result,
+                _version: replaceResult.nextExpectedVersion
+              }
+            };
+          }
+          return operationResult(
+            {
+              successful: true,
+              document: existing
+            },
+            { operationName: "handle", collectionName, errors }
+          );
+        }
+      };
+      return collection;
+    }
+  };
+};
+var 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);
@@ -81,7 +681,7 @@ var isSubset = (superObj, subObj) => {
   assertOk(sup);
   assertOk(sub);
   return Object.keys(sub).every((ele) => {
-    if (typeof sub[ele] == "object") {
+    if (sub[ele] !== null && typeof sub[ele] == "object") {
       return isSubset(sup[ele], sub[ele]);
     }
     return sub[ele] === sup[ele];
@@ -94,9 +694,9 @@ var assertMatches = (actual, expected, message2) => {
   if (!isSubset(actual, expected))
     throw new AssertionError(
       _nullishCoalesce(message2, () => ( `subObj:
-${JSONParser.stringify(expected)}
+${JSONSerializer.serialize(expected)}
 is not subset of
-${JSONParser.stringify(actual)}`))
+${JSONSerializer.serialize(actual)}`))
     );
 };
 function assertOk(obj, message2) {
@@ -106,8 +706,8 @@ function assertEqual(expected, actual, message2) {
   if (expected !== actual)
     throw new AssertionError(
       `${_nullishCoalesce(message2, () => ( "Objects are not equal"))}:
-Expected: ${JSONParser.stringify(expected)}
-Actual: ${JSONParser.stringify(actual)}`
+Expected: ${JSONSerializer.serialize(expected)}
+Actual: ${JSONSerializer.serialize(actual)}`
     );
 }
 var WrapEventStore = (eventStore) => {
@@ -149,6 +749,161 @@ var WrapEventStore = (eventStore) => {
   };
   return wrapped;
 };
+var downcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _31 => _31.downcast]))
+    return recordedMessage;
+  const downcasted = options.downcast(
+    recordedMessage
+  );
+  return {
+    ...recordedMessage,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    data: downcasted.data,
+    ..."metadata" in recordedMessage || "metadata" in downcasted ? {
+      metadata: {
+        ..."metadata" in recordedMessage ? recordedMessage.metadata : {},
+        ..."metadata" in downcasted ? downcasted.metadata : {}
+      }
+    } : {}
+  };
+};
+var downcastRecordedMessages = (recordedMessages, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _32 => _32.downcast]))
+    return recordedMessages;
+  return recordedMessages.map(
+    (recordedMessage) => downcastRecordedMessage(recordedMessage, options)
+  );
+};
+var upcastRecordedMessage = (recordedMessage, options) => {
+  if (!_optionalChain([options, 'optionalAccess', _33 => _33.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 (!_optionalChain([options, 'optionalAccess', _34 => _34.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 = _optionalChain([eventStoreOptions, 'optionalAccess', _35 => _35.database]) || getInMemoryDatabase();
+  const inlineProjections2 = (_nullishCoalesce(_optionalChain([eventStoreOptions, 'optionalAccess', _36 => _36.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 = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _37 => _37.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,
+        _optionalChain([readOptions, 'optionalAccess', _38 => _38.expectedStreamVersion]),
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const from = Number(_nullishCoalesce(_optionalChain([readOptions, 'optionalAccess', _39 => _39.from]), () => ( 0)));
+      const to = Number(
+        _nullishCoalesce(_optionalChain([readOptions, 'optionalAccess', _40 => _40.to]), () => ( (_optionalChain([readOptions, 'optionalAccess', _41 => _41.maxCount]) ? (_nullishCoalesce(readOptions.from, () => ( 0n))) + readOptions.maxCount : _nullishCoalesce(_optionalChain([events, 'optionalAccess', _42 => _42.length]), () => ( 1)))))
+      );
+      const resultEvents = events !== void 0 && events.length > 0 ? upcastRecordedMessages(
+        events.slice(from, to),
+        _optionalChain([readOptions, 'optionalAccess', _43 => _43.schema, 'optionalAccess', _44 => _44.versioning])
+      ) : [];
+      const result = {
+        currentStreamVersion,
+        events: resultEvents,
+        streamExists: events !== void 0 && events.length > 0
+      };
+      return Promise.resolve(result);
+    },
+    appendToStream: async (streamName, events, options) => {
+      const currentEvents = _nullishCoalesce(streams.get(streamName), () => ( []));
+      const currentStreamVersion = currentEvents.length > 0 ? BigInt(currentEvents.length) : InMemoryEventStoreDefaultStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        _optionalChain([options, 'optionalAccess', _45 => _45.expectedStreamVersion]),
+        InMemoryEventStoreDefaultStreamVersion
+      );
+      const newEvents = events.map((event2, index) => {
+        const globalPosition = BigInt(getAllEventsCount() + index + 1);
+        const metadata = {
+          streamName,
+          messageId: _uuid.v4.call(void 0, ),
+          streamPosition: BigInt(currentEvents.length + index + 1),
+          globalPosition,
+          checkpoint: bigIntProcessorCheckpoint(globalPosition)
+        };
+        return {
+          ...event2,
+          kind: _nullishCoalesce(event2.kind, () => ( "Event")),
+          metadata: {
+            ..."metadata" in event2 ? _nullishCoalesce(event2.metadata, () => ( {})) : {},
+            ...metadata
+          }
+        };
+      });
+      const positionOfLastEventInTheStream = BigInt(
+        newEvents.slice(-1)[0].metadata.streamPosition
+      );
+      streams.set(streamName, [
+        ...currentEvents,
+        ...downcastRecordedMessages(newEvents, _optionalChain([options, 'optionalAccess', _46 => _46.schema, 'optionalAccess', _47 => _47.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,
+        _optionalChain([eventStoreOptions, 'optionalAccess', _48 => _48.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
 var _httpproblemdetails = require('http-problem-details');
@@ -264,7 +1019,6 @@ var getETagValueFromIfMatch = (request) => {
 };
 
 // src/handler.ts
-
 var on = (handle) => async (request, response, _next) => {
   const setResponse = await Promise.resolve(handle(request));
   return setResponse(response);
@@ -293,17 +1047,17 @@ var HttpProblem = (statusCode, options) => (response) => {
 
 // src/responses.ts
 
-
 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 } : void 0,
+  body: "createdId" in options ? { id: options.createdId, ..._nullishCoalesce(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 } = _nullishCoalesce(options, () => ( DefaultHttpResponseOptions));
   if (eTag) setETag(response, eTag);
@@ -332,39 +1086,43 @@ var sendProblem = (response, statusCode, options) => {
 // src/testing/apiE2ESpecification.ts
 var _supertest = require('supertest'); var _supertest2 = _interopRequireDefault(_supertest);
 var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
-var ApiE2ESpecification = {
-  for: (getEventStore, getApplication2) => {
-    {
-      return (...givenRequests) => {
-        const eventStore = getEventStore();
-        const application = getApplication2(eventStore);
+function apiE2ESpecificationFor(optionsOrGetApplication) {
+  const resolveApplication = () => {
+    if (typeof optionsOrGetApplication === "function") {
+      return optionsOrGetApplication();
+    }
+    const eventStore = _nullishCoalesce(_optionalChain([optionsOrGetApplication, 'access', _49 => _49.getEventStore, 'optionalCall', _50 => _50()]), () => ( getInMemoryEventStore()));
+    return optionsOrGetApplication.getApplication(eventStore);
+  };
+  return (...givenRequests) => {
+    const application = resolveApplication();
+    return {
+      when: (setupRequest) => {
+        const handle = async () => {
+          for (const requestFn of givenRequests) {
+            await requestFn(_supertest2.default.call(void 0, application));
+          }
+          return setupRequest(_supertest2.default.call(void 0, application));
+        };
         return {
-          when: (setupRequest) => {
-            const handle = async () => {
-              for (const requestFn of givenRequests) {
-                await requestFn(_supertest2.default.call(void 0, application));
-              }
-              return setupRequest(_supertest2.default.call(void 0, application));
-            };
-            return {
-              then: async (verify) => {
-                const response = await handle();
-                verify.forEach((assertion) => {
-                  const succeeded = assertion(response);
-                  if (succeeded === false) _assert2.default.fail();
-                });
-              }
-            };
+          then: async (verify) => {
+            const response = await handle();
+            verify.forEach((assertion) => {
+              const succeeded = assertion(response);
+              if (succeeded === false) _assert2.default.fail();
+            });
           }
         };
-      };
-    }
-  }
+      }
+    };
+  };
+}
+var ApiE2ESpecification = {
+  for: apiE2ESpecificationFor
 };
 
 // src/testing/apiSpecification.ts
 
-
 var existingStream = (streamId, events) => {
   return [streamId, events];
 };
@@ -384,45 +1142,54 @@ var expectError = (errorCode, problemDetails) => expectResponse(
   errorCode,
   problemDetails ? { body: problemDetails } : void 0
 );
-var ApiSpecification = {
-  for: (getEventStore, getApplication2) => {
-    {
-      return (...givenStreams) => {
-        const eventStore = WrapEventStore(getEventStore());
-        const application = getApplication2(eventStore);
+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.default.call(void 0, application));
+        };
         return {
-          when: (setupRequest) => {
-            const handle = async () => {
-              for (const [streamName, events] of givenStreams) {
-                await eventStore.setup(streamName, events);
-              }
-              return setupRequest(_supertest2.default.call(void 0, 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
-                  );
-                }
+          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
+              );
+            }
           }
         };
-      };
-    }
-  }
+      }
+    };
+  };
+}
+var ApiSpecification = {
+  for: apiSpecificationFor
 };
 
 
@@ -462,5 +1229,6 @@ var ApiSpecification = {
 
 
 
-exports.Accepted = Accepted; exports.ApiE2ESpecification = ApiE2ESpecification; exports.ApiSpecification = ApiSpecification; exports.BadRequest = BadRequest; exports.Conflict = Conflict; exports.Created = Created; exports.DefaultHttpProblemResponseOptions = DefaultHttpProblemResponseOptions; exports.DefaultHttpResponseOptions = DefaultHttpResponseOptions; exports.ETagErrors = ETagErrors; exports.Forbidden = Forbidden; exports.HeaderNames = HeaderNames; exports.HttpProblem = HttpProblem; exports.HttpResponse = HttpResponse; exports.NoContent = NoContent; exports.NotFound = NotFound; exports.OK = OK; exports.PreconditionFailed = PreconditionFailed; exports.WeakETagRegex = WeakETagRegex; exports.existingStream = existingStream; exports.expect = expect; exports.expectError = expectError; exports.expectNewEvents = expectNewEvents; exports.expectResponse = expectResponse; exports.getApplication = getApplication; exports.getETagFromIfMatch = getETagFromIfMatch; exports.getETagFromIfNotMatch = getETagFromIfNotMatch; exports.getETagValueFromIfMatch = getETagValueFromIfMatch; exports.getWeakETagValue = getWeakETagValue; exports.isWeakETag = isWeakETag; exports.on = on; exports.send = send; exports.sendAccepted = sendAccepted; exports.sendCreated = sendCreated; exports.sendProblem = sendProblem; exports.setETag = setETag; exports.startAPI = startAPI; exports.toWeakETag = toWeakETag;
+
+exports.Accepted = Accepted; exports.ApiE2ESpecification = ApiE2ESpecification; exports.ApiSpecification = ApiSpecification; exports.BadRequest = BadRequest; exports.Conflict = Conflict; exports.Created = Created; exports.DefaultHttpProblemResponseOptions = DefaultHttpProblemResponseOptions; exports.DefaultHttpResponseOptions = DefaultHttpResponseOptions; exports.ETagErrors = ETagErrors; exports.Forbidden = Forbidden; exports.HeaderNames = HeaderNames; exports.HttpProblem = HttpProblem; exports.HttpResponse = HttpResponse; exports.NoContent = NoContent; exports.NotFound = NotFound; exports.OK = OK; exports.PreconditionFailed = PreconditionFailed; exports.WeakETagRegex = WeakETagRegex; exports.existingStream = existingStream; exports.expect = expect; exports.expectError = expectError; exports.expectNewEvents = expectNewEvents; exports.expectResponse = expectResponse; exports.getApplication = getApplication; exports.getETagFromIfMatch = getETagFromIfMatch; exports.getETagFromIfNotMatch = getETagFromIfNotMatch; exports.getETagValueFromIfMatch = getETagValueFromIfMatch; exports.getWeakETagValue = getWeakETagValue; exports.isWeakETag = isWeakETag; exports.on = on; exports.send = send; exports.sendAccepted = sendAccepted; exports.sendCreated = sendCreated; exports.sendNoContent = sendNoContent; exports.sendProblem = sendProblem; exports.setETag = setETag; exports.startAPI = startAPI; exports.toWeakETag = toWeakETag;
 //# sourceMappingURL=index.cjs.map