chore(feat): add middleware decorator and change validator trait (#11)

* refactor(app/decorator/validator): change validator trait from being single validator to middleware

* refactor(app/decorator): changing and merging validator to middleware

* feat(app/decorator/middleware): implementing the working middleware

* fix: false import (again, duh)

* refactoring(app/decorator/middleware): overloading middleware function

* refactor(app/decorator/middleware): add jsdoc for middleware

Author: ikr4-m

src/App/Decorator/Middleware.ts

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+import type { MiddlewareHandler, ValidationTargets } from "hono";
+import { validator as honoValidator } from "hono/validator";
+import { z } from "zod";
+import { MetadataMiddlewareConstant } from "App/Types/ControllerConstant.js";
+import type Controller from "Controller/Controller.js";
+import { onValidateError } from "Function/OnValidateError.js";
+
+export type ZodData<V> = { [VK in keyof V]: any };
+
+function reflectingMetadata(target: Function, func: MiddlewareHandler): void {
+    if (!Reflect.hasMetadata(MetadataMiddlewareConstant, target)) {
+        Reflect.defineMetadata(MetadataMiddlewareConstant, [func], target);
+        return;
+    }
+
+    const metadata = Reflect.getMetadata(MetadataMiddlewareConstant, target) as MiddlewareHandler[];
+    metadata.push(func);
+
+    Reflect.deleteMetadata(MetadataMiddlewareConstant, target);
+    Reflect.defineMetadata(MetadataMiddlewareConstant, metadata, target);
+}
+
+/**
+ * Validate data for route.
+ *
+ * @param method - Target of request
+ * @param data - Data to validate
+ */
+export function validator<T extends {}>(method: keyof ValidationTargets, data: ZodData<T>): Function {
+    return function decorate(target: Controller, propKey: string, descriptor: PropertyDescriptor): void {
+        const targetFunc = descriptor.value as Function;
+        const funcValidator = honoValidator(method, (val, c) => {
+            const parsed = z.object(data).safeParse(val);
+            if (!parsed.success) return onValidateError(c, data);
+            return parsed.data;
+        });
+        reflectingMetadata(targetFunc, funcValidator);
+    };
+}
+
+/**
+ * Add middleware on route.
+ *
+ * @param handlers - Middleware handlers for route
+ * @see MiddlewareHandler
+ */
+export function middleware(...handlers: MiddlewareHandler[] | Promise<MiddlewareHandler>[] | Promise<void>[]): Function {
+    return function decorate(target: Controller, propKey: string, descriptor: PropertyDescriptor): void {
+        const targetFunc = descriptor.value as Function;
+        for (const handler of handlers) {
+            const targetHandler = handler as MiddlewareHandler;
+            reflectingMetadata(targetFunc, targetHandler);
+        }
+    };
+}

src/App/Decorator/Validator.ts

@@ -1,2 +1,2 @@
 export const MetadataConstant = "agniRouting";
-export const MetadataValidatorConstant = "agniValidator";
+export const MetadataMiddlewareConstant = "agniMiddleware";

src/App/Types/ControllerConstant.ts

@@ -3,7 +3,7 @@ import type { Factory } from "hono/factory";
 import { createFactory } from "hono/factory";
 import type { HandlerInterface, MiddlewareHandler } from "hono/types";
 import { InsufficientControllerMethodError, NotSupportedMethodError } from "App/Error/AppError.js";
-import { MetadataConstant, MetadataValidatorConstant } from "App/Types/ControllerConstant.js";
+import { MetadataConstant, MetadataMiddlewareConstant } from "App/Types/ControllerConstant.js";
 import type {
     AgniRoutingMetadata,
     AgniSupportedMethod,
@@ -40,19 +40,17 @@ export default class Controller {
                 throw new NotSupportedMethodError();
             }
 
-            /**
-             * TODO [2024-02-27]: Add support for middleware, multi handler/middleware
-             */
             const ctx: DefaultHonoFunctionContext[] = [];
-            if (metadataKeys.includes(MetadataValidatorConstant)) {
-                const middleware = Reflect.getMetadata(MetadataValidatorConstant, func) as MiddlewareHandler;
-                ctx.push(this._honoFactory.createMiddleware(middleware));
+            if (metadataKeys.includes(MetadataMiddlewareConstant)) {
+                const middleware = Reflect.getMetadata(MetadataMiddlewareConstant, func) as MiddlewareHandler[];
+                for (const midFunc of middleware) {
+                    ctx.push(this._honoFactory.createMiddleware(midFunc));
+                }
             }
 
             ctx.push(func);
-            Logger.info(`Register ${metadata.method}:${metadata.path} route`);
+            Logger.info(`Register ${metadata.method}:${metadata.path} route [${ctx.length} handler]`);
 
-            // TODO [2024-03-01]: How to bypass this?
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-expect-error
             const handlers = this._honoFactory.createHandlers(...ctx);

src/Controller/Controller.ts

@@ -1,15 +1,27 @@
+import type { Next } from "hono";
+import { cors } from "hono/cors";
 import { z } from "zod";
 import httpRoute from "App/Decorator/HttpRoute.js";
-import validator from "App/Decorator/Validator.js";
+import { middleware, validator } from "App/Decorator/Middleware.js";
 import type { DefaultHonoContext, HonoInputContext } from "App/Types/ControllerTypes.js";
+import Logger from "Logger.js";
 import Controller from "./Controller.js";
 
 type HelloValidator = {
     message: string;
 };
 
+// Since we cannot calling this keyword on decorator,
+// you must create some function outside the class or make some new function file.
+async function indexMiddleware(_: DefaultHonoContext, next: Next): Promise<void> {
+    Logger.info("You're accessing index!");
+    await next();
+    Logger.info("Done!");
+}
+
 export default class HelloController extends Controller {
     @httpRoute("get", "/")
+    @middleware(cors(), indexMiddleware)
     public hellow(c: DefaultHonoContext): Response {
         return c.text("Say hello world!");
     }

src/Controller/HelloController.ts

@@ -1,5 +1,5 @@
 import type { Context } from "hono";
-import type { ZodData } from "App/Decorator/Validator.js";
+import type { ZodData } from "App/Decorator/Middleware.js";
 import isJson from "App/Function/IsJson.js";
 
 export function onValidateError(c: Context<any, any, any>, data: ZodData<any>): Response {