refactor

src/app/pc-listings/[id]/components/PcReportListingModal.tsx

@@ -39,7 +39,7 @@ function PcReportListingModal(props: Props) {
   const [description, setDescription] = useState('')
   const [error, setError] = useState('')
 
-  const createReport = api.pcListings.createReport.useMutation()
+  const createReport = api.pcListingReports.create.useMutation()
   const { user } = useUser()
 
   // Reset form when modal opens/closes
@@ -64,7 +64,7 @@ function PcReportListingModal(props: Props) {
         pcListingId: props.pcListingId,
         reason,
         description: description.trim() || undefined,
-      } satisfies RouterInput['pcListings']['createReport'])
+      } satisfies RouterInput['pcListingReports']['create'])
 
       // Track content flagging in analytics
       if (user?.id) {

src/schemas/pcListing.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { PAGINATION, CHAR_LIMITS } from '@/data/constants'
 import { HumanVerificationTokenSchema } from '@/features/human-verification/shared/schema'
-import { JsonValueSchema } from '@/schemas/common'
+import { JsonValueSchema, SortDirectionSchema } from '@/schemas/common'
 import { CreatePcListingBaseSchema } from '@/schemas/listingCreate'
 import { REVIEW_RISK_FILTERS, ReviewRiskFilterSchema } from '@/schemas/submissionRisk'
 import { ApprovalStatus, PcOs, ReportReason, ReportStatus } from '@orm'
@@ -274,6 +274,8 @@ export const UnpinPcListingCommentSchema = z.object({
 })
 
 // PC Listing Report schemas
+export const PcListingReportSortField = z.enum(['createdAt', 'updatedAt', 'status', 'reason'])
+
 export const CreatePcListingReportSchema = z.object({
   pcListingId: z.string().uuid(),
   reason: z.nativeEnum(ReportReason),
@@ -286,11 +288,17 @@ export const UpdatePcListingReportSchema = z.object({
   reviewNotes: z.string().max(1000).optional(),
 })
 
-export const GetPcListingReportsSchema = z.object({
-  status: z.nativeEnum(ReportStatus).optional(),
-  page: z.number().min(1).default(1),
-  limit: z.number().min(1).max(100).default(20),
-})
+export const GetPcListingReportsSchema = z
+  .object({
+    search: z.string().optional(),
+    status: z.nativeEnum(ReportStatus).optional(),
+    reason: z.nativeEnum(ReportReason).optional(),
+    sortField: PcListingReportSortField.optional(),
+    sortDirection: SortDirectionSchema.optional(),
+    page: z.number().min(1).default(1),
+    limit: z.number().min(1).max(100).default(20),
+  })
+  .optional()
 
 // PC Listing Verification schemas
 export const VerifyPcListingSchema = z.object({

src/server/api/root.ts

@@ -25,6 +25,7 @@ import { listingsRouter } from './routers/listings'
 import { listingVerificationsRouter } from './routers/listingVerifications'
 import { mobileRouter } from './routers/mobile'
 import { notificationsRouter } from './routers/notifications'
+import { pcListingReportsRouter } from './routers/pcListingReports'
 import { pcListingsRouter } from './routers/pcListings'
 import { performanceScalesRouter } from './routers/performanceScales'
 import { permissionLogsRouter } from './routers/permissionLogs'
@@ -47,6 +48,7 @@ export const appRouter = createTRPCRouter({
   activity: activityRouter,
   listings: listingsRouter,
   pcListings: pcListingsRouter,
+  pcListingReports: pcListingReportsRouter,
   apiKeys: apiKeysRouter,
   devices: devicesRouter,
   cpus: cpusRouter,

src/server/api/routers/listings/core.ts

@@ -32,12 +32,12 @@ import { isUserBanned } from '@/server/utils/query-builders'
 import { sanitizeInput, validatePagination } from '@/server/utils/security-validation'
 import { checkSpamContent } from '@/server/utils/spam-check'
 import { withSavepoint } from '@/server/utils/transactions'
+import { validateCustomFields } from '@/server/utils/validate-custom-fields'
 import { updateListingVoteCounts } from '@/server/utils/vote-counts'
 import { handleListingVoteTrustEffects } from '@/server/utils/vote-trust-effects'
 import { roleIncludesRole } from '@/utils/permission-system'
 import { ms } from '@/utils/time'
 import { ApprovalStatus, Prisma, Role, TrustAction } from '@orm/client'
-import { validateCustomFields } from './validation'
 
 const EDIT_TIME_LIMIT_MINUTES = 60
 const EDIT_TIME_LIMIT = ms.minutes(EDIT_TIME_LIMIT_MINUTES)

src/server/api/routers/listings/index.ts

@@ -1,4 +1,3 @@
 export { coreRouter } from './core'
 export { commentsRouter } from './comments'
 export { adminRouter } from './admin'
-export { validateCustomFields } from './validation'

src/server/api/routers/pcListingReports.ts

@@ -0,0 +1,228 @@
+import { ResourceError } from '@/lib/errors'
+import { TrustService } from '@/lib/trust/service'
+import { DeleteReportSchema, GetReportByIdSchema } from '@/schemas/listingReport'
+import {
+  CreatePcListingReportSchema,
+  GetPcListingReportsSchema,
+  UpdatePcListingReportSchema,
+} from '@/schemas/pcListing'
+import { createTRPCRouter, permissionProcedure, protectedProcedure } from '@/server/api/trpc'
+import { ReportSubmissionService } from '@/server/services/report-submission.service'
+import { paginate } from '@/server/utils/pagination'
+import { validateEnum, sanitizeInput, validatePagination } from '@/server/utils/security-validation'
+import { PERMISSIONS } from '@/utils/permission-system'
+import { ApprovalStatus, ReportReason, ReportStatus, TrustAction } from '@orm'
+import { type Prisma } from '@orm/client'
+
+export const pcListingReportsRouter = createTRPCRouter({
+  stats: permissionProcedure(PERMISSIONS.VIEW_STATISTICS).query(async ({ ctx }) => {
+    const [pending, underReview, resolved, dismissed] = await Promise.all([
+      ctx.prisma.pcListingReport.count({ where: { status: ReportStatus.PENDING } }),
+      ctx.prisma.pcListingReport.count({ where: { status: ReportStatus.UNDER_REVIEW } }),
+      ctx.prisma.pcListingReport.count({ where: { status: ReportStatus.RESOLVED } }),
+      ctx.prisma.pcListingReport.count({ where: { status: ReportStatus.DISMISSED } }),
+    ])
+
+    return {
+      total: pending + underReview + resolved + dismissed,
+      pending,
+      underReview,
+      resolved,
+      dismissed,
+    }
+  }),
+
+  get: permissionProcedure(PERMISSIONS.VIEW_USER_BANS)
+    .input(GetPcListingReportsSchema)
+    .query(async ({ ctx, input }) => {
+      const {
+        search,
+        status,
+        reason,
+        sortField = 'createdAt',
+        sortDirection = 'desc',
+      } = input ?? {}
+
+      const { page, limit } = validatePagination(input?.page, input?.limit, 50)
+      const sanitizedSearch = search ? sanitizeInput(search) : undefined
+      const offset = (page - 1) * limit
+
+      const where: Prisma.PcListingReportWhereInput = {}
+
+      if (sanitizedSearch) {
+        where.OR = [
+          { pcListing: { game: { title: { contains: sanitizedSearch, mode: 'insensitive' } } } },
+          { reportedBy: { name: { contains: sanitizedSearch, mode: 'insensitive' } } },
+          { description: { contains: sanitizedSearch, mode: 'insensitive' } },
+        ]
+      }
+
+      if (status) where.status = status
+      if (reason) where.reason = reason
+
+      const orderBy: Prisma.PcListingReportOrderByWithRelationInput = {}
+      if (sortField && sortDirection) orderBy[sortField] = sortDirection
+
+      const [reports, total] = await Promise.all([
+        ctx.prisma.pcListingReport.findMany({
+          where,
+          orderBy,
+          skip: offset,
+          take: limit,
+          include: {
+            pcListing: {
+              include: {
+                game: { select: { id: true, title: true } },
+                author: { select: { id: true, name: true } },
+                cpu: true,
+                gpu: true,
+                emulator: { select: { id: true, name: true } },
+              },
+            },
+            reportedBy: { select: { id: true, name: true, email: true } },
+            reviewedBy: { select: { id: true, name: true } },
+          },
+        }),
+        ctx.prisma.pcListingReport.count({ where }),
+      ])
+
+      return {
+        reports,
+        pagination: paginate({ total: total, page, limit: limit }),
+      }
+    }),
+
+  byId: permissionProcedure(PERMISSIONS.VIEW_USER_BANS)
+    .input(GetReportByIdSchema)
+    .query(async ({ ctx, input }) => {
+      const report = await ctx.prisma.pcListingReport.findUnique({
+        where: { id: input.id },
+        include: {
+          pcListing: {
+            include: {
+              game: true,
+              author: { select: { id: true, name: true, email: true } },
+              cpu: true,
+              gpu: true,
+              emulator: true,
+              performance: true,
+            },
+          },
+          reportedBy: { select: { id: true, name: true, email: true } },
+          reviewedBy: { select: { id: true, name: true } },
+        },
+      })
+
+      return report || ResourceError.listingReport.notFound()
+    }),
+
+  create: protectedProcedure.input(CreatePcListingReportSchema).mutation(async ({ ctx, input }) => {
+    const { pcListingId, reason, description } = input
+    const userId = ctx.session.user.id
+
+    validateEnum(reason, Object.values(ReportReason), 'reason')
+
+    const reportSubmissionService = new ReportSubmissionService(ctx.prisma)
+
+    return await reportSubmissionService.createPcListingReport({
+      pcListingId,
+      reportedById: userId,
+      reason,
+      description,
+    })
+  }),
+
+  updateStatus: permissionProcedure(PERMISSIONS.MANAGE_USER_BANS)
+    .input(UpdatePcListingReportSchema)
+    .mutation(async ({ ctx, input }) => {
+      const { reportId, status, reviewNotes } = input
+      const reviewerId = ctx.session.user.id
+
+      validateEnum(status, Object.values(ReportStatus), 'status')
+
+      const report = await ctx.prisma.pcListingReport.findUnique({
+        where: { id: reportId },
+        include: { pcListing: true },
+      })
+
+      if (!report) {
+        return ResourceError.listingReport.notFound()
+      }
+
+      if (
+        status === ReportStatus.RESOLVED &&
+        report.pcListing?.status === ApprovalStatus.APPROVED
+      ) {
+        await ctx.prisma.pcListing.update({
+          where: { id: report.pcListingId },
+          data: {
+            status: ApprovalStatus.REJECTED,
+            processedAt: new Date(),
+            processedByUserId: reviewerId,
+            processedNotes: `Rejected due to report: ${reviewNotes || 'No additional notes'}`,
+          },
+        })
+      }
+
+      const trustService = new TrustService(ctx.prisma)
+
+      if (status === ReportStatus.RESOLVED) {
+        await trustService.logAction({
+          userId: report.reportedById,
+          action: TrustAction.REPORT_CONFIRMED,
+          metadata: {
+            reportId,
+            pcListingId: report.pcListingId,
+            reviewedBy: reviewerId,
+            reason: report.reason,
+          },
+        })
+      } else if (status === ReportStatus.DISMISSED) {
+        await trustService.logAction({
+          userId: report.reportedById,
+          action: TrustAction.FALSE_REPORT,
+          metadata: {
+            reportId,
+            pcListingId: report.pcListingId,
+            reviewedBy: reviewerId,
+            reason: report.reason,
+            reviewNotes,
+          },
+        })
+      }
+
+      return ctx.prisma.pcListingReport.update({
+        where: { id: reportId },
+        data: {
+          status,
+          reviewNotes,
+          reviewedById: reviewerId,
+          reviewedAt: new Date(),
+        },
+        include: {
+          pcListing: {
+            include: {
+              game: { select: { title: true } },
+              author: { select: { name: true } },
+            },
+          },
+          reportedBy: { select: { name: true } },
+          reviewedBy: { select: { name: true } },
+        },
+      })
+    }),
+
+  delete: permissionProcedure(PERMISSIONS.MANAGE_USER_BANS)
+    .input(DeleteReportSchema)
+    .mutation(async ({ ctx, input }) => {
+      const report = await ctx.prisma.pcListingReport.findUnique({
+        where: { id: input.id },
+      })
+
+      if (!report) return ResourceError.listingReport.notFound()
+
+      return ctx.prisma.pcListingReport.delete({
+        where: { id: input.id },
+      })
+    }),
+})

src/server/api/routers/pcListings.test.ts

@@ -581,48 +581,6 @@ describe('pcListings trust integration', () => {
     })
   })
 
-  describe('createReport', () => {
-    it('creates a PC report and emits a moderator notification event', async () => {
-      const { caller, prisma } = createCaller()
-      prisma.pcListing.findUnique.mockResolvedValue({
-        id: LISTING_ID,
-        authorId: AUTHOR_ID,
-        author: { id: AUTHOR_ID },
-      })
-
-      const report = await caller.createReport({
-        pcListingId: LISTING_ID,
-        reason: ReportReason.SPAM,
-        description: '  needs review  ',
-      })
-
-      expect(report.id).toBe('00000000-0000-4000-a000-000000000030')
-      expect(prisma.pcListingReport.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            pcListingId: LISTING_ID,
-            reportedById: USER_ID,
-            description: 'needs review',
-          }),
-        }),
-      )
-      expect(mockEmitNotificationEvent).toHaveBeenCalledWith({
-        eventType: 'report.created',
-        entityType: 'pcListingReport',
-        entityId: '00000000-0000-4000-a000-000000000030',
-        triggeredBy: USER_ID,
-        includeTriggeredBy: true,
-        payload: {
-          reportId: '00000000-0000-4000-a000-000000000030',
-          contentId: LISTING_ID,
-          contentType: 'PC Compatibility Report',
-          actionUrl: `/pc-listings/${LISTING_ID}`,
-          pcListingId: LISTING_ID,
-        },
-      })
-    })
-  })
-
   describe('byId', () => {
     it('hides review risk profiles for non-reviewers', async () => {
       mockRepositoryGetByIdWithDetails.mockResolvedValueOnce({