@lenne.tech/nest-server 11.7.0 → 11.7.2

package/src/core.module.ts

@@ -19,7 +19,9 @@ import { EmailService } from './core/common/services/email.service';
 import { MailjetService } from './core/common/services/mailjet.service';
 import { ModelDocService } from './core/common/services/model-doc.service';
 import { TemplateService } from './core/common/services/template.service';
+import { BetterAuthUserMapper } from './core/modules/better-auth/better-auth-user.mapper';
 import { BetterAuthModule } from './core/modules/better-auth/better-auth.module';
+import { BetterAuthService } from './core/modules/better-auth/better-auth.service';
 import { CoreHealthCheckModule } from './core/modules/health-check/core-health-check.module';
 
 /**
@@ -66,10 +68,65 @@ export class CoreModule implements NestModule {
   }
 
   /**
-   * Dynamic module
-   * see https://docs.nestjs.com/modules#dynamic-modules
+   * Dynamic module initialization
+   *
+   * @see https://docs.nestjs.com/modules#dynamic-modules
+   *
+   * ## Signatures
+   *
+   * ### IAM-Only Signature (Recommended for new projects)
+   *
+   * ```typescript
+   * CoreModule.forRoot(envConfig)
+   * ```
+   *
+   * Use this for new projects that only use BetterAuth (IAM) for authentication.
+   * GraphQL Subscription authentication uses BetterAuth JWT tokens.
+   *
+   * **Requirements:**
+   * - Configure `betterAuth` in your config (enabled by default)
+   * - Create BetterAuthModule, Resolver, and Controller in your project
+   * - Inject BetterAuthUserMapper in UserService
+   *
+   * ### Legacy + IAM Signature (For existing projects)
+   *
+   * ```typescript
+   * CoreModule.forRoot(CoreAuthService, AuthModule.forRoot(envConfig.jwt), envConfig)
+   * ```
+   *
+   * @deprecated This 3-parameter signature is deprecated for new projects.
+   * Use the single-parameter signature `CoreModule.forRoot(envConfig)` instead.
+   * Existing projects can continue using this signature during migration.
+   *
+   * Use this for existing projects that need Legacy Auth for backwards compatibility.
+   * Both Legacy Auth and BetterAuth (IAM) can run in parallel.
+   *
+   * ## Migration Path
+   *
+   * 1. **Existing projects**: Use the 3-parameter signature, run Legacy + IAM in parallel
+   * 2. **Monitor**: Use `betterAuthMigrationStatus` query to track user migration
+   * 3. **Disable Legacy**: Set `auth.legacyEndpoints.enabled: false` after all users migrated
+   * 4. **New projects**: Use the single-parameter signature with IAM only
+   *
+   * @see https://github.com/lenneTech/nest-server/blob/develop/.claude/rules/module-deprecation.md
    */
