Add reddit module with messages/posts controllers and shared RedditService

Co-authored-by: digitalnomad91 <2067771+digitalnomad91@users.noreply.github.com>

Author: Copilot

.gitignore

@@ -59,4 +59,7 @@ report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 google-service-account-key.json
 google-services.json
 
-bak/
+bak/
+
+# npm lock file (project uses pnpm)
+package-lock.json

src/app-router.module.ts

@@ -4,6 +4,7 @@ import { CloudflareKvModule } from './cloudflare-kv/cloudflare-kv.module';
 import { WssModule } from './wss/wss.module';
 import { JobModule } from './jobs/job.module';
 import { AuthModule } from './auth/auth.module';
+import { RedditModule } from './reddit/reddit.module';
 
 @Module({
   imports: [
@@ -12,23 +13,11 @@ import { AuthModule } from './auth/auth.module';
         path: 'ws',
         module: WssModule,
       },
-      // {
-      //   path: 'api',
-      //   children: [
-      //     {
-      //       path: '', // Empty path here - the controller already has 'jobs' path
-      //       module: JobModule,
-      //     },
-      //     {
-      //       path: '', // Empty path here - the controller already has 'auth' path
-      //       module: AuthModule,
-      //     },
-      //   ],
-      // },
     ]),
     CloudflareKvModule,
     JobModule,
     AuthModule,
+    RedditModule,
   ],
   exports: [RouterModule],
 })

src/jobs/job.controller.ts

@@ -12,7 +12,7 @@ import {UserEntity as User} from '../common/decorators/user.decorator';
 //import { ApiPaginationQuery } from './../common/decorators/api-nested-query.decorator';
 import {PaginationArgs} from '../common/pagination/pagination.args';
 import {Web3CareerService} from './web3career.service';
-import {RedditService} from './reddit.service';
+import {RedditService} from '../reddit/reddit.service';
 import {NotificationsService} from '@/notifications/notifications.service';
 import {PaginatedResponse} from '../common/models/paginated-response';
 import {CreateJobDto as JobDto} from './dto/create-job.dto';

src/jobs/job.module.ts

@@ -1,9 +1,9 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } from '@nestjs/common';
 import { JobService } from './job.service';
 import { JobController } from './job.controller';
 import { CommonModule } from '../common/common.module';
 import { Web3CareerService } from './web3career.service';
