Formatted all files with Prettier

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

@@ -1,22 +1,23 @@
 import { Player } from "@prisma/client"
 import bcrypt from "bcrypt"
 
-export default async function checkPasswordIsValid<T>(payload: T & { player: Player, password: string }) {
-    const { player, password } = payload
+export default async function checkPasswordIsValid<T>(
+  payload: T & { player: Player; password: string }
+) {
+  const { player, password } = payload
 
-    // Validate for correct password
-    return bcrypt.compare(password, player.passwordHash)
-        .then(async result => {
-            if (!result) {
-                return Promise.reject({
-                    message: 'Passwords do not match!',
-                    statusCode: 401,
-                    solved: true,
-                })
-            }
-            return {
-                ...payload,
-                passwordIsValid: true
-            }
-        })
-}
+  // Validate for correct password
+  return bcrypt.compare(password, player.passwordHash).then(async (result) => {
+    if (!result) {
+      return Promise.reject({
+        message: "Passwords do not match!",
+        statusCode: 401,
+        solved: true,
+      })
+    }
+    return {
+      ...payload,
+      passwordIsValid: true,
+    }
+  })
+}

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

@@ -2,27 +2,29 @@ import { Token } from "@prisma/client"
 import jwt from "jsonwebtoken"
 import jwtVerifyCatch from "../jwtVerifyCatch"
 
-async function checkTokenIsValid<T>(payload: T & { token: string, tokenType: Token['type'] }) {
-    const { token, tokenType } = payload
+async function checkTokenIsValid<T>(
+  payload: T & { token: string; tokenType: Token["type"] }
+) {
+  const { token, tokenType } = payload
 
-    // Verify the token and get the payload
-    let tokenData: string | jwt.JwtPayload
-    try {
-        tokenData = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET as string)
-    } catch (err: any) {
-        // Deal with the problem in more detail
-        return Promise.reject(jwtVerifyCatch(tokenType, err))
-    }
-    // Making sure the token data is not a string (because it should be an object)
-    if (typeof tokenData === 'string') {
-        return Promise.reject({
-            message: tokenType + '-Token data was a string. Token: ' + token,
-            statusCode: 401,
-            solved: false
-        })
-    }
+  // Verify the token and get the payload
+  let tokenData: string | jwt.JwtPayload
+  try {
+    tokenData = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET as string)
+  } catch (err: any) {
+    // Deal with the problem in more detail
+    return Promise.reject(jwtVerifyCatch(tokenType, err))
+  }
+  // Making sure the token data is not a string (because it should be an object)
+  if (typeof tokenData === "string") {
+    return Promise.reject({
+      message: tokenType + "-Token data was a string. Token: " + token,
+      statusCode: 401,
+      solved: false,
+    })
+  }
 
-    return { ...payload, tokenBody: token, tokenIsValid: true }
+  return { ...payload, tokenBody: token, tokenIsValid: true }
 }
 
-export default checkTokenIsValid
+export default checkTokenIsValid

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

@@ -1,28 +1,28 @@
 import prisma from "../../prisma"
 
 async function createAnonymousDB<T>(payload: T) {
-    const player = await prisma.player.create({
-        data: {
-            anonymous: true
-        }
-    })
-    // .catch((err: any) => {
-    //     if (err.code === 11000) {
-    //         return Promise.reject({
-    //             message: `Duplicate key error while creating Player in DB!`,
-    //             statusCode: 409,
-    //             solved: true,
-    //             type: 'warn'
-    //         })
-    //     } else {
-    //         console.log(err)
-    //         return Promise.reject({
-    //             message: `Unknown error while creating Player in DB.`,
-    //             solved: false
-    //         })
-    //     }
-    // })
-    return { ...payload, player }
+  const player = await prisma.player.create({
+    data: {
+      anonymous: true,
+    },
+  })
+  // .catch((err: any) => {
+  //     if (err.code === 11000) {
+  //         return Promise.reject({
+  //             message: `Duplicate key error while creating Player in DB!`,
+  //             statusCode: 409,
+  //             solved: true,
+  //             type: 'warn'
+  //         })
+  //     } else {
+  //         console.log(err)
+  //         return Promise.reject({
+  //             message: `Unknown error while creating Player in DB.`,
+  //             solved: false
+  //         })
+  //     }
+  // })
+  return { ...payload, player }
 }
 
-export default createAnonymousDB
+export default createAnonymousDB

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

@@ -1,34 +1,38 @@
 import bcrypt from "bcrypt"
 import prisma from "../../prisma"
 
