4 files changed, 55 insertions, 49 deletions

diff --git a/app/Middleware/AllowGuestOnly.ts b/app/Middleware/AllowGuestOnly.ts
index 5ef5c34..75bf269 100644
--- a/app/Middleware/AllowGuestOnly.ts
+++ b/app/Middleware/AllowGuestOnly.ts
@@ -1,6 +1,6 @@
-import { GuardsList } from '@ioc:Adonis/Addons/Auth'
-import { HttpContext } from '@adonisjs/core/http'
-import { AuthenticationException } from '@adonisjs/auth/build/standalone'
+import { GuardsList } from '@ioc:Adonis/Addons/Auth';
+import { HttpContext } from '@adonisjs/core/http';
+import { AuthenticationException } from '@adonisjs/auth/build/standalone';
 
 /**
  * This is actually a reverted a reverted auth middleware available in ./Auth.ts
@@ -10,24 +10,27 @@ export default class GuestMiddleware {
   /**
    * The URL to redirect to when request is authorized
    */
-  protected redirectTo = '/dashboard'
+  protected redirectTo = '/dashboard';
 
-  protected async authenticate(auth: HttpContext['auth'], guards: (keyof GuardsList)[]) {
-    let guardLastAttempted: string | undefined
+  protected async authenticate(
+    auth: HttpContext['auth'],
+    guards: (keyof GuardsList)[],
+  ) {
+    let guardLastAttempted: string | undefined;
 
     for (const guard of guards) {
-      guardLastAttempted = guard
+      guardLastAttempted = guard;
 
       // eslint-disable-next-line no-await-in-loop
       if (await auth.use(guard).check()) {
-        auth.defaultGuard = guard
+        auth.defaultGuard = guard;
 
         throw new AuthenticationException(
           'Unauthorized access',
           'E_UNAUTHORIZED_ACCESS',
           guardLastAttempted,
-          this.redirectTo
-        )
+          this.redirectTo,
+        );
       }
     }
   }
@@ -38,16 +41,16 @@ export default class GuestMiddleware {
   public async handle(
     { auth }: 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];
 
-    await this.authenticate(auth, guards)
+    await this.authenticate(auth, guards);
 
-    await next()
+    await next();
   }
 }
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();
   }
 }
diff --git a/app/Middleware/Dashboard.ts b/app/Middleware/Dashboard.ts
index f29794c..19c8cfc 100644
--- a/app/Middleware/Dashboard.ts
+++ b/app/Middleware/Dashboard.ts
@@ -1,14 +1,14 @@
-import type { HttpContext } from '@adonisjs/core/http'
-import { Config } from '@adonisjs/core/config'
+import type { HttpContext } from '@adonisjs/core/http';
+import { Config } from '@adonisjs/core/config';
 
 export default class Dashboard {
   public async handle({ response }: HttpContext, next: () => Promise<void>) {
     if (Config.get('dashboard.enabled') === false) {
       response.send(
-        'The user dashboard is disabled on this server\n\nIf you are the server owner, please set IS_DASHBOARD_ENABLED to true to enable the dashboard.'
-      )
+        'The user dashboard is disabled on this server\n\nIf you are the server owner, please set IS_DASHBOARD_ENABLED to true to enable the dashboard.',
+      );
     } else {
-      await next()
+      await next();
     }
   }
 }
diff --git a/app/Middleware/SilentAuth.ts b/app/Middleware/SilentAuth.ts
index a7271d5..6ff7423 100644
--- a/app/Middleware/SilentAuth.ts
+++ b/app/Middleware/SilentAuth.ts
@@ -1,4 +1,4 @@
-import { HttpContext } from '@adonisjs/core/http'
+import { HttpContext } from '@adonisjs/core/http';
 
 /**
  * Silent auth middleware can be used as a global middleware to silent check
@@ -15,7 +15,7 @@ export default class SilentAuthMiddleware {
      * Check if user is logged-in or not. If yes, then `ctx.auth.user` will be
      * set to the instance of the currently logged in user.
      */
-    await auth.check()
-    await next()
+    await auth.check();
+    await next();
   }
 }