Created flows module and defined a flow until getting an access token #…

…44

src/app.module.ts

@@ -6,9 +6,10 @@ import { ConfigModule } from '@nestjs/config';
 import { TokenModule } from './token/token.module';
 import { DiscoveryModule } from './discovery/discovery.module';
 import { TokenModule } from './token/token.module';
+import { FlowsModule } from './flows/flows.module';
 
 @Module({
-  imports: [ConfigModule.forRoot(), UserModule, DiscoveryModule, TokenModule],
+  imports: [ConfigModule.forRoot(), UserModule, DiscoveryModule, TokenModule, FlowsModule],
   providers: [AppService],
   controllers: [AppController],
 })

src/flows/flows.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('flows')
+export class FlowsController {}

src/flows/flows.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { FlowsController } from './flows.controller';
+import { FlowsService } from './flows.service';
+import { TokenModule } from '../token/token.module';
+
+@Module({
+  imports: [TokenModule],
+  controllers: [FlowsController],
+  providers: [FlowsService],
+  exports: [FlowsService],
+})
+export class FlowsModule {}

src/flows/flows.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { FlowsService } from './flows.service';
+
+describe('FlowsService', () => {
+  let service: FlowsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [FlowsService],
+    }).compile();
+
+    service = module.get<FlowsService>(FlowsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/flows/flows.service.ts

@@ -0,0 +1,13 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { TokenService } from '../token/token.service';
+
+@Injectable()
+export class FlowsService {
+  @Inject(TokenService)
+  private readonly tokenService: TokenService;
+
+  async clientCredentialsFlow(issuer_s: string) {
+    const accessToken = await this.tokenService.requestToken(issuer_s);
+    return accessToken;
+  }
+}

src/token/token.controller.ts

@@ -68,16 +68,7 @@ export default class TokenController {
     @Res()
     res: Response,
   ): Promise<any> {
-    const issuer = await this.tokenService.getIssuer(issuer_s).catch(() => {
-      throw new HttpException(
-        {
-          status: HttpStatus.BAD_REQUEST,
-          error: 'invalid issuer',
-        },
-        HttpStatus.BAD_REQUEST,
-      );
-    });
-    const result = await this.tokenService.requestToken(issuer);
+    const result = await this.tokenService.requestToken(issuer_s);
     res.json(result.data).send();
   }
 

src/token/token.module.ts

@@ -8,5 +8,6 @@ import { DiscoveryModule } from 'src/discovery/discovery.module';
   imports: [ConfigModule.forRoot(), DiscoveryModule],
   controllers: [TokenController],
   providers: [TokenService],
+  exports: [TokenService],
 })
 export class TokenModule {}

src/token/token.service.spec.ts

@@ -141,9 +141,15 @@ describe('TokenService', () => {
   });
 
   describe('requestToken', () => {
-    it('should fail if empty issuer is provided', async () => {
+    it('should fail if no issuer is provided', async () => {
       await expect(service.requestToken(undefined)).rejects.toThrow(
-        'Received issuer is empty',
+        'There was no issuer string passed to get the issuer',
+      );
+    });
+
+    it('should fail if empty issuer is provided', async () => {
+      await expect(service.requestToken('')).rejects.toThrow(
+        'There was no issuer string passed to get the issuer',
       );
     });
   });

src/token/token.service.ts

@@ -50,13 +50,24 @@ export class TokenService {
       });
   }
 
-  async requestToken(issuer: Issuer): Promise<any> {
-    if (issuer === undefined) {
+  async requestToken(issuer_s: string): Promise<any> {
+    if (issuer_s === undefined || issuer_s === '') {
       throw new HttpException(
-        'Received issuer is empty',
+        'There was no issuer string passed to get the issuer',
         HttpStatus.BAD_REQUEST,
       );
     }
+
+    const issuer = await this.getIssuer(issuer_s).catch(() => {
+      throw new HttpException(
+        {
+          status: HttpStatus.BAD_REQUEST,
+          error: 'invalid issuer',
+        },
+        HttpStatus.BAD_REQUEST,
+      );
+    });
+
     const grantBody: GrantBody = {
       grant_type: process.env.CLIENT_CREDENTIALS_STRING,
       client_id: process.env.CLIENT_ID,

src/user/user.controller.ts

@@ -1,4 +1,4 @@
-import {Body, Controller, Get, Post, Query, Render} from '@nestjs/common';
+import { Body, Controller, Get, Post, Render } from '@nestjs/common';
 import { UserService } from './user.service';
 import { LoginUserDto } from './Dto/LoginUser.dto';
 
@@ -16,5 +16,4 @@ export class UserController {
   root() {
     return;
   }
-
 }

src/user/user.module.ts

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
+import { FlowsModule } from '../flows/flows.module';
 
 @Module({
+  imports: [FlowsModule],
   controllers: [UserController],
   providers: [UserService],
 })

src/user/user.service.ts

@@ -1,9 +1,15 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { LoginUserDto } from './Dto/LoginUser.dto';
+import { FlowsService } from '../flows/flows.service';
 
 @Injectable()
 export class UserService {
-  login(loginUserDto: LoginUserDto): { result: string } {
-    return { result:'Login Successful' };
+  @Inject(FlowsService)
+  private readonly flowsService: FlowsService;
+
+  async login(loginUserDto: LoginUserDto): Promise<any> {
+    return await this.flowsService.clientCredentialsFlow(
+      process.env.ISSUER_STRING,
+    );
   }
 }