@event-driven-io/emmett 0.21.1 → 0.22.0-alpha.3

package/dist/index.cjs

@@ -442,17 +442,25 @@ var CommandHandler = (options) => async (store, id, handle, handleOptions) => as
         read: {
           // expected stream version is passed to fail fast
           // if stream is in the wrong state
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _15 => _15.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))
         }
       });
-      const state = aggregationResult.state;
-      const currentStreamVersion = aggregationResult.currentStreamVersion;
+      const {
+        state,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        currentStreamVersion,
+        streamExists: _streamExists,
+        ...restOfAggregationResult
+      } = aggregationResult;
       const result2 = await handle(state);
       const newEvents = Array.isArray(result2) ? result2 : [result2];
       if (newEvents.length === 0) {
         return {
+          ...restOfAggregationResult,
           newEvents: [],
           newState: state,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           nextExpectedStreamVersion: currentStreamVersion,
           createdNewStream: false
         };
@@ -957,22 +965,42 @@ var assertFails = (message) => {
 var assertThrowsAsync = async (fun, errorCheck) => {
   try {
     await fun();
-    throw new AssertionError("Function didn't throw expected error");
   } catch (error2) {
     const typedError = error2;
-    if (errorCheck) assertTrue(errorCheck(typedError));
+    if (typedError instanceof AssertionError || !errorCheck) {
+      assertFalse(
+        typedError instanceof AssertionError,
+        "Function didn't throw expected error"
+      );
+      return typedError;
+    }
+    assertTrue(
+      errorCheck(typedError),
+      `Error doesn't match the expected condition: ${JSON.stringify(error2)}`
+    );
     return typedError;
   }
+  throw new AssertionError("Function didn't throw expected error");
 };
 var assertThrows = (fun, errorCheck) => {
   try {
     fun();
-    throw new AssertionError("Function didn't throw expected error");
   } catch (error2) {
     const typedError = error2;
-    if (errorCheck) assertTrue(errorCheck(typedError));
+    if (errorCheck) {
+      assertTrue(
+        errorCheck(typedError),
+        `Error doesn't match the expected condition: ${JSON.stringify(error2)}`
+      );
+    } else if (typedError instanceof AssertionError) {
+      assertFalse(
+        typedError instanceof AssertionError,
+        "Function didn't throw expected error"
+      );
+    }
     return typedError;
   }
+  throw new AssertionError("Function didn't throw expected error");
 };
 var assertRejects = async (promise, errorCheck) => {
   try {
@@ -1017,10 +1045,12 @@ var assertThat = (item) => {
   };
 };
 function assertFalse(condition, message) {
-  if (condition) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
+  if (condition !== false)
+    throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is true`)));
 }
 function assertTrue(condition, message) {
-  if (!condition) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
+  if (condition !== true)
+    throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is false`)));
 }
 function assertOk(obj, message) {
   if (!obj) throw new AssertionError(_nullishCoalesce(message, () => ( `Condition is not truthy`)));
@@ -1095,10 +1125,17 @@ var assertThatArray = (array) => {
     isEmpty: () => assertEqual(array.length, 0),
     isNotEmpty: () => assertNotEqual(array.length, 0),
     hasSize: (length) => assertEqual(array.length, length),
-    containsElements: (...other) => {
-      assertTrue(other.every((ts) => other.some((o) => deepEquals(ts, o))));
+    containsElements: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => deepEquals(ts, o))));
+    },
+    containsElementsMatching: (other) => {
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
+    },
+    containsOnlyElementsMatching: (other) => {
+      assertEqual(array.length, other.length);
+      assertTrue(other.every((ts) => array.some((o) => isSubset(o, ts))));
     },
-    containsExactlyInAnyOrder: (...other) => {
+    containsExactlyInAnyOrder: (other) => {
       assertEqual(array.length, other.length);
       assertTrue(array.every((ts) => other.some((o) => deepEquals(ts, o))));
     },
@@ -1124,7 +1161,7 @@ var assertThatArray = (array) => {
         other.map((o) => array.filter((a) => deepEquals(a, o)).length).filter((a) => a === 1).length === other.length
       );
     },
-    containsAnyOf: (...other) => {
+    containsAnyOf: (other) => {
       assertTrue(array.some((a) => other.some((o) => deepEquals(a, o))));
     },
     allMatch: (matches) => {
@@ -1200,12 +1237,15 @@ var DeciderSpecification = {
 // src/testing/wrapEventStore.ts
 var WrapEventStore = (eventStore) => {
   const appendedEvents = /* @__PURE__ */ new Map();
-  return {
-    async aggregateStream(streamName, options) {
+  const wrapped = {
+    aggregateStream(streamName, options) {
       return eventStore.aggregateStream(streamName, options);
     },
-    readStream(streamName, options) {
-      return eventStore.readStream(streamName, options);
+    async readStream(streamName, options) {
+      return await eventStore.readStream(
+        streamName,
+        options
+      );
     },
     appendToStream: async (streamName, events, options) => {
       const result = await eventStore.appendToStream(
@@ -1231,6 +1271,7 @@ var WrapEventStore = (eventStore) => {
     //   return eventStore.streamEvents();
     // },
   };
+  return wrapped;
 };