chore(eslint,prettier): Upgrade to latest ts-eslint and prettier

Author: doug-martin

.eslintrc.js

@@ -70,7 +70,11 @@ module.exports = {
     // needed so we can use class scoped generics in methods.
     'class-methods-use-this': 'off',
     // airbnb default this doesnt work when using parameter decorators.
-    '@typescript-eslint/no-useless-constructor': 'off'
+    '@typescript-eslint/no-useless-constructor': 'off',
+
+    // disable eslint no-shadow in favor of the typescript version
+    'no-shadow': 'off',
+    '@typescript-eslint/no-shadow': ['error'],
   },
   ignorePatterns: ['**/dist', '**/node_modules'],
   overrides: [

examples/auth/src/auth/jwt-auth.guard.ts

@@ -4,7 +4,7 @@ import { GqlExecutionContext } from '@nestjs/graphql';
 
 @Injectable()
 export class JwtAuthGuard extends AuthGuard('jwt') {
-  getRequest(context: ExecutionContext) {
+  getRequest(context: ExecutionContext): unknown {
     const ctx = GqlExecutionContext.create(context);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-member-access
     return ctx.getContext().req;

examples/package.json

@@ -53,7 +53,7 @@
     "@types/passport-local": "1.0.33",
     "@types/supertest": "2.0.10",
     "jest": "26.4.2",
-    "prettier": "2.0.5",
+    "prettier": "2.1.1",
     "supertest": "4.0.2",
     "ts-jest": "26.3.0",
     "ts-loader": "8.0.3",

package-lock.json

@@ -22,8 +22,8 @@
     "@commitlint/cli": "9.1.2",
     "@commitlint/config-angular": "9.1.2",
     "@types/jest": "26.0.13",
-    "@typescript-eslint/eslint-plugin": "3.10.1",
-    "@typescript-eslint/parser": "3.10.1",
+    "@typescript-eslint/eslint-plugin": "4.0.1",
+    "@typescript-eslint/parser": "4.0.1",
     "coveralls": "3.1.0",
     "eslint": "7.8.1",
     "eslint-config-airbnb-typescript": "9.0.0",
@@ -37,7 +37,7 @@
     "jest": "26.4.2",
     "jest-extended": "0.11.5",
     "lerna": "3.22.1",
-    "prettier": "2.0.5",
+    "prettier": "2.1.1",
     "ts-jest": "26.3.0",
     "tsconfig-extends": "1.0.1",
     "typescript": "4.0.2"

package.json

@@ -4,7 +4,7 @@
 export declare type DeepPartial<T> = {
   [P in keyof T]?: T[P] extends Array<infer U>
     ? Array<DeepPartial<U>>
-    : T[P] extends ReadonlyArray<infer U>
-    ? ReadonlyArray<DeepPartial<U>>
+    : T[P] extends ReadonlyArray<infer U2>
+    ? ReadonlyArray<DeepPartial<U2>>
     : DeepPartial<T[P]>;
 };

packages/core/src/common/deep-partial.type.ts

@@ -2,5 +2,5 @@ import { Inject } from '@nestjs/common';
 import { Class } from '../common';
 import { getQueryServiceToken } from './helpers';
 
-export const InjectQueryService = <DTO, Entity>(DTOClass: Class<DTO>): ParameterDecorator =>
+export const InjectQueryService = <DTO>(DTOClass: Class<DTO>): ParameterDecorator =>
   Inject(getQueryServiceToken(DTOClass));

packages/core/src/decorators/inject-query-service.decorator.ts

@@ -53,11 +53,7 @@ export class SortBuilder {
     return (dtos: DTO[]): DTO[] => [...dtos].sort(comparator);
   }
 
-  static buildComparator<DTO, Field extends keyof DTO>(
-    field: keyof DTO,
-    direction: SortDirection,
-    nulls?: SortNulls,
-  ): SortComparator<DTO> {
+  static buildComparator<DTO>(field: keyof DTO, direction: SortDirection, nulls?: SortNulls): SortComparator<DTO> {
     const nullSort = this.nullsComparator(direction, nulls);
     const fieldValueComparator = this.fieldValueComparator(field, direction);
     return (a, b): SortResult => {

packages/core/src/helpers/sort.builder.ts

@@ -20,6 +20,7 @@ import { DeepPartial, Class } from '../common';
 export class NoOpQueryService<DTO> implements QueryService<DTO> {
   private static instance: QueryService<unknown> = new NoOpQueryService();
 
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   static getInstance<DTO>(): QueryService<DTO> {
     return this.instance as QueryService<DTO>;
   }

packages/core/src/services/noop-query.service.ts

@@ -20,7 +20,7 @@ describe('createDefaultAuthorizer', () => {
       return Promise.resolve({ authorizerOwnerId: { eq: context.user.id } });
     }
 
-    authorizeRelation(relationName: string, context: UserContext): Promise<Filter<unknown>> {
+    authorizeRelation(): Promise<Filter<unknown>> {
       return Promise.reject(new Error('should not have called'));
     }
   }

packages/query-graphql/__tests__/auth/default-crud-auth.service.spec.ts

@@ -5,11 +5,11 @@ import { TestResolverDTO } from './test-resolver.dto';
 
 @Injectable()
 export class TestResolverAuthorizer implements Authorizer<TestResolverDTO> {
-  authorize(context: any): Promise<Filter<TestResolverDTO>> {
+  authorize(): Promise<Filter<TestResolverDTO>> {
     return Promise.reject(new Error('authorize Not Implemented'));
   }
 
-  authorizeRelation<Relation>(relationName: string, context: any): Promise<Filter<Relation>> {
+  authorizeRelation<Relation>(): Promise<Filter<Relation>> {
     return Promise.reject(new Error('authorizeRelation Not Implemented'));
   }
 }

packages/query-graphql/__tests__/resolvers/__fixtures__/test-resolver.authorizer.ts

@@ -26,6 +26,7 @@ describe('AggregateArgsType', (): void => {
     @Resolver()
     class AggregateArgsTypeSpec {
       @Query(() => Int)
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       aggregate(@Args() args: AggArgs): number {
         return 1;
       }

packages/query-graphql/__tests__/types/aggregate/aggregate-args.type.spec.ts

@@ -1,8 +1,9 @@
 import { Filter } from '@nestjs-query/core';
 
 export interface Authorizer<DTO> {
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types,@typescript-eslint/no-explicit-any
   authorize(context: any): Promise<Filter<DTO>>;
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   authorizeRelation(relationName: string, context: any): Promise<Filter<unknown>>;
 }

packages/query-graphql/src/auth/authorizer.ts

@@ -13,6 +13,7 @@ export interface AuthorizerOptions<DTO> {
 
 const createRelationAuthorizer = (opts: AuthorizerOptions<unknown>): Authorizer<unknown> => {
   return {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async authorize(context: any): Promise<Filter<unknown>> {
       return opts.authorize(context) ?? {};
     },
@@ -43,10 +44,12 @@ export function createDefaultAuthorizer<DTO>(
       });
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async authorize(context: any): Promise<Filter<DTO>> {
       return this.authOptions?.authorize(context) ?? {};
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async authorizeRelation(relationName: string, context: any): Promise<Filter<unknown>> {
       return this.relationsAuthorizers.get(relationName)?.authorize(context) ?? {};
     }

packages/query-graphql/src/auth/default-crud.authorizer.ts

@@ -1,3 +1,3 @@
 import { Class } from '@nestjs-query/core';
 
-export const getAuthorizerToken = <DTO>(DTOClass: Class<DTO>) => `${DTOClass.name}Authorizer`;
+export const getAuthorizerToken = <DTO>(DTOClass: Class<DTO>): string => `${DTOClass.name}Authorizer`;

packages/query-graphql/src/auth/tokens.ts

@@ -25,7 +25,7 @@ export function getGraphqlObjectName<DTO>(DTOClass: Class<DTO>, notFoundMsg: str
 }
 
 // eslint-disable-next-line @typescript-eslint/ban-types
-export function getGraphqlEnumMetadata<T>(objType: object): EnumMetadata | undefined {
+export function getGraphqlEnumMetadata(objType: object): EnumMetadata | undefined {
   // hack to get enums loaded it may break in the future :(
   LazyMetadataStorage.load();
   return TypeMetadataStorage.getEnumsMetadata().find((o) => o.ref === objType);

packages/query-graphql/src/common/external.utils.ts

@@ -6,7 +6,7 @@ const reflector = new ValueReflector(AUTHORIZER_KEY);
 export function Authorize<DTO>(
   optsOrAuthorizerOrClass: Class<Authorizer<DTO>> | Authorizer<DTO> | AuthorizerOptions<DTO>,
 ) {
-  return (DTOClass: Class<DTO>) => {
+  return (DTOClass: Class<DTO>): void => {
     if ('authorize' in optsOrAuthorizerOrClass) {
       if ('authorizeRelation' in optsOrAuthorizerOrClass) {
         return reflector.set(DTOClass, optsOrAuthorizerOrClass);

packages/query-graphql/src/decorators/authorizer.decorator.ts

@@ -51,7 +51,7 @@ export function FilterableField(
   returnTypeFunction?: ReturnTypeFunc,
   options?: FilterableFieldOptions,
 ): PropertyDecorator & MethodDecorator;
-export function FilterableField<T>(
+export function FilterableField(
   returnTypeFuncOrOptions?: ReturnTypeFunc | FilterableFieldOptions,
   maybeOptions?: FilterableFieldOptions,
 ): MethodDecorator | PropertyDecorator {

packages/query-graphql/src/decorators/filterable-field.decorator.ts

@@ -72,9 +72,9 @@ export function getQueryManyHook<DTO>(DTOClass: Class<DTO>): MetaValue<BeforeQue
   return getClassMetadata(DTOClass, BEFORE_QUERY_MANY_KEY);
 }
 
-export type BeforeFindOneHook<DTO> = HookFunc<FindOneArgsType>;
+export type BeforeFindOneHook = HookFunc<FindOneArgsType>;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const BeforeFindOne = classMetadataDecorator<BeforeFindOneHook<any>>(BEFORE_FIND_ONE_KEY);
-export function getFindOneHook<DTO>(DTOClass: Class<DTO>): MetaValue<BeforeFindOneHook<DTO>> {
+export const BeforeFindOne = classMetadataDecorator<BeforeFindOneHook>(BEFORE_FIND_ONE_KEY);
+export function getFindOneHook<DTO>(DTOClass: Class<DTO>): MetaValue<BeforeFindOneHook> {
   return getClassMetadata(DTOClass, BEFORE_FIND_ONE_KEY);
 }

packages/query-graphql/src/decorators/hook.decorator.ts

@@ -2,4 +2,4 @@ import { Class } from '@nestjs-query/core';
 import { Inject } from '@nestjs/common';
 import { getAuthorizerToken } from '../auth';
 
-export const InjectAuthorizer = <DTO>(DTOClass: Class<DTO>) => Inject(getAuthorizerToken(DTOClass));
+export const InjectAuthorizer = <DTO>(DTOClass: Class<DTO>): ParameterDecorator => Inject(getAuthorizerToken(DTOClass));

packages/query-graphql/src/decorators/inject-authorizer.decorator.ts

@@ -40,7 +40,7 @@ function convertReferencesToOpts<DTO>(
 
 export function getReferences<DTO>(DTOClass: Class<DTO>, opts?: BaseResolverOptions): ReferencesOpts<DTO> {
   const referenceDescriptors = getReferenceDescriptors(DTOClass);
-  return convertReferencesToOpts(referenceDescriptors);
+  return convertReferencesToOpts(referenceDescriptors, opts);
 }
 
 export function Reference<DTO, Reference>(

packages/query-graphql/src/decorators/reference.decorator.ts

@@ -10,6 +10,7 @@ export const reflector = new ArrayReflector(RELATION_KEY);
 export type RelationDecoratorOpts<Relation> = Omit<ResolverRelation<Relation>, 'DTO'>;
 export type RelationTypeFunc<Relation> = () => Class<Relation> | Class<Relation>[];
 export type ConnectionTypeFunc<Relation> = () => Class<Relation>;
+export type RelationClassDecorator<DTO> = <Cls extends Class<DTO>>(DTOClass: Cls) => Cls | void;
 
 interface RelationDescriptor<Relation> {
   name: string;
@@ -54,7 +55,7 @@ export function Relation<DTO, Relation>(
   name: string,
   relationTypeFunc: RelationTypeFunc<Relation>,
   options?: RelationDecoratorOpts<Relation>,
-) {
+): RelationClassDecorator<DTO> {
   return <Cls extends Class<DTO>>(DTOClass: Cls): Cls | void => {
     const isMany = Array.isArray(relationTypeFunc());
     const relationOpts = isMany ? { pagingStrategy: PagingStrategies.OFFSET, ...options } : options;
@@ -67,15 +68,15 @@ export function FilterableRelation<DTO, Relation>(
   name: string,
   relationTypeFunc: RelationTypeFunc<Relation>,
   options?: RelationDecoratorOpts<Relation>,
-) {
-  return Relation(name, relationTypeFunc, { ...options, allowFiltering: true });
+): RelationClassDecorator<DTO> {
+  return Relation<DTO, Relation>(name, relationTypeFunc, { ...options, allowFiltering: true });
 }
 
 export function Connection<DTO, Relation>(
   name: string,
   relationTypeFunc: ConnectionTypeFunc<Relation>,
   options?: RelationDecoratorOpts<Relation>,
-) {
+): RelationClassDecorator<DTO> {
   const relationOpts = { pagingStrategy: PagingStrategies.CURSOR, ...options };
   return <Cls extends Class<DTO>>(DTOClass: Cls): Cls | void => {
     reflector.append(DTOClass, { name, isMany: true, relationOpts, relationTypeFunc });
@@ -87,6 +88,6 @@ export function FilterableConnection<DTO, Relation>(
   name: string,
   relationTypeFunc: ConnectionTypeFunc<Relation>,
   options?: RelationDecoratorOpts<Relation>,
-) {
-  return Connection(name, relationTypeFunc, { ...options, allowFiltering: true });
+): RelationClassDecorator<DTO> {
+  return Connection<DTO, Relation>(name, relationTypeFunc, { ...options, allowFiltering: true });
 }

packages/query-graphql/src/decorators/relation.decorator.ts

@@ -4,7 +4,7 @@ import { Aggregateable, AggregateResolverOpts } from './aggregate.resolver';
 import { Relatable } from './relations';
 import { Readable, ReadResolverFromOpts, ReadResolverOpts } from './read.resolver';
 import { Creatable, CreateResolver, CreateResolverOpts } from './create.resolver';
-import { Refereceable, ReferenceResolverOpts } from './reference.resolver';
+import { Referenceable, ReferenceResolverOpts } from './reference.resolver';
 import { MergePagingStrategyOpts, ResolverClass } from './resolver.interface';
 import { Updateable, UpdateResolver, UpdateResolverOpts } from './update.resolver';
 import { DeleteResolver, DeleteResolverOpts } from './delete.resolver';
@@ -35,7 +35,7 @@ export interface CRUDResolverOpts<
   read?: R;
   update?: UpdateResolverOpts<DTO, U>;
   delete?: DeleteResolverOpts<DTO>;
-  referenceBy?: ReferenceResolverOpts<DTO>;
+  referenceBy?: ReferenceResolverOpts;
   aggregate?: AggregateResolverOpts;
 }
 
@@ -44,7 +44,10 @@ export interface CRUDResolver<
   C extends DeepPartial<DTO>,
   U extends DeepPartial<DTO>,
   R extends ReadResolverOpts<DTO>
-> extends CreateResolver<DTO, C>, ReadResolverFromOpts<DTO, R>, UpdateResolver<DTO, U>, DeleteResolver<DTO> {}
+> extends CreateResolver<DTO, C>,
+    ReadResolverFromOpts<DTO, R>,
+    UpdateResolver<DTO, U>,
+    DeleteResolver<DTO> {}
 
 /**
  * Factory to create a resolver that includes all CRUD methods from [[CreateResolver]], [[ReadResolver]],
@@ -91,10 +94,10 @@ export const CRUDResolver = <
     aggregate,
   } = opts;
 
-  const referencable = Refereceable(DTOClass, referenceBy);
+  const referencable = Referenceable(DTOClass, referenceBy);
   const relatable = Relatable(
     DTOClass,
-    mergeBaseResolverOpts({ enableTotalCount, enableAggregate } as RelatableOpts<DTO>, opts),
+    mergeBaseResolverOpts({ enableTotalCount, enableAggregate } as RelatableOpts, opts),
   );
   const aggregateable = Aggregateable(DTOClass, {
     enabled: enableAggregate,

packages/query-graphql/src/resolvers/crud.resolver.ts

@@ -5,15 +5,15 @@ import { getDTONames } from '../common';
 import { RepresentationType } from '../federation';
 import { BaseServiceResolver, ResolverClass, ServiceResolver } from './resolver.interface';
 
-export interface ReferenceResolverOpts<DTO> {
+export interface ReferenceResolverOpts {
   key?: string;
 }
 
 /**
  * @internal
  * Mixin to expose `resolveReference` for a DTO on the resolver.
  */
-export const Refereceable = <DTO>(DTOClass: Class<DTO>, opts: ReferenceResolverOpts<DTO>) => <
+export const Referenceable = <DTO>(DTOClass: Class<DTO>, opts: ReferenceResolverOpts) => <
   B extends Class<ServiceResolver<DTO>>
 >(
   BaseClass: B,
@@ -40,5 +40,5 @@ export const Refereceable = <DTO>(DTOClass: Class<DTO>, opts: ReferenceResolverO
 
 export const ReferenceResolver = <DTO>(
   DTOClass: Class<DTO>,
-  opts: ReferenceResolverOpts<DTO> = {},
-): ResolverClass<DTO, ServiceResolver<DTO>> => Refereceable(DTOClass, opts)(BaseServiceResolver);
+  opts: ReferenceResolverOpts = {},
+): ResolverClass<DTO, ServiceResolver<DTO>> => Referenceable(DTOClass, opts)(BaseServiceResolver);

packages/query-graphql/src/resolvers/reference.resolver.ts

@@ -6,7 +6,6 @@ export { ReferencesRelationsResolver } from './references-relation.resolver';
 export { AggregateRelationsResolver } from './aggregate-relations.resolver';
 export {
   RelationTypeMap,
-  RelationTypeOpts,
   ReferencesOpts,
   ResolverRelationReference,
   RelationsOpts,

packages/query-graphql/src/resolvers/relations/index.ts

@@ -78,7 +78,7 @@ export type ResolverRelation<Relation> = {
 
 export type RelationTypeMap<RT> = Record<string, RT>;
 
-export type RelationTypeOpts<RT> = {
+export type RelationsOpts = {
   /**
    * All relations that are a single record
    */
@@ -89,7 +89,5 @@ export type RelationTypeOpts<RT> = {
   many?: RelationTypeMap<ResolverRelation<unknown>>;
 };
 
-export type RelationsOpts = RelationTypeOpts<ResolverRelation<unknown>>;
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ReferencesOpts<DTO> = RelationTypeMap<ResolverRelationReference<DTO, any>>;

packages/query-graphql/src/resolvers/relations/relations.interface.ts

@@ -9,14 +9,12 @@ import { getRelations } from '../../decorators';
 import { getReferences } from '../../decorators/reference.decorator';
 import { BaseResolverOptions } from '../../decorators/resolver-method.decorator';
 
-export interface RelatableOpts<DTO> extends BaseResolverOptions {
+export interface RelatableOpts extends BaseResolverOptions {
   enableTotalCount?: boolean;
   enableAggregate?: boolean;
 }
 
-export const Relatable = <DTO>(DTOClass: Class<DTO>, opts: RelatableOpts<DTO>) => <
-  B extends Class<ServiceResolver<DTO>>
->(
+export const Relatable = <DTO>(DTOClass: Class<DTO>, opts: RelatableOpts) => <B extends Class<ServiceResolver<DTO>>>(
   Base: B,
 ): B => {
   const { enableTotalCount, enableAggregate } = opts;

packages/query-graphql/src/resolvers/relations/relations.resolver.ts

@@ -54,7 +54,7 @@ const isNamed = (SomeType: any): SomeType is { name: string } => {
 };
 
 /** @internal */
-const getTypeName = <T>(SomeType: ReturnTypeFuncValue): string => {
+const getTypeName = (SomeType: ReturnTypeFuncValue): string => {
   if (knownTypes.has(SomeType) || isNamed(SomeType)) {
     const typeName = (SomeType as { name: string }).name;
     return upperCaseFirst(typeName);

packages/query-graphql/src/types/query/field-comparison/field-comparison.factory.ts

@@ -2,7 +2,7 @@ import { ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments
 
 /** @internal */
 @ValidatorConstraint({ async: false })
-export class PropertyMax<T> implements ValidatorConstraintInterface {
+export class PropertyMax implements ValidatorConstraintInterface {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
   validate(value: any, args: ValidationArguments): boolean {
     const object = args.object as Record<string, Record<string, number>>;