feat: progressive auth service

apps/api/.dev.env

@@ -1,5 +1,6 @@
 PORT=4000
 NODE_ENV='development'
+AUTH_GRPC_URL='auth:4010'
 SWAP_GRPC_URL='swap:4040'
 NOSTR_GRPC_URL='nostr:4050'
 SMS_GRPC_URL='sms:4060'

apps/api/src/api.module.ts

@@ -1,9 +1,11 @@
-import { join } from 'path';
 import * as Joi from 'joi';
+import { join } from 'path';
+import { JwtModule } from '@nestjs/jwt';
 import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { ClientsModule, Transport } from '@nestjs/microservices';
 import {
+  AUTH_SERVICE_NAME,
   EVENTS_SERVICE_BUS,
   LoggerModule,
   NOSTR_SERVICE_NAME,
@@ -22,9 +24,12 @@ import { AdminController } from './admin/admin.controller';
 import { AdminService } from './admin/admin.service';
 import { SolowalletService } from './solowallet/solowallet.service';
 import { SolowalletController } from './solowallet/solowallet.controller';
+import { AuthService } from './auth/auth.service';
+import { AuthController } from './auth/auth.controller';
 
 @Module({
   imports: [
+    JwtModule,
     LoggerModule,
     ConfigModule.forRoot({
       isGlobal: true,
@@ -41,6 +46,18 @@ import { SolowalletController } from './solowallet/solowallet.controller';
       }),
     }),
     ClientsModule.registerAsync([
+      {
+        name: AUTH_SERVICE_NAME,
+        useFactory: (configService: ConfigService) => ({
+          transport: Transport.GRPC,
+          options: {
+            package: 'auth',
+            protoPath: join(__dirname, '../../../proto/auth.proto'),
+            url: configService.getOrThrow<string>('AUTH_GRPC_URL'),
+          },
+        }),
+        inject: [ConfigService],
+      },
       {
         name: SWAP_SERVICE_NAME,
         useFactory: (configService: ConfigService) => ({
@@ -115,20 +132,22 @@ import { SolowalletController } from './solowallet/solowallet.controller';
     ]),
   ],
   controllers: [
-    AdminController,
+    AuthController,
     SwapController,
     NostrController,
     SmsController,
     SharesController,
     SolowalletController,
+    AdminController,
   ],
   providers: [
+    AuthService,
     SwapService,
     NostrService,
     SmsService,
     SharesService,
-    AdminService,
     SolowalletService,
+    AdminService,
   ],
 })
 export class ApiModule {}

apps/api/src/auth/auth.controller.spec.ts

@@ -0,0 +1,39 @@
+import { JwtService } from '@nestjs/jwt';
+import { ConfigService } from '@nestjs/config';
+import { TestingModule } from '@nestjs/testing';
+import { createTestingModuleWithValidation } from '@bitsacco/testing';
+
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+
+describe('AuthController', () => {
+  let controller: AuthController;
+  let authService: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await createTestingModuleWithValidation({
+      controllers: [AuthController],
+      providers: [
+        ConfigService,
+        {
+          provide: AuthService,
+          useValue: {
+            loginUser: jest.fn(),
+            registerUser: jest.fn(),
+            verifyUser: jest.fn(),
+            authenticate: jest.fn(),
+          },
+        },
+        JwtService,
+      ],
+    });
+
+    controller = module.get<AuthController>(AuthController);
+    authService = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+    expect(authService).toBeDefined();
+  });
+});

apps/api/src/auth/auth.controller.ts

@@ -0,0 +1,48 @@
+import { type Response } from 'express';
+import { firstValueFrom } from 'rxjs';
+import { JwtService } from '@nestjs/jwt';
+import { Body, Controller, Logger, Post, Res } from '@nestjs/common';
+import { ApiBody, ApiOperation } from '@nestjs/swagger';
+import { AuthTokenPayload, LoginUserRequestDto } from '@bitsacco/common';
+import { AuthService } from './auth.service';
+import { ConfigService } from '@nestjs/config';
+
+@Controller('auth')
+export class AuthController {
+  private readonly logger = new Logger(AuthController.name);
+
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly authService: AuthService,
+    private readonly jwtService: JwtService,
+  ) {
+    this.logger.log('AuthController initialized');
+  }
+
+  @Post('login')
+  @ApiOperation({ summary: 'Login user' })
+  @ApiBody({
+    type: LoginUserRequestDto,
+  })
+  async login(
+    @Body() req: LoginUserRequestDto,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    return firstValueFrom(this.authService.loginUser(req)).then(
+      (authResponse) => {
+        const { expires } = this.jwtService.decode<AuthTokenPayload>(
+          authResponse.token,
+        );
+
+        const env = this.configService.get('NODE_ENV');
+        res.cookie('Authentication', authResponse.token, {
+          httpOnly: true,
+          secure: env === 'production',
+          expires,
+        });
+
+        return authResponse;
+      },
+    );
+  }
+}

