Merge pull request #72 from GeneralMagicio/add-search-functionality

Add semantic search functionality

Author: RamRamez

prisma/migrations/20250416649699_add_search_vector/migration.sql

@@ -0,0 +1,22 @@
+-- Add search vector column
+ALTER TABLE "Poll" ADD COLUMN "searchVector" tsvector;
+
+-- Create function to update search vector
+CREATE OR REPLACE FUNCTION poll_search_vector_update() RETURNS trigger AS $$
+BEGIN
+  NEW."searchVector" :=
+    setweight(to_tsvector('english', COALESCE(NEW.title, '')), 'A') ||
+    setweight(to_tsvector('english', COALESCE(NEW.description, '')), 'B') ||
+    setweight(to_tsvector('english', array_to_string(NEW.tags, ' ')), 'C');
+  RETURN NEW;
+END
+$$ LANGUAGE plpgsql;
+
+-- Create trigger to update search vector
+CREATE TRIGGER poll_search_vector_trigger
+  BEFORE INSERT OR UPDATE ON "Poll"
+  FOR EACH ROW
+  EXECUTE FUNCTION poll_search_vector_update();
+
+-- Update existing records
+UPDATE "Poll" SET "searchVector" = NULL; 

prisma/schema.prisma

@@ -49,9 +49,12 @@ model Poll {
   isAnonymous      Boolean      @default(false)
   participantCount Int          @default(0)
   voteResults      Json
+  searchVector     Unsupported("tsvector")? @db.TsVector
   author           User         @relation("PollAuthor", fields: [authorUserId], references: [id])
   votes            Vote[]
   userAction       UserAction[]
+
+  @@index([searchVector], type: Gin)
 }
 
 model Vote {

src/poll/Poll.dto.ts

@@ -52,6 +52,10 @@ export class GetPollsDto {
   @IsOptional()
   worldID?: string;
 
+  @IsString()
+  @IsOptional()
+  search?: string;
+
   @IsOptional()
   @Type(() => Number)
   @IsInt()

src/poll/poll.service.ts

@@ -1,5 +1,5 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
-import { ActionType } from '@prisma/client';
+import { ActionType, Prisma } from '@prisma/client';
 import { DatabaseService } from 'src/database/database.service';
 import {
   PollNotFoundException,
@@ -12,6 +12,21 @@ import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
 export class PollService {
   constructor(private readonly databaseService: DatabaseService) {}
 
+  private async searchPolls(searchTerm: string): Promise<number[]> {
+    const searchQuery = searchTerm
+      .split(' ')
+      .map((word) => `${word}:*`)
+      .join(' & ');
+    const searchResults = await this.databaseService.$queryRaw<
+      { pollId: number }[]
+    >`
+      SELECT "pollId" FROM "Poll"
+      WHERE "searchVector" @@ to_tsquery('english', ${searchQuery})
+      ORDER BY ts_rank("searchVector", to_tsquery('english', ${searchQuery})) DESC
+    `;
+    return searchResults.map((result) => result.pollId);
+  }
+
   async createPoll(createPollDto: CreatePollDto) {
     const user = await this.databaseService.user.findUnique({
       where: { worldID: createPollDto.worldID },
@@ -72,12 +87,13 @@ export class PollService {
       isActive,
       userVoted,
       userCreated,
+      search,
       sortBy = 'endDate',
       sortOrder = 'asc',
     } = query;
     const skip = (page - 1) * limit;
     const now = new Date();
-    const filters: any = {};
+    const filters: Prisma.PollWhereInput = {};
     let userId: number | undefined;
 
     if (isActive) {
@@ -88,6 +104,7 @@ export class PollService {
     if (isActive === false) {
       filters.OR = [{ startDate: { gt: now } }, { endDate: { lte: now } }];
     }
+
     if ((userCreated || userVoted) && query.worldID) {
       const user = await this.databaseService.user.findUnique({
         where: { worldID: query.worldID },
@@ -99,25 +116,21 @@ export class PollService {
       }
       userId = user.id;
     } else if (userCreated || userVoted) {
-      throw new Error('worldId Not Provided');
+      throw new BadRequestException('worldId Not Provided');
     }
 
     if (userCreated && userVoted) {
-      // Get polls user voted in
       const userVotes = await this.databaseService.vote.findMany({
         where: { userId },
         select: { pollId: true },
       });
       const votedPollIds = userVotes.map((v) => v.pollId);
 
-      // Use OR condition to get polls where user voted OR user created
       filters.OR = [{ authorUserId: userId }, { pollId: { in: votedPollIds } }];
     } else {
       if (userCreated) {
         filters.authorUserId = userId;
       }
-
-      // Get polls user voted in
       let votedPollIds: number[] = [];
       if (userVoted) {
         const userVotes = await this.databaseService.vote.findMany({
@@ -129,15 +142,22 @@ export class PollService {
       }
     }
 
-    // Sorting options
-    const orderBy: any = {};
+    if (search) {
+      const pollIds = await this.searchPolls(search);
+      if (Object.keys(filters).length > 0) {
+        filters.AND = [filters, { pollId: { in: pollIds } }];
+      } else {
+        filters.pollId = { in: pollIds };
+      }
+    }
+
+    const orderBy: Prisma.PollOrderByWithRelationInput = {};
     if (sortBy) {
       orderBy[sortBy] = sortOrder;
     } else {
       orderBy.endDate = 'asc';
     }
 
-    // Fetch polls with pagination
     const [polls, total] = await this.databaseService.$transaction([
       this.databaseService.poll.findMany({
         where: filters,

src/user/user.dto.ts

@@ -1,14 +1,17 @@
+import { ActionType } from '@prisma/client';
+import { Transform, Type } from 'class-transformer';
 import {
-  IsDate,
+  IsArray,
+  IsBoolean,
+  IsDateString,
   IsEnum,
+  IsInt,
   IsNotEmpty,
   IsNumber,
   IsOptional,
   IsString,
   Validate,
 } from 'class-validator';
-import { ActionType } from '@prisma/client';
-import { Transform } from 'class-transformer';
 import { IsPositiveInteger, IsRecordStringNumber } from '../common/validators';
 
 export class GetUserDataDto {
@@ -43,48 +46,47 @@ export class GetUserActivitiesDto {
   @IsEnum(['active', 'inactive', 'created', 'participated'])
   @IsOptional()
   filter?: 'active' | 'inactive' | 'created' | 'participated';
+
+  @IsString()
+  @IsOptional()
+  search?: string;
 }
 
 export class UserActionDto {
-  @IsNumber()
-  @IsNotEmpty()
+  @IsInt()
   id: number;
 
   @IsEnum([ActionType.CREATED, ActionType.VOTED])
-  @IsNotEmpty()
   type: ActionType;
 
-  @IsNumber()
-  @IsNotEmpty()
+  @IsInt()
   pollId: number;
 
   @IsString()
-  @IsNotEmpty()
   pollTitle: string;
 
   @IsString()
-  @IsNotEmpty()
   pollDescription: string;
 
-  @IsDate()
-  @IsNotEmpty()
-  endDate: Date;
+  @IsDateString()
+  endDate: string;
 
-  @IsNumber()
-  @IsNotEmpty()
+  @IsBoolean()
+  isActive: boolean;
+
+  @IsInt()
   votersParticipated: number;
 
   @IsString()
-  @IsNotEmpty()
   authorWorldId: string;
 
-  @IsDate()
-  @IsNotEmpty()
-  createdAt: Date;
+  @IsDateString()
+  createdAt: string;
 }
 
 export class UserActivitiesResponseDto {
-  @IsNotEmpty()
+  @IsArray()
+  @Type(() => UserActionDto)
   userActions: UserActionDto[];
 }
 

src/user/user.module.ts

@@ -1,9 +1,10 @@
 import { Module } from '@nestjs/common';
+import { PollService } from '../poll/poll.service';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
 
 @Module({
   controllers: [UserController],
-  providers: [UserService],
+  providers: [UserService, PollService],
 })
 export class UserModule {}

src/user/user.service.ts

@@ -12,6 +12,7 @@ import {
   VoteOptionException,
 } from '../common/exceptions';
 import { DatabaseService } from '../database/database.service';
+import { PollService } from '../poll/poll.service';
 import {
   CreateUserDto,
   CreateUserResponseDto,
@@ -36,12 +37,18 @@ type UserActionFilters = {
       gte?: Date;
       lt?: Date;
     };
+    pollId?: {
+      in?: number[];
+    };
   };
 };
 
 @Injectable()
 export class UserService {
-  constructor(private readonly databaseService: DatabaseService) {}
+  constructor(
+    private readonly databaseService: DatabaseService,
+    private readonly pollService: PollService,
+  ) {}
 
   private validateWeightDistribution(
     weightDistribution: Record<string, number>,
@@ -124,6 +131,20 @@ export class UserService {
     } else if (dto.filter === 'participated') {
       filters.type = ActionType.VOTED;
     }
+    let pollIds: number[] | undefined;
+    if (dto.search) {
+      pollIds = await this.pollService['searchPolls'](dto.search);
+    }
+    if (pollIds && pollIds.length > 0) {
+      if (filters.poll) {
+        filters.poll.pollId = { in: pollIds };
+      } else {
+        filters.poll = { pollId: { in: pollIds } };
+      }
+    } else if (pollIds && pollIds.length === 0) {
+      return { userActions: [] };
+    }
+
     const userActions = await this.databaseService.userAction.findMany({
       where: filters,
       orderBy: { createdAt: 'desc' },
@@ -138,17 +159,15 @@ export class UserService {
             description: true,
             endDate: true,
             authorUserId: true,
+            participantCount: true,
           },
         },
       },
     });
     const actions: UserActionDto[] = await Promise.all(
-      // TODO: it's a temporary work around, should add count to Poll and User and authorWorldId to UserAction later
+      // TODO: it's a temporary work around, should add authorWorldId to UserAction later
       userActions.map(async (action) => {
-        const participantCount = await this.databaseService.userAction.count({
-          where: { pollId: action.poll.pollId, type: ActionType.VOTED },
-        });
-        const authorWorldId = await this.databaseService.user.findUnique({
+        const author = await this.databaseService.user.findUnique({
           where: { id: action.poll.authorUserId },
           select: { worldID: true },
         });
@@ -158,11 +177,11 @@ export class UserService {
           pollId: action.poll.pollId,
           pollTitle: action.poll.title,
           pollDescription: action.poll.description ?? '',
-          endDate: action.poll.endDate,
+          endDate: action.poll.endDate.toISOString(),
           isActive: action.poll.endDate >= now,
-          votersParticipated: participantCount,
-          authorWorldId: authorWorldId?.worldID || '',
-          createdAt: action.createdAt,
+          votersParticipated: action.poll.participantCount,
+          authorWorldId: author?.worldID || '',
+          createdAt: action.createdAt.toISOString(),
         };
       }),
     );