Merge pull request #46 from NIAEFEUP/fix/post-early-bird-launch-fixes

fix: post early bird launch fixes

website/app/controllers/profiles_controller.ts

@@ -30,7 +30,6 @@ export default class ProfilesController {
 
     const profile = await createProfileValidator.validate(data)
 
-    console.log(profile)
     const profileAdd = new ParticipantProfile()
     profileAdd.fill(profile)
 

website/app/middleware/log_user_middleware.ts

@@ -0,0 +1,17 @@
+import type { HttpContext } from '@adonisjs/core/http'
+import { Logger } from '@adonisjs/core/logger'
+import type { NextFn } from '@adonisjs/core/types/http'
+
+export default class LogUserMiddleware {
+  async handle(ctx: HttpContext, next: NextFn) {
+    await ctx.auth.check()
+    const user = ctx.auth.user
+
+    if (user) {
+      ctx.logger = ctx.logger.child({ user_id: user.id })
+      ctx.containerResolver.bindValue(Logger, ctx.logger)
+    }
+
+    return next()
+  }
+}

website/app/middleware/update_logger_storage_middleware.ts

@@ -0,0 +1,9 @@
+import { loggerStorage } from '#lib/adonisjs/logger.js'
+import type { HttpContext } from '@adonisjs/core/http'
+import type { NextFn } from '@adonisjs/core/types/http'
+
+export default class SetupLoggerStorageMiddleware {
+  async handle(ctx: HttpContext, next: NextFn) {
+    return loggerStorage.run(ctx.logger, next)
+  }
+}

website/app/services/user_service.ts

@@ -5,13 +5,17 @@ import SendForgotPasswordEmail from '#listeners/send_forgot_password_email'
 import SendVerificationEmail from '#listeners/send_verification_email'
 import User from '#models/user'
 import db from '@adonisjs/lucid/services/db'
-import logger from '@adonisjs/core/services/logger'
 import { DateTime } from 'luxon'
-import app from '@adonisjs/core/services/app'
 import Account from '#models/account'
 import { errors } from '@adonisjs/auth'
+import app from '@adonisjs/core/services/app'
+import { inject } from '@adonisjs/core'
+import { Logger } from '@adonisjs/core/logger'
 
+@inject()
 export class UserService {
+  constructor(private logger: Logger) {}
+
   async getUserWithCredentials(email: string, password: string) {
     try {
       const account = await Account.verifyCredentials(`credentials:${email}`, password)
@@ -44,7 +48,7 @@ export class UserService {
   async sendVerificationEmail(user: User) {
     const listener = await app.container.make(SendVerificationEmail)
     listener.handle(new UserCreated(user))
-      .catch((error) => logger.error(error))
+      .catch((error) => this.logger.error(error))
   }
 
   async verifyEmail(email: string) {

website/config/logger.ts

@@ -14,10 +14,15 @@ const loggerConfig = defineConfig({
       enabled: true,
       name: env.get('APP_NAME'),
       level: env.get('LOG_LEVEL'),
+
+      formatters: {
+        level: (label) => ({ level: label }),
+      },
+
       transport: {
-        targets: targets()
+        pipeline: targets()
           .pushIf(!app.inProduction, targets.pretty())
-          .pushIf(app.inProduction, targets.file({ destination: 1 }))
+          .pushIf(!app.inProduction, targets.file({ destination: 1 }))
           .toArray(),
       },
     },

website/database/migrations/1739145873655_alter_participant_profiles_table.ts

@@ -0,0 +1,17 @@
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = 'participant_profiles'
+
+  async up() {
+    this.schema.alterTable(this.tableName, (table) => {
+      table.dropUnique(['phone'])
+    })
+  }
+
+  async down() {
+    this.schema.alterTable(this.tableName, (table) => {
+      table.unique(['phone'])
+    })
+  }
+}

website/lib/adonisjs/events.ts

@@ -1,13 +1,13 @@
 import { BaseEvent as $BaseEvent } from '@adonisjs/core/events'
-import logger from '@adonisjs/core/services/logger'
+import { logger } from './logger.js'
 
 export class BaseEvent extends $BaseEvent {
   static async tryDispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>) {
     try {
       await this.dispatch(...args)
       return [true, undefined] as const
     } catch (error) {
-      logger.error(error)
+      logger().error(error)
       return [false, error] as const
     }
   }

website/lib/adonisjs/logger.ts

@@ -0,0 +1,9 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import $logger from '@adonisjs/core/services/logger'
+import { Logger } from '@adonisjs/core/logger'
+
+export const loggerStorage = new AsyncLocalStorage<Logger>()
+
+export function logger() {
+    return loggerStorage.getStore() || $logger
+}

website/start/events.ts

@@ -1,5 +1,5 @@
 import UserCreated from '#events/user_created'
-import UserEmailVerified from '#events/user_email_verified'
+// import UserEmailVerified from '#events/user_email_verified'
 import UserRequestedVerificationEmail from '#events/user_requested_verification_email'
 import emitter from '@adonisjs/core/services/emitter'
 
@@ -8,4 +8,4 @@ const SendVerificationEmail = () => import('#listeners/send_verification_email')
 emitter.on(UserCreated, [SendVerificationEmail, 'handle'])
 emitter.on(UserRequestedVerificationEmail, [SendVerificationEmail, 'handle'])
 
-emitter.on(UserEmailVerified, (ev) => console.log(ev))
+// emitter.on(UserEmailVerified, (ev) => console.log(ev))

website/start/kernel.ts

@@ -35,11 +35,14 @@ server.use([
  * requests with a registered route.
  */
 router.use([
+  () => import('#middleware/update_logger_storage_middleware'),
   () => import('@adonisjs/core/bodyparser_middleware'),
   () => import('@adonisjs/session/session_middleware'),
   () => import('@adonisjs/shield/shield_middleware'),
   () => import('@adonisjs/auth/initialize_auth_middleware'),
   () => import('#middleware/auth/logout_if_authentication_disabled_middleware'),
+  () => import('#middleware/log_user_middleware'),
+  () => import('#middleware/update_logger_storage_middleware')
 ])
 
 /**

website/start/routes.ts

@@ -33,15 +33,15 @@ router
       .group(() => {
         router.post('/logout', [AuthenticationController, 'logout']).as('actions:auth.logout')
 
-        router.group(() => {
-          router.on('/verify').renderInertia('auth/verify').as('pages:auth.verify')
-          router
-            .post('/verify/new', [AuthenticationController, 'retryEmailVerification'])
-            .as('actions:auth.verify.send')
-            .use(emailVerificationThrottle)
-        })
-        .use(middleware.noVerifiedEmail())
-
+        router
+          .group(() => {
+            router.on('/verify').renderInertia('auth/verify').as('pages:auth.verify')
+            router
+              .post('/verify/new', [AuthenticationController, 'retryEmailVerification'])
+              .as('actions:auth.verify.send')
+              .use(emailVerificationThrottle)
+          })
+          .use(middleware.noVerifiedEmail())
       })
       .use(middleware.auth())
 
@@ -135,16 +135,18 @@ router
 router
   .group(() => {
     router.get('/', [TicketsController, 'index']).as('pages:tickets')
-    router.get('/:id/checkout', [TicketsController, 'showPayment']).as('checkout')
+    router
+      .get('/:id/checkout', [TicketsController, 'showPayment'])
+      .as('checkout')
+      .use([middleware.auth(), middleware.verifiedEmail(), middleware.participant()])
   })
   .prefix('/tickets')
-  .use([middleware.auth(), middleware.participant(), middleware.verifiedEmail()])
 
 router
   .group(() => {
     //router.get('/', [OrdersController, 'index']) acho que isto já nao e usado
-    router.post('/mbway', [OrdersController, 'createMBWay']).use(middleware.auth())
-    router.get('/:id', [OrdersController, 'show']).as('payment.show').use(middleware.auth())
+    router.post('/mbway', [OrdersController, 'createMBWay'])
+    router.get('/:id', [OrdersController, 'show']).as('payment.show')
   })
-  .middleware(middleware.requireAuthenticationEnabled())
+  .use([middleware.auth(), middleware.verifiedEmail(), middleware.participant()])
   .prefix('payment')