From 7584d2d7a7110aef0331ebfa178b2295842c59fa Mon Sep 17 00:00:00 2001
From: MCMXC <16797721+mcmxcdev@users.noreply.github.com>
Date: Sat, 10 Feb 2024 18:19:14 -0700
Subject: refactor: project maintenance

- work in progress
---
 app/Middleware/Auth.ts | 61 ++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 32 deletions(-)

(limited to 'app/Middleware/Auth.ts')

diff --git a/app/Middleware/Auth.ts b/app/Middleware/Auth.ts
index d0b212c..29620bb 100644
--- a/app/Middleware/Auth.ts
+++ b/app/Middleware/Auth.ts
@@ -1,9 +1,9 @@
-import { GuardsList } from '@ioc:Adonis/Addons/Auth';
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-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
@@ -27,9 +27,9 @@ export default class AuthMiddleware {
    * during the current request.
    */
   protected async authenticate(
-    auth: HttpContextContract['auth'],
+    auth: HttpContext['auth'],
     guards: (keyof GuardsList)[],
-    request: HttpContextContract['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,25 +56,22 @@ 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
       }
@@ -87,32 +84,32 @@ export default class AuthMiddleware {
       'Unauthorized access',
       'E_UNAUTHORIZED_ACCESS',
       guardLastAttempted,
-      this.redirectTo,
-    );
+      this.redirectTo
+    )
   }
 
   /**
    * Handle request
    */
   public async handle(
-    { request, auth, response }: HttpContextContract,
+    { 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()
   }
 }
-- 
cgit v1.2.3-54-g00ecf