fix(hydratedMocks): fix recursion (#736)

package.json

@@ -64,7 +64,7 @@
         "@typescript-eslint/eslint-plugin": "^4.22.0",
         "@typescript-eslint/parser": "^4.22.0",
         "all-contributors-cli": "6.20.0",
-        "clean-webpack-plugin": "^3.0.0",
+        "clean-webpack-plugin": "^4.0.0-alpha.0",
         "commitizen": "^4.2.3",
         "conventional-changelog-angular": "^5.0.12",
         "copy-webpack-plugin": "^8.1.1",

src/transformer/descriptor/type/type.ts

@@ -41,7 +41,21 @@ export function GetType(node: ts.Node, scope: Scope): ts.Node {
       node.typeName
     );
 
-    return GetType(declaration, scope);
+    const type: ts.Node = GetType(declaration, scope);
+
+    // if the type is a reusable and finite (reusable types except for typeAlias)
+    // we can return the original node
+    // so it can be re used and we handle recursion
+
+    if (
+      type.kind === ts.SyntaxKind.InterfaceDeclaration ||
+      type.kind === ts.SyntaxKind.ClassDeclaration ||
+      type.kind === ts.SyntaxKind.TypeLiteral
+    ) {
+      return node;
+    }
+
+    return type;
   }
 
   if (ts.isThisTypeNode(node)) {

test/createHydratedMock/create-hydrated-mock.test.ts

@@ -229,4 +229,48 @@ describe('create-hydrated-mock', () => {
       });
     });
   });
+
+  describe('for recursive types', () => {
+    describe('for interfaces', () => {
+      type B = A;
+
+      interface A {
+        recursiveProp: B | null;
+        aProp: string | null;
+      }
+
+      it('should use the define type', () => {
+        const type: A = createHydratedMock<A>();
+        expect(type.recursiveProp?.aProp).toBe('');
+      });
+    });
+
+    describe('for classes', () => {
+      type B = A;
+
+      class A {
+        public recursiveProp: B | null;
+        public aProp: string | null;
+      }
+
+      it('should use the define type', () => {
+        const type: A = createHydratedMock<A>();
+        expect(type.recursiveProp?.aProp).toBe('');
+      });
+    });
+
+    describe('for type literal', () => {
+      type B = A;
+
+      type A = {
+        recursiveProp: B | null;
+        aProp: string | null;
+      };
+
+      it('should use the define type', () => {
+        const type: A = createHydratedMock<A>();
+        expect(type.recursiveProp?.aProp).toBe('');
+      });
+    });
+  });
 });