Add reports

Author: GuidoBR

backend/infrastructure/reports-table.ts

@@ -0,0 +1,30 @@
+import { Construct } from 'constructs';
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { AttributeType, BillingMode, Table } from 'aws-cdk-lib/aws-dynamodb';
+
+export function createReportsTable(scope: Construct, id: string): Table {
+  const table = new Table(scope, id, {
+    tableName: 'reports',
+    partitionKey: {
+      name: 'id',
+      type: AttributeType.STRING,
+    },
+    billingMode: BillingMode.PAY_PER_REQUEST,
+    removalPolicy: RemovalPolicy.RETAIN,
+  });
+
+  // Add a GSI for querying by userId
+  table.addGlobalSecondaryIndex({
+    indexName: 'userIdIndex',
+    partitionKey: {
+      name: 'userId',
+      type: AttributeType.STRING,
+    },
+    sortKey: {
+      name: 'createdAt',
+      type: AttributeType.STRING,
+    },
+  });
+
+  return table;
+}

backend/package-lock.json

@@ -28,6 +28,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.758.0",
+    "@aws-sdk/util-dynamodb": "^3.758.0",
     "@aws-sdk/client-secrets-manager": "^3.758.0",
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.1.1",

backend/package.json

@@ -9,6 +9,8 @@ import { PerplexityController } from './controllers/perplexity/perplexity.contro
 import { AuthModule } from './auth/auth.module';
 import { UserController } from './user/user.controller';
 import { AuthMiddleware } from './auth/auth.middleware';
+import { UserModule } from './user/user.module';
+import { ReportsModule } from './reports/reports.module';
 
 @Module({
   imports: [
@@ -17,6 +19,8 @@ import { AuthMiddleware } from './auth/auth.middleware';
       load: [configuration],
     }),
     AuthModule,
+    UserModule,
+    ReportsModule,
   ],
   controllers: [AppController, PerplexityController, UserController],
   providers: [AppService, AwsSecretsService, PerplexityService],

backend/src/app.module.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumber, IsOptional, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class GetReportsQueryDto {
+  @ApiProperty({
+    description: 'Maximum number of reports to return',
+    required: false,
+    default: 10
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsNumber()
+  @Min(1)
+  @Max(100)
+  limit?: number = 10;
+}

backend/src/reports/dto/get-reports.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum, IsNotEmpty } from 'class-validator';
+import { ReportStatus } from '../models/report.model';
+
+export class UpdateReportStatusDto {
+  @ApiProperty({
+    description: 'New status for the report',
+    enum: ReportStatus,
+    example: ReportStatus.READ
+  })
+  @IsNotEmpty()
+  @IsEnum(ReportStatus)
+  status: ReportStatus;
+}

backend/src/reports/dto/update-report-status.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export enum ReportStatus {
+  UNREAD = 'UNREAD',
+  READ = 'READ',
+}
+
+export class Report {
+  @ApiProperty({ description: 'Unique identifier for the report' })
+  id: string;
+
+  @ApiProperty({ description: 'Title of the report' })
+  title: string;
+
+  @ApiProperty({ description: 'Content of the report' })
+  content: string;
+
+  @ApiProperty({ description: 'User ID of the report owner' })
+  userId: string;
+
+  @ApiProperty({ description: 'Creation timestamp' })
+  createdAt: string;
+
+  @ApiProperty({ description: 'Last update timestamp' })
+  updatedAt: string;
+
+  @ApiProperty({
+    description: 'Status of the report',
+    enum: ReportStatus,
+    default: ReportStatus.UNREAD
+  })
+  status: ReportStatus;
+}

backend/src/reports/models/report.model.ts

@@ -0,0 +1,80 @@
+import {
+  Controller,
+  Get,
+  Patch,
+  Param,
+  Body,
+  Query,
+  UseGuards,
+  ValidationPipe
+} from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiResponse,
+  ApiBearerAuth,
+  ApiParam,
+  ApiQuery
+} from '@nestjs/swagger';
+import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+import { ReportsService } from './reports.service';
+import { Report, ReportStatus } from './models/report.model';
+import { GetReportsQueryDto } from './dto/get-reports.dto';
+import { UpdateReportStatusDto } from './dto/update-report-status.dto';
+
+@ApiTags('reports')
+@Controller('reports')
+@UseGuards(JwtAuthGuard)
+@ApiBearerAuth()
+export class ReportsController {
+  constructor(private readonly reportsService: ReportsService) {}
+
+  @ApiOperation({ summary: 'Get all reports' })
+  @ApiResponse({
+    status: 200,
+    description: 'Returns all reports',
+    type: [Report]
+  })
+  @Get()
+  async findAll(): Promise<Report[]> {
+    return this.reportsService.findAll();
+  }
+
+  @ApiOperation({ summary: 'Get latest reports' })
+  @ApiResponse({
+    status: 200,
+    description: 'Returns the latest reports',
+    type: [Report]
+  })
+  @ApiQuery({
+    name: 'limit',
+    required: false,
+    description: 'Maximum number of reports to return'
+  })
+  @Get('latest')
+  async findLatest(@Query(ValidationPipe) queryDto: GetReportsQueryDto): Promise<Report[]> {
+    return this.reportsService.findLatest(queryDto);
+  }
+
+  @ApiOperation({ summary: 'Update report status' })
+  @ApiResponse({
+    status: 200,
+    description: 'Report status updated successfully',
+    type: Report
+  })
+  @ApiResponse({
+    status: 404,
+    description: 'Report not found'
+  })
+  @ApiParam({
+    name: 'id',
+    description: 'Report ID'
+  })
+  @Patch(':id/status')
+  async updateStatus(
+    @Param('id') id: string,
+    @Body(ValidationPipe) updateDto: UpdateReportStatusDto
+  ): Promise<Report> {
+    return this.reportsService.updateStatus(id, updateDto);
+  }
+}