-  static forRoot(AuthService: any, AuthModule: any, options: Partial<IServerOptions>): DynamicModule {
+  static forRoot(options: Partial<IServerOptions>): DynamicModule;
+  /**
+   * @deprecated Use the single-parameter signature `CoreModule.forRoot(envConfig)` for new projects.
+   * This 3-parameter signature is for existing projects during migration to IAM.
+   */
+  static forRoot(AuthService: any, AuthModule: any, options: Partial<IServerOptions>): DynamicModule;
+  static forRoot(
+    authServiceOrOptions: any,
+    authModuleOrUndefined?: any,
+    optionsOrUndefined?: Partial<IServerOptions>,
+  ): DynamicModule {
+    // Detect which signature was used
+    const isIamOnlyMode = authModuleOrUndefined === undefined && optionsOrUndefined === undefined;
+    const AuthService = isIamOnlyMode ? null : authServiceOrOptions;
+    const AuthModule = isIamOnlyMode ? null : authModuleOrUndefined;
+    const options: Partial<IServerOptions> = isIamOnlyMode ? authServiceOrOptions : optionsOrUndefined;
+
     // Process config
     let cors = {};
     if (options?.cookies) {
@@ -78,73 +135,17 @@ export class CoreModule implements NestModule {
         origin: true,
       };
     }
+
+    // Build GraphQL driver configuration based on auth mode
+    const graphQlDriverConfig = isIamOnlyMode
+      ? this.buildIamOnlyGraphQlDriver(cors, options)
+      : this.buildLegacyGraphQlDriver(AuthService, AuthModule, cors, options);
+
     const config: IServerOptions = merge(
       {
         env: 'develop',
         graphQl: {
-          driver: {
-            imports: [AuthModule],
-            inject: [AuthService],
-            useFactory: async (authService: any) =>
-              Object.assign(
-                {
-                  autoSchemaFile: 'schema.gql',
-                  context: ({ req, res }) => ({ req, res }),
-                  cors,
-                  installSubscriptionHandlers: true,
-                  subscriptions: {
-                    'graphql-ws': {
-                      context: ({ extra }) => extra,
-                      onConnect: async (context: Context<any>) => {
-                        const { connectionParams, extra } = context;
-                        if (config.graphQl.enableSubscriptionAuth) {
-                          // get authToken from authorization header
-                          const headers = this.getHeaderFromArray(extra.request?.rawHeaders);
-                          const authToken: string =
-                            connectionParams?.Authorization?.split(' ')[1] ?? headers.Authorization?.split(' ')[1];
-                          if (authToken) {
-                            // verify authToken/getJwtPayLoad
-                            const payload = authService.decodeJwt(authToken);
-                            const user = await authService.validateUser(payload);
-                            if (!user) {
-                              throw new UnauthorizedException('No user found for token');
-                            }
-                            // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
-                            extra.user = user;
-                            extra.headers = connectionParams ?? headers;
-                            return extra;
-                          }
-
-                          throw new UnauthorizedException('Missing authentication token');
-                        }
-                      },
-                    },
-                    'subscriptions-transport-ws': {
-                      onConnect: async (connectionParams) => {
-                        if (config.graphQl.enableSubscriptionAuth) {
-                          // get authToken from authorization header
-                          const authToken: string = connectionParams?.Authorization?.split(' ')[1];
-
-                          if (authToken) {
-                            // verify authToken/getJwtPayLoad
-                            const payload = authService.decodeJwt(authToken);
-                            const user = await authService.validateUser(payload);
-                            if (!user) {
-                              throw new UnauthorizedException('No user found for token');
-                            }
-                            // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
-                            return { headers: connectionParams, user };
-                          }
-
-                          throw new UnauthorizedException('Missing authentication token');
-                        }
-                      },
-                    },
-                  },
-                },
-                options?.graphQl?.driver,
-              ),
-          },
+          driver: graphQlDriverConfig,
           enableSubscriptionAuth: true,
         },
         mongoose: {
@@ -229,16 +230,25 @@ export class CoreModule implements NestModule {
       imports.push(CoreHealthCheckModule);
     }
 
-    // Add BetterAuthModule only if autoRegister is explicitly true
-    // By default (autoRegister: false), projects integrate via an extended module in their project
-    if (config.betterAuth?.enabled !== false && config.betterAuth?.autoRegister === true) {
-      imports.push(
-        BetterAuthModule.forRoot({
-          config: config.betterAuth || {},
-          // Pass JWT secrets for backwards compatibility fallback
-          fallbackSecrets: [config.jwt?.secret, config.jwt?.refresh?.secret],
-        }),
-      );
+    // Add BetterAuthModule based on mode
+    // IAM-only mode: Always register BetterAuthModule (required for subscription auth)
+    // Legacy mode: Only register if autoRegister is explicitly true
+    // betterAuth can be: boolean | IBetterAuth | undefined
+    const betterAuthConfig = config.betterAuth;
+    const isBetterAuthEnabled =
+      betterAuthConfig === true || (typeof betterAuthConfig === 'object' && betterAuthConfig?.enabled !== false);
+    const isAutoRegister = typeof betterAuthConfig === 'object' && betterAuthConfig?.autoRegister === true;
+
+    if (isBetterAuthEnabled) {
+      if (isIamOnlyMode || isAutoRegister) {
+        imports.push(
+          BetterAuthModule.forRoot({
+            config: betterAuthConfig === true ? {} : betterAuthConfig || {},
+            // Pass JWT secrets for backwards compatibility fallback
+            fallbackSecrets: [config.jwt?.secret, config.jwt?.refresh?.secret],
+          }),
+        );
+      }
     }
 
     // Set exports
@@ -255,4 +265,182 @@ export class CoreModule implements NestModule {
       providers,
     };
   }
+
+  // =============================================================================
+  // GraphQL Driver Configuration Helpers
+  // =============================================================================
+
+  /**
+   * Build GraphQL driver configuration for IAM-only mode
+   *
+   * Uses BetterAuthService for subscription authentication via JWT tokens.
+   * This is the recommended mode for new projects.
+   */
+  private static buildIamOnlyGraphQlDriver(cors: object, options: Partial<IServerOptions>) {
+    return {
+      imports: [BetterAuthModule],
+      inject: [BetterAuthService, BetterAuthUserMapper],
+      useFactory: async (betterAuthService: BetterAuthService, userMapper: BetterAuthUserMapper) =>
+        Object.assign(
+          {
+            autoSchemaFile: 'schema.gql',
+            context: ({ req, res }) => ({ req, res }),
+            cors,
+            installSubscriptionHandlers: true,
+            subscriptions: {
+              'graphql-ws': {
+                context: ({ extra }) => extra,
+                onConnect: async (context: Context<any>) => {
+                  const { connectionParams, extra } = context;
+                  const enableAuth = options?.graphQl?.enableSubscriptionAuth ?? true;
+
+                  if (enableAuth) {
+                    // Get headers from raw headers or connection params
+                    const headers = CoreModule.getHeaderFromArray(extra.request?.rawHeaders);
+                    const authToken: string =
+                      connectionParams?.Authorization?.split(' ')[1] ?? headers.Authorization?.split(' ')[1];
+
+                    if (authToken) {
+                      // Validate via BetterAuth session
+                      const { session, user: sessionUser } = await betterAuthService.getSession({
+                        headers: { authorization: `Bearer ${authToken}` },
+                      });
+
+                      if (!session || !sessionUser) {
+                        throw new UnauthorizedException('Invalid or expired session');
+                      }
+
+                      // Map to full user with roles
+                      const user = await userMapper.mapSessionUser(sessionUser);
+                      if (!user) {
+                        throw new UnauthorizedException('User not found');
+                      }
+
+                      extra.user = user;
+                      extra.headers = connectionParams ?? headers;
+                      return extra;
+                    }
+
+                    throw new UnauthorizedException('Missing authentication token');
+                  }
+                },
+              },
+              'subscriptions-transport-ws': {
+                onConnect: async (connectionParams) => {
+                  const enableAuth = options?.graphQl?.enableSubscriptionAuth ?? true;
+
+                  if (enableAuth) {
+                    const authToken: string = connectionParams?.Authorization?.split(' ')[1];
+
+                    if (authToken) {
+                      // Validate via BetterAuth session
+                      const { session, user: sessionUser } = await betterAuthService.getSession({
+                        headers: { authorization: `Bearer ${authToken}` },
+                      });
+
+                      if (!session || !sessionUser) {
+                        throw new UnauthorizedException('Invalid or expired session');
+                      }
+
+                      // Map to full user with roles
+                      const user = await userMapper.mapSessionUser(sessionUser);
+                      if (!user) {
+                        throw new UnauthorizedException('User not found');
+                      }
+
+                      return { headers: connectionParams, user };
+                    }
+
+                    throw new UnauthorizedException('Missing authentication token');
+                  }
+                },
+              },
+            },
+          },
+          options?.graphQl?.driver,
+        ),
+    };
+  }
+
+  /**
+   * Build GraphQL driver configuration for Legacy Auth mode
+   *
+   * Uses the provided AuthService for subscription authentication via JWT tokens.
+   * This is for existing projects that need backwards compatibility.
+   *
+   * @deprecated Use IAM-only mode (single-parameter forRoot) for new projects
+   */
+  private static buildLegacyGraphQlDriver(
+    AuthService: any,
+    AuthModule: any,
+    cors: object,
+    options: Partial<IServerOptions>,
+  ) {
+    // Store config reference for use in callbacks
+    const enableSubscriptionAuth = options?.graphQl?.enableSubscriptionAuth ?? true;
+
+    return {
+      imports: [AuthModule],
+      inject: [AuthService],
+      useFactory: async (authService: any) =>
+        Object.assign(
+          {
+            autoSchemaFile: 'schema.gql',
+            context: ({ req, res }) => ({ req, res }),
+            cors,
+            installSubscriptionHandlers: true,
+            subscriptions: {
+              'graphql-ws': {
+                context: ({ extra }) => extra,
+                onConnect: async (context: Context<any>) => {
+                  const { connectionParams, extra } = context;
+                  if (enableSubscriptionAuth) {
+                    // get authToken from authorization header
+                    const headers = CoreModule.getHeaderFromArray(extra.request?.rawHeaders);
+                    const authToken: string =
+                      connectionParams?.Authorization?.split(' ')[1] ?? headers.Authorization?.split(' ')[1];
+                    if (authToken) {
+                      // verify authToken/getJwtPayLoad
+                      const payload = authService.decodeJwt(authToken);
+                      const user = await authService.validateUser(payload);
+                      if (!user) {
+                        throw new UnauthorizedException('No user found for token');
+                      }
+                      // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
+                      extra.user = user;
+                      extra.headers = connectionParams ?? headers;
+                      return extra;
+                    }
+
+                    throw new UnauthorizedException('Missing authentication token');
+                  }
+                },
+              },
+              'subscriptions-transport-ws': {
+                onConnect: async (connectionParams) => {
+                  if (enableSubscriptionAuth) {
+                    // get authToken from authorization header
+                    const authToken: string = connectionParams?.Authorization?.split(' ')[1];
+
+                    if (authToken) {
+                      // verify authToken/getJwtPayLoad
+                      const payload = authService.decodeJwt(authToken);
+                      const user = await authService.validateUser(payload);
+                      if (!user) {
+                        throw new UnauthorizedException('No user found for token');
+                      }
+                      // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
+                      return { headers: connectionParams, user };
+                    }
+
+                    throw new UnauthorizedException('Missing authentication token');
+                  }
+                },
+              },
+            },
+          },
+          options?.graphQl?.driver,
+        ),
+    };
+  }
 }

package/src/index.ts

@@ -108,15 +108,19 @@ export * from './core/modules/auth/core-auth.resolver';
 export * from './core/modules/auth/exceptions/expired-refresh-token.exception';
 export * from './core/modules/auth/exceptions/expired-token.exception';
 export * from './core/modules/auth/exceptions/invalid-token.exception';
+export * from './core/modules/auth/exceptions/legacy-auth-disabled.exception';
 export * from './core/modules/auth/guards/auth.guard';
+export * from './core/modules/auth/guards/legacy-auth-rate-limit.guard';
 export * from './core/modules/auth/guards/roles.guard';
 export * from './core/modules/auth/inputs/core-auth-sign-in.input';
 export * from './core/modules/auth/inputs/core-auth-sign-up.input';
+export * from './core/modules/auth/interfaces/auth-provider.interface';
 export * from './core/modules/auth/interfaces/core-auth-user.interface';
 export * from './core/modules/auth/interfaces/core-token-data.interface';
 export * from './core/modules/auth/interfaces/jwt-payload.interface';
 export * from './core/modules/auth/services/core-auth-user.service';
 export * from './core/modules/auth/services/core-auth.service';
+export * from './core/modules/auth/services/legacy-auth-rate-limiter.service';
 export * from './core/modules/auth/strategies/jwt-refresh.strategy';
 export * from './core/modules/auth/strategies/jwt.strategy';
 export * from './core/modules/auth/tokens.decorator';
@@ -162,6 +166,7 @@ export * from './core/modules/user/core-user.model';
 export * from './core/modules/user/core-user.service';
 export * from './core/modules/user/inputs/core-user-create.input';
 export * from './core/modules/user/inputs/core-user.input';
+export * from './core/modules/user/interfaces/core-user-service-options.interface';
 
 // =====================================================================================================================
 // Tests

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

@@ -30,6 +30,8 @@ export class AuthResolver extends CoreAuthResolver {
 
   /**
    * SignIn for User
+   *
+   * @throws LegacyAuthDisabledException if legacy endpoints are disabled
    */
   @Mutation(() => Auth, { description: 'Sign in and get JWT token' })
   @Roles(RoleEnum.S_EVERYONE)
@@ -38,6 +40,8 @@ export class AuthResolver extends CoreAuthResolver {
     @Context() ctx: { res: ResponseType },
     @Args('input') input: AuthSignInInput,
   ): Promise<Auth> {
+    // Check if legacy endpoints are enabled before proceeding
+    this.checkLegacyGraphQLEnabled('signIn');
     const result = await this.authService.signIn(input, {
       ...serviceOptions,
       inputType: AuthSignInInput,
@@ -47,6 +51,8 @@ export class AuthResolver extends CoreAuthResolver {
 
   /**
    * Sign up for user
+   *
+   * @throws LegacyAuthDisabledException if legacy endpoints are disabled
    */
   @Mutation(() => Auth, {
     description: 'Sign up user and get JWT token',
@@ -57,6 +63,8 @@ export class AuthResolver extends CoreAuthResolver {
     @Context() ctx: { res: ResponseType },
     @Args('input') input: AuthSignUpInput,
   ): Promise<Auth> {
+    // Check if legacy endpoints are enabled before proceeding
+    this.checkLegacyGraphQLEnabled('signUp');
     const result = await this.authService.signUp(input, serviceOptions);
     return this.processCookies(ctx, result);
   }

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

@@ -10,9 +10,13 @@ import { BetterAuthResolver } from './better-auth.resolver';
  */
 export interface ServerBetterAuthModuleOptions {
   /**
-   * Better-auth configuration from environment
+   * Better-auth configuration.
+   * Accepts:
+   * - `true`: Enable with all defaults (including JWT)
+   * - `false`: Disable BetterAuth
+   * - `{ ... }`: Enable with custom configuration
    */
-  config: IBetterAuth;
+  config: boolean | IBetterAuth;
 
   /**
    * Fallback secrets for backwards compatibility with JWT config.
@@ -63,7 +67,9 @@ export class BetterAuthModule {
     const { config, fallbackSecrets } = options;
 
     // If better-auth is explicitly disabled, return minimal module
-    if (config?.enabled === false) {
+    // Supports: false, { enabled: false }, or undefined/null
+    const isDisabled = config === false || (typeof config === 'object' && config?.enabled === false);
+    if (isDisabled) {
       return {
         exports: [],
         module: BetterAuthModule,

package/src/server/modules/better-auth/better-auth.resolver.ts

@@ -1,12 +1,10 @@
-import { UseGuards } from '@nestjs/common';
 import { Args, Context, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { Request, Response } from 'express';
 
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
-import { AuthGuardStrategy } from '../../../core/modules/auth/auth-guard-strategy.enum';
-import { AuthGuard } from '../../../core/modules/auth/guards/auth.guard';
 import { BetterAuthAuthModel } from '../../../core/modules/better-auth/better-auth-auth.model';
+import { BetterAuthMigrationStatusModel } from '../../../core/modules/better-auth/better-auth-migration-status.model';
 import {
   BetterAuth2FASetupModel,
   BetterAuthFeaturesModel,
@@ -61,7 +59,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     nullable: true,
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthSession(@Context() ctx: { req: Request }): Promise<BetterAuthSessionModel | null> {
     return super.betterAuthSession(ctx);
   }
@@ -78,12 +75,28 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     return super.betterAuthFeatures();
   }
 
+  @Query(() => BetterAuthMigrationStatusModel, {
+    description: 'Get migration status from Legacy Auth to Better-Auth (IAM) - Admin only',
+  })
+  @Roles(RoleEnum.ADMIN)
+  override async betterAuthMigrationStatus(): Promise<BetterAuthMigrationStatusModel> {
+    return super.betterAuthMigrationStatus();
+  }
+
+  @Query(() => String, {
+    description: 'Get fresh JWT token for the current session (requires valid session)',
+    nullable: true,
+  })
+  @Roles(RoleEnum.S_USER)
+  override async betterAuthToken(@Context() ctx: { req: Request }): Promise<null | string> {
+    return super.betterAuthToken(ctx);
+  }
+
   @Query(() => [BetterAuthPasskeyModel], {
     description: 'List passkeys for the current user',
     nullable: true,
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthListPasskeys(@Context() ctx: { req: Request }): Promise<BetterAuthPasskeyModel[] | null> {
     return super.betterAuthListPasskeys(ctx);
   }
@@ -118,7 +131,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
 
   @Mutation(() => Boolean, { description: 'Sign out via Better-Auth' })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthSignOut(@Context() ctx: { req: Request }): Promise<boolean> {
     return super.betterAuthSignOut(ctx);
   }
@@ -142,7 +154,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     description: 'Enable 2FA for the current user',
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthEnable2FA(
     @Args('password') password: string,
     @Context() ctx: { req: Request },
@@ -154,7 +165,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     description: 'Disable 2FA for the current user',
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthDisable2FA(
     @Args('password') password: string,
     @Context() ctx: { req: Request },
@@ -167,7 +177,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     nullable: true,
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthGenerateBackupCodes(@Context() ctx: { req: Request }): Promise<null | string[]> {
     return super.betterAuthGenerateBackupCodes(ctx);
   }
@@ -180,7 +189,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     description: 'Get passkey registration challenge for WebAuthn',
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthGetPasskeyChallenge(
     @Context() ctx: { req: Request },
   ): Promise<BetterAuthPasskeyChallengeModel> {
@@ -191,7 +199,6 @@ export class BetterAuthResolver extends CoreBetterAuthResolver {
     description: 'Delete a passkey by ID',
   })
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   override async betterAuthDeletePasskey(
     @Args('passkeyId') passkeyId: string,
     @Context() ctx: { req: Request },

package/src/server/modules/user/user.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, Query, UseGuards } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from '@nestjs/common';
 import {
   ApiBearerAuth,
   ApiBody,
@@ -15,8 +15,6 @@ import { CurrentUser } from '../../../core/common/decorators/current-user.decora
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { ServiceOptions } from '../../../core/common/interfaces/service-options.interface';
-import { AuthGuardStrategy } from '../../../core/modules/auth/auth-guard-strategy.enum';
-import { AuthGuard } from '../../../core/modules/auth/guards/auth.guard';
 import { UserCreateInput } from './inputs/user-create.input';
 import { UserInput } from './inputs/user.input';
 import { FindAndCountUsersResult } from './outputs/find-and-count-users-result.output';
@@ -48,7 +46,6 @@ export class UserController {
   @ApiOperation({ description: 'Find users (via filter)', summary: 'Get all users' })
   @Get()
   @Roles(RoleEnum.ADMIN)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async findUsers(@CurrentUser() currentUser: User): Promise<User[]> {
     const serviceOptions: ServiceOptions = {
       currentUser,
@@ -67,7 +64,6 @@ export class UserController {
   })
   @Get('count')
   @Roles(RoleEnum.ADMIN)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async findAndCountUsers(@CurrentUser() currentUser: User): Promise<FindAndCountUsersResult> {
     const serviceOptions: ServiceOptions = {
       currentUser,
@@ -99,7 +95,6 @@ export class UserController {
   @ApiParam({ description: 'User ID', name: 'id', type: String })
   @Get(':id')
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async getUser(@CurrentUser() currentUser: User, @Param('id') id: string): Promise<User> {
     const serviceOptions: ServiceOptions = {
       currentUser,
@@ -121,7 +116,6 @@ export class UserController {
   @ApiOperation({ description: 'Create a new user', summary: 'Create user' })
   @Post()
   @Roles(RoleEnum.ADMIN)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async createUser(@CurrentUser() currentUser: User, @Body() input: UserCreateInput): Promise<User> {
     const serviceOptions: ServiceOptions = {
       currentUser,
@@ -208,7 +202,6 @@ export class UserController {
   @ApiParam({ description: 'User ID', name: 'id', type: String })
   @Patch(':id')
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async updateUser(@CurrentUser() currentUser: User, @Param('id') id: string, @Body() input: UserInput): Promise<User> {
     const serviceOptions: ServiceOptions = {
       currentUser,
@@ -231,7 +224,6 @@ export class UserController {
   @ApiParam({ description: 'User ID', name: 'id', type: String })
   @Delete(':id')
   @Roles(RoleEnum.S_USER)
-  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
   async deleteUser(@CurrentUser() currentUser: User, @Param('id') id: string): Promise<User> {
     const serviceOptions: ServiceOptions = {
       currentUser,

package/src/server/modules/user/user.service.ts

@@ -1,4 +1,4 @@
-import { Inject, Injectable, UnauthorizedException, UnprocessableEntityException } from '@nestjs/common';
+import { Inject, Injectable, Optional, UnauthorizedException, UnprocessableEntityException } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import fs = require('fs');
 import { PubSub } from 'graphql-subscriptions';
@@ -9,6 +9,7 @@ import { ServiceOptions } from '../../../core/common/interfaces/service-options.
 import { ConfigService } from '../../../core/common/services/config.service';
 import { EmailService } from '../../../core/common/services/email.service';
 import { CoreModelConstructor } from '../../../core/common/types/core-model-constructor.type';
+import { BetterAuthUserMapper } from '../../../core/modules/better-auth/better-auth-user.mapper';
 import { CoreUserService } from '../../../core/modules/user/core-user.service';
 import { UserCreateInput } from './inputs/user-create.input';
 import { UserInput } from './inputs/user.input';
@@ -32,8 +33,9 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
     @Inject('USER_CLASS') protected override readonly mainModelConstructor: CoreModelConstructor<User>,
     @InjectModel('User') protected override readonly mainDbModel: Model<UserDocument>,
     @Inject('PUB_SUB') protected readonly pubSub: PubSub,
+    @Optional() private readonly betterAuthUserMapper?: BetterAuthUserMapper,
   ) {
-    super(configService, emailService, mainDbModel, mainModelConstructor);
+    super(configService, emailService, mainDbModel, mainModelConstructor, { betterAuthUserMapper });
   }
 
   // ===================================================================================================================