@lenne.tech/nest-server 9.2.4 → 9.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "9.2.4",
+  "version": "9.2.6",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",

package/src/core/common/helpers/input.helper.ts

@@ -654,14 +654,22 @@ export function processDeep(
   data: any,
   func: (data: any) => any,
   options?: {
+    // Remember already processed objects to avoid infinite processes
     processedObjects?: WeakMap<new () => any, boolean>;
+
+    // For objects of special classes or objects with special functions or special properties,
+    // only the objects themselves are processed with func, not the individual properties of the object additionally
     specialClasses?: ((new (args: any[]) => any) | string)[];
+    specialFunctions?: string[];
+    specialProperties?: string[];
   }
 ): any {
   // Set options
-  const { processedObjects, specialClasses } = {
+  const { processedObjects, specialClasses, specialFunctions, specialProperties } = {
     processedObjects: new WeakMap(),
     specialClasses: [],
+    specialFunctions: [],
+    specialProperties: [],
     ...options,
   };
 
@@ -680,11 +688,17 @@ export function processDeep(
 
   // Process array
   if (Array.isArray(data)) {
-    return data.map((item) => processDeep(item, func, { processedObjects, specialClasses }));
+    return func(data.map((item) => processDeep(item, func, { processedObjects, specialClasses })));
   }
 
   // Process object
   if (typeof data === 'object') {
+    if (
+      specialFunctions.find((sF) => typeof data[sF] === 'function') ||
+      specialProperties.find((sP) => Object.getOwnPropertyNames(data).includes(sP))
+    ) {
+      return func(data);
+    }
     for (const specialClass of specialClasses) {
       if (
         (typeof specialClass === 'string' && specialClass === data.constructor?.name) ||
@@ -696,7 +710,7 @@ export function processDeep(
     for (const [key, value] of Object.entries(data)) {
       data[key] = processDeep(value, func, { processedObjects, specialClasses });
     }
-    return data;
+    return func(data);
   }
 
   // Process others

package/src/core/common/interceptors/check-security.interceptor.ts

@@ -40,12 +40,19 @@ export class CheckSecurityInterceptor implements NestInterceptor {
         }
 
         // Check deep
-        return processDeep(data, (item) => {
-          if (!item || typeof item !== 'object' || typeof item.securityCheck !== 'function') {
-            return item;
-          }
-          return item.securityCheck(user, force);
-        });
+        return processDeep(
+          data,
+          (item) => {
+            if (!item || typeof item !== 'object' || typeof item.securityCheck !== 'function') {
+              if (Array.isArray(item)) {
+                return item.filter((i) => i !== undefined);
+              }
+              return item;
+            }
+            return item.securityCheck(user, force);
+          },
+          { specialFunctions: ['securityCheck'] }
+        );
       })
     );
   }

package/src/core/common/models/core-model.model.ts

@@ -129,7 +129,7 @@ export abstract class CoreModel {
   /**
    * Verification of the user's rights to access the properties of this object
    */
-  securityCheck(user: any, force?: boolean): this {
+  public securityCheck(user: any, force?: boolean): this {
     return this;
   }
 }

package/src/core/common/services/crud.service.ts

@@ -6,14 +6,19 @@ import { convertFilterArgsToQuery } from '../helpers/filter.helper';
 import { mergePlain, prepareServiceOptionsForCreate } from '../helpers/input.helper';
 import { ServiceOptions } from '../interfaces/service-options.interface';
 import { CoreModel } from '../models/core-model.model';
+import { PlainObject } from '../types/plain-object.type';
 import { ConfigService } from './config.service';
 import { ModuleService } from './module.service';
 
-export abstract class CrudService<T extends CoreModel = any> extends ModuleService<T> {
+export abstract class CrudService<
+  Model extends CoreModel = any,
+  CreateInput = any,
+  UpdateInput = any
+> extends ModuleService<Model> {
   /**
    * Create item
    */
-  async create(input: any, serviceOptions?: ServiceOptions): Promise<T> {
+  async create(input: PlainObject<CreateInput>, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = prepareServiceOptionsForCreate(serviceOptions);
     return this.process(
       async (data) => {
@@ -28,7 +33,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Create item without checks or restrictions
    * Warning: Disables the handling of rights and restrictions!
    */
-  async createForce(input: any, serviceOptions: ServiceOptions = {}): Promise<T> {
+  async createForce(input: PlainObject<CreateInput>, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.create(input, serviceOptions);
@@ -38,7 +43,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Create item without checks, restrictions or preparations
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
-  async createRaw(input: any, serviceOptions: ServiceOptions = {}): Promise<T> {
+  async createRaw(input: PlainObject<CreateInput>, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
@@ -48,7 +53,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   /**
    * Get item by ID
    */
-  async get(id: string, serviceOptions?: ServiceOptions): Promise<T> {
+  async get(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
     const dbObject = await this.mainDbModel.findById(id).exec();
     if (!dbObject) {
       throw new NotFoundException(`No ${this.mainModelConstructor.name} found with ID: ${id}`);
@@ -60,7 +65,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Get item by ID without checks or restrictions
    * Warning: Disables the handling of rights and restrictions!
    */
-  async getForce(id: string, serviceOptions: ServiceOptions = {}): Promise<T> {
+  async getForce(id: string, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.get(id, serviceOptions);
@@ -70,7 +75,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Get item by ID without checks, restrictions or preparations
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
-  async getRaw(id: string, serviceOptions: ServiceOptions = {}): Promise<T> {
+  async getRaw(id: string, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
@@ -83,7 +88,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async find(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions?: ServiceOptions
-  ): Promise<T[]> {
+  ): Promise<Model[]> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
     // and should not be processed as FilterArgs
     if (!(filter instanceof FilterArgs) && serviceOptions?.inputType === FilterArgs) {
@@ -124,7 +129,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async findForce(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions: ServiceOptions = {}
-  ): Promise<T[]> {
+  ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.find(filter, serviceOptions);
@@ -137,7 +142,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async findRaw(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions: ServiceOptions = {}
-  ): Promise<T[]> {
+  ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
@@ -150,7 +155,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async findAndCount(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions?: ServiceOptions
-  ): Promise<{ items: T[]; totalCount: number }> {
+  ): Promise<{ items: Model[]; totalCount: number }> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
     // and should not be processed as FilterArgs
     if (!(filter instanceof FilterArgs) && serviceOptions?.inputType === FilterArgs) {
@@ -229,7 +234,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async findAndCountForce(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions: ServiceOptions = {}
-  ): Promise<{ items: T[]; totalCount: number }> {
+  ): Promise<{ items: Model[]; totalCount: number }> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.findAndCount(filter, serviceOptions);
@@ -242,7 +247,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async findAndCountRaw(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     serviceOptions: ServiceOptions = {}
-  ): Promise<{ items: T[]; totalCount: number }> {
+  ): Promise<{ items: Model[]; totalCount: number }> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
@@ -253,15 +258,15 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Find and update
    */
   async findAndUpdate(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
-    update: any,
+    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    update: PlainObject<UpdateInput>,
     serviceOptions?: ServiceOptions
-  ): Promise<T[]> {
-    const dbItems: T[] = await this.find(filter, serviceOptions);
+  ): Promise<Model[]> {
+    const dbItems: Model[] = await this.find(filter, serviceOptions);
     if (!dbItems?.length) {
       return [];
     }
-    const promises: Promise<T>[] = [];
+    const promises: Promise<Model>[] = [];
     for (const dbItem of dbItems) {
       promises.push(
         new Promise(async (resolve, reject) => {
@@ -282,12 +287,13 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Warning: Disables the handling of rights and restrictions!
    */
   async findAndUpdateForce(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    update: PlainObject<UpdateInput>,
     serviceOptions: ServiceOptions = {}
-  ): Promise<T[]> {
+  ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
-    return this.findAndUpdate(filter, serviceOptions);
+    return this.findAndUpdate(filter, update, serviceOptions);
   }
 
   /**
@@ -295,19 +301,20 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async findAndUpdateRaw(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    update: PlainObject<UpdateInput>,
     serviceOptions: ServiceOptions = {}
-  ): Promise<T[]> {
+  ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
-    return this.findAndUpdateForce(filter, serviceOptions);
+    return this.findAndUpdateForce(filter, update, serviceOptions);
   }
 
   /**
    * CRUD alias for get
    */
-  async read(id: string, serviceOptions?: ServiceOptions): Promise<T>;
+  async read(id: string, serviceOptions?: ServiceOptions): Promise<Model>;
 
   /**
    * CRUD alias for find
@@ -315,7 +322,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async read(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T[]>;
+  ): Promise<Model[]>;
 
   /**
    * CRUD alias for get or find
@@ -323,7 +330,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async read(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T | T[]> {
+  ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.get(input, serviceOptions);
     } else {
@@ -335,7 +342,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * CRUD alias for getForce
    * Warning: Disables the handling of rights and restrictions!
    */
-  async readForce(id: string, serviceOptions?: ServiceOptions): Promise<T>;
+  async readForce(id: string, serviceOptions?: ServiceOptions): Promise<Model>;
 
   /**
    * CRUD alias for findForce
@@ -344,7 +351,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async readForce(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T[]>;
+  ): Promise<Model[]>;
 
   /**
    * CRUD alias for getForce or findForce
@@ -353,7 +360,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async readForce(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T | T[]> {
+  ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.getForce(input, serviceOptions);
     } else {
@@ -365,7 +372,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * CRUD alias for getRaw
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
-  async readRaw(id: string, serviceOptions?: ServiceOptions): Promise<T>;
+  async readRaw(id: string, serviceOptions?: ServiceOptions): Promise<Model>;
 
   /**
    * CRUD alias for findRaw
@@ -374,7 +381,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async readRaw(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T[]>;
+  ): Promise<Model[]>;
 
   /**
    * CRUD alias for getRaw or findRaw
@@ -383,7 +390,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   async readRaw(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
     serviceOptions?: ServiceOptions
-  ): Promise<T | T[]> {
+  ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.getRaw(input, serviceOptions);
     } else {
@@ -394,7 +401,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   /**
    * Update item via ID
    */
-  async update(id: string, input: any, serviceOptions?: ServiceOptions): Promise<T> {
+  async update(id: string, input: PlainObject<UpdateInput>, serviceOptions?: ServiceOptions): Promise<Model> {
     const dbObject = await this.mainDbModel.findById(id).lean();
     if (!dbObject) {
       throw new NotFoundException(`No ${this.mainModelConstructor.name} found with ID: ${id}`);
@@ -413,7 +420,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Update item via ID without checks or restrictions
    * Warning: Disables the handling of rights and restrictions!
    */
-  async updateForce(id: string, input: any, serviceOptions?: ServiceOptions): Promise<T> {
+  async updateForce(id: string, input: PlainObject<UpdateInput>, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.update(id, input, serviceOptions);
@@ -423,7 +430,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Update item via ID without checks, restrictions or preparations
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
-  async updateRaw(id: string, input: any, serviceOptions?: ServiceOptions): Promise<T> {
+  async updateRaw(id: string, input: PlainObject<UpdateInput>, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;
@@ -433,7 +440,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   /**
    * Delete item via ID
    */
-  async delete(id: string, serviceOptions?: ServiceOptions): Promise<T> {
+  async delete(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
     const dbObject = await this.mainDbModel.findById(id).exec();
     if (!dbObject) {
       throw new NotFoundException(`No ${this.mainModelConstructor.name} found with ID: ${id}`);
@@ -451,7 +458,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Delete item via ID without checks or restrictions
    * Warning: Disables the handling of rights and restrictions!
    */
-  async deleteForce(id: string, serviceOptions?: ServiceOptions): Promise<T> {
+  async deleteForce(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
     return this.delete(id, serviceOptions);
@@ -461,7 +468,7 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
    * Delete item via ID without checks, restrictions or preparations
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
-  async deleteRaw(id: string, serviceOptions?: ServiceOptions): Promise<T> {
+  async deleteRaw(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
     serviceOptions.prepareOutput = null;

package/src/core/common/types/is-one-of.type.ts

@@ -0,0 +1,26 @@
+/**
+ * Type that ensures that the property or method is of a specific class
+ *
+ * Example (see https://stackoverflow.com/a/66202968):
+ *
+ * interface myFunctions{
+ *     one: () => number;
+ *     two: () => number;
+ *     echo: (str: string) => string;
+ * }
+ *
+ * const myFunctions: myFunctions = {
+ *     one: () => 1,
+ *     two: () => 2,
+ *     echo: (str: string) => str
+ * }
+ *
+ * const wrapper = <U extends (...args: any[]) => any>(func: U extends IsOneOf<myFunctions, U> ? U : never) => (...args: Parameters<U>) : ReturnType<U> => func(...args);
+ *
+ * const one = wrapper(myFunctions.one);
+ * const two = wrapper(myFunctions.two);
+ * const echo = wrapper(myFunctions.echo);
+ * const rand = wrapper((a:string,b:number,c:boolean) => {}); //not assignable to parameter of type 'never'.
+ * const hm = wrapper(() => 'a'); //also error
+ */
+export type IsOneOf<T, F> = { [P in keyof T]: F extends T[P] ? (T[P] extends F ? T[P] : never) : never }[keyof T];

package/src/core/modules/auth/guards/auth.guard.ts

@@ -1,9 +1,8 @@
-import { CanActivate, ExecutionContext, Logger, mixin, Optional, UnauthorizedException } from '@nestjs/common';
+import { CanActivate, ExecutionContext, Logger, mixin, Optional } from '@nestjs/common';
 import { GqlExecutionContext } from '@nestjs/graphql';
 import { AuthModuleOptions, Type } from '@nestjs/passport';
 import { defaultOptions } from '@nestjs/passport/dist/options';
 import { memoize } from '@nestjs/passport/dist/utils/memoize.util';
-import * as jwt from 'jsonwebtoken';
 import * as passport from 'passport';
 import { AuthGuardStrategy } from '../auth-guard-strategy.enum';
 import { ExpiredRefreshTokenException } from '../exceptions/expired-refresh-token.exception';

package/src/core/modules/auth/guards/roles.guard.ts

@@ -3,6 +3,8 @@ import { Reflector } from '@nestjs/core';
 import { GqlExecutionContext } from '@nestjs/graphql';
 import { RoleEnum } from '../../../common/enums/role.enum';
 import { AuthGuardStrategy } from '../auth-guard-strategy.enum';
+import { ExpiredTokenException } from '../exceptions/expired-token.exception';
+import { InvalidTokenException } from '../exceptions/invalid-token.exception';
 import { AuthGuard } from './auth.guard';
 
 /**
@@ -45,14 +47,22 @@ export class RolesGuard extends AuthGuard(AuthGuardStrategy.JWT) {
 
     // Check user and user roles
     if (!user?.hasRole?.(roles)) {
-      // Get args
-      const args: any = GqlExecutionContext.create(context).getArgs();
-
       // Check special user roles (user is logged in or access is free for any)
       if ((user && roles.includes(RoleEnum.S_USER)) || roles.includes(RoleEnum.S_EVERYONE)) {
         return user;
       }
 
+      // If user is missing throw token exception
+      if (!user) {
+        if (err) {
+          throw new InvalidTokenException();
+        }
+        if (info?.name === 'TokenExpiredError') {
+          throw new ExpiredTokenException();
+        }
+        throw new UnauthorizedException('Unauthorized');
+      }
+
       // Requester is not authorized
       throw new UnauthorizedException('Missing role');
     }

package/src/core/modules/user/core-user.service.ts

@@ -20,7 +20,7 @@ export abstract class CoreUserService<
   TUser extends CoreUserModel,
   TUserInput extends CoreUserInput,
   TUserCreateInput extends CoreUserCreateInput
-> extends CrudService<TUser> {
+> extends CrudService<TUser, TUserCreateInput, TUserInput> {
   protected constructor(
     protected override readonly configService: ConfigService,
     protected readonly emailService: EmailService,
@@ -54,7 +54,7 @@ export abstract class CoreUserService<
         try {
           await createdUser.save();
         } catch (error) {
-          if (error.code === 11000) {
+          if (error?.errors?.email?.kind === 'unique') {
             throw new BadRequestException('Email address already in use');
           } else {
             throw new UnprocessableEntityException();

package/src/index.ts

@@ -64,6 +64,7 @@ export * from './core/common/types/core-model-constructor.type';
 export * from './core/common/types/falsy.type';
 export * from './core/common/types/field-selection.type';
 export * from './core/common/types/ids.type';
+export * from './core/common/types/is-one-of.type';
 export * from './core/common/types/maybe-promise.type';
 export * from './core/common/types/plain-input.type';
 export * from './core/common/types/plain-object.type';

package/src/server/modules/auth/auth.module.ts

@@ -4,6 +4,7 @@ import { EmailService } from '../../../core/common/services/email.service';
 import { CoreAuthModule } from '../../../core/modules/auth/core-auth.module';
 import { UserModule } from '../user/user.module';
 import { UserService } from '../user/user.service';
+import { AuthController } from './auth.controller';
 import { AuthResolver } from './auth.resolver';
 import { AuthService } from './auth.service';
 
@@ -28,8 +29,8 @@ export class AuthModule {
           },
         }),
       ],
-      providers: [AuthResolver, AuthService, EmailService],
-      exports: [AuthResolver, CoreAuthModule],
+      providers: [AuthController, AuthResolver, AuthService, EmailService],
+      exports: [AuthController, AuthResolver, CoreAuthModule],
     };
   }
 }