Merge pull request #95 from VictoriqueMoe/allow-login-errors

all login related errors now render IN the login page

src/engine/IHttpErrorRenderEngine.ts

@@ -8,13 +8,11 @@ export interface IHttpErrorRenderEngine<T, E extends Exception> {
      * @param obj
      * @param response
      */
-    render(obj: HttpErrorRenderObj<E>, response: PlatformResponse): Promise<T>;
+    render(obj: HttpErrorRenderObj<E>, response?: PlatformResponse): Promise<T>;
 
     /**
      * Returns true if this render engine supports the exception thrown by the system
      * @param exception
      */
     supportsError(exception: Exception): boolean;
-
-    getTitle(): string | null;
 }

src/engine/impl/HttpErrorRenderers/AuthenticationErrorRenderEngine.ts

@@ -0,0 +1,21 @@
+import { Injectable, ProviderScope } from "@tsed/di";
+import { HTTP_RENDER_ENGINE } from "../../../model/di/tokens.js";
+import type { IHttpErrorRenderEngine } from "../../IHttpErrorRenderEngine.js";
+import { AuthenticationError } from "../../../model/exceptions/AuthenticationError.js";
+import { Exception } from "@tsed/exceptions";
+import { HttpErrorRenderObj } from "../../../utils/typeings.js";
+import { PlatformResponse } from "@tsed/common";
+
+@Injectable({
+    scope: ProviderScope.SINGLETON,
+    type: HTTP_RENDER_ENGINE,
+})
+export class AuthenticationErrorRenderEngine implements IHttpErrorRenderEngine<string, AuthenticationError> {
+    public supportsError(exception: Exception): boolean {
+        return exception instanceof AuthenticationError;
+    }
+
+    public render(obj: HttpErrorRenderObj<AuthenticationError>, response: PlatformResponse): Promise<string> {
+        return response.render("login.ejs", obj);
+    }
+}

src/engine/impl/HttpErrorRenderers/DefaultHttpRenderEngine.ts

@@ -19,19 +19,16 @@ export class DefaultHttpRenderEngine implements IHttpErrorRenderEngine<DefaultRe
         return Promise.resolve(this.mapError(obj.internalError));
     }
 
-    public supportsError(): boolean {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public supportsError(_: Exception): boolean {
         return false;
     }
 
     public mapError(error: Exception): DefaultRenderObj {
         return {
             name: error.origin?.name ?? error.name,
             message: error.message,
-            status: error.status ?? 50,
+            status: error.status ?? 500,
         };
     }
-
-    public getTitle(): string | null {
-        return null;
-    }
 }

src/engine/impl/HttpErrorRenderers/FileProtectedRenderEngine.ts

@@ -15,10 +15,6 @@ export class FileProtectedRenderEngine implements IHttpErrorRenderEngine<string,
         return exception instanceof FileProtectedException;
     }
 
