duckguessr,duckguessr-api: Apply lint

Author: bperel

apps/duckguessr/api/eslint.config.mjs

@@ -0,0 +1,29 @@
+import js from "@eslint/js";
+import eslintConfigPrettier from "eslint-config-prettier";
+import eslintPluginPrettier from "eslint-plugin-prettier/recommended";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintConfigPrettier,
+  eslintPluginPrettier,
+  {
+    ignores: ["**/node_modules", "**/dist", "prisma/client_*"],
+  },
+  {
+    rules: {
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "object-shorthand": ["error", "always"],
+
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
+);

apps/duckguessr/api/game.ts

@@ -3,7 +3,7 @@ import type { player } from "./prisma/client_duckguessr/browser";
 export const numberOfRounds = 8;
 
 export const getGameWithRoundsDatasetPlayers = (gameId: number) =>
- prisma.game.findUnique({
+  prisma.game.findUnique({
     include: {
       rounds: {
         include: {

apps/duckguessr/api/get-player.ts

@@ -17,10 +17,12 @@ export const getPlayer = async (cookies?: {
   let player: player | null = null;
   if (cookies?.token) {
     try {
-      const { id: ducksmanagerId, username } = (jwt.verify(
-        cookies.token,
-        process.env.TOKEN_SECRET as string,
-      ) as jwt.JwtPayload)?.data;
+      const { id: ducksmanagerId, username } = (
+        jwt.verify(
+          cookies.token,
+          process.env.TOKEN_SECRET as string,
+        ) as jwt.JwtPayload
+      ).data;
       if (!username) {
         throw new Error("No username provided");
       }

apps/duckguessr/api/index.ts

@@ -12,7 +12,7 @@ import { server as maintenance } from "./services/maintenance";
 import { server as player } from "./services/player";
 import { server as match } from "./services/match";
 
-(BigInt.prototype as any).toJSON = function () {
+(BigInt.prototype as unknown as { toJSON: () => number }).toJSON = function () {
   const int = Number.parseInt(this.toString());
   return int ?? this.toString();
 };

apps/duckguessr/api/middlewares/required-player.ts

@@ -1,15 +1,18 @@
 import { Socket } from "socket.io";
 import { getPlayer } from "../get-player";
 
-export const RequiredPlayerMiddleware = ({ _socket }: { _socket: Socket }, next: (error?: Error) => void) => {
-    getPlayer({ token: _socket.handshake.auth.token })
-      .then((player) => {
-        _socket.data.user = player;
-      })
-      .then(() => {
-        next();
-      })
-      .catch((e) => {
-        next(e);
-      });
-  };
+export const RequiredPlayerMiddleware = (
+  { _socket }: { _socket: Socket },
+  next: (error?: Error) => void,
+) => {
+  getPlayer({ token: _socket.handshake.auth.token })
+    .then((player) => {
+      _socket.data.user = player;
+    })
+    .then(() => {
+      next();
+    })
+    .catch((e) => {
+      next(e);
+    });
+};

apps/duckguessr/api/package.json

@@ -38,6 +38,7 @@
     "concurrently": "^8.2.2",
     "eslint": "^9.39.3",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
     "prettier": "^3.8.1",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.56.1"

apps/duckguessr/api/pnpm-lock.yaml

@@ -1,16 +1,16 @@
-import 'dotenv/config'
-import type { PrismaConfig } from 'prisma/config'
+import "dotenv/config";
+import type { PrismaConfig } from "prisma/config";
 
-const databaseUrl = process.env.DATABASE_URL
+const databaseUrl = process.env.DATABASE_URL;
 if (!databaseUrl) {
-  throw new Error('DATABASE_URL is not set')
+  throw new Error("DATABASE_URL is not set");
 }
 
 const prismaConfig: PrismaConfig = {
-  schema: 'prisma/schema.prisma',
+  schema: "prisma/schema.prisma",
   datasource: {
     url: databaseUrl,
   },
-}
+};
 
-export default prismaConfig
+export default prismaConfig;

apps/duckguessr/api/prisma.config.ts

@@ -14,14 +14,16 @@ export type DatasetsServices = NamespaceProxyTarget<
 >;
 
 const listenEvents = () => ({
-  getDatasets: async () => prisma.$queryRaw<{
-    id: number;
-    name: string;
-    title: string;
-    description: string;
-    images: number;
-    authors: number;
-  }[]>`
+  getDatasets: async () => prisma.$queryRaw<
+    {
+      id: number;
+      name: string;
+      title: string;
+      description: string;
+      images: number;
+      authors: number;
+    }[]
+  >`
       SELECT dataset.id, name, title, description, COUNT(*) AS images, COUNT(DISTINCT personcode) AS authors
       FROM dataset
       LEFT JOIN dataset_entryurl de ON dataset.id = de.dataset_id
@@ -33,8 +35,8 @@ const listenEvents = () => ({
 
   previewDataset: async ({
     personNationalityFilter,
-    oldestDateFilterMin,
-    oldestDateFilterMax,
+    oldestDateFilterMin: _oldestDateFilterMin,
+    oldestDateFilterMax: _oldestDateFilterMax,
   }: {
     personNationalityFilter: string[] | undefined;
     oldestDateFilterMin: number | undefined;

apps/duckguessr/api/services/datasets.ts

@@ -44,7 +44,7 @@ export type GameServices = NamespaceProxyTarget<
 
 export type ClientEmitEvents = NonNullable<
   Awaited<ReturnType<typeof createGameSocket>>
->["client"]["emitEvents"]; 
+>["client"]["emitEvents"];
 
 const checkAndAssociatePlayer = async (
   currentGame: CurrentGame,
@@ -178,7 +178,8 @@ const startRound = (socket: GameServices) => {
 
 const finishRound = async (gameServices: GameServices) => {
   const { _socket, ...events } = gameServices;
-  let { currentRound, currentGame } = _socket.data;
+  let { currentRound } = _socket.data;
+  const currentGame = _socket.data.currentGame;
   console.log(`Round ${currentRound.id} finished`);
   const missingScores = await getPlayersMissingRoundScore(
     _socket.data.currentRound,
@@ -203,8 +204,7 @@ const finishRound = async (gameServices: GameServices) => {
   } else {
     currentRound = await setRoundTimes(
       currentGame!.rounds.find(
-        ({ roundNumber }) =>
-          roundNumber === currentRound.roundNumber! + 1,
+        ({ roundNumber }) => roundNumber === currentRound.roundNumber! + 1,
       )!,
     );
     const roundWithoutPersoncode: UnfinishedRound = {
@@ -350,7 +350,8 @@ const listenEvents = ({ _socket, ...events }: GameServices) => ({
   disconnect: async ({ _socket }: GameServices, reason: string) => {
     if (reason !== "client namespace disconnect") {
       if (
-        _socket && _socket.data.currentGame.gamePlayers.findIndex(
+        _socket &&
+        _socket.data.currentGame.gamePlayers.findIndex(
           ({ player }) => player.id === _socket.data.user.id,
         ) > 0
       ) {
@@ -363,7 +364,9 @@ const listenEvents = ({ _socket, ...events }: GameServices) => ({
   },
 });
 
-const getPublicGame = async (game: Awaited<ReturnType<typeof getGameWithRoundsDatasetPlayers>>) => {
+const getPublicGame = async (
+  game: Awaited<ReturnType<typeof getGameWithRoundsDatasetPlayers>>,
+) => {
   if (!game) {
     return null;
   }
@@ -408,29 +411,26 @@ export const createGameSocket = async (gameId: number) => {
 
   console.log(`Creating game socket for game ${gameId}`);
 
-  const { server, client } = useSocketEvents<typeof listenEvents, ClientListenEvents>(
-    namespaces.GAME.replace("{id}", gameId.toString()),
-    {
-      listenEvents,
-      middlewares: [
-        (
-          { _socket, sendGame: sendGameEvent },
-          next: (error?: Error) => void,
-        ) => {
-          getPlayer(_socket.handshake.auth).then(async (user) => {
-            if (user) {
-              _socket.data.user = user;
-              _socket.data.currentGame = currentGame;
-              sendGameEvent(await getPublicGame(currentGame));
-              next()
-            } else {
-              next(new Error("User not found"));
-            }
-          });
-        },
-      ],
-    },
-  )
+  const { server, client } = useSocketEvents<
+    typeof listenEvents,
+    ClientListenEvents
+  >(namespaces.GAME.replace("{id}", gameId.toString()), {
+    listenEvents,
+    middlewares: [
+      ({ _socket, sendGame: sendGameEvent }, next: (error?: Error) => void) => {
+        getPlayer(_socket.handshake.auth).then(async (user) => {
+          if (user) {
+            _socket.data.user = user;
+            _socket.data.currentGame = currentGame;
+            sendGameEvent(await getPublicGame(currentGame));
+            next();
+          } else {
+            next(new Error("User not found"));
+          }
+        });
+      },
+    ],
+  });
   server(io);
   return { client };
 };