Merge pull request #30 from klayrHQ/search-api

search module

.gitignore

@@ -56,3 +56,4 @@ pids
 report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 
 prisma/db
+

src/app.module.ts

@@ -14,6 +14,7 @@ import { ScheduleModule } from '@nestjs/schedule';
 import { StateModule } from './state/state.module';
 import { GeneratorModule } from './generator/generator.module';
 import { DbCacheModule } from './db-cache/db-cache.module';
+import { SearchModule } from './search/search.module';
 
 @Module({
   imports: [
@@ -32,6 +33,7 @@ import { DbCacheModule } from './db-cache/db-cache.module';
     IndexerModule,
     ChainEventModule,
     GeneratorModule,
+    SearchModule,
   ],
   controllers: [],
   providers: [],

src/block/block-repo.service.ts

@@ -124,4 +124,25 @@ export class BlockRepoService {
       });
     }
   }
+
+  public async searchBlocks(search: string): Promise<{ id: string; height: number }[]> {
+    const height = Number(search);
+    const where: Prisma.BlockWhereInput = {
+      OR: [{ id: { equals: search } }],
+    };
+
+    if (!isNaN(height)) {
+      where.OR.push({ height: { equals: height } });
+    }
+
+    const blocks = await this.prisma.block.findMany({
+      where,
+      select: {
+        id: true,
+        height: true,
+      },
+    });
+
+    return blocks;
+  }
 }

src/search/dto/get-search-res.dto.ts

@@ -0,0 +1,30 @@
+import { ApiResponseOptions } from '@nestjs/swagger';
+
+export class SearchValidators {
+  name: string;
+  address: string;
+  publicKey: string;
+  rank: number;
+}
+
+export class SearchBlocks {
+  height: number;
+  id: string;
+}
+
+export class SearchTransactions {
+  id: string;
+  sender: string;
+}
+
+export class GetSearchResponse {
+  validators: SearchValidators[];
+  blocks: SearchBlocks[];
+  transactions: SearchTransactions[];
+}
+
+export const getSearchResponse: ApiResponseOptions = {
+  status: 200,
+  description: 'The search results have been successfully fetched.',
+  type: GetSearchResponse,
+};

src/search/dto/get-search.dto.ts

@@ -0,0 +1,9 @@
+import { IsString } from 'class-validator';
+
+export class SearchQueryDto {
+  /**
+   * The search query to search in blocks, transactions and validators
+   */
+  @IsString()
+  search: string;
+}

src/search/search.controller.ts

@@ -0,0 +1,58 @@
+import { Controller, Query, Get, ValidationPipe, UsePipes } from '@nestjs/common';
+import { BlockRepoService } from 'src/block/block-repo.service';
+import { TransactionRepoService } from 'src/transaction/transaction-repo.service';
+import { ValidatorRepoService } from 'src/validator/validator.repo-service';
+import { SearchQueryDto } from './dto/get-search.dto';
+import { ApiResponse } from '@nestjs/swagger';
+import { GetSearchResponse, getSearchResponse } from './dto/get-search-res.dto';
+import { getKlayr32AddressFromAddress } from 'src/utils/helpers';
+import { HEX_ADDRESS_LENGTH } from 'src/utils/constants';
+
+@Controller('search')
+export class SearchController {
+  constructor(
+    private readonly blockRepoService: BlockRepoService,
+    private readonly validatorRepoService: ValidatorRepoService,
+    private readonly transactionRepoService: TransactionRepoService,
+  ) {}
+
+  @Get()
+  @UsePipes(new ValidationPipe({ transform: true, whitelist: true, forbidNonWhitelisted: true }))
+  @ApiResponse(getSearchResponse)
+  async getSearchResults(@Query() query: SearchQueryDto): Promise<GetSearchResponse> {
+    let { search } = query;
+
+    if (search.length === HEX_ADDRESS_LENGTH) {
+      search = getKlayr32AddressFromAddress(search);
+    }
+
+    const [blocks, validators, transactions] = await Promise.all([
+      this.blockRepoService.searchBlocks(search),
+      this.validatorRepoService.searchValidators(search),
+      this.transactionRepoService.searchTransactions(search),
+    ]);
+
+    const formattedBlocks = blocks.map((block) => ({
+      height: block.height,
+      id: block.id,
+    }));
+
+    const formattedValidators = validators.map((validator) => ({
+      name: validator.account.name,
+      address: validator.address,
+      publicKey: validator.account.publicKey,
+      rank: validator.rank,
+    }));
+
+    const formattedTransactions = transactions.map((transaction) => ({
+      id: transaction.id,
+      sender: transaction.sender.address,
+    }));
+
+    return {
+      validators: formattedValidators,
+      blocks: formattedBlocks,
+      transactions: formattedTransactions,
+    };
+  }
+}

src/search/search.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { SearchController } from './search.controller';
+import { BlockModule } from 'src/block/block.module';
+import { ValidatorModule } from 'src/validator/validator.module';
+import { TransactionModule } from 'src/transaction/transaction.module';
+
+@Module({
+  imports: [BlockModule, ValidatorModule, TransactionModule],
+  controllers: [SearchController],
+})
+export class SearchModule {}

src/transaction/transaction-repo.service.ts

@@ -94,4 +94,25 @@ export class TransactionRepoService {
       });
     }
   }
+
+  public async searchTransactions(search: string): Promise<
+    Prisma.TransactionGetPayload<{
+      include: {
+        sender: true;
+      };
+    }>[]
+  > {
+    const where: Prisma.TransactionWhereInput = {
+      id: { contains: search },
+    };
+
+    const transactions = await this.prisma.transaction.findMany({
+      where,
+      include: {
+        sender: true,
+      },
+    });
+
+    return transactions;
+  }
 }

src/transaction/transaction.module.ts

@@ -12,7 +12,7 @@ import { AccountModule } from 'src/account/account.module';
 @Module({
   imports: [StateModule, NodeApiModule, EventModule, DbCacheModule, AccountModule],
   providers: [PrismaService, TransactionRepoService, TransactionService],
-  exports: [TransactionService],
+  exports: [TransactionService, TransactionRepoService],
   controllers: [TransactionController],
 })
 export class TransactionModule {}

src/utils/constants.ts

@@ -60,3 +60,9 @@ export const DEFAULT_VALIDATORS_TO_FETCH = 10;
 export const MAX_VALIDATORS_TO_FETCH = 100;
 export const MINIMUM_VALIDATOR_WEIGHT = BigInt(1_000e8);
 export const ACTIVE_VALIDATORS = 51;
+
+////////////////////////////
+///       Search         ///
+////////////////////////////
+
+export const HEX_ADDRESS_LENGTH = 40;

src/validator/validator.repo-service.ts

@@ -105,4 +105,39 @@ export class ValidatorRepoService {
       },
     });
   }
+
+  public async searchValidators(search: string): Promise<
+    {
+      address: string;
+      rank: number;
+      account: {
+        name: string;
+        publicKey: string;
+      };
+    }[]
+  > {
+    const where: Prisma.ValidatorWhereInput = {
+      OR: [
+        { account: { name: { contains: search } } },
+        { address: { equals: search } },
+        { account: { publicKey: { equals: search } } },
+      ],
+    };
+
+    const validators = await this.prisma.validator.findMany({
+      where,
+      select: {
+        address: true,
+        rank: true,
+        account: {
+          select: {
+            name: true,
+            publicKey: true,
+          },
+        },
+      },
+    });
+
+    return validators;
+  }
 }