enhancement(types): Enable strictNullChecks and throw errors in unhandled situations

Author: martinjlowm

src/create-mock-list.ts

@@ -1,2 +1,2 @@
 import { DeepPartial } from './partial/deepPartial';
-export declare function createMockList<T extends object>(quantity: number, iterator?: (index: number) => DeepPartial<T>): T[];
+export declare function createMockList<T extends object | undefined>(quantity: number, iterator?: (index: number) => DeepPartial<T>): T[];

src/create-mock.ts

@@ -1,3 +1,3 @@
 import { DeepPartial } from './partial/deepPartial';
 
-export declare function createMock<T extends object>(values?: DeepPartial<T>): T;
+export declare function createMock<T extends object | undefined>(values?: DeepPartial<T>): T;

src/extension/extensionHandler.ts

@@ -25,6 +25,10 @@ export class ExtensionHandler<TMock> {
       return extensionOrPropertyName(this._mock);
     }
 
+    if (!maybePropertyHandler) {
+      throw new Error('Unhandled');
+    }
+
     return maybePropertyHandler(this._mock[extensionOrPropertyName], this._mock, extensionOrPropertyName);
   }
 }

src/options/options.ts

@@ -7,9 +7,9 @@ export interface TsAutoMockOptions {
   cacheBetweenTests: TsAutoMockCacheOptions;
 }
 
-let options: TsAutoMockOptions = null;
+let options: TsAutoMockOptions | undefined;
 
