Added error handling in "lg" namespace and "create-game" command

src/commands/create-game.ts

@@ -23,13 +23,15 @@ export default new app.Command({
   ],
   async run(message) {
 
-    const author = message.client.user
     const lap_duration: number = message.args.lap_duration
     const max_players: number = message.args.max_players
 
-    const [game, player] = await app.createGame(author, max_players, lap_duration)
+    const result = await app.createGame(message, max_players, lap_duration)
 
-    return message.channel.send(`New game created (\`${game}\`) by player \`${player}\`, with the following parameters : \n Max number of players : ${max_players} \n Lap duration : ${lap_duration ? lap_duration : 120}s`)
-    // return message.channel.send(`New game created (\`${id}\`) with the following options : ${message.args.lap} mins and ${message.args.template}`)
+    if (result instanceof Error) return;
+
+    const [game, gameId, author] = result
+
+    return message.channel.send(`New game created (\`${gameId}\`) by player \`${author}\`, with the following parameters : \n Max number of players : ${max_players} \n Lap duration : ${lap_duration ? lap_duration : 120}s`)
   }
 })

src/namespaces/lg.ts

@@ -1,7 +1,7 @@
 import * as app from "#app"
 import ShortUniqueId from "short-unique-id"
-import gameTable from "#tables/game.ts"
-import lgUserTable from "#tables/lgUser.ts"
+import gameTable, { Game } from "#tables/game.ts"
+import lgUserTable, { LGUser } from "#tables/lgUser.ts"
 
 
 const createLogger = new app.Logger({ section: "create" })
@@ -12,7 +12,9 @@ export function genId(char: number): string {
     return id.rnd()
 }
 
-export async function findOrCreatePlayer(user: app.User): Promise<string> {
+export async function findOrCreatePlayer(message: app.Message): Promise<[LGUser[], string] | Error> {
+
+    const user = message.client.user
 
     const data = await lgUserTable.query.where('discordId', parseInt(user.id)).returning('*')
 
@@ -24,29 +26,32 @@ export async function findOrCreatePlayer(user: app.User): Promise<string> {
 
         app.log(`Player "${existing}" already exists in db`)
 
-        return existing
+        return [data, existing]
 
     }
 
     else {
 
         createLogger.log(`Creating player in db...`)
 
-        return createPlayer(user)
+        return createPlayer(message)
     }
 
 }
 
-export async function createPlayer(user: app.User): Promise<string> {
+export async function createPlayer(message: app.Message): Promise<[LGUser[], string] | Error> {
 
     try {
+
+        const user = message.client.user
+
         const data = await lgUserTable.query.insert({
             _id: genId(12),
             discordId: parseInt(user.id),
             username: user.username,
             created_at: Date.now()
         })
-            .returning('_id')
+            .returning('*')
             .onConflict("discordId")
             .merge(['discordId', 'games', 'created_at', 'friends', 'guild', 'hated', 'is_admin', 'level', 'nickname', 'username', 'wallet'])
             .returning('*')
@@ -57,28 +62,41 @@ export async function createPlayer(user: app.User): Promise<string> {
 
         createLogger.success(`Created new player : ${newPlayer}`)
 
-        return newPlayer
+        return [data, newPlayer]
     } catch (err: any) {
-        createLogger.error(`An error occured during the player insertion : `, err)
+        createLogger.error(`An error occured during the player insertion : ${err}`)
+
+        await message.reply(`An error occured during the player insertion : ${err}`)
 
-        return err
+        return err as Error
     }
 
 }
 
-export async function createGame(user: app.User, max_players: number, lap_duration?: number): Promise<[string, string]> {
+export async function createGame(message: app.Message, max_players: number, lap_duration?: number): Promise<[Game[], string, string] | Error> {
 
     try {
 
-        const author: string | void = await findOrCreatePlayer(user)
+        const author = await findOrCreatePlayer(message)
+
+        if (author instanceof Error) {
+
+            const err = author as Error
+
+            createLogger.error(`An error occured during the game insertion : ${err}`)
+
+            await message.reply(`An error occured during the game insertion : ${err}`)
+
+            return author
+        }
 
         const data = await gameTable.query.insert({
             _id: genId(12),
             gameId: genId(5),
             created_at: Date.now(),
             max_players: max_players,
             lap_duration: lap_duration ? lap_duration : 120,
-            players: { 1: author }
+            players: { 1: author[1] }
         }).returning('*')
 
         console.log(data)
@@ -87,11 +105,14 @@ export async function createGame(user: app.User, max_players: number, lap_durati
 
         createLogger.success(`Created new game : ${newGame}`)
 
-        return [newGame, author]
+        return [data, newGame, author[1]]
 
     } catch (err: any) {
 
-        createLogger.error(`An error occured during the game insertion : `, err)
-        return err
+        createLogger.error(`An error occured during the game insertion : ${err}`)
+
+        await message.reply(`An error occured during the game insertion : ${err}`)
+
+        return err as Error
     }
 }