Backend rewrite using async/await

leaky-ships/lib/backend/components/checkPasswordIsValid.ts

@@ -6,12 +6,11 @@ import bcrypt from "bcrypt"
 export default async function checkPasswordIsValid<T>(
   context: API<T>,
   player: Player,
-  password: string,
-  next: () => void
+  password: string
 ) {
   // Validate for correct password
   const result = await bcrypt.compare(password, player.passwordHash ?? "")
-  if (!result) return sendError(context, rejectionErrors.wrongPassword)
+  if (!result) throw sendError(context, rejectionErrors.wrongPassword)
 
-  return next()
+  return
 }

leaky-ships/lib/backend/components/checkTokenIsValid.ts

@@ -4,11 +4,7 @@ import type { IdToken, RawToken } from "./createTokenDB"
 import sendError, { API } from "./sendError"
 import jwt from "jsonwebtoken"
 
-async function checkTokenIsValid<T>(
-  context: API<T>,
-  rawToken: RawToken,
-  next: (token: IdToken) => void
-) {
+async function checkTokenIsValid<T>(context: API<T>, rawToken: RawToken) {
   const { value, type } = rawToken
 
   // Verify the token and get the payload
@@ -17,13 +13,13 @@ async function checkTokenIsValid<T>(
     data = jwt.verify(value, process.env.TOKEN_SECRET as string)
   } catch (err: any) {
     // Deal with the problem in more detail
-    return sendError(context, jwtVerifyCatch(type, err))
+    throw sendError(context, jwtVerifyCatch(type, err))
   }
   // Making sure the token data is not a string (because it should be an object)
   if (typeof data === "string")
-    return sendError(context, rejectionErrorFns.tokenWasString(type, value))
+    throw sendError(context, rejectionErrorFns.tokenWasString(type, value))
 
-  return next({ id: data.id, type })
+  return { id: data.id, type }
 }
 
 export default checkTokenIsValid

leaky-ships/lib/backend/components/createPlayerDB.ts

@@ -2,11 +2,11 @@ import prisma from "../../prisma"
 import logging from "../logging"
 import type { Player } from "@prisma/client"
 
-async function createPlayerDB(next: (player: Player) => void) {
+async function createPlayerDB() {
   const player = await prisma.player.create({ data: {} })
   logging("Anonymous player created: " + player.id, ["debug"])
 
-  return next(player)
+  return player
 }
 
 export default createPlayerDB

leaky-ships/lib/backend/components/createTokenDB.ts

@@ -18,8 +18,7 @@ export const tokenLifetime = {
 
 export default async function createTokenDB(
   player: Player,
-  newTokenType: TokenType,
-  next: (newToken: RawToken, newTokenDB: Token) => void
+  newTokenType: TokenType
 ) {
   // Create token entry in DB
   const newTokenDB = await prisma.token.create({
@@ -41,5 +40,5 @@ export default async function createTokenDB(
     { expiresIn: tokenLifetime[newTokenType] }
   )
 
-  return next({ value: newToken, type: newTokenType }, newTokenDB)
+  return { newToken: { value: newToken, type: newTokenType }, newTokenDB }
 }

leaky-ships/lib/backend/components/decodeToken.ts

@@ -5,11 +5,7 @@ import type { IdToken, RawToken } from "./createTokenDB"
 import sendError, { API } from "./sendError"
 import jwt from "jsonwebtoken"
 
-async function decodeToken<T>(
-  context: API<T>,
-  rawToken: RawToken,
-  next: (token: IdToken) => void
-) {
+async function decodeToken<T>(context: API<T>, rawToken: RawToken) {
   const { value, type } = rawToken
 
   // Verify the token and get the payload
@@ -22,14 +18,14 @@ async function decodeToken<T>(
     const fallbackData = jwt.decode(value)
     // Making sure the token data is not a string (because it should be an object)
     if (typeof fallbackData === "string")
-      return sendError(context, rejectionErrorFns.tokenWasString(type, value))
-    return next({ id: fallbackData?.id, type })
+      throw sendError(context, rejectionErrorFns.tokenWasString(type, value))
+    return { id: fallbackData?.id, type }
   }
   // Making sure the token data is not a string (because it should be an object)
   if (typeof data === "string")
-    return sendError(context, rejectionErrorFns.tokenWasString(type, value))
+    throw sendError(context, rejectionErrorFns.tokenWasString(type, value))
 
-  return next({ id: data.id, type })
+  return { id: data.id, type }
 }
 
 export default decodeToken

leaky-ships/lib/backend/components/getPinFromBody.ts

@@ -1,6 +1,6 @@
 import sendError, { API } from "./sendError"
 
-async function getPinFromBody<T>(context: API<T>, next: (pin: string) => void) {
+async function getPinFromBody<T>(context: API<T>) {
   const body = JSON.parse(context.req.body)
   if (
     typeof body !== "object" ||
@@ -8,7 +8,7 @@ async function getPinFromBody<T>(context: API<T>, next: (pin: string) => void) {
     !("pin" in body) ||
     typeof body.pin !== "string"
   )
-    return sendError(context, {
+    throw sendError(context, {
       rejected: true,
       message: "No pin in request body!",
       statusCode: 401,
@@ -17,7 +17,7 @@ async function getPinFromBody<T>(context: API<T>, next: (pin: string) => void) {
     })
   const { pin } = body
 
-  return next(pin)
+  return pin
 }
 
 export default getPinFromBody

leaky-ships/lib/backend/components/getPlayer.ts

@@ -3,19 +3,13 @@ import getPlayerByIdDB from "./getPlayerByIdDB"
 import getTokenDB from "./getTokenDB"
 import getTokenFromBody from "./getTokenFromBody"
 import { API } from "./sendError"
-import { Player, Token } from "@prisma/client"
 
-function getPlayer<T>(
-  context: API<T>,
-  next: (player: Player, tokenDB: Token) => void
-) {
-  return getTokenFromBody(context, (accessToken) => {
-    checkTokenIsValid(context, accessToken, (token) => {
-      getTokenDB(context, token, (tokenDB) => {
-        getPlayerByIdDB(context, tokenDB, (player) => next(player, tokenDB))
-      })
-    })
-  })
+async function getPlayer<T>(context: API<T>) {
+  const accessToken = await getTokenFromBody(context)
+  const token = await checkTokenIsValid(context, accessToken)
+  const tokenDB = await getTokenDB(context, token)
+  const player = await getPlayerByIdDB(context, tokenDB)
+  return { player, tokenDB }
 }
 
 export default getPlayer

leaky-ships/lib/backend/components/getPlayerByIdDB.ts

@@ -5,8 +5,7 @@ import type { Player, Token } from "@prisma/client"
 
 export default async function getPlayerByIdDB<T>(
   context: API<T>,
-  tokenDB: Token,
-  next: (player: Player) => void
+  tokenDB: Token
 ) {
   // Find Host in DB if it still exists (just to make sure)
   const player = await prisma.player.findUnique({
@@ -15,8 +14,8 @@ export default async function getPlayerByIdDB<T>(
     },
   })
   if (!player) {
-    return sendError(context, rejectionErrors.playerNotFound)
+    throw sendError(context, rejectionErrors.playerNotFound)
   }
 
-  return next(player)
+  return player
 }

leaky-ships/lib/backend/components/getPlayerByNameDB.ts

@@ -5,8 +5,7 @@ import type { Player } from "@prisma/client"
 
 export default async function getPlayerByNameDB<T>(
   context: API<T>,
-  username: string,
-  next: (player: Player) => void
+  username: string
 ) {
   // Find Player in DB if it still exists (just to make sure)
   const player = await Promise.any([
@@ -21,7 +20,7 @@ export default async function getPlayerByNameDB<T>(
       },
     }),
   ]).catch(() => null)
-  if (player === null) return sendError(context, rejectionErrors.playerNotFound)
+  if (player === null) throw sendError(context, rejectionErrors.playerNotFound)
 
-  return next(player)
+  return player
 }

leaky-ships/lib/backend/components/getTokenDB.ts

@@ -2,13 +2,12 @@ import prisma from "../../prisma"
 import { rejectionErrorFns, rejectionErrors } from "../errors"
 import type { IdToken } from "./createTokenDB"
 import sendError, { API } from "./sendError"
-import type { Token } from "@prisma/client"
 import { deleteCookie } from "cookies-next"
 
 async function getTokenDB<T>(
   context: API<T>,
   token: IdToken,
-  next: (tokenDB: Token) => void,
+
   ignoreChecks?: boolean
 ) {
   const { id, type } = token
@@ -20,11 +19,11 @@ async function getTokenDB<T>(
   })
   if (!tokenDB) {
     deleteCookie("token", { ...context, path: "/api" })
-    return sendError(context, rejectionErrorFns.tokenNotFound(type))
+    throw sendError(context, rejectionErrorFns.tokenNotFound(type))
   }
 
   if (tokenDB.used && !ignoreChecks)
-    return sendError(context, rejectionErrors.tokenUsed)
+    throw sendError(context, rejectionErrors.tokenUsed)
 
   await prisma.token.update({
     where: {
@@ -37,7 +36,7 @@ async function getTokenDB<T>(
 
   // await logging('Old token has been invalidated.', ['debug'], req)
 
-  return next(tokenDB)
+  return tokenDB
 }
 
 export default getTokenDB

leaky-ships/lib/backend/components/getTokenFromBody.ts

@@ -2,10 +2,7 @@ import { rejectionErrorFns } from "../errors"
 import type { RawToken } from "./createTokenDB"
 import sendError, { API } from "./sendError"
 
-async function getTokenFromBody<T>(
-  context: API<T>,
-  next: (accessToken: RawToken) => void
-) {
+async function getTokenFromBody<T>(context: API<T>): Promise<RawToken> {
   const type = "ACCESS"
   const body = JSON.parse(context.req.body)
   // Checking for cookie presens, because it is necessary
@@ -16,11 +13,11 @@ async function getTokenFromBody<T>(
     typeof body.token === "string"
   ) {
     const value = body.token
-    return next({ value, type })
+    return { value, type }
   }
   console.log(body)
 
-  return sendError(context, rejectionErrorFns.noToken(type))
+  throw sendError(context, rejectionErrorFns.noToken(type))
 }
 
 export default getTokenFromBody

leaky-ships/lib/backend/components/getTokenFromCookie.ts

@@ -3,25 +3,29 @@ import createTokenDB, { RawToken } from "./createTokenDB"
 import type { API } from "./sendError"
 import { Player, Token } from "@prisma/client"
 
-async function getTokenFromCookie<T>(
-  context: API<T>,
-  next: (
-    refreshToken: RawToken,
-    newPlayer?: { player: Player; newToken: RawToken; newTokenDB: Token }
-  ) => void
-) {
+interface Returning {
+  refreshToken: RawToken
+  newPlayer?: { player: Player; newToken: RawToken; newTokenDB: Token }
+}
+
+async function getTokenFromCookie<T>(context: API<T>): Promise<Returning> {
   const type = "REFRESH"
   const value = context.req.cookies.token
 
   // Checking for cookie presens, because it is necessary
   if (!value) {
-    return createPlayerDB((player) =>
-      createTokenDB(player, type, (newToken, newTokenDB) =>
-        next(newToken, { player, newToken, newTokenDB })
-      )
-    )
+    const player = await createPlayerDB()
+    const { newToken, newTokenDB } = await createTokenDB(player, type)
+    return {
+      refreshToken: newToken,
+      newPlayer: {
+        player,
+        newToken,
+        newTokenDB,
+      },
+    }
   }
-  return next({ value, type })
+  return { refreshToken: { value, type } }
 }
 
 export default getTokenFromCookie

leaky-ships/lib/backend/components/getUserFromBody.ts

@@ -1,10 +1,7 @@
 import { rejectionErrors } from "../errors"
 import sendError, { API } from "./sendError"
 
-async function getUserFromBody<T>(
-  context: API<T>,
-  next: (username: string, password: string) => void
-) {
+async function getUserFromBody<T>(context: API<T>) {
   const body = JSON.parse(context.req.body)
   if (
     typeof body !== "object" ||
@@ -12,13 +9,13 @@ async function getUserFromBody<T>(
     !("username" in body) ||
     typeof body.username !== "string"
   )
-    return sendError(context, rejectionErrors.noUsername)
+    throw sendError(context, rejectionErrors.noUsername)
   const { username } = body
   if (!("password" in body) || typeof body.password !== "string")
-    return sendError(context, rejectionErrors.noPassword)
+    throw sendError(context, rejectionErrors.noPassword)
   const { password } = body
 
-  return next(username, password)
+  return { username, password }
 }
 
 export default getUserFromBody

leaky-ships/lib/backend/components/sendResponse.ts

@@ -37,4 +37,5 @@ export default function sendResponse<T>(context: API<T>, result: Result<T>) {
   res.status(result.statusCode ?? 200)
   result.body ? res.json(result.body) : res.end()
   logging(result.message, result.type ?? ["debug"], req)
+  return "done" as const
 }

leaky-ships/lib/backend/components/updatePlayerDB.ts

@@ -6,16 +6,15 @@ import type { Player, Prisma } from "@prisma/client"
 async function updatePlayerDB<T>(
   context: API<T>,
   player: Player,
-  data: Prisma.PlayerUpdateInput,
-  next: (updatedPlayer: Player) => void
+  data: Prisma.PlayerUpdateInput
 ) {
-  if (!player.anonymous) return sendError(context, rejectionErrors.registered)
+  if (!player.anonymous) throw sendError(context, rejectionErrors.registered)
   const updatedPlayer = await prisma.player.update({
     where: { id: player.id },
     data,
   })
 
-  return next(updatedPlayer)
+  return updatedPlayer
 }
 
 export default updatePlayerDB

leaky-ships/lib/frontend/getAccessToken.ts

@@ -28,7 +28,7 @@ async function getAccessToken() {
     .then(successfulResponse)
     .then((response) => {
       try {
-        const token = tokenSchema.parse(response)
+        const { token } = tokenSchema.parse(response)
 
         return token
       } catch (err: any) {

leaky-ships/pages/api/game/create.ts

@@ -1,8 +1,6 @@
-import sendError from "@backend/components/sendError"
 import sendResponse from "@backend/components/sendResponse"
 import getPlayer from "@lib/backend/components/getPlayer"
 import prisma from "@lib/prisma"
-import { Game, Gamepin, Player_Game } from "@prisma/client"
 import type { NextApiRequest, NextApiResponse } from "next"
 import { z } from "zod"
 
@@ -36,25 +34,40 @@ export default async function create(
 ) {
   const context = { req, res }
 
-  return getPlayer(context, async (player) => {
-    // Generate a random 4-digit code
-    const pin = Math.floor(Math.random() * 10000)
-      .toString()
-      .padStart(4, "0")
+  const { player } = await getPlayer(context)
+  // Generate a random 4-digit code
+  const pin = Math.floor(Math.random() * 10000)
+    .toString()
+    .padStart(4, "0")
 
-    let created = false
-    let game:
-      | (Game & {
-          pin: Gamepin | null
-          players: Player_Game[]
-        })
-      | null
+  let created = false
 
-    game = await prisma.game.findFirst({
-      where: {
-        running: true,
+  let game = await prisma.game.findFirst({
+    where: {
+      running: true,
+      players: {
+        some: {
+          playerId: player.id,
+        },
+      },
+    },
+    include: {
+      pin: true,
+      players: true,
+    },
+  })
+  if (!game) {
+    created = true
+    game = await prisma.game.create({
+      data: {
+        pin: {
+          create: {
+            pin,
+          },
+        },
         players: {
-          some: {
+          create: {
+            isOwner: true,
             playerId: player.id,
           },
         },
@@ -64,42 +77,20 @@ export default async function create(
         players: true,
       },
     })
-    if (!game) {
-      created = true
-      game = await prisma.game.create({
-        data: {
-          pin: {
-            create: {
-              pin,
-            },
-          },
-          players: {
-            create: {
-              isOwner: true,
-              playerId: player.id,
-            },
-          },
-        },
-        include: {
-          pin: true,
-          players: true,
-        },
-      })
-    }
+  }
 
-    return sendResponse(context, {
-      message: `Player: ${player.id} created game: ${game.id}`,
-      statusCode: created ? 201 : 200,
-      body: {
-        game,
-        pin: game.pin?.pin,
-        player: {
-          id: player.id,
-          username: player.username ?? undefined,
-          isOwner: true,
-        },
+  return sendResponse(context, {
+    message: `Player: ${player.id} created game: ${game.id}`,
+    statusCode: created ? 201 : 200,
+    body: {
+      game,
+      pin: game.pin?.pin,
+      player: {
+        id: player.id,
+        username: player.username ?? undefined,
+        isOwner: true,
       },
-      type: ["debug", "infoCyan"],
-    })
-  }).catch((err) => sendError(context, err))
+    },
+    type: ["debug", "infoCyan"],
+  })
 }

leaky-ships/pages/api/game/join.ts

@@ -17,63 +17,61 @@ export default async function join(
 ) {
   const context = { req, res }
 
-  return getPinFromBody(context, (pin) =>
-    getPlayer(context, async (player) => {
-      try {
-        const pinDB = await prisma.gamepin.update({
-          where: {
-            pin,
-          },
-          data: {
-            game: {
-              update: {
-                players: {
-                  create: {
-                    isOwner: false,
-                    playerId: player.id,
-                  },
-                },
+  const pin = await getPinFromBody(context)
+  const { player } = await getPlayer(context)
+  try {
+    const pinDB = await prisma.gamepin.update({
+      where: {
+        pin,
+      },
+      data: {
+        game: {
+          update: {
+            players: {
+              create: {
+                isOwner: false,
+                playerId: player.id,
               },
             },
           },
+        },
+      },
+      include: {
+        game: {
           include: {
-            game: {
+            players: {
               include: {
-                players: {
-                  include: {
-                    player: true,
-                  },
-                },
+                player: true,
               },
             },
           },
-        })
-
-        const enemy = pinDB.game.players.find(
-          (enemy) => enemy.player.id !== player.id
-        )
-        return sendResponse(context, {
-          message: `Player: ${player.id} joined game: ${pinDB.game.id}`,
-          body: {
-            game: pinDB.game,
-            pin: pinDB.pin,
-            player: {
-              id: player.id,
-              username: player.username ?? undefined,
-              isOwner: true,
-            },
-            enemy: {
-              id: enemy?.player.id,
-              username: enemy?.player.username ?? undefined,
-              isOwner: false,
-            },
-          },
-          type: ["debug", "infoCyan"],
-        })
-      } catch (err: any) {
-        console.log("HERE".red, err.code, err.meta, err.message)
-        return sendError(context, rejectionErrors.gameNotFound)
-      }
+        },
+      },
     })
-  ).catch((err) => sendError(context, err))
+
+    const enemy = pinDB.game.players.find(
+      (enemy) => enemy.player.id !== player.id
+    )
+    return sendResponse(context, {
+      message: `Player: ${player.id} joined game: ${pinDB.game.id}`,
+      body: {
+        game: pinDB.game,
+        pin: pinDB.pin,
+        player: {
+          id: player.id,
+          username: player.username ?? undefined,
+          isOwner: true,
+        },
+        enemy: {
+          id: enemy?.player.id,
+          username: enemy?.player.username ?? undefined,
+          isOwner: false,
+        },
+      },
+      type: ["debug", "infoCyan"],
+    })
+  } catch (err: any) {
+    console.log("HERE".red, err.code, err.meta, err.message)
+    throw sendError(context, rejectionErrors.gameNotFound)
+  }
 }

leaky-ships/pages/api/user/auth.ts

@@ -19,24 +19,25 @@ export default async function auth(
   const context = { req, res }
   const type = "ACCESS"
 
-  return getTokenFromCookie(context, (refreshToken, newPlayer) => {
-    const next = (player: Player, tokenDB: Token, cookie?: string) =>
-      createTokenDB(player, type, (newToken, newTokenDB) =>
-        sendResponse(context, {
-          message: `Access-Token generated: ${newTokenDB.id} with Refreshtoken-Token: ${tokenDB.id}`,
-          body: { token: newToken.value },
-          type: ["debug", "infoCyan"],
-          cookie,
-        })
-      )
-    if (!newPlayer) {
-      return checkTokenIsValid(context, refreshToken, (token) =>
-        getTokenDB(context, token, (tokenDB) =>
-          getPlayerByIdDB(context, tokenDB, (player) => next(player, tokenDB))
-        )
-      )
-    }
-    const { player, newToken, newTokenDB } = newPlayer
-    return next(player, newTokenDB, newToken.value)
-  }).catch((err) => sendError(context, err))
+  const { refreshToken, newPlayer } = await getTokenFromCookie(context)
+
+  let player: Player, tokenDB: Token, cookie: string | undefined
+
+  if (!newPlayer) {
+    const token = await checkTokenIsValid(context, refreshToken)
+    tokenDB = await getTokenDB(context, token)
+    player = await getPlayerByIdDB(context, tokenDB)
+  } else {
+    player = newPlayer.player
+    tokenDB = newPlayer.newTokenDB
+    cookie = newPlayer.newToken.value
+  }
+
+  const { newToken, newTokenDB } = await createTokenDB(player, type)
+  return sendResponse(context, {
+    message: `Access-Token generated: ${newTokenDB.id} with Refreshtoken-Token: ${tokenDB.id}`,
+    body: { token: newToken.value },
+    type: ["debug", "infoCyan"],
+    cookie,
+  })
 }

leaky-ships/pages/api/user/data.ts

@@ -1,4 +1,3 @@
-import sendError from "@backend/components/sendError"
 import sendResponse from "@backend/components/sendResponse"
 import getPlayer from "@lib/backend/components/getPlayer"
 import type { Game } from "@prisma/client"
@@ -14,12 +13,11 @@ export default async function data(
 ) {
   const context = { req, res }
 
-  return getPlayer(context, (player, tokenDB) => {
-    const games: any = {}
-    sendResponse(context, {
-      message: `Requested data of user: ${player.id} with Access-Token: ${tokenDB.id}`,
-      body: { games },
-      type: ["debug", "infoCyan"],
-    })
-  }).catch((err) => sendError(context, err))
+  const { player, tokenDB } = await getPlayer(context)
+  const games: any = {}
+  return sendResponse(context, {
+    message: `Requested data of user: ${player.id} with Access-Token: ${tokenDB.id}`,
+    body: { games },
+    type: ["debug", "infoCyan"],
+  })
 }

leaky-ships/pages/api/user/login.ts

@@ -7,7 +7,6 @@ import sendResponse from "@backend/components/sendResponse"
 import logging from "@backend/logging"
 import { rejectionErrors } from "@lib/backend/errors"
 import prisma from "@lib/prisma"
-import { setCookie } from "cookies-next"
 import jwt from "jsonwebtoken"
 import type { NextApiRequest, NextApiResponse } from "next"
 
@@ -21,34 +20,29 @@ export default async function login(
 ) {
   const context = { req, res }
 
-  return preCheck(context, () =>
-    getUserFromBody(context, (username, password) =>
-      getPlayerByNameDB(context, username, (player) => {
-        checkPasswordIsValid(context, player, password, () => {
-          createTokenDB(player, "REFRESH", (newToken, newTokenDB) => {
-            sendResponse(context, {
-              message:
-                "User " +
-                player.id +
-                " logged in and generated Refresh-Token: " +
-                newTokenDB.id,
-              body: { loggedIn: true },
-              type: ["debug", "infoCyan"],
-              cookie: newToken.value,
-            })
-          })
-        })
-      })
-    )
-  ).catch((err) => sendError(context, err))
+  await preCheck(context)
+  const { username, password } = await getUserFromBody(context)
+  const player = await getPlayerByNameDB(context, username)
+  await checkPasswordIsValid(context, player, password)
+  const { newToken, newTokenDB } = await createTokenDB(player, "REFRESH")
+  return sendResponse(context, {
+    message:
+      "User " +
+      player.id +
+      " logged in and generated Refresh-Token: " +
+      newTokenDB.id,
+    body: { loggedIn: true },
+    type: ["debug", "infoCyan"],
+    cookie: newToken.value,
+  })
 }
 
-async function preCheck<T>(context: API<T>, next: () => void) {
+async function preCheck<T>(context: API<T>) {
   const { req } = context
   const oldRefreshToken = req.cookies.token
 
   try {
-    if (!oldRefreshToken) return sendError(context, rejectionErrors.noCookie)
+    if (!oldRefreshToken) throw sendError(context, rejectionErrors.noCookie)
     // Check for old cookie, if unused invalidate it
     const tokenData = jwt.verify(
       oldRefreshToken,
@@ -80,5 +74,5 @@ async function preCheck<T>(context: API<T>, next: () => void) {
     // err is expected if no correct cookie, just continue, otherwise it has been invalidated above
   }
 
-  return next()
+  return
 }

leaky-ships/pages/api/user/loginCheck.ts

@@ -2,7 +2,6 @@ import checkTokenIsValid from "@backend/components/checkTokenIsValid"
 import getPlayerByIdDB from "@backend/components/getPlayerByIdDB"
 import getTokenDB from "@backend/components/getTokenDB"
 import getTokenFromCookie from "@backend/components/getTokenFromCookie"
-import sendError from "@backend/components/sendError"
 import sendResponse from "@backend/components/sendResponse"
 import type { NextApiRequest, NextApiResponse } from "next"
 
@@ -16,16 +15,12 @@ export default async function auth(
 ) {
   const context = { req, res }
 
-  getTokenFromCookie(context, (refreshToken) => {
-    checkTokenIsValid(context, refreshToken, (token) => {
-      getTokenDB(context, token, (tokenDB) => {
-        getPlayerByIdDB(context, tokenDB, (player) => {
-          sendResponse(context, {
-            message: "loginCheck -> true : " + player.id,
-            type: ["debug", "infoCyan"],
-          })
-        })
-      })
-    })
-  }).catch((err) => sendError(context, err))
+  const { refreshToken } = await getTokenFromCookie(context)
+  const token = await checkTokenIsValid(context, refreshToken)
+  const tokenDB = await getTokenDB(context, token)
+  const player = await getPlayerByIdDB(context, tokenDB)
+  return sendResponse(context, {
+    message: "loginCheck -> true : " + player.id,
+    type: ["debug", "infoCyan"],
+  })
 }

leaky-ships/pages/api/user/logout.ts

@@ -15,21 +15,14 @@ export default async function logout(
 ) {
   const context = { req, res }
 
-  return getTokenFromCookie(context, (refreshToken) =>
-    decodeToken(context, refreshToken, (token) =>
-      getTokenDB(
-        context,
-        token,
-        (tokenDB) => {
-          return sendResponse(context, {
-            message: "User of Token " + tokenDB.id + " logged out.",
-            body: { loggedOut: true },
-            type: ["debug", "infoCyan"],
-            cookie: "",
-          })
-        },
-        true
-      )
-    )
-  ).catch((err) => sendError(context, err))
+  const { refreshToken } = await getTokenFromCookie(context)
+  const token = await decodeToken(context, refreshToken)
+  const tokenDB = await getTokenDB(context, token, true)
+
+  return sendResponse(context, {
+    message: "User of Token " + tokenDB.id + " logged out.",
+    body: { loggedOut: true },
+    type: ["debug", "infoCyan"],
+    cookie: "",
+  })
 }

leaky-ships/pages/api/user/register.ts

@@ -19,32 +19,22 @@ export default async function register(
 ) {
   const context = { req, res }
 
-  return getTokenFromCookie(context, (refreshToken) => {
-    checkTokenIsValid(context, refreshToken, (token) => {
-      getTokenDB(context, token, (tokenDB) => {
-        getUserFromBody(context, (username, password) =>
-          getPlayerByIdDB(context, tokenDB, async (player) =>
-            updatePlayerDB(
-              context,
-              player,
-              {
-                username,
-                email: "arst",
-                passwordHash: await bcrypt.hash(password, 10),
-                anonymous: false,
-              },
-              (player) => {
-                sendResponse(context, {
-                  message: "Player registered : " + player.id,
-                  statusCode: 201,
-                  body: { registered: true },
-                  type: ["debug", "infoCyan"],
-                })
-              }
-            )
-          )
-        )
-      })
-    })
-  }).catch((err) => sendError(context, err))
+  const { refreshToken } = await getTokenFromCookie(context)
+  const token = await checkTokenIsValid(context, refreshToken)
+  const tokenDB = await getTokenDB(context, token)
+  const { username, password } = await getUserFromBody(context)
+  let player = await getPlayerByIdDB(context, tokenDB)
+  player = await updatePlayerDB(context, player, {
+    username,
+    email: "arst",
+    passwordHash: await bcrypt.hash(password, 10),
+    anonymous: false,
+  })
+
+  return sendResponse(context, {
+    message: "Player registered : " + player.id,
+    statusCode: 201,
+    body: { registered: true },
+    type: ["debug", "infoCyan"],
+  })
 }

leaky-ships/pages/api/user/remove.ts

@@ -16,25 +16,23 @@ export default async function remove(
 ) {
   const context = { req, res }
 
-  return getUserFromBody(context, (username, password) =>
-    getPlayerByNameDB(context, username, (player) => {
-      checkPasswordIsValid(context, player, password, () => {
-        prisma.player.update({
-          where: {
-            id: player.id,
-          },
-          data: {
-            deleted: true,
-            username: null,
-            email: null,
-            passwordHash: null,
-          },
-        })
-        sendResponse(context, {
-          message: "User successfully deleted: " + player.id,
-          type: ["debug", "infoCyan"],
-        })
-      })
-    })
-  ).catch((err) => sendError(context, err))
+  const { username, password } = await getUserFromBody(context)
+  const player = await getPlayerByNameDB(context, username)
+  await checkPasswordIsValid(context, player, password)
+  prisma.player.update({
+    where: {
+      id: player.id,
+    },
+    data: {
+      deleted: true,
+      username: null,
+      email: null,
+      passwordHash: null,
+    },
+  })
+
+  return sendResponse(context, {
+    message: "User successfully deleted: " + player.id,
+    type: ["debug", "infoCyan"],
+  })
 }

leaky-ships/pages/api/ws.ts

@@ -34,7 +34,7 @@ interface SocketData {
 
 // const authenticate = (socket, next) => {
 //   socket.isAuthenticated = false
-//   next()
+//
 // }
 
 async function checkTokenIsValid(rawToken: string) {