Merge pull request #1433 from AudunWA/awa/fix/strict-ts

fix: enable compilerOptions.strict for all packages

Author: WoH

packages/cli/src/cli.ts

@@ -60,18 +60,17 @@ const getConfig = async (configPath = 'tsoa.json'): Promise<Config> => {
       config = JSON.parse(configRaw.toString('utf8'));
     }
   } catch (err) {
-    if (err.code === 'MODULE_NOT_FOUND') {
+    if (!(err instanceof Error)) {
+      console.error(err);
+      throw Error(`Unhandled error encountered loading '${configPath}': ${String(err)}`);
+    } else if ('code' in err && err.code === 'MODULE_NOT_FOUND') {
       throw Error(`No config file found at '${configPath}'`);
     } else if (err.name === 'SyntaxError') {
-      // eslint-disable-next-line no-console
       console.error(err);
       const errorType = ext === '.js' ? 'JS' : 'JSON';
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
       throw Error(`Invalid ${errorType} syntax in config at '${configPath}': ${err.message}`);
     } else {
-      // eslint-disable-next-line no-console
       console.error(err);
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
       throw Error(`Unhandled error encountered loading '${configPath}': ${err.message}`);
     }
   }

packages/cli/src/metadataGeneration/extension.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getInitializerValue } from './initializer-value';
+import { getInitializerValue, isNonUndefinedInitializerValue } from './initializer-value';
 import { MetadataGenerator } from './metadataGenerator';
 import { Tsoa } from '@tsoa/runtime';
 import { safeFromJson } from '../utils/jsonUtils';
@@ -22,10 +22,12 @@ export function getExtensions(decorators: ts.Identifier[], metadataGenerator: Me
       throw new Error(`Extension '${attributeKey}' must contain a value`);
     }
 
-    validateExtensionKey(attributeKey);
+    assertValidExtensionKey(attributeKey);
 
     const attributeValue = getInitializerValue(decoratorValueArg, metadataGenerator.typeChecker);
-
+    if (!isNonUndefinedInitializerValue(attributeValue)) {
+      throw new Error(`Extension '${attributeKey}' cannot have an undefined initializer value`);
+    }
     return { key: attributeKey, value: attributeValue };
   });
 
@@ -39,8 +41,7 @@ export function getExtensionsFromJSDocComments(comments: string[]): Tsoa.Extensi
     if (extensionData) {
       const keys = Object.keys(extensionData);
       keys.forEach(key => {
-        validateExtensionKey(key);
-
+        assertValidExtensionKey(key);
         extensions.push({ key: key, value: extensionData[key] });
       });
     }
@@ -49,8 +50,8 @@ export function getExtensionsFromJSDocComments(comments: string[]): Tsoa.Extensi
   return extensions;
 }
 