-async function createPlayerDB<T>(payload: T & { username: string, password: string }) {
-    const { username, password } = payload
+async function createPlayerDB<T>(
+  payload: T & { username: string; password: string }
+) {
+  const { username, password } = payload
 
-    return await prisma.player.create({
-        data: {
-            username,
-            passwordHash: await bcrypt.hash(password, 10),
-            anonymous: false
-        }
+  return await prisma.player
+    .create({
+      data: {
+        username,
+        passwordHash: await bcrypt.hash(password, 10),
+        anonymous: false,
+      },
     })
-        .then(player => {
-            return { ...payload, player }
-        }).catch((err: any) => {
-            if (err.code === 11000) {
-                return Promise.reject({
-                    message: `Duplicate key error while creating Player in DB!`,
-                    statusCode: 409,
-                    solved: true,
-                    type: 'warn'
-                })
-            } else {
-                console.log(err)
-                return Promise.reject({
-                    message: `Unknown error while creating Player in DB.`,
-                    solved: false
-                })
-            }
+    .then((player) => {
+      return { ...payload, player }
+    })
+    .catch((err: any) => {
+      if (err.code === 11000) {
+        return Promise.reject({
+          message: `Duplicate key error while creating Player in DB!`,
+          statusCode: 409,
+          solved: true,
+          type: "warn",
         })
+      } else {
+        console.log(err)
+        return Promise.reject({
+          message: `Unknown error while creating Player in DB.`,
+          solved: false,
+        })
+      }
+    })
 }
 
-export default createPlayerDB
+export default createPlayerDB

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

@@ -4,33 +4,39 @@ import { v4 as uuidv4 } from "uuid"
 import prisma from "../../prisma"
 
 const tokenLifetime = {
-    REFRESH: 172800,
-    ACCESS: 15
-};
+  REFRESH: 172800,
+  ACCESS: 15,
+}
 
-export default async function createTokenDB<T>(payload: T & { player: Player, newTokenType: Token['type'] }) {
-    const { player, newTokenType } = payload
+export default async function createTokenDB<T>(
+  payload: T & { player: Player; newTokenType: Token["type"] }
+) {
+  const { player, newTokenType } = payload
 
-    // Sign a new access token
-    const newToken = jwt.sign({ uuid: uuidv4(), user: player.id }, process.env.ACCESS_TOKEN_SECRET as string, { expiresIn: tokenLifetime[newTokenType] })
+  // Sign a new access token
+  const newToken = jwt.sign(
+    { uuid: uuidv4(), user: player.id },
+    process.env.ACCESS_TOKEN_SECRET as string,
+    { expiresIn: tokenLifetime[newTokenType] }
+  )
 
-    // Save token to DB
-    const newTokenDB = await prisma.token.create({
-        data: {
-            token: newToken,
-            type: newTokenType,
-            expires: new Date(Date.now() + tokenLifetime[newTokenType] + '000'),
-            owner: {
-                connect: {
-                    id: player.id
-                }
-            }
-        }
-    })
+  // Save token to DB
+  const newTokenDB = await prisma.token.create({
+    data: {
+      token: newToken,
+      type: newTokenType,
+      expires: new Date(Date.now() + tokenLifetime[newTokenType] + "000"),
+      owner: {
+        connect: {
+          id: player.id,
+        },
+      },
+    },
+  })
 
-    return {
-        ...payload,
-        newToken,
-        newTokenDB
-    }
-}
+  return {
+    ...payload,
+    newToken,
+    newTokenDB,
+  }
+}

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

@@ -1,24 +1,26 @@
 import { Token } from "@prisma/client"
 import prisma from "../../prisma"
 
-export default async function getPlayerByIdDB<T>(payload: T & { tokenDB: Token }) {
-    const { tokenDB } = payload
-    // Find Host in DB if it still exists (just to make sure)
-    const player = await prisma.player.findUnique({
-        where: {
-            id: tokenDB.ownerId
-        }
+export default async function getPlayerByIdDB<T>(
+  payload: T & { tokenDB: Token }
+) {
+  const { tokenDB } = payload
+  // Find Host in DB if it still exists (just to make sure)
+  const player = await prisma.player.findUnique({
+    where: {
+      id: tokenDB.ownerId,
+    },
+  })
+  if (!player) {
+    return Promise.reject({
+      message: "Player not found in DB!",
+      statusCode: 401,
+      solved: false,
     })
-    if (!player) {
-        return Promise.reject({
-            message: 'Player not found in DB!',
-            statusCode: 401,
-            solved: false
-        })
-    }
+  }
 
-    return {
-        ...payload,
-        player
-    }
-}
+  return {
+    ...payload,
+    player,
+  }
+}

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

@@ -1,29 +1,32 @@
 import prisma from "../../prisma"
 
-export default async function getPlayerByNameDB<T>(payload: T & { username: string }) {
-    const { username } = payload
-    // Find Player in DB if it still exists (just to make sure)
-    const player = await Promise.any([
-        prisma.player.findUnique({
-            where: {
-                username: username
-            }
-        }), prisma.player.findUnique({
-            where: {
-                email: username
-            }
-        })
-    ])
-    if (!player) {
-        return Promise.reject({
-            message: 'Player not found in DB!',
-            statusCode: 401,
-            solved: false
-        })
-    }
+export default async function getPlayerByNameDB<T>(
+  payload: T & { username: string }
+) {
+  const { username } = payload
+  // Find Player in DB if it still exists (just to make sure)
+  const player = await Promise.any([
+    prisma.player.findUnique({
+      where: {
+        username: username,
+      },
+    }),
+    prisma.player.findUnique({
+      where: {
+        email: username,
+      },
+    }),
+  ])
+  if (!player) {
+    return Promise.reject({
+      message: "Player not found in DB!",
+      statusCode: 401,
+      solved: false,
+    })
+  }
 
-    return {
-        ...payload,
-        player
-    }
-}
+  return {
+    ...payload,
+    player,
+  }
+}

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

@@ -1,52 +1,54 @@
 import { NextApiRequest, NextApiResponse } from "next"
 import prisma from "../../prisma"
 
-async function getTokenDB<T>(payload: T & {
+async function getTokenDB<T>(
+  payload: T & {
     tokenBody: string
-    tokenIsValid: boolean,
-    req: NextApiRequest,
-    res: NextApiResponse<any>,
-}) {
-    const { tokenBody } = payload
+    tokenIsValid: boolean
+    req: NextApiRequest
+    res: NextApiResponse<any>
+  }
+) {
+  const { tokenBody } = payload
 
-    // Find refresh token in DB
-    const tokenDB = await prisma.token.findUnique({
-        where: {
-            token: tokenBody
-        }
+  // Find refresh token in DB
+  const tokenDB = await prisma.token.findUnique({
+    where: {
+      token: tokenBody,
+    },
+  })
+  if (!tokenDB) {
+    return Promise.reject({
+      message: "Access-Token not found in DB!",
+      statusCode: 401,
+      solved: true,
+      type: "warn",
     })
-    if (!tokenDB) {
-        return Promise.reject({
-            message: 'Access-Token not found in DB!',
-            statusCode: 401,
-            solved: true,
-            type: 'warn'
-        })
-    }
+  }
 
-    if (tokenDB.used) {
-        return Promise.reject({
-            message: 'DBToken was already used!',
-            statusCode: 401,
-            solved: true
-        })
-    }
-
-    await prisma.token.update({
-        where: {
-            token: tokenBody
-        },
-        data: {
-            used: true
-        }
+  if (tokenDB.used) {
+    return Promise.reject({
+      message: "DBToken was already used!",
+      statusCode: 401,
+      solved: true,
     })
+  }
 
-    // await logging('Old token has been invalidated.', ['debug'], req)
+  await prisma.token.update({
+    where: {
+      token: tokenBody,
+    },
+    data: {
+      used: true,
+    },
+  })
 
-    return {
-        ...payload,
-        tokenDB
-    }
+  // await logging('Old token has been invalidated.', ['debug'], req)
+
+  return {
+    ...payload,
+    tokenDB,
+  }
 }
 
-export default getTokenDB
+export default getTokenDB

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

@@ -1,19 +1,19 @@
 import { NextApiRequest } from "next"
 
 async function getTokenFromBody<T>(payload: T & { req: NextApiRequest }) {
-    const { req } = payload
-    const token: string = req.body.token
+  const { req } = payload
+  const token: string = req.body.token
 
-    // Checking for cookie presens, because it is necessary
-    if (!token) {
-        return Promise.reject({
-            message: 'Unauthorized. No Access-Token.',
-            statusCode: 401,
-            solved: true,
-        })
-    }
+  // Checking for cookie presens, because it is necessary
+  if (!token) {
+    return Promise.reject({
+      message: "Unauthorized. No Access-Token.",
+      statusCode: 401,
+      solved: true,
+    })
+  }
 
-    return { ...payload, token }
+  return { ...payload, token }
 }
 
-export default getTokenFromBody
+export default getTokenFromBody

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

@@ -2,19 +2,19 @@ import { Token } from "@prisma/client"
 import { NextApiRequest } from "next"
 
 async function getTokenFromCookie<T>(payload: T & { req: NextApiRequest }) {
-    const { req } = payload
-    const token = req.cookies.token
+  const { req } = payload
+  const token = req.cookies.token
 
-    // Checking for cookie presens, because it is necessary
-    if (!token) {
-        return Promise.reject({
-            message: 'Unauthorized. No cookie.',
-            statusCode: 401,
-            solved: true,
-        })
-    }
+  // Checking for cookie presens, because it is necessary
+  if (!token) {
+    return Promise.reject({
+      message: "Unauthorized. No cookie.",
+      statusCode: 401,
+      solved: true,
+    })
+  }
 
-    return { ...payload, token, tokenType: 'REFRESH' as Token['type'] }
+  return { ...payload, token, tokenType: "REFRESH" as Token["type"] }
 }
 
-export default getTokenFromCookie
+export default getTokenFromCookie

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

@@ -1,15 +1,17 @@
 import { Token } from "@prisma/client"
 import { Logging } from "../logging"
 
-export default async function loginCheck<T>(payload: T & { loginCheck: boolean, tokenDB: Token, tokenType: 'REFRESH' }) {
-    const { loginCheck, tokenDB } = payload
-    // True login check response
-    if (loginCheck) {
-        return Promise.resolve({
-            message: 'loginCheck ' + loginCheck + ' of ' + tokenDB.id,
-            body: { loggedIn: true },
-            type: ['debug', 'info.cyan'] as Logging[]
-        })
-    }
-    return payload
-}
+export default async function loginCheck<T>(
+  payload: T & { loginCheck: boolean; tokenDB: Token; tokenType: "REFRESH" }
+) {
+  const { loginCheck, tokenDB } = payload
+  // True login check response
+  if (loginCheck) {
+    return Promise.resolve({
+      message: "loginCheck " + loginCheck + " of " + tokenDB.id,
+      body: { loggedIn: true },
+      type: ["debug", "info.cyan"] as Logging[],
+    })
+  }
+  return payload
+}

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

@@ -2,11 +2,11 @@ import { NextApiRequest, NextApiResponse } from "next"
 import logging from "../logging"
 
 export default function sendError<T>(
-    req: NextApiRequest,
-    res: NextApiResponse<T>,
-    err: any
+  req: NextApiRequest,
+  res: NextApiResponse<T>,
+  err: any
 ) {
-    // If something went wrong, let the client know with status 500
-    res.status(err.statusCode ?? 500).end()
-    logging(err.message, [err.type ?? (err.solved ? 'debug' : 'error')], req)
-}
+  // If something went wrong, let the client know with status 500
+  res.status(err.statusCode ?? 500).end()
+  logging(err.message, [err.type ?? (err.solved ? "debug" : "error")], req)
+}

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

@@ -2,21 +2,19 @@ import { NextApiRequest, NextApiResponse } from "next"
 import logging, { Logging } from "../logging"
 
 export interface Result<T> {
-    message: string,
-    statusCode?: number,
-    body?: T,
-    type?: Logging[],
+  message: string
+  statusCode?: number
+  body?: T
+  type?: Logging[]
 }
 
 export default function sendResponse<T>(payload: {
-    req: NextApiRequest,
-    res: NextApiResponse<T>,
-    result: Result<T>
+  req: NextApiRequest
+  res: NextApiResponse<T>
+  result: Result<T>
 }) {
-    const { req, res, result } = payload
-    res.status(result.statusCode ?? 200)
-    result.body ?
-        res.json(result.body) :
-        res.end()
-    logging(result.message, result.type ?? ['debug'], req)
+  const { req, res, result } = payload
+  res.status(result.statusCode ?? 200)
+  result.body ? res.json(result.body) : res.end()
+  logging(result.message, result.type ?? ["debug"], req)
 }

leaky-ships/lib/backend/jwtVerifyCatch.ts

@@ -1,21 +1,36 @@
 import { Token } from "@prisma/client"
 
 export default async function jwtVerifyCatch(
-    tokenType: Token['type'],
-    err: Error
+  tokenType: Token["type"],
+  err: Error
 ) {
-    switch (err.message) {
-        case 'jwt expired':
-            return { message: `JWT (${tokenType}) expired!`, statusCode: 403, solved: true, type: 'warn' }
+  switch (err.message) {
+    case "jwt expired":
+      return {
+        message: `JWT (${tokenType}) expired!`,
+        statusCode: 403,
+        solved: true,
+        type: "warn",
+      }
 
-        case 'invalid signature':
-            return { message: `Invalid JWT (${tokenType}) signature! Token: `, statusCode: 401, solved: true, type: 'error' }
+    case "invalid signature":
+      return {
+        message: `Invalid JWT (${tokenType}) signature! Token: `,
+        statusCode: 401,
+        solved: true,
+        type: "error",
+      }
 
-        case 'jwt must be provided':
-            return { message: `No JWT (${tokenType}) given.`, statusCode: 401, solved: true, type: 'warn' }
+    case "jwt must be provided":
+      return {
+        message: `No JWT (${tokenType}) given.`,
+        statusCode: 401,
+        solved: true,
+        type: "warn",
+      }
 
-        default:
-            console.log(err)
-            return { message: `Unknown error on 'JWT.verify()'.`, solved: false }
-    }
-}
+    default:
+      console.log(err)
+      return { message: `Unknown error on 'JWT.verify()'.`, solved: false }
+  }
+}

leaky-ships/lib/backend/logging.ts

@@ -1,17 +1,17 @@
-import fs from 'fs'
-import colors, { Color } from 'colors'
-import { NextApiRequest } from 'next'
-import { IncomingMessage } from 'http'
+import fs from "fs"
+import colors, { Color } from "colors"
+import { NextApiRequest } from "next"
+import { IncomingMessage } from "http"
 colors.enable()
 
 const loggingTemplates: { [key: string]: LoggingType } = {
-    'system': ['SYSTEM', 'green'],
-    'info.green': ['INFO', 'green'],
-    'info.cyan': ['INFO', 'cyan'],
-    'debug': ['Debug', 'grey'],
-    'post': ['Post', 'white'],
-    'warn': ['WARN', 'yellow'],
-    'error': ['ERROR', 'red']
+  system: ["SYSTEM", "green"],
+  "info.green": ["INFO", "green"],
+  "info.cyan": ["INFO", "cyan"],
+  debug: ["Debug", "grey"],
+  post: ["Post", "white"],
+  warn: ["WARN", "yellow"],
+  error: ["ERROR", "red"],
 }
 
 type LoggingType = [string, keyof Color]
@@ -20,32 +20,40 @@ export type Logging = keyof typeof loggingTemplates | LoggingType
 let started: boolean = false
 
 async function logStartup() {
-    await fs.promises.stat('log').catch(async () => {
-        await fs.promises.mkdir('log')
-        await logging(`Created 'log' Folder.`, ['info.cyan', 'system'])
-    })
-    started = true
+  await fs.promises.stat("log").catch(async () => {
+    await fs.promises.mkdir("log")
+    await logging(`Created 'log' Folder.`, ["info.cyan", "system"])
+  })
+  started = true
 }
 
-async function logging(message: string, types: Logging[], req?: NextApiRequest | IncomingMessage) {
-    if (!started)
-        await logStartup()
-    const messages = { console: message, file: message }
-    types.slice().reverse().forEach(async (type) => {
-        const [name, color] = typeof type === 'object' ? type : loggingTemplates[type]
-        messages.console = `[${name}] `[color] + messages.console
-        messages.file = `[${name}] ` + messages.file
+async function logging(
+  message: string,
+  types: Logging[],
+  req?: NextApiRequest | IncomingMessage
+) {
+  if (!started) await logStartup()
+  const messages = { console: message, file: message }
+  types
+    .slice()
+    .reverse()
+    .forEach(async (type) => {
+      const [name, color] =
+        typeof type === "object" ? type : loggingTemplates[type]
+      messages.console = `[${name}] `[color] + messages.console
+      messages.file = `[${name}] ` + messages.file
     })
-    messages.console = `[${new Date().toString().slice(0, 33)}] ` + messages.console
-    messages.file = `[${new Date().toString().slice(0, 33)}] ` + messages.file
-    if (req) {
-        const forwardedFor: any = req.headers['x-forwarded-for']
-        const ip = (forwardedFor || '127.0.0.1, 192.168.178.1').split(',')
-        messages.console = ip[0].yellow + ' - ' + messages.console
-        messages.file = ip[0] + ' - ' + messages.file
-    }
-    await fs.promises.appendFile('log/log.txt', messages.file + '\n')
-    console.log(messages.console)
+  messages.console =
+    `[${new Date().toString().slice(0, 33)}] ` + messages.console
+  messages.file = `[${new Date().toString().slice(0, 33)}] ` + messages.file
+  if (req) {
+    const forwardedFor: any = req.headers["x-forwarded-for"]
+    const ip = (forwardedFor || "127.0.0.1, 192.168.178.1").split(",")
+    messages.console = ip[0].yellow + " - " + messages.console
+    messages.file = ip[0] + " - " + messages.file
+  }
+  await fs.promises.appendFile("log/log.txt", messages.file + "\n")
+  console.log(messages.console)
 }
 
-export default logging
+export default logging