Many nested factories (#57)

.changeset/breezy-icons-collect.md

@@ -0,0 +1,5 @@
+---
+'@withease/factories': patch
+---
+
+Fix false-positive exception in case of many nexted factories

packages/factories/src/factories.test.ts

@@ -77,4 +77,72 @@ describe('nested factories', () => {
 
     expect(() => invoke(externalFactory)).not.toThrowError();
   });
+
+  test('valid many nested factories', () => {
+    const internalFactory = createFactory(() => {
+      return 1;
+    });
+
+    const externalFactory = createFactory(() => {
+      const internal2 = invoke(internalFactory);
+      const internal1 = invoke(internalFactory);
+      return { internal1, internal2 };
+    });
+
+    expect(() => invoke(externalFactory)).not.toThrowError();
+  });
+
+  test('invalid many nested factories', () => {
+    const internalFactory = createFactory(() => {
+      return 1;
+    });
+
+    const externalFactory = createFactory(() => {
+      const internal2 = invoke(internalFactory);
+      const internal1 = internalFactory();
+      return { internal1, internal2 };
+    });
+
+    expect(() => invoke(externalFactory)).toThrowErrorMatchingInlineSnapshot(
+      '"Do not call factory directly, pass it to invoke function instead"'
+    );
+  });
+
+  test('valid very many nested factories', () => {
+    const veryInternalFactory = createFactory(() => {
+      return 1;
+    });
+
+    const internalFactory = createFactory(() => {
+      return invoke(veryInternalFactory);
+    });
+
+    const externalFactory = createFactory(() => {
+      const internal2 = invoke(internalFactory);
+      const internal1 = invoke(internalFactory);
+      return { internal1, internal2 };
+    });
+
+    expect(() => invoke(externalFactory)).not.toThrowError();
+  });
+
+  test('invalid very many nested factories', () => {
+    const veryInternalFactory = createFactory(() => {
+      return 1;
+    });
+
+    const internalFactory = createFactory(() => {
+      return veryInternalFactory();
+    });
+
+    const externalFactory = createFactory(() => {
+      const internal2 = invoke(internalFactory);
+      const internal1 = invoke(internalFactory);
+      return { internal1, internal2 };
+    });
+
+    expect(() => invoke(externalFactory)).toThrowErrorMatchingInlineSnapshot(
+      '"Do not call factory directly, pass it to invoke function instead"'
+    );
+  });
 });

packages/factories/src/invoke.ts

@@ -4,8 +4,8 @@ import { factoryCalledDirectly, invokeAcceptsOnlyFactories } from './errors';
  * The following variables are used for checking that factory is called inside invoke function on correct nesting level
  */
 export let invokeLevel = 0;
+let invokeCount = 0;
 let factoryCalledCount = 0;
-let maxInvokeLevel = 0;
 
 /**
  * Have to be called inside factory created by createFactory
@@ -29,11 +29,10 @@ export function invoke<
 >(factory: C, params?: P): OverloadReturn<P, OverloadUnion<C>> {
   /* Increase invoke level before factory calling */
   invokeLevel += 1;
+  invokeCount += 1;
 
   const result = factory(params);
 
-  /* Save max invoke level for later checks */
-  maxInvokeLevel = Math.max(maxInvokeLevel, invokeLevel);
   /* And descrese in after */
   invokeLevel -= 1;
 
@@ -42,11 +41,11 @@ export function invoke<
 
   if (invokeLevel === 0 /* Ending of nexted invoke calls */) {
     haveToThrowErrorBecauseInvokeLevel /* Amount of invokes and factoies does not match */ =
-      factoryCalledCount !== maxInvokeLevel;
+      factoryCalledCount !== invokeCount;
 
     /* Reset related variables */
     factoryCalledCount = 0;
-    maxInvokeLevel = 0;
+    invokeCount = 0;
   }
 
   if (haveToThrowBecauseOfCalledFactory) {