Strip away unsupported types in constructor arguments

Related to #56
Related to #65
Closes #66

Author: rubensworks

lib/parse/ParameterLoader.ts

@@ -244,6 +244,14 @@ export class ParameterLoader {
         return { type: 'raw', value: 'string' };
       case AST_NODE_TYPES.TSTypeLiteral:
         return { type: 'hash', value: typeNode };
+      case AST_NODE_TYPES.TSUnknownKeyword:
+      case AST_NODE_TYPES.TSUndefinedKeyword:
+      case AST_NODE_TYPES.TSVoidKeyword:
+      case AST_NODE_TYPES.TSNullKeyword:
+      case AST_NODE_TYPES.TSAnyKeyword:
+      case AST_NODE_TYPES.TSUnionType:
+      case AST_NODE_TYPES.TSTupleType:
+        return { type: 'undefined' };
     }
     throw new Error(`Could not understand parameter type ${typeNode.type} of ${errorIdentifier
     } in ${this.classLoaded.localName} at ${this.classLoaded.fileName}`);
@@ -424,6 +432,8 @@ export type ParameterRangeUnresolved = {
 } | {
   type: 'hash';
   value: TSTypeLiteral;
+} | {
+  type: 'undefined';
 };
 
 export type ParameterRangeResolved = {

lib/parse/ParameterResolver.ts

@@ -93,6 +93,10 @@ export class ParameterResolver {
           type: 'nested',
           value: await this.getNestedFieldsFromHash(range.value, owningClass),
         };
+      case 'undefined':
+        return {
+          type: 'undefined',
+        };
     }
   }
 

test/parse/ParameterLoader.test.ts

@@ -1064,6 +1064,41 @@ export interface A{
           },
         });
     });
+
+    it('should get the range of an unknown type as undefined', async() => {
+      expect(await getFieldRange('fieldA: unknown', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of an undefined type as undefined', async() => {
+      expect(await getFieldRange('fieldA: undefined', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of an any type as undefined', async() => {
+      expect(await getFieldRange('fieldA: any', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of an void type as undefined', async() => {
+      expect(await getFieldRange('fieldA: void', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of a null type as undefined', async() => {
+      expect(await getFieldRange('fieldA: null', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of a union type as undefined', async() => {
+      expect(await getFieldRange('fieldA: number | string', {}))
+        .toEqual({ type: 'undefined' });
+    });
+
+    it('should get the range of a tuple type as undefined', async() => {
+      expect(await getFieldRange('fieldA: [ number, string ]', {}))
+        .toEqual({ type: 'undefined' });
+    });
   });
 
   describe('getFieldDefault', () => {

test/parse/ParameterResolver.test.ts

@@ -359,6 +359,14 @@ export interface MyInterface extends IgnoredInterface{};
         value: [],
       });
     });
+
+    it('should handle an undefined range', async() => {
+      expect(await loader.resolveRange({
+        type: 'undefined',
+      }, classReference)).toMatchObject({
+        type: 'undefined',
+      });
+    });
   });
 
   describe('resolveRangeInterface', () => {