-export function SetTsAutoMockOptions(_options: TsAutoMockOptions): void {
+export function SetTsAutoMockOptions(_options?: TsAutoMockOptions): void {
   options = _options;
 }
 

src/transformer/base/base.ts

@@ -42,13 +42,17 @@ function visitNode(node: ts.Node, visitor: Visitor, customFunctions: CustomFunct
     return node;
   }
 
-  const signature: ts.Signature = TypescriptHelper.getSignatureOfCallExpression(node);
+  const signature: ts.Signature | undefined = TypescriptHelper.getSignatureOfCallExpression(node);
 
-  if (!isFunctionFromThisLibrary(signature, customFunctions)) {
+  if (!signature || !isFunctionFromThisLibrary(signature, customFunctions)) {
     return node;
   }
 
-  const nodeToMock: ts.TypeNode = node.typeArguments[0];
+  const nodeToMock: ts.TypeNode | undefined = node.typeArguments?.[0];
+
+  if (!nodeToMock) {
+    throw new Error('Unhandled');
+  }
 
   MockDefiner.instance.setFileNameFromNode(nodeToMock);
   MockDefiner.instance.setTsAutoMockImportIdentifier();

src/transformer/descriptor/helper/helper.ts

@@ -16,7 +16,11 @@ export namespace TypescriptHelper {
 
   export function GetDeclarationFromNode(node: ts.Node): ts.Declaration {
     const typeChecker: ts.TypeChecker = TypeChecker();
-    const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node);
+    const symbol: ts.Symbol | undefined = typeChecker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+      throw new Error('Unhandled');
+    }
 
     return GetDeclarationFromSymbol(symbol);
   }
@@ -56,11 +60,13 @@ export namespace TypescriptHelper {
   export function GetParameterOfNode(node: ts.EntityName): ts.NodeArray<ts.TypeParameterDeclaration> {
     const declaration: ts.Declaration = GetDeclarationFromNode(node);
 
-    return (declaration as Declaration).typeParameters;
+    const { typeParameters = ts.createNodeArray([]) }: Declaration = (declaration as Declaration);
+
+    return typeParameters;
   }
 
-  export function GetTypeParameterOwnerMock(declaration: ts.Declaration): ts.Declaration {
-    const typeDeclaration: ts.Declaration = ts.getTypeParameterOwner(declaration);
+  export function GetTypeParameterOwnerMock(declaration: ts.Declaration): ts.Declaration | undefined {
+    const typeDeclaration: ts.Declaration | undefined = ts.getTypeParameterOwner(declaration);
 
     // THIS IS TO FIX A MISSING IMPLEMENTATION IN TYPESCRIPT https://github.com/microsoft/TypeScript/blob/ba5e86f1406f39e89d56d4b32fd6ff8de09a0bf3/src/compiler/utilities.ts#L5138
     if (typeDeclaration && (typeDeclaration as Declaration).typeParameters) {
@@ -79,7 +85,12 @@ export namespace TypescriptHelper {
       return propertyName.text;
     }
 
-    const symbol: ts.Symbol = TypeChecker().getSymbolAtLocation(propertyName);
+    const symbol: ts.Symbol | undefined = TypeChecker().getSymbolAtLocation(propertyName);
+
+    if (!symbol) {
+      throw new Error('Unhandled');
+    }
+
     return symbol.escapedName.toString();
   }
 
@@ -88,7 +99,7 @@ export namespace TypescriptHelper {
   }
 
 
-  export function getSignatureOfCallExpression(node: ts.CallExpression): ts.Signature {
+  export function getSignatureOfCallExpression(node: ts.CallExpression): ts.Signature | undefined {
     const typeChecker: ts.TypeChecker = TypeChecker();
 
     return typeChecker.getResolvedSignature(node);
@@ -109,9 +120,9 @@ export namespace TypescriptHelper {
 
   function GetDeclarationsForImport(node: ImportDeclaration): ts.Declaration[] {
     const typeChecker: ts.TypeChecker = TypeChecker();
-    const symbol: ts.Symbol = typeChecker.getSymbolAtLocation(node.name);
-    const originalSymbol: ts.Symbol = typeChecker.getAliasedSymbol(symbol);
+    const symbol: ts.Symbol | undefined = node.name && typeChecker.getSymbolAtLocation(node.name);
+    const originalSymbol: ts.Symbol | undefined = symbol && typeChecker.getAliasedSymbol(symbol);
 
-    return originalSymbol.declarations;
+    return originalSymbol?.declarations ?? [];
   }
 }

src/transformer/descriptor/indexedAccess/indexedAccess.ts

@@ -37,7 +37,12 @@ export function GetIndexedAccessTypeDescriptor(node: ts.IndexedAccessTypeNode, s
   }
 
   if (propertyName !== null) {
-    const propertySymbol: ts.Symbol = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(node.objectType), propertyName);
+    const propertySymbol: ts.Symbol | undefined = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(node.objectType), propertyName);
+
+    if (!propertySymbol) {
+      throw new Error('Unhandled');
+    }
+
     return GetDescriptor(TypescriptHelper.GetDeclarationFromSymbol(propertySymbol), scope);
   }
 

src/transformer/descriptor/mapped/mapped.ts

@@ -6,9 +6,15 @@ import { GetMockPropertiesFromDeclarations } from '../mock/mockProperties';
 import { GetTypes } from '../type/type';
 
 export function GetMappedDescriptor(node: ts.MappedTypeNode, scope: Scope): ts.Expression {
-  const typeParameter: ts.TypeNode = node.typeParameter.constraint;
+  const typeParameter: ts.TypeNode | undefined = node.typeParameter.constraint;
   const typeChecker: ts.TypeChecker = TypeChecker();
-  const types: ts.Node[] = GetTypes(ts.createNodeArray([typeParameter]), scope);
+
+  const parameters: ts.TypeNode[] = [];
+  if (typeParameter) {
+    parameters.push(typeParameter);
+  }
+
+  const types: ts.Node[] = GetTypes(ts.createNodeArray(parameters), scope);
 
   const properties: ts.PropertyDeclaration[] = types.reduce((acc: ts.PropertyDeclaration[], possibleType: ts.Node) => {
     if (ts.isLiteralTypeNode(possibleType)) {

src/transformer/descriptor/method/bodyReturnType.ts

@@ -8,11 +8,11 @@ export function GetReturnTypeFromBodyDescriptor(node: ts.ArrowFunction | ts.Func
 }
 
 export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node {
-  let returnValue: ts.Node;
+  let returnValue: ts.Node | undefined;
 
-  const functionBody: ts.ConciseBody = node.body;
+  const functionBody: ts.ConciseBody | undefined = node.body;
 
-  if (ts.isBlock(functionBody)) {
+  if (functionBody && ts.isBlock(functionBody)) {
     const returnStatement: ts.ReturnStatement = GetReturnStatement(functionBody);
 
     if (returnStatement) {
@@ -24,6 +24,10 @@ export function GetReturnNodeFromBody(node: ts.FunctionLikeDeclaration): ts.Node
     returnValue = node.body;
   }
 
+  if (!returnValue) {
+    throw new Error('Unhandled');
+  }
+
   return returnValue;
 }
 

src/transformer/descriptor/method/functionType.ts

@@ -7,6 +7,10 @@ import { GetMethodDescriptor } from './method';
 export function GetFunctionTypeDescriptor(node: ts.FunctionTypeNode | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration, scope: Scope): ts.Expression {
   const property: ts.PropertyName = PropertySignatureCache.instance.get();
 
+  if (!node.type) {
+    throw new Error('Unhandled');
+  }
+
   const returnValue: ts.Expression = GetDescriptor(node.type, scope);
 
   return GetMethodDescriptor(property, returnValue);