Improve logging and handle errors beter

src/pages/api/env.ts

@@ -1,11 +1,51 @@
 import { NextApiRequest, NextApiResponse } from "next";
+import logger from "@/utils/logger";
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === "GET") {
-    const EVE_SSO_CALLBACK_URL = process.env.EVE_SSO_CALLBACK_URL;
-    const EVE_SSO_CLIENT_ID = process.env.EVE_SSO_CLIENT_ID;
-    res.json({ EVE_SSO_CLIENT_ID, EVE_SSO_CALLBACK_URL });
+    logger.info({ 
+      event: 'env_request_start'
+    });
+
+    try {
+      const EVE_SSO_CALLBACK_URL = process.env.EVE_SSO_CALLBACK_URL;
+      const EVE_SSO_CLIENT_ID = process.env.EVE_SSO_CLIENT_ID;
+
+      if (!EVE_SSO_CALLBACK_URL || !EVE_SSO_CLIENT_ID) {
+        logger.error({ 
+          event: 'env_request_failed',
+          reason: 'missing_env_vars',
+          vars: {
+            hasCallbackUrl: !!EVE_SSO_CALLBACK_URL,
+            hasClientId: !!EVE_SSO_CLIENT_ID
+          }
+        });
+        return res.status(500).json({ error: 'Missing required environment variables' });
+      }
+
+      logger.info({ 
+        event: 'env_request_success',
+        vars: {
+          hasCallbackUrl: true,
+          hasClientId: true
+        }
+      });
+
+      return res.json({ EVE_SSO_CLIENT_ID, EVE_SSO_CALLBACK_URL });
+    } catch (e) {
+      logger.error({ 
+        event: 'env_request_failed',
+        reason: 'unexpected_error',
+        error: e
+      });
+      return res.status(500).json({ error: 'Internal server error' });
+    }
   } else {
+    logger.warn({ 
+      event: 'invalid_method',
+      method: req.method,
+      path: req.url
+    });
     res.status(404).end();
   }
 };

src/pages/api/praisal.ts

@@ -1,19 +1,45 @@
 import { getPraisal } from "@/eve-praisal";
 import { NextApiRequest, NextApiResponse } from "next";
+import logger from "@/utils/logger";
 
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === "POST") {
-    const praisalRequest: { quantity: number; type_id: number }[] = JSON.parse(
-      req.body
-    );
+    logger.info({ 
+      event: 'praisal_request_start'
+    });
+
     try {
+      const praisalRequest: { quantity: number; type_id: number }[] = JSON.parse(
+        req.body
+      );
+
+      logger.info({ 
+        event: 'praisal_request_parsed',
+        items: praisalRequest.length
+      });
+
       const praisal = await getPraisal(praisalRequest);
+
+      logger.info({ 
+        event: 'praisal_request_success',
+        items: praisalRequest.length
+      });
+
       return res.json(praisal);
     } catch (e) {
-      console.log(e);
-      res.status(404).end();
+      logger.error({ 
+        event: 'praisal_request_failed',
+        error: e,
+        body: req.body
+      });
+      return res.status(500).json({ error: 'Failed to get praisal' });
     }
   } else {
+    logger.warn({ 
+      event: 'invalid_method',
+      method: req.method,
+      path: req.url
+    });
     res.status(404).end();
   }
 };

src/pages/api/refresh.ts

@@ -1,7 +1,8 @@
 import { AccessToken } from "@/types";
-import { extractCharacterFromToken } from "@/utils";
+import { extractCharacterFromToken } from "@/utils/utils";
 import { NextApiRequest, NextApiResponse } from "next";
 import crypto from "crypto-js";
+import logger from "@/utils/logger";
 
 const EVE_SSO_TOKEN_URL = "https://login.eveonline.com/v2/oauth/token";
 const EVE_SSO_CLIENT_ID = process.env.EVE_SSO_CLIENT_ID ?? "";
@@ -10,6 +11,14 @@ const EVE_SSO_SECRET = process.env.EVE_SSO_SECRET ?? "";
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === "POST") {
     const accessToken: AccessToken = req.body;
+    logger.info({ 
+      event: 'token_refresh_start',
+      character: {
+        name: accessToken.character.name,
+        characterId: accessToken.character.characterId
+      }
+    });
+
     const params = new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: crypto.AES.decrypt(
@@ -33,7 +42,20 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
         body: params,
         headers,
       }).then((res) => res.json());
