Adjusted the expected version check and added tests for retries

Author: oskardudycz

src/packages/emmett/src/commandHandling/handleCommand.unit.spec.ts

@@ -3,7 +3,6 @@ import { describe, it } from 'node:test';
 import {
   ExpectedVersionConflictError,
   getInMemoryEventStore,
-  isExpectedVersionConflictError,
 } from '../eventStore';
 import {
   assertDeepEqual,
@@ -298,6 +297,49 @@ void describe('Command Handler', () => {
       assertEqual(nextExpectedStreamVersion, 2n);
     });
 
+    void it('does NOT retry handling for wrong explicit version', async () => {
+      // Given
+      const productItem: PricedProductItem = {
+        productId: '123',
+        quantity: 10,
+        price: 3,
+      };
+
+      const shoppingCartId = randomUUID();
+      const command: AddProductItem = {
+        type: 'AddProductItem',
+        data: { productItem },
+      };
+
+      // Create the stream
+      await handleCommand(
+        eventStore,
+        shoppingCartId,
+        (state) => addProductItem(command, state),
+        { expectedStreamVersion: 'STREAM_DOES_NOT_EXIST' },
+      );
+
+      let tried = 0;
+
+      await assertThrowsAsync(
+        async () => {
+          await handleCommand(
+            eventStore,
+            shoppingCartId,
+            (state) => {
+              tried++;
+              return addProductItem(command, state);
+            },
+            { expectedStreamVersion: 'STREAM_DOES_NOT_EXIST' },
+          );
+        },
+        (error) => error instanceof ExpectedVersionConflictError,
+      );
+
+      // 0 as it should fail already on aggregating stream
+      assertEqual(0, tried);
+    });
+
     void it('When called successfuly returns new state for multiple returned events', async () => {
       const productItem: PricedProductItem = {
         productId: '123',
@@ -506,7 +548,7 @@ void describe('Command Handler', () => {
 
       let tried = 0;
 
-      const error = await assertThrowsAsync(
+      await assertThrowsAsync(
         async () => {
           await handleCommand(eventStore, shoppingCartId, () => {
             tried++;
@@ -516,8 +558,6 @@ void describe('Command Handler', () => {
         (error) => error instanceof ExpectedVersionConflictError,
       );
 
-      assertTrue(isExpectedVersionConflictError(error));
-
       assertEqual(1, tried);
     });
   });

src/packages/emmett/src/errors/index.ts

@@ -55,7 +55,7 @@ export class EmmettError extends Error {
   public static mapFrom(
     error: Error | { message?: string; errorCode?: number },
   ): EmmettError {
-    if (error instanceof EmmettError) {
+    if (EmmettError.isInstanceOf(error)) {
       return error;
     }
 
@@ -70,17 +70,16 @@ export class EmmettError extends Error {
     });
   }
 
-  public static isInstanceOf<ErrorType extends EmmettError>(
+  public static isInstanceOf<ErrorType extends EmmettError = EmmettError>(
     error: unknown,
-    errorCode: (typeof EmmettError.Codes)[keyof typeof EmmettError.Codes],
+    errorCode?: (typeof EmmettError.Codes)[keyof typeof EmmettError.Codes],
   ): error is ErrorType {
     return (
-      error !== undefined &&
-      error !== null &&
       typeof error === 'object' &&
+      error !== null &&
       'errorCode' in error &&
       isNumber(error.errorCode) &&
-      error.errorCode === errorCode
+      (errorCode === undefined || error.errorCode === errorCode)
     );
   }
 }

src/packages/emmett/src/eventStore/expectedVersion.ts

@@ -1,4 +1,4 @@
-import { ConcurrencyError } from '../errors';
+import { ConcurrencyError, EmmettError } from '../errors';
 import type { BigIntStreamPosition, Flavour } from '../typing';
 
 export type ExpectedStreamVersion<VersionType = BigIntStreamPosition> =
@@ -63,4 +63,8 @@ export class ExpectedVersionConflictError<
 export const isExpectedVersionConflictError = (
   error: unknown,
 ): error is ExpectedVersionConflictError =>
-  error instanceof ExpectedVersionConflictError;
+  error instanceof ExpectedVersionConflictError ||
+  EmmettError.isInstanceOf<ConcurrencyError>(
+    error,
+    ExpectedVersionConflictError.Codes.ConcurrencyError,
+  );