-function validateExtensionKey(key: string) {
-  if (key.indexOf('x-') !== 0) {
+function assertValidExtensionKey(key: string): asserts key is `x-${string}` {
+  if (!key.startsWith('x-')) {
     throw new Error('Extensions must begin with "x-" to be valid. Please see the following link for more information: https://swagger.io/docs/specification/openapi-extensions/');
   }
 }

packages/cli/src/metadataGeneration/initializer-value.ts

@@ -5,7 +5,17 @@ const hasInitializer = (node: ts.Node): node is ts.HasInitializer => Object.prot
 const extractInitializer = (decl?: ts.Declaration) => (decl && hasInitializer(decl) && (decl.initializer as ts.Expression)) || undefined;
 const extractImportSpecifier = (symbol?: ts.Symbol) => (symbol?.declarations && symbol.declarations.length > 0 && ts.isImportSpecifier(symbol.declarations[0]) && symbol.declarations[0]) || undefined;
 
-export const getInitializerValue = (initializer?: ts.Expression | ts.ImportSpecifier, typeChecker?: ts.TypeChecker, type?: Tsoa.Type) => {
+export type InitializerValue = string | number | boolean | undefined | null | InitializerValue[];
+export type DefinedInitializerValue = string | number | boolean | null | DefinedInitializerValue[];
+export function isNonUndefinedInitializerValue(value: InitializerValue): value is DefinedInitializerValue {
+  if (Array.isArray(value)) {
+    return value.every(isNonUndefinedInitializerValue);
+  } else {
+    return value !== undefined;
+  }
+}
+
+export function getInitializerValue(initializer?: ts.Expression | ts.ImportSpecifier, typeChecker?: ts.TypeChecker, type?: Tsoa.Type): InitializerValue | DefinedInitializerValue {
   if (!initializer || !typeChecker) {
     return;
   }
@@ -81,4 +91,4 @@ export const getInitializerValue = (initializer?: ts.Expression | ts.ImportSpeci
       return getInitializerValue(extractInitializer(symbol?.valueDeclaration) || extractImportSpecifier(symbol), typeChecker);
     }
   }
-};
+}

packages/cli/src/metadataGeneration/methodGenerator.ts

@@ -12,9 +12,11 @@ import { Tsoa } from '@tsoa/runtime';
 import { TypeResolver } from './typeResolver';
 import { getHeaderType } from '../utils/headerTypeHelpers';
 
+type HttpMethod = 'options' | 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head';
+
 export class MethodGenerator {
-  private method: 'options' | 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head';
-  private path: string;
+  protected method?: HttpMethod;
+  protected path?: string;
   private produces?: string[];
   private consumes?: string;
 
@@ -30,8 +32,8 @@ export class MethodGenerator {
     this.processMethodDecorators();
   }
 
-  public IsValid() {
-    return !!this.method;
+  public IsValid(): this is { method: HttpMethod; path: string } {
+    return this.method !== undefined && this.path !== undefined;
   }
 
   public Generate(): Tsoa.Method {
@@ -76,15 +78,21 @@ export class MethodGenerator {
   }
 
   private buildParameters() {
+    if (!this.IsValid()) {
+      throw new GenerateMetadataError("This isn't a valid a controller method.");
+    }
+
     const fullPath = path.join(this.parentPath || '', this.path);
+    const method = this.method;
     const parameters = this.node.parameters
       .map(p => {
         try {
-          return new ParameterGenerator(p, this.method, fullPath, this.current).Generate();
+          return new ParameterGenerator(p, method, fullPath, this.current).Generate();
         } catch (e) {
           const methodId = this.node.name as ts.Identifier;
           const controllerId = (this.node.parent as ts.ClassDeclaration).name as ts.Identifier;
-          throw new GenerateMetadataError(`${String(e.message)} \n in '${controllerId.text}.${methodId.text}'`);
+          const message = e instanceof Error ? e.message : String(e);
+          throw new GenerateMetadataError(`${message} \n in '${controllerId.text}.${methodId.text}'`);
         }
       })
       .reduce((flattened, params) => [...flattened, ...params], []);

packages/cli/src/metadataGeneration/parameterGenerator.ts

@@ -414,7 +414,8 @@ export class ParameterGenerator {
           exampleLabels,
         };
       } catch (e) {
-        throw new GenerateMetadataError(`JSON format is incorrect: ${String(e.message)}`);
+        const message = e instanceof Error ? e.message : String(e);
+        throw new GenerateMetadataError(`JSON format is incorrect: ${message}`);
       }
     }
   }
@@ -427,7 +428,7 @@ export class ParameterGenerator {
     return ['header', 'query', 'queries', 'path', 'body', 'bodyprop', 'request', 'res', 'inject', 'uploadedfile', 'uploadedfiles', 'formfield'].some(d => d === decoratorName.toLocaleLowerCase());
   }
 
-  private supportPathDataType(parameterType: Tsoa.Type) {
+  private supportPathDataType(parameterType: Tsoa.Type): boolean {
     const supportedPathDataTypes: Tsoa.TypeStringLiteral[] = ['string', 'integer', 'long', 'float', 'double', 'date', 'datetime', 'buffer', 'boolean', 'enum', 'refEnum', 'file', 'any'];
     if (supportedPathDataTypes.find(t => t === parameterType.dataType)) {
       return true;

packages/cli/src/metadataGeneration/typeResolver.ts

@@ -109,25 +109,23 @@ export class TypeResolver {
     }
 
     if (ts.isTypeLiteralNode(this.typeNode)) {
-      const properties = this.typeNode.members
-        .filter(member => ts.isPropertySignature(member))
-        .reduce((res, propertySignature: ts.PropertySignature) => {
-          const type = new TypeResolver(propertySignature.type as ts.TypeNode, this.current, propertySignature, this.context).resolve();
-          const property: Tsoa.Property = {
-            example: this.getNodeExample(propertySignature),
-            default: getJSDocComment(propertySignature, 'default'),
-            description: this.getNodeDescription(propertySignature),
-            format: this.getNodeFormat(propertySignature),
-            name: (propertySignature.name as ts.Identifier).text,
-            required: !propertySignature.questionToken,
-            type,
-            validators: getPropertyValidators(propertySignature) || {},
-            deprecated: isExistJSDocTag(propertySignature, tag => tag.tagName.text === 'deprecated'),
-            extensions: this.getNodeExtension(propertySignature),
-          };
+      const properties = this.typeNode.members.filter(ts.isPropertySignature).reduce<Tsoa.Property[]>((res, propertySignature: ts.PropertySignature) => {
+        const type = new TypeResolver(propertySignature.type as ts.TypeNode, this.current, propertySignature, this.context).resolve();
+        const property: Tsoa.Property = {
+          example: this.getNodeExample(propertySignature),
+          default: getJSDocComment(propertySignature, 'default'),
+          description: this.getNodeDescription(propertySignature),
+          format: this.getNodeFormat(propertySignature),
+          name: (propertySignature.name as ts.Identifier).text,
+          required: !propertySignature.questionToken,
+          type,
+          validators: getPropertyValidators(propertySignature) || {},
+          deprecated: isExistJSDocTag(propertySignature, tag => tag.tagName.text === 'deprecated'),
+          extensions: this.getNodeExtension(propertySignature),
+        };
 
-          return [property, ...res];
-        }, []);
+        return [property, ...res];
+      }, []);
 
       const indexMember = this.typeNode.members.find(member => ts.isIndexSignatureDeclaration(member));
       let additionalType: Tsoa.Type | undefined;
@@ -256,7 +254,7 @@ export class TypeResolver {
       const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
 
       if (type.isUnion()) {
-        const literals = type.types.filter(t => t.isLiteral()).reduce((acc, t: ts.LiteralType) => [...acc, t.value.toString()], []);
+        const literals = type.types.filter((t): t is ts.LiteralType => t.isLiteral()).reduce<string[]>((acc, t: ts.LiteralType) => [...acc, t.value.toString()], []);
 
         // Warn on nonsense (`number`, `typeof Symbol.iterator`)
         if (type.types.find(t => !t.isLiteral()) !== undefined) {
@@ -361,7 +359,7 @@ export class TypeResolver {
 
     if (ts.isTemplateLiteralTypeNode(this.typeNode)) {
       const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
-      if (type.isUnion() && type.types.every(unionElementType => unionElementType.isStringLiteral())) {
+      if (type.isUnion() && type.types.every((unionElementType): unionElementType is ts.StringLiteralType => unionElementType.isStringLiteral())) {
         const stringLiteralEnum: Tsoa.EnumType = {
           dataType: 'enum',
           enums: type.types.map((stringLiteralType: ts.StringLiteralType) => stringLiteralType.value),
@@ -544,7 +542,7 @@ export class TypeResolver {
     return nodes;
   }
 
-  private hasFlag(type: ts.Symbol | ts.Declaration, flag) {
+  private hasFlag(type: ts.Symbol | ts.Declaration, flag: ts.NodeFlags | ts.SymbolFlags) {
     return (type.flags & flag) === flag;
   }
 
@@ -913,7 +911,9 @@ export class TypeResolver {
 
     // Interface model
     if (ts.isInterfaceDeclaration(node)) {
-      return node.members.filter(member => !isIgnored(member) && ts.isPropertySignature(member)).map((member: ts.PropertySignature) => this.propertyFromSignature(member, overrideToken));
+      return node.members
+        .filter((member): member is ts.PropertySignature => !isIgnored(member) && ts.isPropertySignature(member))
+        .map((member: ts.PropertySignature) => this.propertyFromSignature(member, overrideToken));
     }
 
     const properties: Array<ts.PropertyDeclaration | ts.ParameterDeclaration> = [];

packages/cli/src/swagger/specGenerator.ts

@@ -96,9 +96,9 @@ export abstract class SpecGenerator {
     }
   }
 
-  protected abstract getSwaggerTypeForUnionType(type: Tsoa.UnionType, title?: string);
+  protected abstract getSwaggerTypeForUnionType(type: Tsoa.UnionType, title?: string): Swagger.Schema | Swagger.BaseSchema;
 
-  protected abstract getSwaggerTypeForIntersectionType(type: Tsoa.IntersectionType, title?: string);
+  protected abstract getSwaggerTypeForIntersectionType(type: Tsoa.IntersectionType, title?: string): Swagger.Schema | Swagger.BaseSchema;
 
   protected abstract buildProperties(properties: Tsoa.Property[]): { [propertyName: string]: Swagger.Schema | Swagger.Schema3 };
 

packages/cli/src/swagger/specGenerator2.ts

@@ -5,6 +5,7 @@ import { convertColonPathParams, normalisePath } from './../utils/pathUtils';
 import { DEFAULT_REQUEST_MEDIA_TYPE, DEFAULT_RESPONSE_MEDIA_TYPE, getValue } from './../utils/swaggerUtils';
 import { SpecGenerator } from './specGenerator';
 import { UnspecifiedObject } from '../utils/unspecifiedObject';
+import { shouldIncludeValidatorInSchema } from '../utils/validatorUtils';
 
 export class SpecGenerator2 extends SpecGenerator {
   constructor(protected readonly metadata: Tsoa.Metadata, protected readonly config: ExtendedSpecConfig) {
@@ -113,13 +114,11 @@ export class SpecGenerator2 extends SpecGenerator {
         const swaggerType = this.getSwaggerType(referenceType.type);
         const format = referenceType.format as Swagger.DataFormat;
         const validators = Object.keys(referenceType.validators)
-          .filter(key => {
-            return !key.startsWith('is') && key !== 'minDate' && key !== 'maxDate';
-          })
+          .filter(shouldIncludeValidatorInSchema)
           .reduce((acc, key) => {
             return {
               ...acc,
-              [key]: referenceType.validators[key].value,
+              [key]: referenceType.validators[key]!.value,
             };
           }, {});
 
@@ -229,11 +228,11 @@ export class SpecGenerator2 extends SpecGenerator {
       }
 
       if (res.headers) {
-        const headers = {};
+        const headers: { [name: string]: Swagger.Header } = {};
         if (res.headers.dataType === 'refObject' || res.headers.dataType === 'nestedObjectLiteral') {
           res.headers.properties.forEach((each: Tsoa.Property) => {
             headers[each.name] = {
-              ...this.getSwaggerType(each.type),
+              ...(this.getSwaggerType(each.type) as Swagger.Header),
               description: each.description,
             };
           });
@@ -353,13 +352,11 @@ export class SpecGenerator2 extends SpecGenerator {
       return parameter;
     }
 
-    const validatorObjs = {};
+    const validatorObjs: Partial<Record<Tsoa.SchemaValidatorKey, unknown>> = {};
     Object.keys(source.validators)
-      .filter(key => {
-        return !key.startsWith('is') && key !== 'minDate' && key !== 'maxDate';
-      })
-      .forEach((key: string) => {
-        validatorObjs[key] = source.validators[key].value;
+      .filter(shouldIncludeValidatorInSchema)
+      .forEach(key => {
+        validatorObjs[key] = source.validators[key]!.value;
       });
 
     if (source.in === 'body' && source.type.dataType === 'array') {
@@ -396,7 +393,7 @@ export class SpecGenerator2 extends SpecGenerator {
     const properties: { [propertyName: string]: Swagger.Schema2 } = {};
 
     source.forEach(property => {
-      const swaggerType = this.getSwaggerType(property.type) as Swagger.Schema2;
+      let swaggerType = this.getSwaggerType(property.type) as Swagger.Schema2;
       const format = property.format as Swagger.DataFormat;
       swaggerType.description = property.description;
       swaggerType.example = property.example;
@@ -405,11 +402,9 @@ export class SpecGenerator2 extends SpecGenerator {
         swaggerType.default = property.default;
 
         Object.keys(property.validators)
-          .filter(key => {
-            return !key.startsWith('is') && key !== 'minDate' && key !== 'maxDate';
-          })
+          .filter(shouldIncludeValidatorInSchema)
           .forEach(key => {
-            swaggerType[key] = property.validators[key].value;
+            swaggerType = { ...swaggerType, [key]: property.validators[key]!.value };
           });
       }
       if (property.deprecated) {