Refactoring and tests for the account creation endpoint

Author: Christopher Graney-Ward

src/repositories/hive-account/hive-account.repository.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
 import { HiveAccount } from './schemas/hive-account.schema';
+import { ObjectId } from 'mongodb';
 
 @Injectable()
 export class HiveAccountRepository {
@@ -11,8 +12,21 @@ export class HiveAccountRepository {
     @InjectModel(HiveAccount.name, 'threespeak') private hiveAccountModel: Model<HiveAccount>,
   ) {}
 
-  async findOneByOwner(created_by: string): Promise<HiveAccount | null> {
-    const acelaUser = await this.hiveAccountModel.findOne({ created_by });
+  async findOneByOwnerIdAndHiveAccountName({
+    user_id,
+    account,
+  }: {
+    user_id: string | ObjectId;
+    account: string;
+  }): Promise<HiveAccount | null> {
+    const acelaUser = await this.hiveAccountModel.findOne({ user_id, account });
+    this.#logger.log(acelaUser);
+
+    return acelaUser;
+  }
+
+  async findOneByOwnerId({ user_id }: { user_id: string | ObjectId }): Promise<HiveAccount | null> {
+    const acelaUser = await this.hiveAccountModel.findOne({ user_id });
     this.#logger.log(acelaUser);
 
     return acelaUser;
@@ -31,14 +45,10 @@ export class HiveAccountRepository {
     });
   }
 
-  async insertCreated(username: string, created_by) {
+  async insertCreated(username: string, created_by: string) {
     return await this.hiveAccountModel.create({
-      status: 'created',
-      username,
-      keys_requested: false,
-      created_by,
-      requested_at: new Date(),
-      created_at: new Date(),
+      account: username,
+      user_id: created_by,
     });
   }
 }

src/repositories/hive-chain/hive-chain.repository.ts

@@ -93,8 +93,8 @@ export class HiveChainRepository {
   }
 
   async createAccountWithAuthority(
-    newAccountname,
-    authorityAccountname,
+    newAccountname: string,
+    authorityAccountname: string,
     options?: {
       posting_auths?: string[];
       active_auths?: string[];

src/services/api/api.contoller.test.ts

@@ -22,6 +22,7 @@ import { MockAuthGuard, MockUserDetailsInterceptor, UserDetailsInterceptor } fro
 import { HiveChainModule } from '../../repositories/hive-chain/hive-chain.module';
 import { EmailModule } from '../email/email.module';
 import * as crypto from 'crypto';
+import { HiveModule } from '../hive/hive.module';
 
 describe('ApiController', () => {
   let app: INestApplication;
@@ -64,11 +65,12 @@ describe('ApiController', () => {
           connectionName: '3speakAuth',
           dbName: '3speakAuth',
         }),
-        HiveAccountModule,
+        HiveModule,
         UserModule,
         AuthModule,
-        EmailModule,
+        HiveAccountModule,
         HiveChainModule,
+        EmailModule,
         ApiModule,
         JwtModule.register({
           secretOrPrivateKey: process.env.JWT_PRIVATE_KEY,

src/services/api/api.controller.ts

@@ -24,14 +24,13 @@ import {
 } from '@nestjs/swagger';
 import { HiveAccountRepository } from '../../repositories/hive-account/hive-account.repository';
 import { UserRepository } from '../../repositories/user/user.repository';
-import { HiveRepository } from '../../repositories/hive-chain/hive-chain.repository';
+import { HiveChainRepository } from '../../repositories/hive-chain/hive-chain.repository';
 import { LinkAccountPostDto } from './dto/LinkAccountPost.dto';
 import { VotePostResponseDto } from './dto/VotePostResponse.dto';
 import { VotePostDto } from './dto/VotePost.dto';
 import { LinkedAccountRepository } from '../../repositories/linked-accounts/linked-account.repository';
 import { EmailService } from '../email/email.service';
 import { parseAndValidateRequest } from '../auth/auth.utils';
-import { HiveChainRepository } from '../../repositories/hive-chain/hive-chain.repository';
 
 @Controller('/api/v1')
 export class ApiController {
@@ -316,7 +315,7 @@ export class ApiController {
     if (delegatedAuth) {
       try {
         // console.log(out)
-        return this.hiveRepository.vote({ author, permlink, voter, weight: 500 });
+        return this.hiveChainRepository.vote({ author, permlink, voter, weight: 500 });
       } catch (ex) {
         console.log(ex);
         console.log(ex.message);

src/services/api/dto/RequestHiveAccount.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty } from 'class-validator';
+
+export class RequestHiveAccountDto {
+  @IsNotEmpty()
+  @ApiProperty({
+    description: 'Did of the account',
+    default: 'test-did',
+  })
+  username: string;
+}

src/services/auth/auth.controller.test.ts

@@ -20,8 +20,11 @@ import { INestApplication, Module, ValidationPipe } from '@nestjs/common';
 import * as KeyResolver from 'key-did-resolver';
 import { TestingModule } from '@nestjs/testing';
 import crypto from 'crypto';
-import { HiveChainRepository } from '../../repositories/hive-chain/hive-chain.repository';
 import { PrivateKey } from '@hiveio/dhive';
+import { AuthGuard } from '@nestjs/passport';
+import { MockAuthGuard, MockUserDetailsInterceptor, UserDetailsInterceptor } from '../api/utils';
+import { HiveService } from '../hive/hive.service';
+import { HiveModule } from '../hive/hive.module';
 
 describe('AuthController', () => {
   let app: INestApplication
@@ -31,7 +34,7 @@ describe('AuthController', () => {
   const did = new DID({ provider: key, resolver: KeyResolver.getResolver() })
   let mongod: MongoMemoryServer;
   let authService: AuthService;
-  let hiveChainRepository: HiveChainRepository;
+  let hiveService: HiveService;
 
 
   beforeEach(async () => {
@@ -77,6 +80,7 @@ describe('AuthController', () => {
         HiveChainModule,
         EmailModule,
         AuthModule,
+        HiveModule
       ],
       controllers: [AuthController],
       providers: [AuthService]
@@ -87,9 +91,13 @@ describe('AuthController', () => {
 
     moduleRef = await Test.createTestingModule({
       imports: [TestModule],
-    }).compile();
+    }).overrideGuard(AuthGuard('jwt'))
+      .useClass(MockAuthGuard)
+      .overrideInterceptor(UserDetailsInterceptor)
+      .useClass(MockUserDetailsInterceptor)
+      .compile();
     authService = moduleRef.get<AuthService>(AuthService);
-    hiveChainRepository = moduleRef.get<HiveChainRepository>(HiveChainRepository);
+    hiveService = moduleRef.get<HiveService>(HiveService);
     app = moduleRef.createNestApplication();
     app.useGlobalPipes(new ValidationPipe());
     await app.init()
@@ -129,7 +137,40 @@ describe('AuthController', () => {
     });
   });
 
-  describe('/POST login singleton hive', () => {
+  describe('/POST /request_hive_account', () => {
+    it('creates a Hive account successfully', async () => {
+  
+      // Make the request to the endpoint
+      return request(app.getHttpServer())
+        .post('/api/v1/auth/request_hive_account')
+        .send({ username: 'test_user_id' })
+        .set('Authorization', 'Bearer <your_mocked_jwt_token>')
+        .expect(201)
+        .then(response => {
+          expect(response.body).toEqual({});
+        });
+    });
+  
+    it('throws error when user has already created a Hive account', async () => {
+
+      await hiveService.requestHiveAccount('yeet', 'test_user_id')
+  
+      // Make the request to the endpoint
+      return request(app.getHttpServer())
+        .post('/api/v1/auth/request_hive_account')
+        .send({ username: 'yeet' })
+        .set('Authorization', 'Bearer <your_mocked_jwt_token>')
+        .expect(400)
+        .then(response => {
+          expect(response.body).toEqual({
+            reason: "You have already created the maximum of 1 free Hive account",
+          });
+        });
+    });
+  });
+  
+
+  describe('/POST login_singleton_hive', () => {
     it('Logs in sucessfully on the happy path', async () => {
       const privateKey = PrivateKey.fromSeed(crypto.randomBytes(32).toString("hex"));
       const message = { account: 'sisygoboom', ts: Date.now() };

src/services/auth/auth.controller.ts

@@ -41,6 +41,8 @@ import { EmailService } from '../email/email.service';
 import bcrypt from 'bcryptjs';
 import { WithAuthData } from './auth.interface';
 import { parseAndValidateRequest } from './auth.utils';
+import { RequestHiveAccountDto } from '../api/dto/RequestHiveAccount.dto';
+import { HiveService } from '../hive/hive.service';
 
 @Controller('/api/v1/auth')
 export class AuthController {
@@ -51,6 +53,7 @@ export class AuthController {
     private readonly hiveAccountRepository: HiveAccountRepository,
     private readonly userRepository: UserRepository,
     private readonly hiveRepository: HiveChainRepository,
+    private readonly hiveService: HiveService,
     //private readonly delegatedAuthorityRepository: DelegatedAuthorityRepository,
     private readonly emailService: EmailService,
   ) {}
@@ -382,17 +385,6 @@ export class AuthController {
       'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c',
     required: true,
   })
-  @ApiBody({
-    schema: {
-      properties: {
-        username: {
-          type: 'string',
-          default: 'test-account',
-          description: 'Username of requested HIVE account',
-        },
-      },
-    },
-  })
   @ApiOkResponse({
     description: 'Account created',
     schema: {
@@ -406,42 +398,9 @@ export class AuthController {
   })
   @UseGuards(AuthGuard('jwt'))
   @Post('/request_hive_account')
-  async requestHiveAccount(
-    @Body() body: { username: string },
-    @Request() req: { user: { user_id: string } },
-  ) {
-    const existingAcocunt = await this.hiveAccountRepository.findOneByOwner(req.user.user_id);
-    if (existingAcocunt) {
-      throw new HttpException(
-        { reason: 'You have already created the maximum of 1 free Hive account' },
-        HttpStatus.BAD_REQUEST,
-      );
-    }
-    // console.log(existingAcocunt)
-    const output = await HiveClient.database.getAccounts([body.username]);
-    // console.log(output)
-    if (output.length === 0) {
-      try {
-        const accountCreation = await this.hiveRepository.createAccountWithAuthority(
-          body.username,
-          process.env.ACCOUNT_CREATOR,
-        );
-        //Here will be thrown if failed at this point
+  async requestHiveAccount(@Body() body: RequestHiveAccountDto, @Request() req) {
+    const parsedRequest = parseAndValidateRequest(req, this.#logger);
 
-        await this.hiveAccountRepository.insertCreated(body.username, req.user.user_id);
-
-        return accountCreation;
-      } catch (ex) {
-        throw new HttpException(
-          { reason: `On chain error - ${ex.message}` },
-          HttpStatus.INTERNAL_SERVER_ERROR,
-        );
-      }
-    } else {
-      throw new HttpException(
-        { reason: 'Hive account with the requested name already exists' },
-        HttpStatus.BAD_REQUEST,
-      );
-    }
+    await this.hiveService.requestHiveAccount(body.username, parsedRequest.user.sub);
   }
 }

src/services/auth/auth.module.ts

@@ -8,18 +8,23 @@ import { UserAccountModule } from '../../repositories/userAccount/user-account.m
 import { SessionModule } from '../../repositories/session/session.module';
 import { AuthController } from './auth.controller';
 import { EmailModule } from '../email/email.module';
-import { HiveAccountModule } from '../../repositories/hive-account/hive-account.module';
-import { HiveChainModule } from '../../repositories/hive-chain/hive-chain.module';
 import { AuthMiddleware } from './auth.middleware';
 import { ConfigModule, ConfigService } from '@nestjs/config';
+import { HiveModule } from '../hive/hive.module';
+import { HiveChainModule } from '../../repositories/hive-chain/hive-chain.module';
+import { HiveAccountModule } from '../../repositories/hive-account/hive-account.module';
 
 @Module({
   imports: [
     ConfigModule,
     UserModule,
     UserAccountModule,
+    HiveChainModule,
     HiveAccountModule,
     HiveChainModule,
+    HiveAccountModule,
+    UserModule,
+    HiveModule,
     EmailModule,
     SessionModule,
     PassportModule.register({ defaultStrategy: 'jwt' }),
@@ -28,7 +33,6 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
       inject: [ConfigService],
       useFactory: async (configService: ConfigService) => {
         const key = configService.get<string>('JWT_PRIVATE_KEY');
-        console.log(key);
         return {
           secretOrPrivateKey: key,
           signOptions: { expiresIn: '30d' },

src/services/hive/hive.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { HiveChainModule } from '../../repositories/hive-chain/hive-chain.module';
+import { HiveService } from './hive.service';
+import { HiveAccountModule } from '../../repositories/hive-account/hive-account.module';
+
+@Module({
+  imports: [HiveAccountModule, HiveChainModule],
+  providers: [HiveService],
+  exports: [HiveService],
+})
+export class HiveModule {}