+
       const character = extractCharacterFromToken(response);
+      if (!character) {
+        logger.error({ 
+          event: 'token_refresh_failed',
+          reason: 'character_extraction_failed',
+          character: {
+            name: accessToken.character.name,
+            characterId: accessToken.character.characterId
+          }
+        });
+        return res.json({ ...accessToken, needsLogin: true });
+      }
+
       const token: AccessToken = {
         access_token: response.access_token,
         token_type: response.token_type,
@@ -51,12 +73,26 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
         planetConfig: accessToken.planetConfig ?? [],
       };
 
-      console.log("Refresh", character.name, character.characterId);
+      logger.info({ 
+        event: 'token_refresh_success',
+        character: {
+          name: character.name,
+          characterId: character.characterId
+        }
+      });
 
       return res.json(token);
     } catch (e) {
-      console.log(e);
-      res.json({ ...accessToken, needsLogin: true });
+      logger.error({ 
+        event: 'token_refresh_failed',
+        reason: 'api_error',
+        error: e,
+        character: {
+          name: accessToken.character.name,
+          characterId: accessToken.character.characterId
+        }
+      });
+      return res.json({ ...accessToken, needsLogin: true });
     }
   } else {
     res.status(404).end();

src/pages/api/revoke.ts

@@ -1,6 +1,7 @@
 import { AccessToken } from "@/types";
 import { NextApiRequest, NextApiResponse } from "next";
 import crypto from "crypto-js";
+import logger from "@/utils/logger";
 
 const EVE_SSO_REVOKE_URL = "https://login.eveonline.com/v2/oauth/revoke";
 const EVE_SSO_CLIENT_ID = process.env.EVE_SSO_CLIENT_ID ?? "";
@@ -9,6 +10,14 @@ const EVE_SSO_SECRET = process.env.EVE_SSO_SECRET ?? "";
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === "POST") {
     const accessToken: AccessToken = req.body;
+    logger.info({ 
+      event: 'token_revoke_start',
+      character: {
+        name: accessToken.character.name,
+        characterId: accessToken.character.characterId
+      }
+    });
+
     const params = new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: crypto.AES.decrypt(
@@ -27,24 +36,42 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
     };
 
     try {
-      await fetch(EVE_SSO_REVOKE_URL, {
+      const response = await fetch(EVE_SSO_REVOKE_URL, {
         method: "POST",
         body: params,
         headers,
-      }).then((res) => res.json());
+      });
 
-      console.log(
-        "Revoke",
-        accessToken.character.name,
-        accessToken.character.characterId
-      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      logger.info({ 
+        event: 'token_revoke_success',
+        character: {
+          name: accessToken.character.name,
+          characterId: accessToken.character.characterId
+        }
+      });
 
       return res.end();
     } catch (e) {
-      console.log(e);
+      logger.error({ 
+        event: 'token_revoke_failed',
+        error: e,
+        character: {
+          name: accessToken.character.name,
+          characterId: accessToken.character.characterId
+        }
+      });
       return res.status(500).end();
     }
   } else {
+    logger.warn({ 
+      event: 'invalid_method',
+      method: req.method,
+      path: req.url
+    });
     res.status(404).end();
   }
 };

src/pages/api/token.ts

@@ -1,7 +1,8 @@
 import { AccessToken } from "@/types";
-import { extractCharacterFromToken } from "@/utils";
+import { extractCharacterFromToken } from "@/utils/utils";
 import { NextApiRequest, NextApiResponse } from "next";
 import crypto from "crypto-js";
+import logger from "@/utils/logger";
 
 const EVE_SSO_TOKEN_URL = "https://login.eveonline.com/v2/oauth/token";
 const EVE_SSO_CLIENT_ID = process.env.EVE_SSO_CLIENT_ID ?? "";
