Added most of the required typescript types

Author: CodingFactoryT

RaspberryPi-WebServer/backend/package.json

@@ -32,6 +32,7 @@
     "@types/express": "^5.0.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.15.18",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/parser": "^8.32.1",
     "eslint": "^9.26.0",
     "globals": "^16.1.0",
@@ -42,4 +43,4 @@
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   }
-}
+}

RaspberryPi-WebServer/backend/src/api/middleware/getAccessTokenFromHeader.ts

@@ -1,9 +1,11 @@
-export function getAccessTokenFromHeader(req, res, next) {
+import { Request, Response, NextFunction } from "express";
+
+export function getAccessTokenFromHeader(req: Request, res: Response, next: NextFunction) {
 	const authHeader = req.headers["authorization"];
 	if (authHeader && authHeader.startsWith("Bearer ")) {
 		req.accessToken = authHeader.split(" ")[1];
 	} else {
-		req.accessToken = null;
+		req.accessToken = undefined;
 	}
 
 	next();

RaspberryPi-WebServer/backend/src/api/routes/auth.ts

@@ -1,4 +1,4 @@
-import express from "express";
+import express, { Request, Response } from "express";
 import axios from "axios";
 import config from "@shared/config";
 import MainEventStream from "@src/controllers/Streams/MainEventStream";
@@ -24,7 +24,7 @@ router.get("/login", (req, res) => {
 router.get("/logout", (req, res) => {
 	res.clearCookie("lichess-access-token", {
 		httpOnly: true,
-		sameSite: "Strict",
+		sameSite: "strict",
 	});
 
 	if (LichessTokenVault.getAccessToken()) {
@@ -47,13 +47,13 @@ router.get("/logout", (req, res) => {
 	MainEventStream.getInstance().stop();
 });
 
-router.post("/set-access-token", (req, res) => {
+router.post("/set-access-token", (req: Request, res: Response) => {
 	const token = req.accessToken;
 	const expiresIn_seconds = req.body.expiresIn_seconds;
 	if (!token || !expiresIn_seconds) {
 		res.status(401).send();
 	}
-	LichessTokenVault.setAccessToken(token, expiresIn_seconds);
+	LichessTokenVault.setAccessToken(token, BigInt(expiresIn_seconds));
 
 	res.status(204).send();
 });

RaspberryPi-WebServer/backend/src/controllers/LichessControllers/LichessChallengeController.ts

@@ -4,15 +4,15 @@ import LichessTokenVault from "./LichessTokenVault";
 
 const challengeBaseURL = `${config.lichess_base_url}/api/challenge`;
 export default class LichessChallengeController {
-	static async acceptChallenge(challengeId) {
+	static async acceptChallenge(challengeId: string) {
 		try {
 			await axios.post(`${challengeBaseURL}/${challengeId}/accept`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {
 			console.error(`Error while accepting challenge with id ${challengeId}: ${error}`);
 		}
 	}
 
-	static async declineChallenge(challengeId) {
+	static async declineChallenge(challengeId: string) {
 		try {
 			await axios.post(`${challengeBaseURL}/${challengeId}/decline`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {

RaspberryPi-WebServer/backend/src/controllers/LichessControllers/LichessChatController.ts

@@ -5,7 +5,7 @@ import LichessTokenVault from "./LichessTokenVault";
 const gameBaseURL = `${config.lichess_base_url}/api/board/game`;
 
 export default class LichessChatController {
-	static async sendMessage(gameId, message) {
+	static async sendMessage(gameId: string, message: string) {
 		try {
 			await axios.post(
 				`${gameBaseURL}/${gameId}/chat`,
@@ -20,7 +20,7 @@ export default class LichessChatController {
 		}
 	}
 
-	static async fetchChat(gameId) {
+	static async fetchChat(gameId: string) {
 		try {
 			const response = await axios.get(`${gameBaseURL}/${gameId}/chat`, LichessTokenVault.getAuthorizationHeaderObject());
 			return response.data;

RaspberryPi-WebServer/backend/src/controllers/LichessControllers/LichessGameController.ts

@@ -5,91 +5,91 @@ import LichessTokenVault from "./LichessTokenVault";
 const gameBaseURL = `${config.lichess_base_url}/api/board/game`;
 
 export default class LichessGameController {
-	static async makeMove(gameId, move) {
+	static async makeMove(gameId: string, move: string) {
 		try {
 			await axios.post(`${gameBaseURL}/${gameId}/move/${move}`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {
 			console.error(`Error while making the move ${move} in game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async abortGame(gameId) {
+	static async abortGame(gameId: string) {
 		try {
 			await axios.post(`${gameBaseURL}/${gameId}/abort`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {
 			console.error(`Error while aborting game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async resignGame(gameId) {
+	static async resignGame(gameId: string) {
 		try {
 			await axios.post(`${gameBaseURL}/${gameId}/resign`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {
 			console.error(`Error while resigning game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async offerDraw(gameId) {
+	static async offerDraw(gameId: string) {
 		try {
 			await LichessGameController.#handleDrawOffer(gameId, "yes");
 		} catch (error) {
 			console.error(`Error while offering a draw to game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async acceptDraw(gameId) {
+	static async acceptDraw(gameId: string) {
 		try {
 			await LichessGameController.#handleDrawOffer(gameId, "yes");
 		} catch (error) {
 			console.error(`Error while accepting a draw from game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async declineDraw(gameId) {
+	static async declineDraw(gameId: string) {
 		try {
 			await LichessGameController.#handleDrawOffer(gameId, "no");
 		} catch (error) {
 			console.error(`Error while declining a draw from game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async createTakeback(gameId) {
+	static async createTakeback(gameId: string) {
 		try {
 			await LichessGameController.#handleTakebackOffer(gameId, "yes");
 		} catch (error) {
 			console.error(`Error while creating a takeback for game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async acceptTakeback(gameId) {
+	static async acceptTakeback(gameId: string) {
 		try {
 			await LichessGameController.#handleTakebackOffer(gameId, "yes");
 		} catch (error) {
 			console.error(`Error while accepting takeback from game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async declineTakeback(gameId) {
+	static async declineTakeback(gameId: string) {
 		try {
 			await LichessGameController.#handleTakebackOffer(gameId, "no");
 		} catch (error) {
 			console.error(`Error while declining takeback from game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async claimVictory(gameId) {
+	static async claimVictory(gameId: string) {
 		try {
 			await axios.post(`${gameBaseURL}/${gameId}/claim-victory`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 		} catch (error) {
 			console.error(`Error while claiming victory for game with id ${gameId}: ${error}`);
 		}
 	}
 
-	static async #handleDrawOffer(gameId, accept) {
+	static async #handleDrawOffer(gameId: string, accept: "yes" | "no") {
 		await axios.post(`${gameBaseURL}/${gameId}/draw/${accept}`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 	}
 
-	static async #handleTakebackOffer(gameId, accept) {
+	static async #handleTakebackOffer(gameId: string, accept: "yes" | "no") {
 		await axios.post(`${gameBaseURL}/${gameId}/takeback/${accept}`, {}, LichessTokenVault.getAuthorizationHeaderObject());
 	}
 }

RaspberryPi-WebServer/backend/src/controllers/LichessControllers/LichessTokenVault.ts

@@ -2,9 +2,12 @@
  * This Controller stores the lichess access token for the current user as only one user can be logged into the board at a time
  */
 export default class LichessTokenVault {
-	static setAccessToken(accessToken, expiresIn_seconds) {
+	private static accessToken : string | undefined;
+	private static accessTokenExpirationDate : bigint | undefined;
+
+	static setAccessToken(accessToken: string | undefined, expiresIn_seconds: bigint | undefined) {
 		this.accessToken = accessToken;
-		this.accessTokenExpirationDate = Date.now() + expiresIn_seconds * 1000; //expiresIn is in seconds, Date.now() is in milliseconds
+		this.accessTokenExpirationDate = expiresIn_seconds ? BigInt(Date.now()) + expiresIn_seconds * BigInt(1000) : undefined; //expiresIn is in seconds, Date.now() is in milliseconds
 	}
 
 	static getAccessToken() {
@@ -29,7 +32,7 @@ export default class LichessTokenVault {
 	}
 
 	static deleteAccessToken() {
-		this.accessToken = null;
-		this.accessTokenExpirationDate = null;
+		this.accessToken = undefined;
+		this.accessTokenExpirationDate = undefined;
 	}
 }

RaspberryPi-WebServer/backend/src/controllers/LichessControllers/LichessUserController.ts

@@ -5,7 +5,7 @@ import LichessTokenVault from "./LichessTokenVault";
 const userBaseURL = `${config.lichess_base_url}/api/user`;
 
 export default class LichessUserController {
-	static async fetchUserInformation(username) {
+	static async fetchUserInformation(username: string) {
 		try {
 			const response = await axios.get(`${userBaseURL}/${username}`, LichessTokenVault.getAuthorizationHeaderObject());
 			return response.data;
@@ -24,6 +24,6 @@ export default class LichessUserController {
 	}
 
 	static async fetchLoggedInUsername() {
-		return await this.fetchLoggedInUserInformation().username;
+		return (await this.fetchLoggedInUserInformation()).username;
 	}
 }

RaspberryPi-WebServer/backend/src/controllers/PhysicalBoardController.ts

@@ -1,4 +1,4 @@
-import { BISHOP, KING, KNIGHT, PAWN, QUEEN, ROOK } from "chess.js";
+import { BISHOP, KING, KNIGHT, PAWN, PieceSymbol, QUEEN, ROOK, Move } from "chess.js";
 import BoardPosition from "@src/helpers/BoardPosition";
 import VirtualBoardController from "./VirtualBoardController";
 import LichessGameController from "./LichessControllers/LichessGameController";
@@ -7,30 +7,31 @@ import { concatZeroesUntilSizeMatches, hexToBinary64 } from "@src/helpers/util";
 import { ArduinoCommunicator } from "@src/services/ArduinoCommunicator";
 
 export default class PhysicalBoardController {
-	static #instance = null;
+	private static instance : PhysicalBoardController;
+	private lastReadPositioning : string | null = null;
 
 	constructor() {
-		if (PhysicalBoardController.#instance) {
+		if (PhysicalBoardController.instance) {
 			throw new Error("Use PhysicalBoardController.getInstance() instead of new.");
 		}
 
 		this.lastReadPositioning = null;
-		PhysicalBoardController.#instance = this;
+		PhysicalBoardController.instance = this;
 	}
 
 	static getInstance() {
-		if (!PhysicalBoardController.#instance) {
-			PhysicalBoardController.#instance = new PhysicalBoardController();
+		if (!PhysicalBoardController.instance) {
+			PhysicalBoardController.instance = new PhysicalBoardController();
 		}
 
-		return PhysicalBoardController.#instance;
+		return PhysicalBoardController.instance;
 	}
 
 	/**
 	 * move: e.g. "a2a3"
 	 */
 	// eslint-disable-next-line no-unused-vars
-	async movePiece(move, pieceType, moveInformation) {
+	async movePiece(move: string, pieceType: PieceSymbol, moveInformation: Move) {
 		const fromPosition = new BoardPosition(move[0], Number(move[1]));
 		const toPosition = new BoardPosition(move[2], Number(move[3]));
 
@@ -61,24 +62,24 @@ export default class PhysicalBoardController {
 		}
 	}
 
-	async #movePawn(fromPosition, toPosition) {
+	async #movePawn(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		await this.#executePhysicalMovesInOrder(fromPosition, toPosition);
 	}
 
 	/**
 	 * Tries to move the knight without moving another piece first.
 	 * If thats's not possible, it moves a helper piece to a corner, moves the knight, and the moves the helper piece back
 	 */
-	async #moveKnight(fromPosition, toPosition) {
+	async #moveKnight(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		const helperPiecePositions = this.calculateKnightHelperPiecePositions(fromPosition, toPosition);
 
 		//if the tile near the from-position is empty
-		if (!VirtualBoardController.getInstance().getPieceAtPosition(helperPiecePositions.nearFromPositionFrom?.toChessNotationString())) {
+		if (!VirtualBoardController.getInstance().getPieceAtPosition(helperPiecePositions.nearFromPositionFrom?.toSquareString())) {
 			return await this.#executePhysicalMovesInOrder(fromPosition, helperPiecePositions.nearFromPositionFrom, toPosition);
 		}
 
 		//if the tile near the to-position is empty
-		if (!VirtualBoardController.getInstance().getPieceAtPosition(helperPiecePositions.nearToPositionFrom?.toChessNotationString())) {
+		if (!VirtualBoardController.getInstance().getPieceAtPosition(helperPiecePositions.nearToPositionFrom?.toSquareString())) {
 			return await this.#executePhysicalMovesInOrder(fromPosition, helperPiecePositions.nearToPositionFrom, toPosition);
 		}
 
@@ -96,19 +97,19 @@ export default class PhysicalBoardController {
 		await this.#executePhysicalMovesInOrder(helperToPositionToUse, helperFromPositionToUse);
 	}
 
-	async #moveBishop(fromPosition, toPosition) {
+	async #moveBishop(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		await this.#executePhysicalMovesInOrder(fromPosition, toPosition);
 	}
 
-	async #moveRook(fromPosition, toPosition) {
+	async #moveRook(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		await this.#executePhysicalMovesInOrder(fromPosition, toPosition);
 	}
 
-	async #moveQueen(fromPosition, toPosition) {
+	async #moveQueen(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		await this.#executePhysicalMovesInOrder(fromPosition, toPosition);
 	}
 
-	async #moveKing(fromPosition, toPosition) {
+	async #moveKing(fromPosition: BoardPosition, toPosition: BoardPosition) {
 		await this.#executePhysicalMovesInOrder(fromPosition, toPosition);
 	}
 
@@ -119,7 +120,7 @@ export default class PhysicalBoardController {
 	 * along the rest of the positions and is released at the last position in the array
 	 * @param {BoardPosition} moves
 	 */
-	async #executePhysicalMovesInOrder(...moves) {
+	async #executePhysicalMovesInOrder(...moves: BoardPosition[]) {
 		if (moves.length < 2) return;
 		const communicator = ArduinoCommunicator.getInstance();
 		try {
@@ -188,13 +189,13 @@ export default class PhysicalBoardController {
 		}
 	}
 
-	#getChangedPosition(pos1, pos2) {
+	#getChangedPosition(pos1: string, pos2: string) {
 		const num1 = BigInt("0b" + pos1);
 		const num2 = BigInt("0b" + pos2);
 
-		const position_int = concatZeroesUntilSizeMatches((num1 ^ num2).toString(2), 64).indexOf(1); //because of the xor, theres a 1 only at the changed position
+		const position_int = concatZeroesUntilSizeMatches((num1 ^ num2).toString(2), 64).indexOf("1"); //because of the xor, theres a 1 only at the changed position
 		const xPositionStr = String.fromCharCode("a".charCodeAt(0) + (position_int % 8));
-		const yPositionStr = parseInt(position_int / 8) + 1;
+		const yPositionStr = String.fromCharCode(position_int / 8 + 1);
 		const positionInChessNotation = xPositionStr + yPositionStr;
 		return positionInChessNotation;
 	}
@@ -205,7 +206,7 @@ export default class PhysicalBoardController {
 	 * @param {BoardPosition} knightToPosition
 	 * @returns and object containing the from and to positions of the two potential helper pieces
 	 */
-	calculateKnightHelperPiecePositions(knightFromPosition, knightToPosition) {
+	calculateKnightHelperPiecePositions(knightFromPosition: BoardPosition, knightToPosition: BoardPosition) {
 		const delta = knightFromPosition.getDelta(knightToPosition);
 		let nearFromDelta = { x: Math.ceil(delta.x / 2), y: Math.ceil(delta.y / 2) };
 		let nearToDelta = { x: Math.floor(delta.x / 2), y: Math.floor(delta.y / 2) };