backend/src/reports/reports.controller.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ReportsController } from './reports.controller';
+import { ReportsService } from './reports.service';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [ReportsController],
+  providers: [ReportsService],
+  exports: [ReportsService],
+})
+export class ReportsModule {}

backend/src/reports/reports.module.ts

@@ -0,0 +1,90 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  DynamoDBClient,
+  ScanCommand,
+  GetItemCommand,
+  UpdateItemCommand,
+  QueryCommand
+} from '@aws-sdk/client-dynamodb';
+import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
+import { Report, ReportStatus } from './models/report.model';
+import { GetReportsQueryDto } from './dto/get-reports.dto';
+import { UpdateReportStatusDto } from './dto/update-report-status.dto';
+
+@Injectable()
+export class ReportsService {
+  private readonly dynamoClient: DynamoDBClient;
+  private readonly tableName: string;
+
+  constructor(private configService: ConfigService) {
+    this.dynamoClient = new DynamoDBClient({
+      region: this.configService.get<string>('AWS_REGION', 'us-east-1'),
+    });
+    this.tableName = this.configService.get<string>('DYNAMODB_TABLE_NAME', 'reports');
+  }
+
+  async findAll(): Promise<Report[]> {
+    const command = new ScanCommand({
+      TableName: this.tableName,
+    });
+
+    const response = await this.dynamoClient.send(command);
+    return (response.Items || []).map(item => unmarshall(item) as Report);
+  }
+
+  async findLatest(queryDto: GetReportsQueryDto): Promise<Report[]> {
+    const limit = queryDto.limit || 10;
+
+    const command = new ScanCommand({
+      TableName: this.tableName,
+      Limit: limit,
+      ScanIndexForward: false, // This will sort in descending order
+    });
+
+    const response = await this.dynamoClient.send(command);
+    const reports = (response.Items || []).map(item => unmarshall(item) as Report);
+
+    // Sort by createdAt in descending order
+    return reports.sort((a, b) =>
+      new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    ).slice(0, limit);
+  }
+
+  async findOne(id: string): Promise<Report> {
+    const command = new GetItemCommand({
+      TableName: this.tableName,
+      Key: marshall({ id }),
+    });
+
+    const response = await this.dynamoClient.send(command);
+
+    if (!response.Item) {
+      throw new NotFoundException(`Report with ID ${id} not found`);
+    }
+
+    return unmarshall(response.Item) as Report;
+  }
+
+  async updateStatus(id: string, updateDto: UpdateReportStatusDto): Promise<Report> {
+    // First check if the report exists
+    await this.findOne(id);
+
+    const command = new UpdateItemCommand({
+      TableName: this.tableName,
+      Key: marshall({ id }),
+      UpdateExpression: 'SET #status = :status, updatedAt = :updatedAt',
+      ExpressionAttributeNames: {
+        '#status': 'status',
+      },
+      ExpressionAttributeValues: marshall({
+        ':status': updateDto.status,
+        ':updatedAt': new Date().toISOString(),
+      }),
+      ReturnValues: 'ALL_NEW',
+    });
+
+    const response = await this.dynamoClient.send(command);
+    return unmarshall(response.Attributes) as Report;
+  }
+}