apps/api/src/auth/auth.service.spec.ts

@@ -0,0 +1,34 @@
+import { TestingModule } from '@nestjs/testing';
+import { AuthServiceClient } from '@bitsacco/common';
+import { createTestingModuleWithValidation } from '@bitsacco/testing';
+import { ClientGrpc } from '@nestjs/microservices';
+import { AuthService } from './auth.service';
+
+describe('AuthService', () => {
+  let service: AuthService;
+  let serviceGenerator: ClientGrpc;
+  let mockAuthServiceClient: Partial<AuthServiceClient>;
+
+  beforeEach(async () => {
+    serviceGenerator = {
+      getService: jest.fn().mockReturnValue(mockAuthServiceClient),
+      getClientByServiceName: jest.fn().mockReturnValue(mockAuthServiceClient),
+    };
+
+    const module: TestingModule = await createTestingModuleWithValidation({
+      providers: [
+        {
+          provide: AuthService,
+          useFactory: () => {
+            return new AuthService(serviceGenerator);
+          },
+        },
+      ],
+    });
+    service = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/api/src/auth/auth.service.ts

@@ -0,0 +1,37 @@
+import {
+  AUTH_SERVICE_NAME,
+  AuthRequest,
+  AuthServiceClient,
+  LoginUserRequest,
+  RegisterUserRequest,
+  VerifyUserRequest,
+} from '@bitsacco/common';
+import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
+import { type ClientGrpc } from '@nestjs/microservices';
+
+@Injectable()
+export class AuthService implements OnModuleInit {
+  private client: AuthServiceClient;
+
+  constructor(@Inject(AUTH_SERVICE_NAME) private readonly grpc: ClientGrpc) {}
+
+  onModuleInit() {
+    this.client = this.grpc.getService<AuthServiceClient>(AUTH_SERVICE_NAME);
+  }
+
+  loginUser(req: LoginUserRequest) {
+    return this.client.loginUser(req);
+  }
+
+  registerUser(req: RegisterUserRequest) {
+    this.client.registerUser(req);
+  }
+
+  verifyUser(req: VerifyUserRequest) {
+    this.client.verifyUser(req);
+  }
+
+  authenticate(req: AuthRequest) {
+    this.client.authenticate(req);
+  }
+}

apps/auth/src/auth.controller.ts

@@ -25,7 +25,7 @@ export class AuthController {
   }
 
   @GrpcMethod()
-  verifyuser(req: VerifyUserRequestDto) {
+  verifyUser(req: VerifyUserRequestDto) {
     return this.authService.verifyUser(req);
   }
 

apps/auth/src/auth.service.ts

@@ -3,18 +3,14 @@ import { ConfigService } from '@nestjs/config';
 import { Injectable, Logger } from '@nestjs/common';
 import {
   AuthRequest,
+  AuthTokenPayload,
   LoginUserRequestDto,
   RegisterUserRequestDto,
   User,
   VerifyUserRequestDto,
 } from '@bitsacco/common';
 import { UsersService } from './users';
 
-interface AuthTokenPayload {
-  user: User;
-  expires: Date;
-}
-
 @Injectable()
 export class AuthService {
   private readonly logger = new Logger(AuthService.name);
@@ -29,8 +25,9 @@ export class AuthService {
 
   async loginUser(req: LoginUserRequestDto) {
     const user = await this.userService.validateUser(req);
-
-    return this.createAuthToken(user);
+    return {
+      token: this.createAuthToken(user),
+    };
   }
 
   async registerUser(req: RegisterUserRequestDto) {
@@ -66,6 +63,8 @@ export class AuthService {
       expires,
     };
 
-    return this.jwtService.sign(payload);
+    return {
+      token: this.createAuthToken(user),
+    };
   }
 }

libs/common/src/index.ts

@@ -1,4 +1,3 @@
-export * from './auth';
 export * from './types';
 export * from './logger';
 export * from './utils';

libs/common/src/types/auth.ts

@@ -0,0 +1,6 @@
+import { User } from './proto/auth';
+
+export interface AuthTokenPayload {
+  user: User;
+  expires: Date;
+}

libs/common/src/types/index.ts

@@ -9,3 +9,4 @@ export * from './proto/solowallet';
 export * from './api';
 export * from './validator';
 export * from './fedimint';
+export * from './auth';

libs/common/src/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './currency';
 export { CustomStore } from './cache';
+export { JwtAuthGuard } from './jwt-auth.guard';