feat!: move to stable elysia version + ignore bots + safer link code updates

Author: axeelz

bun.lockb

@@ -1,10 +1,10 @@
 {
-  "name": "app",
-  "version": "1.0.50",
+  "name": "link-manager-api",
+  "version": "2.0.0",
   "scripts": {
     "dev": "bun --watch src/index.ts",
-    "build": "bun build src/index.ts",
-    "start": "NODE_ENV=production bun src/index.ts",
+    "build": "bun build src/index.ts --target bun --outdir ./dist",
+    "start": "NODE_ENV=production bun dist/index.js",
     "test": "bun test"
   },
   "dependencies": {
@@ -16,9 +16,10 @@
     "dotenv": "^16.4.5",
     "drizzle-orm": "^0.30.6",
     "drizzle-typebox": "^0.1.1",
-    "elysia": "latest",
+    "elysia": "^1.1.25",
     "elysia-helmet": "^1.0.2",
-    "elysia-ip": "^1.0.3",
+    "elysia-ip": "^1.0.7",
+    "isbot": "^5.1.17",
     "nanoid": "^5.0.6",
     "ua-parser-js": "^1.0.37"
   },

package.json

@@ -1,12 +1,25 @@
 import { count, desc, eq, sql, sum } from "drizzle-orm";
 import { db } from "../db/db";
 import { InsertLink, SelectLink, linksTable } from "../db/schema";
+import { generateCode } from "./utils";
 
 export async function codeAlreadyUsed(code: SelectLink["code"]): Promise<boolean> {
   const link = await db.select().from(linksTable).where(eq(linksTable.code, code));
   return link.length > 0;
 }
 
+export async function validateCode(code: string | undefined): Promise<string> {
+  if (!code || code.includes("/")) {
+    let generatedCode = "";
+    do {
+      generatedCode = generateCode();
+    } while (await codeAlreadyUsed(generatedCode));
+    return generatedCode;
+  } else {
+    return code;
+  }
+}
+
 export async function insertLink(data: InsertLink): Promise<SelectLink[]> {
   return await db.insert(linksTable).values(data).returning();
 }

src/functions/links.ts

@@ -12,6 +12,7 @@ import { redirectsRoutes } from "./routes/redirects";
 import bearer from "@elysiajs/bearer";
 import { demoRoutes } from "./routes/demo";
 import { NOT_FOUND_PAGE, PERSONAL_WEBSITE } from "./utils/constants";
+import { isbot } from "isbot";
 
 const app = new Elysia()
   .use(cors())
@@ -38,51 +39,54 @@ const app = new Elysia()
     }
   })
   // Logging
-  .onResponse(({ path, request }) => {
+  .onAfterResponse(({ path, request }) => {
     console.log(`🦊 ${request.method} - ${path}`);
   })
   // Mesure request performance
-  .trace(async ({ handle }) => {
-    const { time, end } = await handle;
-    console.log("⏳ it took", (await end) - time, "ms");
+  .trace(async ({ onHandle }) => {
+    onHandle(({ begin, onStop }) => {
+      onStop(({ end }) => {
+        console.log("⏳ it took", end - begin, "ms");
+      });
+    });
   })
   // Health check
   .get("/ping", () => "pong")
   // Homepage redirects to personal website
-  .get("/", ({ set }) => (set.redirect = PERSONAL_WEBSITE))
+  .get("/", ({ redirect }) => redirect(PERSONAL_WEBSITE))
   // Link redirection, where all the magic happens
   .get(
     "/:code",
-    async ({ params, set }) => {
+    async ({ params, set, redirect }) => {
       const link = await getLink(params.code);
 
       if (!link) {
-        set.redirect = `${NOT_FOUND_PAGE}?code=${params.code}`;
+        return redirect(`${NOT_FOUND_PAGE}?code=${params.code}`);
       } else {
         set.status = 301;
-        set.redirect = link.url;
+        return redirect(link.url);
       }
     },
     {
       params: t.Object({
         code: t.String(),
       }),
       // Save analytics data after redirection, for performance reasons
-      async onResponse({ params, ip, headers }) {
+      async afterResponse({ params, ip, headers }) {
         const link = await getLink(params.code);
-        if (!link) {
+        if (!link || isbot(headers["user-agent"])) {
           return;
         }
 
-        const parser = new UAParser(headers["user-agent"]);
+        const parserResult = new UAParser(headers["user-agent"]).getResult();
         const lang = headers["accept-language"]?.split(",")[0];
         const loc = await getIPLocation(ip);
         await insertRedirect({
           linkId: link.id,
           location: loc ? JSON.stringify(loc) : null,
           language: lang,
           referrer: headers["referer"],
-          userAgent: JSON.stringify(parser.getResult()),
+          userAgent: JSON.stringify(parserResult),
         });
         await incrementRedirects(params.code);
       },

src/index.ts

@@ -7,8 +7,9 @@ import {
   deleteLink,
   deleteAllLinks,
   editLink,
+  validateCode,
 } from "../functions/links";
-import { generateCode, isValidUrl } from "../functions/utils";
+import { isValidUrl } from "../functions/utils";
 
 export const linksRoutes = new Elysia({ prefix: "/links" })
   // Get all short links
@@ -23,12 +24,8 @@ export const linksRoutes = new Elysia({ prefix: "/links" })
         set.status = 400;
         return { status: 400, message: "Invalid URL" };
       }
-      if (!body.code || body.code.includes("/")) {
-        do {
-          body.code = generateCode();
-        } while (await codeAlreadyUsed(body.code));
-      }
-      const insertedLink = await insertLink(body as { code: string; url: string });
+      const finalCode = await validateCode(body.code);
+      const insertedLink = await insertLink({ code: finalCode, url: body.url });
       set.status = 201;
       return insertedLink;
     },
@@ -50,7 +47,8 @@ export const linksRoutes = new Elysia({ prefix: "/links" })
         set.status = 400;
         return { status: 400, message: "Invalid URL" };
       }
-      const updatedLink = await editLink(params.code, body as { code: string; url: string });
+      const finalCode = await validateCode(body.code);
+      const updatedLink = await editLink(params.code, { code: finalCode, url: body.url });
       set.status = 200;
       return updatedLink;
     },