feat: enhance logging functionality and improve type definitions in core components

Author: hasib-devs

src/core/Application.ts

@@ -3,6 +3,7 @@ import type { RouteMetadata, ServerOptions } from "@/types";
 import { defaultOptions } from "@/utils/constants";
 import { controllerMetadata, routeMetadata } from "@/utils/meta-data";
 import { Container } from "@/di/Container";
+import { Logger } from "@/utils/logger";
 
 export class Application {
     private readonly app: Hono;
@@ -26,6 +27,7 @@ export class Application {
             const routes = routeMetadata.get(Controller) ?? [];
             const instance = Container.resolve(Controller);
 
+            Logger.success(`${Controller.name}: ${controllerPath}`);
             const controllerGroup = new Hono();
 
             for (const route of routes) {
@@ -36,7 +38,7 @@ export class Application {
 
         this.app.route(this.options.basePath ?? '', baseGroup);
     }
-    private getControllerPath(Controller: any): string {
+    private getControllerPath(Controller: Function): string {
         const path = controllerMetadata.get(Controller) ?? "";
         return path.replace(/\/$/, ""); // Normalize trailing slash
     }
@@ -49,6 +51,8 @@ export class Application {
         const { method, path, handler } = route;
         const normalizedPath = path === "/" ? "" : path;
 
+        Logger.info(`${method.toUpperCase()}: "${normalizedPath}"`);
+
         group.on(
             method.toUpperCase(),
             normalizedPath,

src/decorators/Controller.ts

@@ -2,7 +2,7 @@ import { Container } from "@/di/Container";
 import { controllerMetadata } from "@/utils/meta-data";
 
 export function Controller(path: string) {
-    return (target: object) => {
+    return (target: Function) => {
         controllerMetadata.set(target, path);
         // Auto-register the controller as a singleton
         Container.register(target, () => new (target as any)(), "singleton");

src/decorators/Inject.ts

@@ -11,6 +11,13 @@ export function Inject(token: unknown) {
     };
 }
 
+export function Injectable() {
+    return (constructor: new (...args: any[]) => any) => {
+        Container.register(constructor, () => createInstance(constructor));
+    };
+}
+
+
 export function createInstance<T>(constructor: new (...args: any[]) => T): T {
     const metadata = injectionMetadata.get(constructor) ?? [];
     const args = metadata.map((token) => {

src/di/Container.ts

@@ -16,7 +16,7 @@ export class Container {
         this.registry.set(token, { factory, lifetime });
     }
 
-    static resolve<T>(token: unknown): T {
+    static resolve<T>(token: T): T {
         // Detect circular dependencies
         if (this.resolutionStack.includes(token)) {
             const cycleStart = this.resolutionStack.indexOf(token);

src/types/index.ts

@@ -1,6 +1,6 @@
 export type ServerOptions = {
     basePath?: string;
-    controllers?: any[];
+    controllers?: Function[];
     middlewares?: any[];
 };
 

src/utils/logger.ts

@@ -0,0 +1,31 @@
+// console.log("\x1b[32m Output with green text \x1b[0m")
+// console.log("\x1b[35m Output with magenta text \x1b[0m")
+// console.log("\x1b[34m Output with blue text \x1b[0m")
+// console.log("\x1b[36m Output with cyan text \x1b[0m")
+
+// console.log("\x1b[41m Output with red background \x1b[0m")
+// console.log("\x1b[42m Output with green background \x1b[0m")
+// console.log("\x1b[43m Output with yellow background \x1b[0m")
+
+
+export class Logger {
+    public static info(message: string): void {
+        console.log(`\x1b[36m${message}\x1b[0m`);
+    }
+
+    public static warn(message: string): void {
+        console.log(`\x1b[33mWARN: ${message}\x1b[0m`);
+    }
+
+    public static error(message: string): void {
+        console.log(`\x1b[31mERROR: ${message}\x1b[0m`);
+    }
+
+    public static success(message: string): void {
+        console.log(`\x1b[34m${message}\x1b[0m`);
+    }
+
+    public static debug(message: string): void {
+        console.log(`\x1b[34mDEBUG: ${message}\x1b[0m`);
+    }
+}

src/utils/meta-data.ts

@@ -1,5 +1,5 @@
 import type { RouteMetadata } from "@/types";
 
-export const controllerMetadata = new WeakMap<object, string>();
+export const controllerMetadata = new WeakMap<Function, string>();
 export const routeMetadata = new WeakMap<object, RouteMetadata[]>();
 export const injectionMetadata = new WeakMap<object, unknown[]>();