-    public getTitle(): string {
-        return "Please enter a password for this file..";
-    }
-
     public render(obj: HttpErrorRenderObj<FileProtectedException>, response: PlatformResponse): Promise<string> {
         const isEncrypted = obj.internalError.isEncrypted;
         return response.render("fileLogin.ejs", {

src/engine/impl/HttpErrorRenderers/ReCAPTCHALoginExceptionRenderEngine.ts

@@ -0,0 +1,24 @@
+import type { IHttpErrorRenderEngine } from "../../IHttpErrorRenderEngine.js";
+import { ReCAPTCHAException } from "../../../model/exceptions/ReCAPTCHAException.js";
+import { Injectable, InjectContext, ProviderScope } from "@tsed/di";
+import { HTTP_RENDER_ENGINE } from "../../../model/di/tokens.js";
+import { HttpErrorRenderObj } from "../../../utils/typeings.js";
+import { type PlatformContext, PlatformResponse } from "@tsed/common";
+import { Exception } from "@tsed/exceptions";
+
+@Injectable({
+    scope: ProviderScope.SINGLETON,
+    type: HTTP_RENDER_ENGINE,
+})
+export class ReCAPTCHALoginExceptionRenderEngine implements IHttpErrorRenderEngine<string, ReCAPTCHAException> {
+    @InjectContext()
+    protected $ctx?: PlatformContext;
+
+    public render(obj: HttpErrorRenderObj<ReCAPTCHAException>, response: PlatformResponse): Promise<string> {
+        return response.render("login.ejs", obj);
+    }
+
+    public supportsError(exception: Exception): boolean {
+        return this.$ctx?.url.includes("/login") ? exception instanceof ReCAPTCHAException : false;
+    }
+}

src/engine/impl/index.ts

@@ -5,6 +5,7 @@
 export * from "./FileEngine.js";
 export * from "./av/ClamAvEngine.js";
 export * from "./av/MsDefenderEngine.js";
-export * from "./HttpErrorRenderers/AbstractEjsHttpRenderEngine.js";
+export * from "./HttpErrorRenderers/AuthenticationErrorRenderEngine.js";
 export * from "./HttpErrorRenderers/DefaultHttpRenderEngine.js";
 export * from "./HttpErrorRenderers/FileProtectedRenderEngine.js";
+export * from "./HttpErrorRenderers/ReCAPTCHALoginExceptionRenderEngine.js";

src/filters/HttpExceptionFilter.ts

@@ -18,7 +18,6 @@ export class HttpExceptionFilter implements ExceptionFilterMethods<Exception> {
             status: exception.status,
             message: exception.message,
             internalError: exception,
-            title: renderEngine.getTitle(),
         };
         const response = ctx.response;
         const template = await renderEngine.render(obj, response);

src/filters/PassportExceptionFilter.ts

@@ -3,15 +3,15 @@ import { Catch } from "@tsed/common";
 import { PassportException } from "@tsed/passport";
 import { Inject } from "@tsed/di";
 import { HttpExceptionFilter } from "./HttpExceptionFilter.js";
-import { Unauthorized } from "@tsed/exceptions";
+import { AuthenticationError } from "../model/exceptions/AuthenticationError.js";
 
 @Catch(PassportException)
 export class PassportExceptionFilter implements ExceptionFilterMethods<PassportException> {
     public constructor(@Inject() private httpExceptionFilter: HttpExceptionFilter) {}
 
     public catch(exception: PassportException, ctx: PlatformContext): unknown {
         if (exception.name === "AuthenticationError") {
-            return this.httpExceptionFilter.catch(new Unauthorized("Unauthorized", exception.origin), ctx);
+            return this.httpExceptionFilter.catch(new AuthenticationError(exception.message, exception.origin), ctx);
         }
         return this.httpExceptionFilter.catch(exception, ctx);
     }

src/middleware/endpoint/ReCAPTCHAMiddleWare.ts

@@ -3,6 +3,7 @@ import { Inject } from "@tsed/di";
 import { ReCAPTCHAService } from "../../services/ReCAPTCHAService.js";
 import { BadRequest } from "@tsed/exceptions";
 import { BodyParams } from "@tsed/platform-params";
+import { ReCAPTCHAException } from "../../model/exceptions/ReCAPTCHAException.js";
 
 @Middleware()
 export class ReCAPTCHAMiddleWare implements MiddlewareMethods {
@@ -15,7 +16,7 @@ export class ReCAPTCHAMiddleWare implements MiddlewareMethods {
         }
         const reCAPTCHAResp = await this.reCAPTCHAService.validateResponse(reCAPTCHA);
         if (!reCAPTCHAResp) {
-            throw new BadRequest("reCAPTCHA response invalid.");
+            throw new ReCAPTCHAException("reCAPTCHA response invalid.");
         }
     }
 }

src/middleware/global/IpFilterMiddleware.ts

@@ -13,7 +13,7 @@ export class IpFilterMiddleware implements MiddlewareMethods {
         const ip = NetworkUtils.getIp(req);
         const isBlocked = await this.ipRepo.isIpBlocked(ip);
         if (isBlocked) {
-            throw new Forbidden("Your IP has been blocked");
+            throw new Forbidden("");
         }
     }
 }

src/model/exceptions/AuthenticationError.ts

@@ -0,0 +1,11 @@
+import { Unauthorized } from "@tsed/exceptions";
+
+export class AuthenticationError extends Unauthorized {
+    public constructor(message: string, origin?: Error | string) {
+        if (message === "Unauthorized") {
+            super("Incorrect email/password", origin);
+        } else {
+            super(message, origin);
+        }
+    }
+}

src/model/exceptions/ReCAPTCHAException.ts

@@ -0,0 +1,7 @@
+import { BadRequest } from "@tsed/exceptions";
+
+export class ReCAPTCHAException extends BadRequest {
+    public constructor(message: string, origin?: Error | string) {
+        super(message, origin);
+    }
+}

src/public/login.ejs

@@ -61,6 +61,14 @@
                         </div>
                     </form>
                 </div>
+                <% if(typeof internalError !== "undefined") { %>
+                    <div class="card-footer">
+                        <div class="alert alert-danger alert-dismissible" role="alert">
+                            <%-message-%>
+                            <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                        </div>
+                    </div>
+                <% } %>
             </div>
         </div>
     </div>

src/utils/typeings.ts

@@ -3,7 +3,6 @@ import { FileUploadModel } from "../model/db/FileUpload.model.js";
 
 export type HttpErrorRenderObj<T extends Exception> = {
     status: number;
-    title: string | null;
     message: string;
     internalError: T;
 };

tsconfig.json

@@ -24,6 +24,8 @@
     "noEmit": true,
     "esModuleInterop": true,
     "resolveJsonModule": true,
+    "noImplicitOverride": true,
+    "skipLibCheck": true,
     "lib": [
       "es7",
       "dom",