feat: udpates

access-guard-ts/main.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S deno run --allow-env --allow-net
 
-import {Mutex} from "https://deno.land/x/async@v2.1.0/mutex.ts";
+import { Mutex } from "https://deno.land/x/async@v2.1.0/mutex.ts";
 
 // Reference:
 // * https://docs.deno.com/runtime/reference/env_variables/
@@ -14,7 +14,7 @@ const listen = {
 const startTime = new Date().getTime();
 
 // IP: Add time
-let globalIpAddressMap = {};
+const globalIpAddressMap = {};
 const globalIpAddressMapMutex = new Mutex();
 
 async function addIpAddress(ip: string): Promise<void> {
@@ -29,9 +29,9 @@ async function addIpAddress(ip: string): Promise<void> {
 async function cleanAndGetIpAddresses(): Promise<Array<string>> {
     await globalIpAddressMapMutex.acquire();
     try {
-        let currentTimeMillis = new Date().getTime();
-        let invalidKeys = [];
-        let validKeys = [];
+        const currentTimeMillis = new Date().getTime();
+        const invalidKeys = [];
+        const validKeys = [];
         for (let k in globalIpAddressMap) {
             const t = globalIpAddressMap[k];
             if ((currentTimeMillis - t) > 60 * 60 * 1000) {
@@ -49,17 +49,20 @@ async function cleanAndGetIpAddresses(): Promise<Array<string>> {
     }
 }
 
-let globalFilters = [];
-let globalHandlerMap = {};
+const globalFilters: any[] = [];
+const globalHandlerMap = {};
 
 type RequestHandler = (url: URL, req: any) => Promise<Response>;
 
-
 function registerFilter(handler: RequestHandler) {
     globalFilters.push(handler);
 }
 
-function registerHandler(method: string, path: string, handler: RequestHandler) {
+function registerHandler(
+    method: string,
+    path: string,
+    handler: RequestHandler,
+) {
     const requestIdent = `${method}::${path}`;
     if (globalHandlerMap[requestIdent] != null) {
         throw `Handler for ${method} ${path} exists.`;
@@ -81,7 +84,10 @@ function buildOkJsonResponse(body: any): Response {
 }
 
 function notFoundHandler(url: URL, req: any): Response {
-    return buildJsonResponse(404, {"error": "not_found", "message": "Resource not found.",});
+    return buildJsonResponse(404, {
+        "error": "not_found",
+        "message": "Resource not found.",
+    });
 }
 
 registerFilter(async (url: URL, req: any) => {
@@ -89,41 +95,47 @@ registerFilter(async (url: URL, req: any) => {
         return null;
     }
     if (TOKEN == null) {
-        return buildJsonResponse(500, {"error": "bad_token", "message": "Bad token."});
+        return buildJsonResponse(500, {
+            "error": "bad_token",
+            "message": "Bad token.",
+        });
     }
-    const token = url.searchParams.get('__token');
+    const token = url.searchParams.get("__token");
     if (TOKEN !== token) {
-        return buildJsonResponse(401, {"error": "invalid_token", "message": "Invalid token."})
+        return buildJsonResponse(401, {
+            "error": "invalid_token",
+            "message": "Invalid token.",
+        });
     }
     return null;
 });
 
 function formatHumanTime(time: number): string {
-    let t = [];
-    let leftMs = time % 1000;
+    const t = [];
+    const leftMs = time % 1000;
     if (leftMs > 0) {
         t.push(`${leftMs}ms`);
     }
-    let secs = Math.floor(time / 1000);
-    let leftSecs = secs % 60;
+    const secs = Math.floor(time / 1000);
+    const leftSecs = secs % 60;
     if (leftSecs > 0) {
         t.push(`${leftSecs}s`);
     }
-    let mins = Math.floor(secs / 60);
-    let leftMins = mins % 60;
+    const mins = Math.floor(secs / 60);
+    const leftMins = mins % 60;
     if (leftMins > 0) {
         t.push(`${leftMins}min`);
     }
-    let hours = Math.floor(mins / 60);
-    let leftHours = hours % 24;
+    const hours = Math.floor(mins / 60);
+    const leftHours = hours % 24;
     if (leftHours > 0) {
         t.push(`${leftHours}hour`);
     }
-    let days = Math.floor(hours / 24);
+    const days = Math.floor(hours / 24);
     if (days > 0) {
         t.push(`${days}day`);
     }
-    return t.reverse().join(' ');
+    return t.reverse().join(" ");
 }
 
 registerHandler("GET", "/version", async (url, req) => {
@@ -142,7 +154,10 @@ registerHandler("POST", "/ip_addresses", async (url, req) => {
     try {
         addIpAddressRequest = await req.json();
     } catch (e) {
-        return buildJsonResponse(400, {"error": "bad_request", "message": "Bad request."});
+        return buildJsonResponse(400, {
+            "error": "bad_request",
+            "message": "Bad request.",
+        });
     }
     await addIpAddress(addIpAddressRequest.ip);
     return buildOkJsonResponse({});
@@ -156,15 +171,21 @@ registerHandler("GET", "/ip_addresses", async (url, req) => {
 });
 
 registerHandler("*", "/check_ip_address", async (url, req) => {
-    const clientIp = req.headers.get('x-real-ip');
+    const clientIp = req.headers.get("x-real-ip");
     if (clientIp == null) {
-        return buildJsonResponse(400, {"error": "bad_request", "message": "Bad request: no client IP"});
+        return buildJsonResponse(400, {
+            "error": "bad_request",
+            "message": "Bad request: no client IP",
+        });
     }
     const ipAddresses = await cleanAndGetIpAddresses();
     if (ipAddresses.indexOf(clientIp) >= 0) {
         return buildOkJsonResponse({});
     }
-    return buildJsonResponse(401, {"error": "access_denied", "message": "Access denied: not allowed IP"});
+    return buildJsonResponse(401, {
+        "error": "access_denied",
+        "message": "Access denied: not allowed IP",
+    });
 });
 
 Deno.serve(listen, async (req) => {
@@ -178,6 +199,7 @@ Deno.serve(listen, async (req) => {
     console.log("Handler request:", req.method, url.pathname);
     const req1 = `${req.method}::${url.pathname}`;
     const req2 = `*::${url.pathname}`;
-    const req_handler = globalHandlerMap[req1] || globalHandlerMap[req2] || notFoundHandler;
+    const req_handler = globalHandlerMap[req1] || globalHandlerMap[req2] ||
+        notFoundHandler;
     return await req_handler(url, req);
-});
+});