feat: add pagination to errors

Author: linventif

src/classes/db/Query.ts

@@ -3,28 +3,28 @@ import { QueryInput, QuerySchema } from '../../schemas/db/QuerySchema.js';
 export class Query {
   public readonly offset: number;
   public readonly limit: number;
-  public readonly sort?: {
-    field: string;
-    order: 'asc' | 'desc';
-  };
-  public readonly filter?: {
-    field: string;
-    comparator: 'equal' | 'not_equal' | 'greater_than' | 'less_than' | 'contains' | 'starts_with' | 'ends_with';
-    value: any;
-  };
+  public readonly sort?: string;
+  public readonly orderBy?: 'ASC' | 'DESC';
+  public readonly filterField?: string;
+  public readonly filterComparator?:
+    | 'equal'
+    | 'not_equal'
+    | 'greater_than'
+    | 'less_than'
+    | 'contains'
+    | 'starts_with'
+    | 'ends_with';
+  public readonly filterValue?: unknown;
 
   private constructor(data: QueryInput) {
     const parsed = QuerySchema.parse(data);
     this.offset = parsed.offset;
     this.limit = parsed.limit;
-    this.sort = parsed.sort ? { field: parsed.sort.field, order: parsed.sort.order } : undefined;
-    this.filter = parsed.filter
-      ? {
-          field: parsed.filter.field,
-          comparator: parsed.filter.comparator,
-          value: parsed.filter.value,
-        }
-      : undefined;
+    this.sort = parsed.sort;
+    this.orderBy = parsed.orderBy;
+    this.filterField = parsed.filterField;
+    this.filterComparator = parsed.filterComparator;
+    this.filterValue = parsed.filterValue;
   }
 
   public static from(data: unknown): Query {

src/classes/gmod/GmodErrors.ts

@@ -0,0 +1,75 @@
+import { GmodErrorsInput, GmodErrorsSchema } from '../../schemas/gmod/GmodErrorsSchema.js';
+import { mongoClient } from '../../services/mongo/index.js';
+import { Query } from '../db/Query.js';
+
+const db = mongoClient.db('gmod_integration');
+const collection = db.collection('errors');
+
+export class GmodErrors {
+  public readonly serverID: string;
+  public readonly count: number;
+  public readonly realm: string;
+  public readonly error: string;
+  public readonly stack: string;
+  public readonly name: string;
+  public readonly steamID64: string;
+  public readonly workshopID: string;
+  public readonly uptime: number;
+
+  private constructor(data: GmodErrorsInput) {
+    const parsed = GmodErrorsSchema.parse(data);
+    this.serverID = parsed.serverID;
+    this.count = parsed.count;
+    this.realm = parsed.realm;
+    this.error = parsed.error;
+    this.stack = parsed.stack;
+    this.name = parsed.name || '';
+    this.steamID64 = parsed.steamID64 || '';
+    this.workshopID = parsed.workshopID || '';
+    this.uptime = parsed.uptime;
+  }
+
+  public static from(data: unknown): GmodErrors {
+    return new GmodErrors(data as GmodErrorsInput);
+  }
+
+  public async save() {
+    return await collection.insertOne({
+      error: this.error,
+      stack: this.stack,
+      workshopID: this.workshopID || '',
+      serverID: this.serverID,
+      name: this.name,
+      realm: this.realm,
+      steamID64: this.steamID64 || '',
+      uptime: this.uptime,
+      count: this.count,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+}
+
+export async function getErrorsCountByServer(serverID: string): Promise<number> {
+  return await collection.countDocuments({
+    serverID,
+  });
+}
+
+export async function getErrorsByServer(query: Query, serverID: string) {
+  return {
+    errors: await collection
+      .find({
+        serverID,
+      })
+      .limit(query.limit)
+      .skip(query.offset)
+      .toArray(),
+    query: {
+      ...query,
+      total: await collection.countDocuments({
+        serverID,
+      }),
+    },
+  };
+}

src/controllers/gmod/GmodErrorsControllers.ts

@@ -0,0 +1,27 @@
+import { Request, Response } from 'express';
+import { GmodErrors } from '../../classes/gmod/GmodErrors.js';
+
+export async function reportError(req: Request, res: Response) {
+  const { error, stack, id, name, realm, uptime, count } = req.body;
+  const { serverID, steamID64 } = req.params;
+
+  let plyError: GmodErrors;
+  try {
+    plyError = GmodErrors.from({
+      error,
+      stack: JSON.stringify(stack),
+      workshopID: id,
+      name,
+      realm,
+      uptime,
+      count,
+      serverID,
+      steamID64,
+    });
+  } catch (err) {
+    return res.status(400).json({ error: 'Invalid error data' });
+  }
+
+  const rtnError = await plyError.save();
+  return res.status(200).json(rtnError);
+}

src/controllers/v3/errorsControllers.ts

@@ -1186,31 +1186,6 @@ export async function putServerSetting(req: Request, res: Response) {
   }
 }
 
-export async function getServerErrors(req: Request, res: Response) {
-  const { serverID } = req.params;
-  const { offset, limit: number } = req.query;
-  const limit = Number(number);
-
-  if (limit && limit > 100) {
-    return res.status(400).send({
-      error: 'limit too high',
-    });
-  }
-
-  const errors = await prisma.gm_server_errors.findMany({
-    where: {
-      serverID,
-    },
-    orderBy: {
-      createdAt: 'desc',
-    },
-    skip: Number(offset) || 0,
-    take: limit || 500,
-  });
-
-  return res.send(errors || []);
-}
-
 export async function getAdminGuilds(req: Request, res: Response) {
   return res.send((await prisma.gm_guild.findMany()) || []);
 }

src/controllers/v3/usersControllers.ts

@@ -0,0 +1,18 @@
+import { Request, Response } from 'express';
+import { Query } from '../../classes/db/Query.js';
+import { getErrorsByServer } from '../../classes/gmod/GmodErrors.js';
+
+export async function getServerErrors(req: Request, res: Response) {
+  const { serverID } = req.params;
+
+  let query: Query;
+  try {
+    query = Query.from(req.query);
+  } catch (err) {
+    console.error('Invalid query parameters:', err);
+    return res.status(400).json({ error: 'Invalid query parameters' });
+  }
+
+  const errors = await getErrorsByServer(query, serverID);
+  return res.send(errors || []);
+}

src/controllers/website/WebsiteErrorsControllers.ts

@@ -1,6 +1,6 @@
 import express from 'express';
 import { reportBugs, uploadScreenshot } from '../../controllers/v3/clientsControllers.js';
-import { reportError } from '../../controllers/v3/errorsControllers.js';
+import { reportError } from '../../controllers/gmod/GmodErrorsControllers.js';
 import asyncHandler from '../../middleware/asyncHandler.js';
 import clientValidator from '../../middleware/v3/clientValidator.js';
 

src/routes/v3/clientsRoutes.ts

@@ -17,7 +17,7 @@ import {
   serverStart,
   serverStop,
 } from '../../controllers/v3/serversControllers.js';
-import { reportError } from '../../controllers/v3/errorsControllers.js';
+import { reportError } from '../../controllers/gmod/GmodErrorsControllers.js';
 import {
   getPlayer,
   playerBan,

src/routes/v3/serversRoutes.ts

@@ -48,7 +48,6 @@ import {
   getProfile,
   getPublicServers,
   getScreenshotsList,
-  getServerErrors,
   getServerLogs,
   getServerLogsTrigger,
   getServerPlayers,
@@ -111,6 +110,7 @@ import {
 } from '../../middleware/v3/userValidator.js';
 import asyncHandler from '../../middleware/asyncHandler.js';
 import { getAllPanelUsers } from '../../controllers/v3/usersAdminControllers.js';
+import { getServerErrors } from '../../controllers/website/WebsiteErrorsControllers.js';
 
 const router = express.Router();
 

src/routes/v3/usersRoutes.ts

@@ -5,50 +5,37 @@ extendZodWithOpenApi(z);
 
 export const QuerySchema = z
   .object({
-    offset: z.number().openapi({
+    offset: z.coerce.number().int().nonnegative().default(0).openapi({
       example: 0,
       description: 'Offset for pagination',
     }),
-    limit: z.number().max(500).openapi({
-      example: 10,
+    limit: z.coerce.number().int().nonnegative().max(500).default(25).openapi({
+      example: 25,
       description: 'Limit for pagination',
     }),
-    sort: z
-      .object({
-        field: z.string().openapi({
-          example: 'name',
-          description: 'Field to sort by',
-        }),
-        order: z.enum(['asc', 'desc']).openapi({
-          example: 'asc',
-          description: 'Order of sorting',
-        }),
-      })
-      .optional()
-      .openapi({
-        description: 'Sorting options',
-      }),
-    filter: z
-      .object({
-        field: z.string().openapi({
-          example: 'status',
-          description: 'Field to filter by',
-        }),
-        comparator: z
-          .enum(['equal', 'not_equal', 'greater_than', 'less_than', 'contains', 'starts_with', 'ends_with'])
-          .openapi({
-            example: 'equal',
-            description: 'Comparator for filtering',
-          }),
-        value: z.any().openapi({
-          example: 'active',
-          description: 'Value to filter by',
-        }),
-      })
+    sort: z.string().optional().openapi({
+      example: 'createdAt',
+      description: 'Field to sort by, e.g., "createdAt" or "name"',
+    }),
+    orderBy: z.enum(['ASC', 'DESC']).optional().openapi({
+      example: 'ASC',
+      description: 'Order of sorting, either "ASC" or "DESC"',
+    }),
+    filterField: z.string().optional().openapi({
+      example: 'status',
+      description: 'Field to filter by, e.g., "status" or "type"',
+    }),
+    filterComparator: z
+      .enum(['equal', 'not_equal', 'greater_than', 'less_than', 'contains', 'starts_with', 'ends_with'])
       .optional()
       .openapi({
-        description: 'Filtering options',
+        example: 'equal',
+        description: 'Comparator for filtering, e.g., "equal" or "contains"',
       }),
+    filterValue: z.any().optional().openapi({
+      example: 'active',
+      description: 'Value to filter by, e.g., "active" or "error"',
+    }),
   })
   .openapi({ ref: 'Query' });