move to @atums/echo logger,

.gitignore

@@ -2,3 +2,4 @@
 bun.lock
 .env
 .vscode/settings.json
+logs

logger.json

@@ -0,0 +1,39 @@
+{
+	"directory": "logs",
+	"level": "debug",
+	"disableFile": false,
+
+	"rotate": true,
+	"maxFiles": 3,
+
+	"console": true,
+	"consoleColor": true,
+
+	"dateFormat": "yyyy-MM-dd HH:mm:ss.SSS",
+	"timezone": "local",
+
+	"silent": false,
+
+	"pattern": "{color:gray}{pretty-timestamp}{reset} {color:levelColor}[{level-name}]{reset} {color:gray}({reset}{file-name}:{color:blue}{line}{reset}:{color:blue}{column}{color:gray}){reset} {data}",
+	"levelColor": {
+		"debug": "blue",
+		"info": "green",
+		"warn": "yellow",
+		"error": "red",
+		"fatal": "red"
+	},
+
+	"customPattern": "{color:gray}{pretty-timestamp}{reset} {color:tagColor}[{tag}]{reset} {color:contextColor}({context}){reset} {data}",
+	"customColors": {
+		"GET": "green",
+		"POST": "blue",
+		"PUT": "yellow",
+		"DELETE": "red",
+		"PATCH": "cyan",
+		"HEAD": "magenta",
+		"OPTIONS": "white",
+		"TRACE": "gray"
+	},
+
+	"prettyPrint": true
+}

package.json

@@ -19,7 +19,7 @@
 		"typescript": "^5.8.3"
 	},
 	"dependencies": {
-		"@creations.works/logger": "^1.0.3",
+		"@atums/echo": "^1.0.3",
 		"ejs": "^3.1.10"
 	}
 }

src/index.ts

@@ -1,4 +1,4 @@
-import { logger } from "@creations.works/logger";
+import { echo } from "@atums/echo";
 
 import { serverHandler } from "@/server";
 
@@ -7,7 +7,10 @@ async function main(): Promise<void> {
 }
 
 main().catch((error: Error) => {
-	logger.error(["Error initializing the server:", error]);
+	echo.error({
+		message: "Error initializing the server",
+		error: error.message,
+	});
 	process.exit(1);
 });
 

src/server.ts

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
+import { echo } from "@atums/echo";
 import { environment } from "@config/environment";
-import { logger } from "@creations.works/logger";
 import {
 	type BunFile,
 	FileSystemRouter,
@@ -37,15 +37,20 @@ class ServerHandler {
 			},
 		});
 
