chore: Format code again.

api/src/backendimpl/passyfire-reimpl/routes.ts

@@ -3,7 +3,7 @@ import type { PassyFireBackendProvider } from "./index.js";
 
 export function route(instance: PassyFireBackendProvider) {
   const { fastify } = instance;
-  
+
   const proxiedPort: number = instance.options.publicPort ?? 443;
 
   const unsupportedSpoofedRoutes: string[] = [
@@ -16,7 +16,7 @@ export function route(instance: PassyFireBackendProvider) {
     "/api/v1/tunnels/stop",
 
     // Same scenario for this API.
-    "/api/v1/users", 
+    "/api/v1/users",
     "/api/v1/users/add",
     "/api/v1/users/remove",
     "/api/v1/users/enable",
@@ -31,7 +31,7 @@ export function route(instance: PassyFireBackendProvider) {
           add: true,
           remove: true,
           get: true,
-          getPasswords: true
+          getPasswords: true,
         },
         routes: {
           add: true,
@@ -39,125 +39,140 @@ export function route(instance: PassyFireBackendProvider) {
           start: true,
           stop: true,
           get: true,
-          getPasswords: true
-        }
-      }
-    }
+          getPasswords: true,
+        },
+      },
+    };
   });
 
   for (const spoofedRoute of unsupportedSpoofedRoutes) {
     fastify.post(spoofedRoute, (req, res) => {
-      if (typeof req.body != "string") return res.status(400).send({
-        error: "Invalid token"
-      });
+      if (typeof req.body != "string")
+        return res.status(400).send({
+          error: "Invalid token",
+        });
 
       try {
         JSON.parse(req.body);
       } catch (e) {
         return res.status(400).send({
-          error: "Invalid token"
-        })
+          error: "Invalid token",
+        });
       }
 
       // @ts-ignore
-      if (!req.body.token) return res.status(400).send({
-        error: "Invalid token"
-      });
+      if (!req.body.token)
+        return res.status(400).send({
+          error: "Invalid token",
+        });
 
       return res.status(403).send({
-        error: "Invalid scope(s)"
+        error: "Invalid scope(s)",
       });
-    })
+    });
   }
 
-  fastify.post("/api/v1/users/login", {
-    schema: {
-      body: {
-        type: "object",
-        required: ["username", "password"],
+  fastify.post(
+    "/api/v1/users/login",
+    {
+      schema: {
+        body: {
+          type: "object",
+          required: ["username", "password"],
 
-        properties: {
-          username: { type: "string" },
-          password: { type: "string" }
-        }
-      }
-    }
-  }, (req, res) => {
-    // @ts-ignore
-    const body: {
-      username: string,
-      password: string
-    } = req.body;
-
-    if (!instance.options.users.find((i) => i.username == body.username && i.password == body.password)) {
-      return res.status(403).send({
-        error: "Invalid username/password."
-      });
-    };
-    
-    const token = generateRandomData();
-
-    instance.users.push({
-      username: body.username,
-      token
-    });
-
-    return {
-      success: true,
-      data: {
-        token
-      }
-    }
-  });
-  
-  fastify.post("/api/v1/tunnels", {
-    schema: {
-      body: {
-        type: "object",
-        required: ["token"],
-        properties: {
-          token: { type: "string" },
+          properties: {
+            username: { type: "string" },
+            password: { type: "string" },
+          },
         },
       },
     },
-  }, async (req, res) => {
-    // @ts-ignore
-    const body: {
-      token: string
-    } = req.body;
+    (req, res) => {
+      // @ts-ignore
+      const body: {
+        username: string;
+        password: string;
+      } = req.body;
 
-    const userData = instance.users.find(user => user.token == body.token);
+      if (
+        !instance.options.users.find(
+          i => i.username == body.username && i.password == body.password,
+        )
+      ) {
+        return res.status(403).send({
+          error: "Invalid username/password.",
+        });
+      }
 
-    if (!userData) return res.status(403).send({
-      error: "Invalid token"
-    });
+      const token = generateRandomData();
 
-    // const host = req.hostname.substring(0, req.hostname.indexOf(":"));
-    const unparsedPort = req.hostname.substring(req.hostname.indexOf(":") + 1);
-    
-    // @ts-ignore
-    // parseInt(...) can take a number just fine, at least in Node.JS
-    const port = parseInt(unparsedPort == "" ? proxiedPort : unparsedPort);
+      instance.users.push({
+        username: body.username,
+        token,
+      });
 
-    // This protocol is so confusing. I'm sorry.
-    res.send({
-      success: true,
-      data: instance.proxies.map((proxy) => ({
-        proxyUrlSettings: {
-          host: "sameAs", // Makes pfC work (this is by design apparently)
-          port,
-          protocol: proxy.protocol.toUpperCase()
+      return {
+        success: true,
+        data: {
+          token,
         },
-  
-        dest: `${proxy.sourceIP}:${proxy.destPort}`,
-        name: `${proxy.protocol.toUpperCase()} on ::${proxy.sourcePort} -> ::${proxy.destPort}`,
-  
-        passwords: [
-          proxy.userConfig[userData.username]
-        ],
+      };
+    },
+  );
 
-        running: true
-      }))
-    });
-  });
-}
+  fastify.post(
+    "/api/v1/tunnels",
+    {
+      schema: {
+        body: {
+          type: "object",
+          required: ["token"],
+          properties: {
+            token: { type: "string" },
+          },
+        },
+      },
+    },
+    async (req, res) => {
+      // @ts-ignore
+      const body: {
+        token: string;
+      } = req.body;
+
+      const userData = instance.users.find(user => user.token == body.token);
+
+      if (!userData)
+        return res.status(403).send({
+          error: "Invalid token",
+        });
+
+      // const host = req.hostname.substring(0, req.hostname.indexOf(":"));
+      const unparsedPort = req.hostname.substring(
+        req.hostname.indexOf(":") + 1,
+      );
+
+      // @ts-ignore
+      // parseInt(...) can take a number just fine, at least in Node.JS
+      const port = parseInt(unparsedPort == "" ? proxiedPort : unparsedPort);
+
+      // This protocol is so confusing. I'm sorry.
+      res.send({
+        success: true,
+        data: instance.proxies.map(proxy => ({
+          proxyUrlSettings: {
+            host: "sameAs", // Makes pfC work (this is by design apparently)
+            port,
+            protocol: proxy.protocol.toUpperCase(),
+          },
+
+          dest: `${proxy.sourceIP}:${proxy.destPort}`,
+          name: `${proxy.protocol.toUpperCase()} on ::${proxy.sourcePort} -> ::${proxy.destPort}`,
+
+          passwords: [proxy.userConfig[userData.username]],
+
+          running: true,
+        })),
+      });
+    },
+  );
+}