fix: remove logger util

Author: imrim12

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thecodeorigin/nuxt",
   "type": "module",
-  "version": "2.7.6",
+  "version": "2.7.7",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"

server/api/firebase.post.ts

@@ -47,7 +47,7 @@ export default defineEventHandler(async (event) => {
     }
   }
   catch (error: any) {
-    logger.error('[Firebase API] Error sending notification:', error)
+    console.error('[Firebase API] Error sending notification:', error)
 
     throw parseError(error)
   }

server/api/payments/payos/webhook.post.ts

@@ -4,38 +4,38 @@ export default defineEventHandler(async (event) => {
   try {
     const body = await readBody(event)
 
-    logger.log('[PayOS Webhook] Received webhook data:', body)
+    console.log('[PayOS Webhook] Received webhook data:', body)
 
     const webhookData = getPayOSAdmin().verifyPaymentWebhookData(body)
 
     if (!webhookData) {
-      logger.error('[PayOS Webhook] Invalid webhook data received:', body)
+      console.error('[PayOS Webhook] Invalid webhook data received:', body)
       throw createError({
         statusCode: 400,
         message: ErrorMessage.INVALID_WEBHOOK_BODY,
         data: body,
       })
     }
 
-    logger.log('[PayOS Webhook] Verified webhook data:', webhookData)
+    console.log('[PayOS Webhook] Verified webhook data:', webhookData)
     const transactionStatus = webhookData.code === '00' ? PaymentStatus.RESOLVED : PaymentStatus.FAILED
 
     const { updatePaymentStatus, updateProviderTransactionStatus, getProviderTransactionByOrderCode } = usePayment()
 
     const paymentTransactionOfProvider = await getProviderTransactionByOrderCode(String(webhookData.orderCode))
 
     if (!paymentTransactionOfProvider?.payment.order.package) {
-      logger.warn(`[PayOS Webhook] Transaction not found or invalid: orderCode=${webhookData.orderCode}`)
+      console.warn(`[PayOS Webhook] Transaction not found or invalid: orderCode=${webhookData.orderCode}`)
       return { success: true }
     }
 
-    logger.log(`[PayOS Webhook] Processing transaction: orderCode=${webhookData.orderCode}, status=${transactionStatus}`)
+    console.log(`[PayOS Webhook] Processing transaction: orderCode=${webhookData.orderCode}, status=${transactionStatus}`)
 
     const priceDiscount = Number(paymentTransactionOfProvider.payment.order.package.price_discount)
     const price = Number(paymentTransactionOfProvider.payment.order.package.price)
 
     if (priceDiscount !== Number(webhookData.amount) && price !== Number(webhookData.amount)) {
-      logger.error(`[PayOS Webhook] Amount mismatch, transaction [${paymentTransactionOfProvider.id}]: expected=${price}, received=${webhookData.amount}`)
+      console.error(`[PayOS Webhook] Amount mismatch, transaction [${paymentTransactionOfProvider.id}]: expected=${price}, received=${webhookData.amount}`)
 
       throw createError({
         statusCode: 400,
@@ -48,33 +48,33 @@ export default defineEventHandler(async (event) => {
 
     // The userId is already the UUID from our database since we've updated
     // our schemas to use UUID references between tables
-    logger.log(`[PayOS Webhook] Adding credits: userId=${userId}, amount=${creditAmount}`)
+    console.log(`[PayOS Webhook] Adding credits: userId=${userId}, amount=${creditAmount}`)
 
     await addCreditToUser(userId, creditAmount)
 
-    logger.log(`[PayOS Webhook] Credits added successfully: userId=${userId}, amount=${creditAmount}`)
+    console.log(`[PayOS Webhook] Credits added successfully: userId=${userId}, amount=${creditAmount}`)
 
     if (!paymentTransactionOfProvider?.payment.order.package) {
-      logger.error(`[PayOS Webhook] No product found for transaction: ${webhookData.orderCode}`)
+      console.error(`[PayOS Webhook] No product found for transaction: ${webhookData.orderCode}`)
       throw createError({
         statusCode: 400,
         message: 'No product found for this transaction!',
       })
     }
 
-    logger.log(`[PayOS Webhook] Updating transaction ${paymentTransactionOfProvider.id} to status: ${transactionStatus}`)
+    console.log(`[PayOS Webhook] Updating transaction ${paymentTransactionOfProvider.id} to status: ${transactionStatus}`)
 
     await updateProviderTransactionStatus(paymentTransactionOfProvider.id, transactionStatus, webhookData.transactionDateTime)
 
     await updatePaymentStatus(paymentTransactionOfProvider.payment.id, transactionStatus)
 
-    logger.log(`[PayOS Webhook] Transaction updated successfully: id=${paymentTransactionOfProvider.id}, status=${transactionStatus}`)
+    console.log(`[PayOS Webhook] Transaction updated successfully: id=${paymentTransactionOfProvider.id}, status=${transactionStatus}`)
 
-    logger.log('[PayOS Webhook] Webhook processing completed successfully')
+    console.log('[PayOS Webhook] Webhook processing completed successfully')
     return { success: true }
   }
   catch (error: any) {
-    logger.error('[PayOS Webhook] Error processing webhook:', error)
+    console.error('[PayOS Webhook] Error processing webhook:', error)
 
     throw parseError(error)
   }

server/api/payments/sepay/webhook.post.ts

@@ -22,14 +22,14 @@ export default defineEventHandler(async (event) => {
     )
 
     if (process.env.SEPAY_WEBHOOK_SIGNING_KEY !== getHeader(event, 'Authorization')?.match(/Apikey (.*)/)?.[1]) {
-      logger.error('[SePay Webhook] Invalid webhook authentication')
+      console.error('[SePay Webhook] Invalid webhook authentication')
       throw createError({
         statusCode: 401,
         message: 'Invalid webhook authentication',
       })
     }
 
-    logger.log('[SePay Webhook] Verified webhook data:', body)
+    console.log('[SePay Webhook] Verified webhook data:', body)
 
     // SePay Webhook always success (if not, it will not call this endpoint anyway)
 
@@ -41,11 +41,11 @@ export default defineEventHandler(async (event) => {
     const paymentTransactionOfProvider = await getProviderTransactionByOrderCode(String(orderCode))
 
     if (!paymentTransactionOfProvider?.payment.order.package) {
-      logger.warn(`[SePay Webhook] Transaction not found or invalid: code=${orderCode}`)
+      console.warn(`[SePay Webhook] Transaction not found or invalid: code=${orderCode}`)
       return { success: true }
     }
 
-    logger.log(`[SePay Webhook] Processing transaction: code=${orderCode}, status=${transactionStatus}`)
+    console.log(`[SePay Webhook] Processing transaction: code=${orderCode}, status=${transactionStatus}`)
 
     const userId = paymentTransactionOfProvider.payment.order.user_id
 
@@ -61,7 +61,7 @@ export default defineEventHandler(async (event) => {
     )
 
     if (price !== Number(body.transferAmount)) {
-      logger.error(`[SePay Webhook] Amount mismatch, transaction [${paymentTransactionOfProvider.id}]: expected=${price}, received=${body.transferAmount}`)
+      console.error(`[SePay Webhook] Amount mismatch, transaction [${paymentTransactionOfProvider.id}]: expected=${price}, received=${body.transferAmount}`)
 
       throw createError({
         statusCode: 400,
@@ -73,21 +73,21 @@ export default defineEventHandler(async (event) => {
 
     // The userId is already the UUID from our database since we've updated
     // our schemas to use UUID references between tables
-    logger.log(`[SePay Webhook] Adding credits: userId=${userId}, amount=${creditAmount}`)
+    console.log(`[SePay Webhook] Adding credits: userId=${userId}, amount=${creditAmount}`)
 
     await addCreditToUser(userId, creditAmount)
 
-    logger.log(`[SePay Webhook] Credits added successfully: userId=${userId}, amount=${creditAmount}`)
+    console.log(`[SePay Webhook] Credits added successfully: userId=${userId}, amount=${creditAmount}`)
 
     if (!paymentTransactionOfProvider?.payment.order.package) {
-      logger.error(`[SePay Webhook] No product found for transaction: ${orderCode}`)
+      console.error(`[SePay Webhook] No product found for transaction: ${orderCode}`)
       throw createError({
         statusCode: 400,
         message: 'No product found for this transaction!',
       })
     }
 
-    logger.log(`[SePay Webhook] Updating transaction ${paymentTransactionOfProvider.id} to status: ${transactionStatus}`)
+    console.log(`[SePay Webhook] Updating transaction ${paymentTransactionOfProvider.id} to status: ${transactionStatus}`)
 
     await updateProviderTransactionStatus(paymentTransactionOfProvider.id, transactionStatus, body.transactionDate!)
 
@@ -103,13 +103,13 @@ export default defineEventHandler(async (event) => {
       )
     }
 
-    logger.log(`[SePay Webhook] Transaction updated successfully: id=${paymentTransactionOfProvider.id}, status=${transactionStatus}`)
+    console.log(`[SePay Webhook] Transaction updated successfully: id=${paymentTransactionOfProvider.id}, status=${transactionStatus}`)
 
-    logger.log('[SePay Webhook] Webhook processing completed successfully')
+    console.log('[SePay Webhook] Webhook processing completed successfully')
     return { success: true }
   }
   catch (error: any) {
-    logger.error('[SePay Webhook] Error processing webhook:', error)
+    console.error('[SePay Webhook] Error processing webhook:', error)
 
     throw parseError(error)
   }

server/api/scopes.get.ts

@@ -5,7 +5,7 @@ export default defineEventHandler(async (event) => {
     return await getUserScopes()
   }
   catch (error: any) {
-    logger.error('[Scopes API] Error fetching scopes:', error)
+    console.error('[Scopes API] Error fetching scopes:', error)
 
     throw parseError(error)
   }