-		logger.info(`Server running at http://${server.hostname}:${server.port}`, {
+		const accessUrls: string[] = [
-			breakLine: true,
+			`http://${server.hostname}:${server.port}`,
-		});
+			`http://localhost:${server.port}`,
+			`http://127.0.0.1:${server.port}`,
+		];
+
+		echo.info(`Server running at ${accessUrls[0]}`);
+		echo.info(`Access via: ${accessUrls[1]} or ${accessUrls[2]}`);
 
 		this.logRoutes();
 	}
 
 	private logRoutes(): void {
-		logger.info("Available routes:");
+		echo.info("Available routes:");
 
 		const sortedRoutes: [string, string][] = Object.entries(
 			this.router.routes,
@@ -54,14 +59,19 @@ class ServerHandler {
 		);
 
 		for (const [path, filePath] of sortedRoutes) {
-			logger.info(`Route: ${path}, File: ${filePath}`);
+			echo.info(`Route: ${path}, File: ${filePath}`);
 		}
 	}
 
-	private async serveStaticFile(pathname: string): Promise<Response> {
+	private async serveStaticFile(
-		try {
+		request: ExtendedRequest,
+		pathname: string,
+		ip: string,
+	): Promise<Response> {
 		let filePath: string;
+		let response: Response;
 
+		try {
 			if (pathname === "/favicon.ico") {
 				filePath = resolve("public", "assets", "favicon.ico");
 			} else {
@@ -74,16 +84,47 @@ class ServerHandler {
 				const fileContent: ArrayBuffer = await file.arrayBuffer();
 				const contentType: string = file.type || "application/octet-stream";
 
-				return new Response(fileContent, {
+				response = new Response(fileContent, {
 					headers: { "Content-Type": contentType },
 				});
+			} else {
+				echo.warn(`File not found: ${filePath}`);
+				response = new Response("Not Found", { status: 404 });
 			}
-			logger.warn(`File not found: ${filePath}`);
-			return new Response("Not Found", { status: 404 });
 		} catch (error) {
-			logger.error([`Error serving static file: ${pathname}`, error as Error]);
+			echo.error({
-			return new Response("Internal Server Error", { status: 500 });
+				message: `Error serving static file: ${pathname}`,
+				error: error as Error,
+			});
+			response = new Response("Internal Server Error", { status: 500 });
 		}
+
+		this.logRequest(request, response, ip);
+		return response;
+	}
+
+	private logRequest(
+		request: ExtendedRequest,
+		response: Response,
+		ip: string | undefined,
+	): void {
+		const pathname = new URL(request.url).pathname;
+
+		const ignoredStartsWith: string[] = ["/public"];
+		const ignoredPaths: string[] = ["/favicon.ico"];
+
+		if (
+			ignoredStartsWith.some((prefix) => pathname.startsWith(prefix)) ||
+			ignoredPaths.includes(pathname)
+		) {
+			return;
+		}
+
+		echo.custom(`${request.method}`, `${response.status}`, [
+			request.url,
+			`${(performance.now() - request.startPerf).toFixed(2)}ms`,
+			ip || "unknown",
+		]);
 	}
 
 	private async handleRequest(
@@ -93,14 +134,44 @@ class ServerHandler {
 		const extendedRequest: ExtendedRequest = request as ExtendedRequest;
 		extendedRequest.startPerf = performance.now();
 
+		const headers = request.headers;
+		let ip = server.requestIP(request)?.address;
+		let response: Response;
+
+		if (!ip || ip.startsWith("172.") || ip === "127.0.0.1") {
+			ip =
+				headers.get("CF-Connecting-IP")?.trim() ||
+				headers.get("X-Real-IP")?.trim() ||
+				headers.get("X-Forwarded-For")?.split(",")[0].trim() ||
+				"unknown";
+		}
+
 		const pathname: string = new URL(request.url).pathname;
+
+		const baseDir = resolve("public/custom");
+		const customPath = resolve(baseDir, pathname.slice(1));
+
+		if (!customPath.startsWith(baseDir)) {
+			return new Response("Forbidden", { status: 403 });
+		}
+
+		const customFile = Bun.file(customPath);
+		if (await customFile.exists()) {
+			const content = await customFile.arrayBuffer();
+			const type = customFile.type || "application/octet-stream";
+			response = new Response(content, {
+				headers: { "Content-Type": type },
+			});
+			this.logRequest(extendedRequest, response, ip);
+			return response;
+		}
+
 		if (pathname.startsWith("/public") || pathname === "/favicon.ico") {
-			return await this.serveStaticFile(pathname);
+			return await this.serveStaticFile(extendedRequest, pathname, ip);
 		}
 
 		const match: MatchedRoute | null = this.router.match(request);
 		let requestBody: unknown = {};
-		let response: Response;
 
 		if (match) {
 			const { filePath, params, query } = match;
@@ -198,7 +269,10 @@ class ServerHandler {
 					}
 				}
 			} catch (error: unknown) {
-				logger.error([`Error handling route ${request.url}:`, error as Error]);
+				echo.error({
+					message: `Error handling route ${request.url}`,
+					error: error,
+				});
 
 				response = Response.json(
 					{
@@ -220,31 +294,11 @@ class ServerHandler {
 			);
 		}
 
-		const headers = request.headers;
+		this.logRequest(extendedRequest, response, ip);
-		let ip = server.requestIP(request)?.address;
-
-		if (!ip || ip.startsWith("172.") || ip === "127.0.0.1") {
-			ip =
-				headers.get("CF-Connecting-IP")?.trim() ||
-				headers.get("X-Real-IP")?.trim() ||
-				headers.get("X-Forwarded-For")?.split(",")[0].trim() ||
-				"unknown";
-		}
-
-		logger.custom(
-			`[${request.method}]`,
-			`(${response.status})`,
-			[
-				request.url,
-				`${(performance.now() - extendedRequest.startPerf).toFixed(2)}ms`,
-				ip || "unknown",
-			],
-			"90",
-		);
-
 		return response;
 	}
 }
+
 const serverHandler: ServerHandler = new ServerHandler(
 	environment.port,
 	environment.host,

src/websocket.ts

@@ -1,27 +1,33 @@
-import { logger } from "@creations.works/logger";
+import { echo } from "@atums/echo";
 import type { ServerWebSocket } from "bun";
 
 class WebSocketHandler {
 	public handleMessage(ws: ServerWebSocket, message: string): void {
-		logger.info(`WebSocket received: ${message}`);
+		echo.info(`WebSocket received: ${message}`);
 		try {
 			ws.send(`You said: ${message}`);
 		} catch (error) {
-			logger.error(["WebSocket send error", error as Error]);
+			echo.error({
+				message: "WebSocket send error",
+				error: (error as Error).message,
+			});
 		}
 	}
 
 	public handleOpen(ws: ServerWebSocket): void {
-		logger.info("WebSocket connection opened.");
+		echo.info("WebSocket connection opened.");
 		try {
 			ws.send("Welcome to the WebSocket server!");
 		} catch (error) {
-			logger.error(["WebSocket send error", error as Error]);
+			echo.error({
+				message: "WebSocket send error",
+				error: (error as Error).message,
+			});
 		}
 	}
 
 	public handleClose(ws: ServerWebSocket, code: number, reason: string): void {
-		logger.warn(`WebSocket closed with code ${code}, reason: ${reason}`);
+		echo.info(`WebSocket closed with code ${code}, reason: ${reason}`);
 	}
 }