-import { RedditService } from './reddit.service';
+import { RedditModule } from '../reddit/reddit.module';
 // Notifications are now provided globally by NotificationsModule
 
 /**
@@ -21,9 +21,10 @@ import { RedditService } from './reddit.service';
 @Module({
   imports: [
     CommonModule, // Provides database, authentication, and other shared services
+    forwardRef(() => RedditModule), // Shared Reddit service (avoids circular dependency)
   ],
   controllers: [JobController], // REST API endpoints
-  providers: [JobService, Web3CareerService, RedditService], // Business logic
-  exports: [JobService, Web3CareerService, RedditService], // Allow other modules to use these services
+  providers: [JobService, Web3CareerService], // Business logic
+  exports: [JobService, Web3CareerService], // Allow other modules to use these services
 })
 export class JobModule {}

src/jobs/reddit.service.ts

@@ -0,0 +1,90 @@
+import {Controller, Get, Param, ParseIntPipe, Put, Query} from '@nestjs/common';
+import {ApiTags} from '@nestjs/swagger';
+import {Api} from '@/common/decorators/api.decorator';
+import {MessagesService} from './messages.service';
+import {RedditService} from '../reddit.service';
+import {PaginationArgs} from '../../common/pagination/pagination.args';
+
+@ApiTags('reddit')
+@Controller('reddit/messages')
+export class MessagesController {
+  constructor(
+    private readonly messagesService: MessagesService,
+    private readonly redditService: RedditService
+  ) {}
+
+  /**
+   * Returns a paginated table of all Reddit messages stored in the database.
+   */
+  @Get()
+  @Api({
+    summary: 'List Reddit messages',
+    description: 'Returns a paginated list of Reddit messages (DMs, comments) stored in the database.',
+    queriesFrom: PaginationArgs,
+    envelope: true,
+    responses: [
+      {status: 200, description: 'Messages retrieved successfully.'},
+    ],
+  })
+  async findAll(
+    @Query() paginationArgs: PaginationArgs,
+    @Query('isRead') isRead?: string,
+    @Query('type') type?: string,
+    @Query('subreddit') subreddit?: string
+  ) {
+    const filter: {isRead?: boolean; type?: string; subreddit?: string} = {};
+    if (isRead !== undefined) filter.isRead = isRead === 'true';
+    if (type) filter.type = type;
+    if (subreddit) filter.subreddit = subreddit;
+    return this.messagesService.findAll(paginationArgs, filter);
+  }
+
+  /**
+   * Triggers a Reddit inbox check and stores any new messages in the database.
+   */
+  @Get('check')
+  @Api({
+    summary: 'Check Reddit inbox for new messages',
+    description: 'Connects to Reddit, fetches inbox messages and stores any new ones in the database.',
+    envelope: true,
+    responses: [
+      {status: 200, description: 'Inbox checked and new messages stored.'},
+    ],
+  })
+  async checkInbox() {
+    const newMessages = await this.redditService.checkRedditMessages();
+    return {count: newMessages.length, messages: newMessages};
+  }
+
+  /**
+   * Returns a single Reddit message by ID.
+   */
+  @Get(':id')
+  @Api({
+    summary: 'Get Reddit message by ID',
+    description: 'Returns a single Reddit message stored in the database.',
+    responses: [
+      {status: 200, description: 'Message retrieved successfully.'},
+      {status: 404, description: 'Message not found.'},
+    ],
+  })
+  async findOne(@Param('id', ParseIntPipe) id: number) {
+    return this.messagesService.findOne(id);
+  }
+
+  /**
+   * Marks a Reddit message as read.
+   */
+  @Put(':id/read')
+  @Api({
+    summary: 'Mark message as read',
+    description: 'Marks a Reddit message as read in the database.',
+    responses: [
+      {status: 200, description: 'Message marked as read.'},
+      {status: 404, description: 'Message not found.'},
+    ],
+  })
+  async markAsRead(@Param('id', ParseIntPipe) id: number) {
+    return this.messagesService.markAsRead(id);
+  }
+}

src/reddit/messages/messages.controller.ts

@@ -0,0 +1,63 @@
+import {Injectable, NotFoundException} from '@nestjs/common';
+import {DatabaseService} from '../../common/database/database.service';
+import {PaginationArgs} from '../../common/pagination/pagination.args';
+import {buildPaginatedResult} from '../../common/pagination/pagination.util';
+
+@Injectable()
+export class MessagesService {
+  constructor(private readonly db: DatabaseService) {}
+
+  /**
+   * Returns a paginated list of Reddit messages stored in the database.
+   */
+  async findAll(paginationArgs: PaginationArgs, filter?: {isRead?: boolean; type?: string; subreddit?: string}) {
+    const where: any = {};
+
+    if (filter?.isRead !== undefined) {
+      where.isRead = filter.isRead;
+    }
+    if (filter?.type) {
+      where.type = filter.type;
+    }
+    if (filter?.subreddit) {
+      where.subreddit = {contains: filter.subreddit, mode: 'insensitive'};
+    }
+
+    const take = paginationArgs.first ? Number(paginationArgs.first) : 20;
+    const skip = paginationArgs.skip ? Number(paginationArgs.skip) : 0;
+
+    const [messages, totalCount] = await Promise.all([
+      this.db.redditMessage.findMany({
+        where,
+        orderBy: {createdAt: 'desc'},
+        skip,
+        take,
+      }),
+      this.db.redditMessage.count({where}),
+    ]);
+
+    return buildPaginatedResult({items: messages, skip, take, totalCount, meta: null});
+  }
+
+  /**
+   * Returns a single Reddit message by its database ID.
+   */
+  async findOne(id: number) {
+    const message = await this.db.redditMessage.findUnique({where: {id}});
+    if (!message) {
+      throw new NotFoundException(`Reddit message with ID ${id} not found`);
+    }
+    return message;
+  }
+
+  /**
+   * Marks a Reddit message as read.
+   */
+  async markAsRead(id: number) {
+    await this.findOne(id);
+    return this.db.redditMessage.update({
+      where: {id},
+      data: {isRead: true},
+    });
+  }
+}