@@ -10,7 +11,19 @@ const EVE_SSO_SECRET = process.env.EVE_SSO_SECRET ?? "";
 const handler = async (req: NextApiRequest, res: NextApiResponse) => {
   if (req.method === "GET") {
     const code = req.query.code as string;
-    if (!code || code === undefined) return res.status(404).end();
+    if (!code || code === undefined) {
+      logger.warn({ 
+        event: 'token_request_failed',
+        reason: 'missing_code',
+        query: req.query
+      });
+      return res.status(404).end();
+    }
+
+    logger.info({ 
+      event: 'token_request_start',
+      code: code
+    });
 
     const params = new URLSearchParams({
       grant_type: "authorization_code",
@@ -26,34 +39,69 @@ const handler = async (req: NextApiRequest, res: NextApiResponse) => {
       "User-Agent": "https://github.com/calli-eve/eve-pi",
     };
 
-    const response = await fetch(EVE_SSO_TOKEN_URL, {
-      method: "POST",
-      body: params,
-      headers,
-    }).then((res) => res.json());
+    try {
+      const response = await fetch(EVE_SSO_TOKEN_URL, {
+        method: "POST",
+        body: params,
+        headers,
+      });
 
-    const character = extractCharacterFromToken(response);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
 
-    console.log("Login", character.name, character.characterId);
+      const data = await response.json();
+      const character = extractCharacterFromToken(data);
 
-    const token: AccessToken = {
-      access_token: response.access_token,
-      token_type: response.token_type,
-      refresh_token: crypto.AES.encrypt(
-        response.refresh_token,
-        EVE_SSO_SECRET,
-      ).toString(),
-      expires_at: Date.now() + response.expires_in * 1000,
-      character,
-      needsLogin: false,
-      account: "-",
-      comment: "",
-      system: "",
-      planets: [],
-      planetConfig: [],
-    };
-    res.json(token);
+      if (!character) {
+        logger.error({ 
+          event: 'token_request_failed',
+          reason: 'character_extraction_failed',
+          data
+        });
+        return res.status(500).end();
+      }
+
+      logger.info({ 
+        event: 'token_request_success',
+        character: {
+          name: character.name,
+          characterId: character.characterId
+        }
+      });
+
+      const token: AccessToken = {
+        access_token: data.access_token,
+        token_type: data.token_type,
+        refresh_token: crypto.AES.encrypt(
+          data.refresh_token,
+          EVE_SSO_SECRET,
+        ).toString(),
+        expires_at: Date.now() + data.expires_in * 1000,
+        character,
+        needsLogin: false,
+        account: "-",
+        comment: "",
+        system: "",
+        planets: [],
+        planetConfig: [],
+      };
+      return res.json(token);
+    } catch (e) {
+      logger.error({ 
+        event: 'token_request_failed',
+        reason: 'api_error',
+        error: e,
+        code: code
+      });
+      return res.status(500).end();
+    }
   } else {
+    logger.warn({ 
+      event: 'invalid_method',
+      method: req.method,
+      path: req.url
+    });
     res.status(404).end();
   }
 };

src/utils.ts

@@ -1,13 +0,0 @@
-import { AccessToken, Character } from "./types";
-
-export const extractCharacterFromToken = (token: AccessToken): Character => {
-  const decodedToken = parseJwt(token.access_token);
-  return {
-    name: decodedToken.name,
-    characterId: decodedToken.sub.split(":")[2],
-  };
-};
-
-const parseJwt = (token: string) => {
-  return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
-};

src/utils/logger.ts

@@ -0,0 +1,18 @@
+import pino from 'pino';
+
+const logger = pino({
+  level: process.env.LOG_LEVEL || 'info',
+  transport: {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      translateTime: 'SYS:standard',
+      ignore: 'pid,hostname',
+    },
+  },
+  base: {
+    env: process.env.NODE_ENV,
+  },
+});
+
+export default logger; 

src/utils/utils.ts

@@ -0,0 +1,22 @@
+import { AccessToken, Character } from "../types";
+
+export const extractCharacterFromToken = (token: AccessToken): Character | null => {
+  const decodedToken = parseJwt(token.access_token);
+  if (!decodedToken || !decodedToken.name || !decodedToken.sub) {
+    return null;
+  }
+  return {
+    name: decodedToken.name,
+    characterId: decodedToken.sub.split(":")[2],
+  };
+};
+
+const parseJwt = (token: string | undefined) => {
+  if (!token) return null;
+  try {
+    return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+  } catch (error) {
+    console.error('Failed to parse JWT token:', error);
+    return null;
+  }
+};