refactor: reduce implicit types

packages/common/cache/interceptors/cache.interceptor.ts

@@ -23,7 +23,7 @@ export class CacheInterceptor implements NestInterceptor {
     @Inject(HTTP_SERVER_REF)
     protected readonly httpServer: HttpServer,
     @Inject(CACHE_MANAGER) protected readonly cacheManager: any,
-    @Inject(REFLECTOR) protected readonly reflector,
+    @Inject(REFLECTOR) protected readonly reflector: any,
   ) {
     this.isHttpApp = httpServer && !!httpServer.getRequestMethod;
   }
@@ -41,7 +41,9 @@ export class CacheInterceptor implements NestInterceptor {
       if (value) {
         return of(value);
       }
-      return call$.pipe(tap(response => this.cacheManager.set(key, response)));
+      return call$.pipe(
+        tap((response: any) => this.cacheManager.set(key, response)),
+      );
     } catch {
       return call$;
     }

packages/common/decorators/core/bind.decorator.ts

@@ -3,8 +3,12 @@
  * Useful when the language doesn't provide a 'Parameter Decorators' feature (vanilla JavaScript)
  * @param  {} ...decorators
  */
-export function Bind(...decorators: any[]) {
+export function Bind(...decorators: any[]): MethodDecorator {
-  return (target: object, key, descriptor) => {
+  return <T>(
+    target: object,
+    key: string | symbol,
+    descriptor: TypedPropertyDescriptor<T>,
+  ) => {
     decorators.forEach((fn, index) => fn(target, key, index));
     return descriptor;
   };

packages/common/files/interceptors/file-fields.interceptor.ts

@@ -42,7 +42,7 @@ export function FileFieldsInterceptor(
         this.upload.fields(uploadFields)(
           ctx.getRequest(),
           ctx.getResponse(),
-          err => {
+          (err: any) => {
             if (err) {
               const error = transformException(err);
               return reject(error);

packages/common/files/interceptors/file.interceptor.ts

@@ -39,7 +39,7 @@ export function FileInterceptor(
         this.upload.single(fieldName)(
           ctx.getRequest(),
           ctx.getResponse(),
-          err => {
+          (err: any) => {
             if (err) {
               const error = transformException(err);
               return reject(error);

packages/common/files/interceptors/files.interceptor.ts

@@ -40,7 +40,7 @@ export function FilesInterceptor(
         this.upload.array(fieldName, maxCount)(
           ctx.getRequest(),
           ctx.getResponse(),
-          err => {
+          (err: any) => {
             if (err) {
               const error = transformException(err);
               return reject(error);

packages/common/interfaces/features/pipe-transform.interface.ts

@@ -4,7 +4,7 @@ export type Transform<T = any> = (value: T, metadata: ArgumentMetadata) => any;
 
 export interface ArgumentMetadata {
   readonly type: Paramtype;
-  readonly metatype?: new (...args) => any | undefined;
+  readonly metatype?: new (...args: any[]) => any | undefined;
   readonly data?: string | undefined;
 }
 

packages/common/interfaces/nest-application.interface.ts

@@ -21,7 +21,7 @@ export interface INestApplication extends INestApplicationContext {
    *
    * @returns {void}
    */
-  use(...args): this;
+  use(...args: any[]): this;
 
   /**
    * Enables CORS (Cross-Origin Resource Sharing)

packages/common/interfaces/websockets/web-socket-adapter.interface.ts

@@ -2,8 +2,8 @@ import { Observable } from 'rxjs';
 
 export interface WebSocketAdapter<T = any> {
   create(port: number, options?: T);
-  bindClientConnect(server: any, callback: (...args) => void);
+  bindClientConnect(server: any, callback: (...args: any[]) => void);
-  bindClientDisconnect?(client: any, callback: (...args) => void);
+  bindClientDisconnect?(client: any, callback: (...args: any[]) => void);
   bindMessageHandlers(
     client: any,
     handlers: Array<{

packages/common/utils/shared.utils.ts

@@ -1,11 +1,11 @@
-export const isUndefined = (obj): obj is undefined =>
+export const isUndefined = (obj: any): obj is undefined =>
   typeof obj === 'undefined';
-export const isFunction = (fn): boolean => typeof fn === 'function';
+export const isFunction = (fn: any): boolean => typeof fn === 'function';
-export const isObject = (fn): fn is object => typeof fn === 'object';
+export const isObject = (fn: any): fn is object => typeof fn === 'object';
-export const isString = (fn): fn is string => typeof fn === 'string';
+export const isString = (fn: any): fn is string => typeof fn === 'string';
-export const isConstructor = (fn): boolean => fn === 'constructor';
+export const isConstructor = (fn: any): boolean => fn === 'constructor';
-export const validatePath = (path): string =>
+export const validatePath = (path: string): string =>
   path.charAt(0) !== '/' ? '/' + path : path;
-export const isNil = (obj): boolean => isUndefined(obj) || obj === null;
+export const isNil = (obj: any): boolean => isUndefined(obj) || obj === null;
-export const isEmpty = (array): boolean => !(array && array.length > 0);
+export const isEmpty = (array: any): boolean => !(array && array.length > 0);
-export const isSymbol = (fn): boolean => typeof fn === 'symbol';
+export const isSymbol = (fn: any): boolean => typeof fn === 'symbol';

packages/core/guards/guards-consumer.ts

@@ -1,6 +1,6 @@
-import { isEmpty } from '@nestjs/common/utils/shared.utils';
-import { Controller } from '@nestjs/common/interfaces';
 import { CanActivate } from '@nestjs/common';
+import { Controller } from '@nestjs/common/interfaces';
+import { isEmpty } from '@nestjs/common/utils/shared.utils';
 import { Observable } from 'rxjs';
 import { ExecutionContextHost } from '../helpers/execution-context.host';
 
@@ -9,7 +9,7 @@ export class GuardsConsumer {
     guards: CanActivate[],
     args: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): Promise<boolean> {
     if (!guards || isEmpty(guards)) {
       return true;
@@ -28,7 +28,7 @@ export class GuardsConsumer {
   public createContext(
     args: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): ExecutionContextHost {
     return new ExecutionContextHost(
       args,

packages/core/guards/guards-context-creator.ts

@@ -2,7 +2,11 @@ import { CanActivate } from '@nestjs/common';
 import { GUARDS_METADATA } from '@nestjs/common/constants';
 import { Controller } from '@nestjs/common/interfaces';
 import { ConfigurationProvider } from '@nestjs/common/interfaces/configuration-provider.interface';
-import { isEmpty, isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
+import {
+  isEmpty,
+  isFunction,
+  isUndefined,
+} from '@nestjs/common/utils/shared.utils';
 import iterate from 'iterare';
 import { ContextCreator } from '../helpers/context-creator';
 import { NestContainer } from '../injector/container';
@@ -19,7 +23,7 @@ export class GuardsContextCreator extends ContextCreator {
 
   public create(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     module: string,
   ): CanActivate[] {
     this.moduleContext = module;

packages/core/helpers/context-creator.ts

@@ -8,7 +8,7 @@ export abstract class ContextCreator {
 
   public createContext<T extends any[], R extends any[]>(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     metadataKey: string,
   ): R {
     const globalMetadata =
@@ -28,7 +28,7 @@ export abstract class ContextCreator {
   }
 
   public reflectMethodMetadata<T>(
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     metadataKey: string,
   ): T {
     return Reflect.getMetadata(metadataKey, callback);

packages/core/helpers/external-context-creator.ts

@@ -52,7 +52,7 @@ export class ExternalContextCreator {
 
   public create<T extends ParamsMetadata = ParamsMetadata>(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     methodName: string,
     metadataKey?: string,
     paramsFactory?: ParamsFactory,
@@ -95,7 +95,7 @@ export class ExternalContextCreator {
       return callback.apply(instance, args);
     };
 
-    return async (...args) => {
+    return async (...args: any[]) => {
       const initialArgs = this.contextUtils.createNullArray(argsLength);
       const canActivate = await this.guardsConsumer.tryActivate(
         guards,
@@ -165,9 +165,12 @@ export class ExternalContextCreator {
     });
   }
 
-  public getCustomFactory(factory: (...args) => void, data): (...args) => any {
+  public getCustomFactory(
+    factory: (...args: any[]) => void,
+    data,
+  ): (...args: any[]) => any {
     return !isUndefined(factory) && isFunction(factory)
-      ? (...args) => factory(data, args)
+      ? (...args: any[]) => factory(data, args)
       : () => null;
   }
 

packages/core/injector/module.ts

@@ -31,7 +31,7 @@ export interface CustomProvider {
 export type OpaqueToken = string | symbol | object | Type<any>;
 export type CustomClass = CustomProvider & { useClass: Type<any> };
 export type CustomFactory = CustomProvider & {
-  useFactory: (...args) => any;
+  useFactory: (...args: any[]) => any;
   inject?: OpaqueToken[];
 };
 export type CustomValue = CustomProvider & { useValue: any };

packages/core/interceptors/interceptors-consumer.ts

@@ -10,7 +10,7 @@ export class InterceptorsConsumer {
     interceptors: NestInterceptor[],
     args: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     next: () => Promise<any>,
   ): Promise<any> {
     if (isEmpty(interceptors)) {
@@ -27,7 +27,8 @@ export class InterceptorsConsumer {
     };
     */
     const result$ = await interceptors.reduce(
-      async (stream$, interceptor) => interceptor.intercept(context, await stream$),
+      async (stream$, interceptor) =>
+        interceptor.intercept(context, await stream$),
       Promise.resolve(start$),
     );
     return result$.toPromise();
@@ -36,7 +37,7 @@ export class InterceptorsConsumer {
   public createContext(
     args: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): ExecutionContextHost {
     return new ExecutionContextHost(
       args,

packages/core/interceptors/interceptors-context-creator.ts

@@ -1,7 +1,11 @@
 import { INTERCEPTORS_METADATA } from '@nestjs/common/constants';
 import { Controller, NestInterceptor } from '@nestjs/common/interfaces';
 import { ConfigurationProvider } from '@nestjs/common/interfaces/configuration-provider.interface';
-import { isEmpty, isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
+import {
+  isEmpty,
+  isFunction,
+  isUndefined,
+} from '@nestjs/common/utils/shared.utils';
 import iterate from 'iterare';
 import { ContextCreator } from '../helpers/context-creator';
 import { NestContainer } from '../injector/container';
@@ -18,7 +22,7 @@ export class InterceptorsContextCreator extends ContextCreator {
 
   public create(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     module: string,
   ): NestInterceptor[] {
     this.moduleContext = module;

packages/core/middleware/utils.ts

@@ -15,7 +15,7 @@ export const mapToClass = middleware => {
   }
   return assignToken(
     class {
-      resolve = (...args) => (...params) => middleware(...params);
+      resolve = (...args: any[]) => (...params) => middleware(...params);
     },
   );
 };

packages/core/nest-factory.ts

@@ -162,7 +162,7 @@ export class NestFactoryStatic {
       if (!(prop in receiver)) return;
 
       if (isFunction(receiver[prop])) {
-        return (...args) => {
+        return (...args: any[]) => {
           let result;
           ExceptionsZone.run(() => {
             result = receiver[prop](...args);

packages/core/pipes/pipes-consumer.ts

@@ -1,24 +1,23 @@
-import { Transform } from '@nestjs/common/interfaces';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+import { ArgumentMetadata, Transform } from '@nestjs/common/interfaces';
 import { ParamsTokenFactory } from './params-token-factory';
 
 export class PipesConsumer {
   private readonly paramsTokenFactory = new ParamsTokenFactory();
 
-  public async apply(
+  public async apply<TInput = any>(
-    value,
+    value: TInput,
-    { metatype, type, data },
+    { metatype, type, data }: ArgumentMetadata,
     transforms: Transform<any>[],
   ) {
-    const token = this.paramsTokenFactory.exchangeEnumForString(type);
+    const token = this.paramsTokenFactory.exchangeEnumForString(
-    return this.applyPipes(
+      (type as any) as RouteParamtypes,
-      value,
-      { metatype, type: token, data },
-      transforms,
     );
+    return this.applyPipes(value, { metatype, type: token, data }, transforms);
   }
 
-  public async applyPipes(
+  public async applyPipes<TInput = any>(
-    value,
+    value: TInput,
     { metatype, type, data }: { metatype; type?; data? },
     transforms: Transform<any>[],
   ) {

packages/core/pipes/pipes-context-creator.ts

@@ -1,6 +1,14 @@
 import { PIPES_METADATA } from '@nestjs/common/constants';
-import { Controller, PipeTransform, Transform } from '@nestjs/common/interfaces';
+import {
-import { isEmpty, isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
+  Controller,
+  PipeTransform,
+  Transform,
+} from '@nestjs/common/interfaces';
+import {
+  isEmpty,
+  isFunction,
+  isUndefined,
+} from '@nestjs/common/utils/shared.utils';
 import iterate from 'iterare';
 import { ApplicationConfig } from '../application-config';
 import { ContextCreator } from '../helpers/context-creator';
@@ -18,7 +26,7 @@ export class PipesContextCreator extends ContextCreator {
 
   public create(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     module: string,
   ): Transform<any>[] {
     this.moduleContext = module;

packages/core/router/router-execution-context.ts

@@ -62,7 +62,7 @@ export class RouterExecutionContext {
 
   public create(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
     methodName: string,
     module: string,
     requestMethod: RequestMethod,
@@ -127,7 +127,7 @@ export class RouterExecutionContext {
     };
   }
 
-  public reflectHttpStatusCode(callback: (...args) => any): number {
+  public reflectHttpStatusCode(callback: (...args: any[]) => any): number {
     return Reflect.getMetadata(HTTP_CODE_METADATA, callback);
   }
 
@@ -168,7 +168,10 @@ export class RouterExecutionContext {
     });
   }
 
-  public getCustomFactory(factory: (...args) => void, data): (...args) => any {
+  public getCustomFactory(
+    factory: (...args: any[]) => void,
+    data,
+  ): (...args: any[]) => any {
     return !isUndefined(factory) && isFunction(factory)
       ? (req, res, next) => factory(data, req)
       : () => null;
@@ -197,7 +200,7 @@ export class RouterExecutionContext {
   public createGuardsFn(
     guards: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): Function | null {
     const canActivateFn = async (args: any[]) => {
       const canActivate = await this.guardsConsumer.tryActivate(

packages/core/services/reflector.service.ts

@@ -1,5 +1,8 @@
 export class Reflector {
-  public get<T>(metadataKey, target): T {
+  public get<TResult = any, TKey = any, TInput = any>(
-    return Reflect.getMetadata(metadataKey, target) as T;
+    metadataKey: TKey,
+    target: TInput,
+  ): TResult {
+    return Reflect.getMetadata(metadataKey, target) as TResult;
   }
 }

packages/core/test/exceptions/exceptions-handler.spec.ts

@@ -1,11 +1,11 @@
-import * as sinon from 'sinon';
-import { expect } from 'chai';
-import { ExceptionsHandler } from '../../exceptions/exceptions-handler';
-import { Logger } from '../../../common/services/logger.service';
-import { NestEnvironment } from '../../../common/enums/nest-environment.enum';
-import { InvalidExceptionFilterException } from '../../errors/exceptions/invalid-exception-filter.exception';
 import { HttpException } from '@nestjs/common';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { NestEnvironment } from '../../../common/enums/nest-environment.enum';
+import { Logger } from '../../../common/services/logger.service';
 import { ExpressAdapter } from '../../adapters/express-adapter';
+import { InvalidExceptionFilterException } from '../../errors/exceptions/invalid-exception-filter.exception';
+import { ExceptionsHandler } from '../../exceptions/exceptions-handler';
 import { ExecutionContextHost } from '../../helpers/execution-context.host';
 
 describe('ExceptionsHandler', () => {
@@ -116,7 +116,7 @@ describe('ExceptionsHandler', () => {
           const exception = new TestException();
           const res = { foo: 'bar' };
 
-          handler.invokeCustomFilters(exception, res);
+          handler.invokeCustomFilters(exception, res as any);
           expect(funcSpy.calledWith(exception, res)).to.be.true;
         });
         it('should returns true', () => {

packages/microservices/client/client-grpc.ts

@@ -57,7 +57,7 @@ export class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
   public createServiceMethod(
     client: any,
     methodName: string,
-  ): (...args) => Observable<any> {
+  ): (...args: any[]) => Observable<any> {
     return client[methodName].responseStream
       ? this.createStreamServiceMethod(client, methodName)
       : this.createUnaryServiceMethod(client, methodName);
@@ -66,8 +66,8 @@ export class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
   public createStreamServiceMethod(
     client: any,
     methodName: string,
-  ): (...args) => Observable<any> {
+  ): (...args: any[]) => Observable<any> {
-    return (...args) => {
+    return (...args: any[]) => {
       return new Observable(observer => {
         let isClientCanceled = false;
         const call = client[methodName](...args);
@@ -100,8 +100,8 @@ export class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
   public createUnaryServiceMethod(
     client: any,
     methodName: string,
-  ): (...args) => Observable<any> {
+  ): (...args: any[]) => Observable<any> {
-    return (...args) => {
+    return (...args: any[]) => {
       return new Observable(observer => {
         client[methodName](...args, (error: any, data: any) => {
           if (error) {

packages/microservices/client/client-mqtt.ts

@@ -67,7 +67,7 @@ export class ClientMqtt extends ClientProxy {
     source$: Observable<T>,
   ): Observable<T> {
     const close$ = fromEvent(instance, CLOSE_EVENT).pipe(
-      map(err => {
+      map((err: any) => {
         throw err;
       }),
     );
@@ -81,7 +81,7 @@ export class ClientMqtt extends ClientProxy {
   public handleError(client: MqttClient) {
     client.addListener(
       ERROR_EVENT,
-      err => err.code !== ECONNREFUSED && this.logger.error(err),
+      (err: any) => err.code !== ECONNREFUSED && this.logger.error(err),
     );
   }
 
@@ -118,7 +118,7 @@ export class ClientMqtt extends ClientProxy {
       const pattern = this.normalizePattern(partialPacket.pattern);
       const responseChannel = this.getResPatternName(pattern);
 
-      this.mqttClient.subscribe(responseChannel, err => {
+      this.mqttClient.subscribe(responseChannel, (err: any) => {
         if (err) {
           return;
         }

packages/microservices/client/client-nats.ts

@@ -54,7 +54,7 @@ export class ClientNats extends ClientProxy {
   public handleError(client: Client) {
     client.addListener(
       ERROR_EVENT,
-      err => err.code !== CONN_ERR && this.logger.error(err),
+      (err: any) => err.code !== CONN_ERR && this.logger.error(err),
     );
   }
 

packages/microservices/client/client-proxy.ts

@@ -70,7 +70,7 @@ export abstract class ClientProxy {
     connectEvent = CONNECT_EVENT,
   ): Observable<any> {
     const error$ = fromEvent(instance, errorEvent).pipe(
-      map(err => {
+      map((err: any) => {
         throw err;
       }),
     );

packages/microservices/client/client-redis.ts

@@ -85,7 +85,7 @@ export class ClientRedis extends ClientProxy {
   }
 
   public handleError(client: RedisClient) {
-    client.addListener(ERROR_EVENT, err => this.logger.error(err));
+    client.addListener(ERROR_EVENT, (err: any) => this.logger.error(err));
   }
 
   public getClientOptions(error$: Subject<Error>): Partial<ClientOpts> {
@@ -148,7 +148,7 @@ export class ClientRedis extends ClientProxy {
       const responseChannel = this.getResPatternName(pattern);
 
       this.routingMap.set(packet.id, callback);
-      this.subClient.subscribe(responseChannel, err => {
+      this.subClient.subscribe(responseChannel, (err: any) => {
         if (err) {
           return;
         }

packages/microservices/client/client-rmq.ts

@@ -63,7 +63,8 @@ export class ClientRMQ extends ClientProxy {
     this.channel.addSetup(channel =>
       channel.consume(
         this.replyQueue,
-        msg => this.responseEmitter.emit(msg.properties.correlationId, msg),
+        (msg: any) =>
+          this.responseEmitter.emit(msg.properties.correlationId, msg),
         { noAck: true },
       ),
     );
@@ -101,7 +102,7 @@ export class ClientRMQ extends ClientProxy {
     source$: Observable<T>,
   ): Observable<T> {
     const close$ = fromEvent(instance, DISCONNECT_EVENT).pipe(
-      map(err => {
+      map((err: any) => {
         throw err;
       }),
     );
@@ -166,6 +167,6 @@ export class ClientRMQ extends ClientProxy {
   }
 
   public handleError(client: any): void {
-    client.addListener(ERROR_EVENT, err => this.logger.error(err));
+    client.addListener(ERROR_EVENT, (err: any) => this.logger.error(err));
   }
 }

packages/microservices/client/client-tcp.ts

@@ -88,7 +88,7 @@ export class ClientTCP extends ClientProxy {
   public bindEvents(socket: JsonSocket) {
     socket.on(
       ERROR_EVENT,
-      err => err.code !== ECONNREFUSED && this.handleError(err),
+      (err: any) => err.code !== ECONNREFUSED && this.handleError(err),
     );
     socket.on(CLOSE_EVENT, () => this.handleClose());
   }

packages/microservices/context/exception-filters-context.ts

@@ -17,7 +17,7 @@ export class ExceptionFiltersContext extends BaseExceptionFilterContext {
 
   public create(
     instance: Controller,
-    callback: (data) => Observable<any>,
+    callback: <T = any>(data: T) => Observable<any>,
     module: string,
   ): RpcExceptionsHandler {
     this.moduleContext = module;

packages/microservices/context/rpc-context-creator.ts

@@ -26,9 +26,9 @@ export class RpcContextCreator {
 
   public create(
     instance: Controller,
-    callback: (data) => Observable<any>,
+    callback: (data: any) => Observable<any>,
-    module,
+    module: string,
-  ): (...args) => Promise<Observable<any>> {
+  ): (...args: any[]) => Promise<Observable<any>> {
     const exceptionHandler = this.exceptionFiltersContext.create(
       instance,
       callback,
@@ -53,7 +53,7 @@ export class RpcContextCreator {
       return callback.call(instance, result, ...params);
     };
 
-    return this.rpcProxy.create(async (...args) => {
+    return this.rpcProxy.create(async (...args: any[]) => {
       fnCanActivate && (await fnCanActivate(args));
 
       return this.interceptorsConsumer.intercept(
@@ -68,12 +68,15 @@ export class RpcContextCreator {
 
   public reflectCallbackParamtypes(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): any[] {
     return Reflect.getMetadata(PARAMTYPES_METADATA, instance, callback.name);
   }
 
-  public getDataMetatype(instance, callback) {
+  public getDataMetatype(
+    instance: Controller,
+    callback: (...args: any[]) => any,
+  ) {
     const paramtypes = this.reflectCallbackParamtypes(instance, callback);
     return paramtypes && paramtypes.length ? paramtypes[0] : null;
   }
@@ -81,7 +84,7 @@ export class RpcContextCreator {
   public createGuardsFn(
     guards: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): Function | null {
     const canActivateFn = async (args: any[]) => {
       const canActivate = await this.guardsConsumer.tryActivate(

packages/microservices/context/rpc-proxy.ts

@@ -4,10 +4,10 @@ import { RpcExceptionsHandler } from '../exceptions/rpc-exceptions-handler';
 
 export class RpcProxy {
   public create(
-    targetCallback: (...args) => Promise<Observable<any>>,
+    targetCallback: (...args: any[]) => Promise<Observable<any>>,
     exceptionsHandler: RpcExceptionsHandler,
-  ): (...args) => Promise<Observable<any>> {
+  ): (...args: any[]) => Promise<Observable<any>> {
-    return async (...args) => {
+    return async (...args: any[]) => {
       try {
         return await targetCallback(...args);
       } catch (e) {

packages/microservices/listener-metadata-explorer.ts

@@ -1,14 +1,14 @@
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { isFunction, isUndefined } from '@nestjs/common/utils/shared.utils';
+import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import {
-  PATTERN_METADATA,
-  PATTERN_HANDLER_METADATA,
   CLIENT_CONFIGURATION_METADATA,
   CLIENT_METADATA,
+  PATTERN_HANDLER_METADATA,
+  PATTERN_METADATA,
 } from './constants';
-import { PatternMetadata } from './interfaces/pattern-metadata.interface';
 import { ClientOptions } from './interfaces/client-metadata.interface';
-import { MetadataScanner } from '@nestjs/core/metadata-scanner';
+import { PatternMetadata } from './interfaces/pattern-metadata.interface';
 
 export class ListenerMetadataExplorer {
   constructor(private readonly metadataScanner: MetadataScanner) {}
@@ -71,5 +71,5 @@ export interface ClientProperties {
 
 export interface PatternProperties {
   pattern: PatternMetadata;
-  targetCallback: (...args) => any;
+  targetCallback: (...args: any[]) => any;
 }

packages/microservices/server/server-grpc.ts

@@ -13,6 +13,12 @@ import { Server } from './server';
 let grpcPackage: any = {};
 let grpcProtoLoaderPackage: any = {};
 
+interface GrpcCall<TRequest = any, TMetadata = any> {
+  request: TRequest;
+  metadata: TMetadata;
+  end: Function;
+  write: Function;
+}
 export class ServerGrpc extends Server implements CustomTransportStrategy {
   private readonly url: string;
   private grpcClient: any;
@@ -99,22 +105,22 @@ export class ServerGrpc extends Server implements CustomTransportStrategy {
       : this.createUnaryServiceMethod(methodHandler);
   }
 
-  public createUnaryServiceMethod(methodHandler): Function {
+  public createUnaryServiceMethod(methodHandler: Function): Function {
-    return async (call, callback) => {
+    return async (call: GrpcCall, callback: Function) => {
       const handler = methodHandler(call.request, call.metadata);
       this.transformToObservable(await handler).subscribe(
         data => callback(null, data),
-        err => callback(err),
+        (err: any) => callback(err),
       );
     };
   }
 
-  public createStreamServiceMethod(methodHandler): Function {
+  public createStreamServiceMethod(methodHandler: Function): Function {
-    return async (call, callback) => {
+    return async (call: GrpcCall, callback: Function) => {
       const handler = methodHandler(call.request, call.metadata);
       const result$ = this.transformToObservable(await handler);
       await result$
-        .pipe(takeUntil(fromEvent(call, CANCEL_EVENT)))
+        .pipe(takeUntil(fromEvent(call as any, CANCEL_EVENT)))
         .forEach(data => call.write(data));
       call.end();
     };

packages/microservices/server/server-mqtt.ts

@@ -57,7 +57,8 @@ export class ServerMqtt extends Server implements CustomTransportStrategy {
   }
 
   public getMessageHandler(pub: MqttClient): any {
-    return async (channel, buffer) => this.handleMessage(channel, buffer, pub);
+    return async (channel: string, buffer: Buffer) =>
+      this.handleMessage(channel, buffer, pub);
   }
 
   public async handleMessage(
@@ -81,14 +82,14 @@ export class ServerMqtt extends Server implements CustomTransportStrategy {
   }
 
   public getPublisher(client: MqttClient, pattern: any, id: string): any {
-    return response =>
+    return (response: any) =>
       client.publish(
         this.getResQueueName(pattern),
         JSON.stringify(Object.assign(response, { id })),
       );
   }
 
-  public deserialize(content): ReadPacket & PacketId {
+  public deserialize(content: any): ReadPacket & PacketId {
     try {
       return JSON.parse(content);
     } catch (e) {
@@ -104,7 +105,7 @@ export class ServerMqtt extends Server implements CustomTransportStrategy {
     return `${pattern}_res`;
   }
 
-  public handleError(stream) {
+  public handleError(stream: any) {
-    stream.on(ERROR_EVENT, err => this.logger.error(err));
+    stream.on(ERROR_EVENT, (err: any) => this.logger.error(err));
   }
 }

packages/microservices/server/server-nats.ts

@@ -73,7 +73,7 @@ export class ServerNats extends Server implements CustomTransportStrategy {
   }
 
   public getMessageHandler(channel: string, client: Client) {
-    return async (buffer, replyTo: string) =>
+    return async (buffer: ReadPacket & PacketId, replyTo: string) =>
       this.handleMessage(channel, buffer, client, replyTo);
   }
 
@@ -97,7 +97,7 @@ export class ServerNats extends Server implements CustomTransportStrategy {
   }
 
   public getPublisher(publisher: Client, replyTo: string, id: string) {
-    return response =>
+    return (response: any) =>
       publisher.publish(
         replyTo,
         Object.assign(response, {
@@ -107,6 +107,6 @@ export class ServerNats extends Server implements CustomTransportStrategy {
   }
 
   public handleError(stream) {
-    stream.on(ERROR_EVENT, err => this.logger.error(err));
+    stream.on(ERROR_EVENT, (err: any) => this.logger.error(err));
   }
 }

packages/microservices/server/server-redis.ts

@@ -91,7 +91,7 @@ export class ServerRedis extends Server implements CustomTransportStrategy {
   }
 
   public getPublisher(pub: RedisClient, pattern: any, id: string) {
-    return response =>
+    return (response: any) =>
       pub.publish(
         this.getResQueueName(pattern),
         JSON.stringify(Object.assign(response, { id })),
@@ -115,7 +115,7 @@ export class ServerRedis extends Server implements CustomTransportStrategy {
   }
 
   public handleError(stream) {
-    stream.on(ERROR_EVENT, err => this.logger.error(err));
+    stream.on(ERROR_EVENT, (err: any) => this.logger.error(err));
   }
 
   public getClientOptions(): Partial<ClientOpts> {

packages/microservices/server/server-rmq.ts

@@ -65,7 +65,7 @@ export class ServerRMQ extends Server implements CustomTransportStrategy {
         setup: channel => this.setupChannel(channel, callback),
       });
     });
-    this.server.on(DISCONNECT_EVENT, err => {
+    this.server.on(DISCONNECT_EVENT, (err: any) => {
       this.logger.error(DISCONNECTED_RMQ_MESSAGE);
     });
   }

packages/microservices/server/server.ts

@@ -40,13 +40,13 @@ export abstract class Server {
   ): Subscription {
     return stream$
       .pipe(
-        catchError(err => {
+        catchError((err: any) => {
           respond({ err, response: null });
           return empty;
         }),
         finalize(() => respond({ isDisposed: true })),
       )
-      .subscribe(response => respond({ err: null, response }));
+      .subscribe((response: any) => respond({ err: null, response }));
   }
 
   public transformToObservable<T = any>(resultOrDeffered): Observable<T> {

packages/microservices/test/client/client-mqtt.spec.ts

@@ -269,7 +269,7 @@ describe('ClientMqtt', () => {
       };
       client
         .mergeCloseEvent(instance as any, empty())
-        .subscribe(null, err => expect(err).to.be.eql(error));
+        .subscribe(null, (err: any) => expect(err).to.be.eql(error));
     });
   });
   describe('handleError', () => {

packages/microservices/test/client/client-rmq.spec.ts

@@ -173,7 +173,7 @@ describe('ClientRQM', () => {
       };
       client
         .mergeDisconnectEvent(instance as any, empty())
-        .subscribe(null, err => expect(err).to.be.eql(error));
+        .subscribe(null, (err: any) => expect(err).to.be.eql(error));
     });
   });
 

packages/microservices/test/exceptions/rpc-exceptions-handler.spec.ts

@@ -1,9 +1,9 @@
-import * as sinon from 'sinon';
 import { expect } from 'chai';
-import { RpcExceptionsHandler } from '../../exceptions/rpc-exceptions-handler';
+import { EMPTY as empty, of } from 'rxjs';
-import { RpcException } from '../../exceptions/rpc-exception';
-import { Observable, of, EMPTY as empty } from 'rxjs';
 import { catchError } from 'rxjs/operators';
+import * as sinon from 'sinon';
+import { RpcException } from '../../exceptions/rpc-exception';
+import { RpcExceptionsHandler } from '../../exceptions/rpc-exceptions-handler';
 
 describe('RpcExceptionsHandler', () => {
   let handler: RpcExceptionsHandler;
@@ -17,7 +17,7 @@ describe('RpcExceptionsHandler', () => {
       const stream$ = handler.handle(new Error(), null);
       stream$
         .pipe(
-          catchError(err => {
+          catchError((err: any) => {
             expect(err).to.be.eql({
               status: 'error',
               message: 'Internal server error',
@@ -36,7 +36,7 @@ describe('RpcExceptionsHandler', () => {
         const stream$ = handler.handle(new RpcException(message), null);
         stream$
           .pipe(
-            catchError(err => {
+            catchError((err: any) => {
               expect(err).to.be.eql(message);
               done();
               return empty;
@@ -50,7 +50,7 @@ describe('RpcExceptionsHandler', () => {
         const stream$ = handler.handle(new RpcException(message), null);
         stream$
           .pipe(
-            catchError(err => {
+            catchError((err: any) => {
               expect(err).to.be.eql({ message, status: 'error' });
               done();
               return empty;

packages/microservices/test/server/server-nats.spec.ts

@@ -74,7 +74,7 @@ describe('ServerNats', () => {
           .stub(server, 'handleMessage')
           .callsFake(() => null);
         (await server.getMessageHandler('', (server as any).natsClient))(
-          '',
+          '' as any,
           '',
         );
         expect(handleMessageStub.called).to.be.true;

packages/testing/interfaces/override-by-factory-options.interface.ts

@@ -1,4 +1,4 @@
 export interface OverrideByFactoryOptions {
-  factory: (...args) => any;
+  factory: (...args: any[]) => any;
   inject?: any[];
 }

packages/testing/interfaces/override-by.interface.ts

@@ -1,8 +1,8 @@
-import { OverrideByFactoryOptions } from './override-by-factory-options.interface';
 import { TestingModuleBuilder } from '../testing-module.builder';
+import { OverrideByFactoryOptions } from './override-by-factory-options.interface';
 
 export interface OverrideBy {
-  useValue: (value) => TestingModuleBuilder;
+  useValue: (value: any) => TestingModuleBuilder;
   useFactory: (options: OverrideByFactoryOptions) => TestingModuleBuilder;
-  useClass: (metatype) => TestingModuleBuilder;
+  useClass: (metatype: any) => TestingModuleBuilder;
 }

packages/testing/testing-module.builder.ts

@@ -27,31 +27,31 @@ export class TestingModuleBuilder {
     this.module = this.createModule(metadata);
   }
 
-  public overridePipe(typeOrToken): OverrideBy {
+  public overridePipe<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, false);
   }
 
-  public overrideFilter(typeOrToken): OverrideBy {
+  public overrideFilter<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, false);
   }
 
-  public overrideGuard(typeOrToken): OverrideBy {
+  public overrideGuard<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, false);
   }
 
-  public overrideInterceptor(typeOrToken): OverrideBy {
+  public overrideInterceptor<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, false);
   }
 
   /** @deprecated */
-  public overrideComponent(typeOrToken): OverrideBy {
+  public overrideComponent<T = any>(typeOrToken: T): OverrideBy {
     deprecate(
       'The "overrideComponent()" method is deprecated and will be removed within next major release. Use "overrideProvider()" instead.',
     );
     return this.override(typeOrToken, true);
   }
 
-  public overrideProvider(typeOrToken): OverrideBy {
+  public overrideProvider<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, true);
   }
 
@@ -67,8 +67,8 @@ export class TestingModuleBuilder {
     return new TestingModule(this.container, [], root, this.applicationConfig);
   }
 
-  private override(typeOrToken, isProvider: boolean): OverrideBy {
+  private override<T = any>(typeOrToken: T, isProvider: boolean): OverrideBy {
-    const addOverload = options => {
+    const addOverload = (options: any) => {
       this.overloadsMap.set(typeOrToken, {
         ...options,
         isProvider,
@@ -79,7 +79,7 @@ export class TestingModuleBuilder {
   }
 
   private createOverrideByBuilder(
-    add: (provider) => TestingModuleBuilder,
+    add: (provider: any) => TestingModuleBuilder,
   ): OverrideBy {
     return {
       useValue: value => add({ useValue: value }),
@@ -100,7 +100,7 @@ export class TestingModuleBuilder {
     return modules.next().value;
   }
 
-  private createModule(metadata) {
+  private createModule(metadata: ModuleMetadata) {
     class TestModule {}
     Module(metadata)(TestModule);
     return TestModule;

packages/testing/testing-module.ts

@@ -18,12 +18,13 @@ import { ExpressFactory } from '@nestjs/core/adapters/express-factory';
 import { FastifyAdapter } from '@nestjs/core/adapters/fastify-adapter';
 import { ApplicationConfig } from '@nestjs/core/application-config';
 import { NestContainer } from '@nestjs/core/injector/container';
+import { Module } from '@nestjs/core/injector/module';
 
 export class TestingModule extends NestApplicationContext {
   constructor(
     container: NestContainer,
     scope: Type<any>[],
-    contextModule,
+    contextModule: Module,
     private readonly applicationConfig: ApplicationConfig,
   ) {
     super(container, scope, contextModule);

packages/websockets/adapters/io-adapter.ts

@@ -43,11 +43,11 @@ export class IoAdapter implements WebSocketAdapter {
     return io(port, options);
   }
 
-  public bindClientConnect(server: any, callback: (...args) => void) {
+  public bindClientConnect(server: any, callback: (...args: any[]) => void) {
     server.on(CONNECTION_EVENT, callback);
   }
 
-  public bindClientDisconnect(client: any, callback: (...args) => void) {
+  public bindClientDisconnect(client: any, callback: (...args: any[]) => void) {
     client.on(DISCONNECT_EVENT, callback);
   }
 
@@ -66,8 +66,8 @@ export class IoAdapter implements WebSocketAdapter {
         mergeMap((payload: any) => {
           const { data, ack } = this.mapPayload(payload);
           return transform(callback(data)).pipe(
-            filter(response => !isNil(response)),
+            filter((response: any) => !isNil(response)),
-            map(response => [response, ack]),
+            map((response: any) => [response, ack]),
           );
         }),
         takeUntil(disconnect$),
@@ -78,7 +78,8 @@ export class IoAdapter implements WebSocketAdapter {
         }
         isFunction(ack) && ack(response);
       };
-      const onError = err => this.baseExceptionFilter.handleError(client, err);
+      const onError = (err: any) =>
+        this.baseExceptionFilter.handleError(client, err);
       source$.subscribe(onMessage as any, onError);
     });
   }

packages/websockets/adapters/ws-adapter.ts

@@ -59,11 +59,11 @@ export class WsAdapter implements WebSocketAdapter {
         );
   }
 
-  public bindClientConnect(server, callback: (...args) => void) {
+  public bindClientConnect(server, callback: (...args: any[]) => void) {
     server.on(CONNECTION_EVENT, callback);
   }
 
-  public bindClientDisconnect(client, callback: (...args) => void) {
+  public bindClientDisconnect(client, callback: (...args: any[]) => void) {
     client.on(CLOSE_EVENT, callback);
   }
 
@@ -81,13 +81,14 @@ export class WsAdapter implements WebSocketAdapter {
       ),
       takeUntil(close$),
     );
-    const onMessage = response => {
+    const onMessage = (response: any) => {
       if (client.readyState !== READY_STATE.OPEN_STATE) {
         return;
       }
       client.send(JSON.stringify(response));
     };
-    const onError = err => this.baseExceptionFilter.handleError(client, err);
+    const onError = (err: any) =>
+      this.baseExceptionFilter.handleError(client, err);
     source$.subscribe(onMessage, onError);
   }
 
@@ -114,9 +115,9 @@ export class WsAdapter implements WebSocketAdapter {
 
   public bindErrorHandler(server: any) {
     server.on(CONNECTION_EVENT, ws =>
-      ws.on(ERROR_EVENT, err => this.logger.error(err)),
+      ws.on(ERROR_EVENT, (err: any) => this.logger.error(err)),
     );
-    server.on(ERROR_EVENT, err => this.logger.error(err));
+    server.on(ERROR_EVENT, (err: any) => this.logger.error(err));
     return server;
   }
 }

packages/websockets/context/ws-context-creator.ts

@@ -25,9 +25,9 @@ export class WsContextCreator {
 
   public create(
     instance: Controller,
-    callback: (...args) => void,
+    callback: (...args: any[]) => void,
-    module,
+    module: string,
-  ): (...args) => Promise<void> {
+  ): (...args: any[]) => Promise<void> {
     const exceptionHandler = this.exceptionFiltersContext.create(
       instance,
       callback,
@@ -52,7 +52,7 @@ export class WsContextCreator {
       return callback.call(instance, client, result, ...params);
     };
 
-    return this.wsProxy.create(async (...args) => {
+    return this.wsProxy.create(async (...args: any[]) => {
       fnCanActivate && (await fnCanActivate(args));
 
       return this.interceptorsConsumer.intercept(
@@ -67,12 +67,15 @@ export class WsContextCreator {
 
   public reflectCallbackParamtypes(
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): any[] {
     return Reflect.getMetadata(PARAMTYPES_METADATA, instance, callback.name);
   }
 
-  public getDataMetatype(instance, callback) {
+  public getDataMetatype(
+    instance: Controller,
+    callback: (...args: any[]) => any,
+  ) {
     const paramtypes = this.reflectCallbackParamtypes(instance, callback);
     return paramtypes && paramtypes.length ? paramtypes[1] : null;
   }
@@ -80,7 +83,7 @@ export class WsContextCreator {
   public createGuardsFn(
     guards: any[],
     instance: Controller,
-    callback: (...args) => any,
+    callback: (...args: any[]) => any,
   ): Function | null {
     const canActivateFn = async (args: any[]) => {
       const canActivate = await this.guardsConsumer.tryActivate(

packages/websockets/context/ws-proxy.ts

@@ -3,10 +3,10 @@ import { WsExceptionsHandler } from '../exceptions/ws-exceptions-handler';
 
 export class WsProxy {
   public create(
-    targetCallback: (...args) => Promise<void>,
+    targetCallback: (...args: any[]) => Promise<void>,
     exceptionsHandler: WsExceptionsHandler,
-  ): (...args) => Promise<void> {
+  ): (...args: any[]) => Promise<void> {
-    return async (...args) => {
+    return async (...args: any[]) => {
       try {
         return await targetCallback(...args);
       } catch (e) {

packages/websockets/gateway-metadata-explorer.ts

@@ -10,7 +10,7 @@ import { NestGateway } from './interfaces/nest-gateway.interface';
 
 export interface MessageMappingProperties {
   message: any;
-  callback: (...args) => Observable<any> | Promise<any> | any;
+  callback: (...args: any[]) => Observable<any> | Promise<any> | any;
 }
 
 export class GatewayMetadataExplorer {
@@ -27,7 +27,7 @@ export class GatewayMetadataExplorer {
   }
 
   public exploreMethodMetadata(
-    instancePrototype,
+    instancePrototype: any,
     methodName: string,
   ): MessageMappingProperties {
     const callback = instancePrototype[methodName];

tsconfig.json

@@ -12,16 +12,8 @@
     "sourceMap": true,
     "allowJs": true,
     "outDir": "dist",
-    "lib": [
+    "lib": ["es7"]
-      "es7"
-    ]
   },
-  "include": [
+  "include": ["packages/**/*", "integration/**/*"],
-    "packages/**/*",
+  "exclude": ["node_modules", "**/*.spec.ts"]
-    "integration/**/*"
+}
-  ],
-  "exclude": [
-    "node_modules",
-    "**/*.spec.ts"
-  ]
-}