updates

1 files changed, 30 insertions, 27 deletions

diff --git a/app/Middleware/Auth.ts b/app/Middleware/Auth.ts
index 29620bb..b6ff446 100644
--- a/app/Middleware/Auth.ts
+++ b/app/Middleware/Auth.ts
@@ -1,9 +1,9 @@
-import { GuardsList } from '@ioc:Adonis/Addons/Auth'
-import { HttpContext } from '@adonisjs/core/http'
-import { AuthenticationException } from '@adonisjs/auth/build/standalone'
-import * as jose from 'jose'
-import { appKey } from '#config/app'
-import User from '#app/Models/User'
+import { GuardsList } from '@ioc:Adonis/Addons/Auth';
+import { HttpContext } from '@adonisjs/core/http';
+import { AuthenticationException } from '@adonisjs/auth/build/standalone';
+import * as jose from 'jose';
+import { appKey } from '#config/app';
+import User from '#app/Models/User';
 
 /**
  * Auth middleware is meant to restrict un-authenticated access to a given route
@@ -16,7 +16,7 @@ export default class AuthMiddleware {
   /**
    * The URL to redirect to when request is Unauthorized
    */
-  protected redirectTo = '/user/login'
+  protected redirectTo = '/user/login';
 
   /**
    * Authenticates the current HTTP request against a custom set of defined
@@ -29,7 +29,7 @@ export default class AuthMiddleware {
   protected async authenticate(
     auth: HttpContext['auth'],
     guards: (keyof GuardsList)[],
-    request: HttpContext['request']
+    request: HttpContext['request'],
   ) {
     /**
      * Hold reference to the guard last attempted within the for loop. We pass
@@ -37,15 +37,15 @@ export default class AuthMiddleware {
      * it can decide the correct response behavior based upon the guard
      * driver
      */
-    let guardLastAttempted: string | undefined
+    let guardLastAttempted: string | undefined;
 
     for (const guard of guards) {
-      guardLastAttempted = guard
+      guardLastAttempted = guard;
 
-      let isLoggedIn = false
+      let isLoggedIn = false;
       try {
         // eslint-disable-next-line no-await-in-loop
-        isLoggedIn = await auth.use(guard).check()
+        isLoggedIn = await auth.use(guard).check();
       } catch {
         // Silent fail to allow the rest of the code to handle the error
       }
@@ -56,22 +56,25 @@ export default class AuthMiddleware {
          * the rest of the request, since the user authenticated
          * succeeded here
          */
-        auth.defaultGuard = guard
-        return
+        auth.defaultGuard = guard;
+        return;
       }
     }
 
     // Manually try authenticating using the JWT (verfiy signature required)
     // Legacy support for JWTs so that the client still works (older than 2.0.0)
-    const authToken = request.headers().authorization?.split(' ')[1]
+    const authToken = request.headers().authorization?.split(' ')[1];
     if (authToken) {
       try {
-        const jwt = await jose.jwtVerify(authToken, new TextEncoder().encode(appKey))
-        const { uid } = jwt.payload
+        const jwt = await jose.jwtVerify(
+          authToken,
+          new TextEncoder().encode(appKey),
+        );
+        const { uid } = jwt.payload;
 
         // @ts-expect-error
-        request.user = await User.findOrFail(uid)
-        return
+        request.user = await User.findOrFail(uid);
+        return;
       } catch {
         // Silent fail to allow the rest of the code to handle the error
       }
@@ -84,8 +87,8 @@ export default class AuthMiddleware {
       'Unauthorized access',
       'E_UNAUTHORIZED_ACCESS',
       guardLastAttempted,
-      this.redirectTo
-    )
+      this.redirectTo,
+    );
   }
 
   /**
@@ -94,22 +97,22 @@ export default class AuthMiddleware {
   public async handle(
     { request, auth, response }: HttpContext,
     next: () => Promise<void>,
-    customGuards: (keyof GuardsList)[]
+    customGuards: (keyof GuardsList)[],
   ) {
     /**
      * Uses the user defined guards or the default guard mentioned in
      * the config file
      */
-    const guards = customGuards.length > 0 ? customGuards : [auth.name]
+    const guards = customGuards.length > 0 ? customGuards : [auth.name];
     try {
-      await this.authenticate(auth, guards, request)
+      await this.authenticate(auth, guards, request);
     } catch (error) {
       // If the user is not authenticated and it is a web endpoint, redirect to the login page
       if (guards.includes('web')) {
-        return response.redirect(error.redirectTo)
+        return response.redirect(error.redirectTo);
       }
-      throw error
+      throw error;
     }
-    await next()
+    await next();
   }
 }