refactor: Migrate from NextJs's API routes to Hono based routes for the API (#1432)

* Setup Hono and migrate the highlights API there

* Implement the tags and lists endpoint

* Implement the bookmarks and users endpoints

* Add the trpc error code adapter

* Remove the old nextjs handlers

* fix api key not found handling

* Fix trpc error handling

* Fix 204 handling

* Fix search ordering

* Implement the singlefile endpoint

* Implement the asset serving endpoints

* Implement webauth

* Add hono as a catch all route under api

* fix tests

1 files changed, 252 insertions, 0 deletions

diff --git a/packages/api/routes/bookmarks.ts b/packages/api/routes/bookmarks.ts
new file mode 100644
index 00000000..fbc46d2f
--- /dev/null
+++ b/packages/api/routes/bookmarks.ts
@@ -0,0 +1,252 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+
+import {
+  BookmarkTypes,
+  zAssetSchema,
+  zManipulatedTagSchema,
+  zNewBookmarkRequestSchema,
+  zUpdateBookmarksRequestSchema,
+} from "@karakeep/shared/types/bookmarks";
+
+import { authMiddleware } from "../middlewares/auth";
+import { adaptPagination, zPagination } from "../utils/pagination";
+import {
+  zGetBookmarkQueryParamsSchema,
+  zGetBookmarkSearchParamsSchema,
+  zIncludeContentSearchParamsSchema,
+  zStringBool,
+} from "../utils/types";
+import { uploadAsset } from "../utils/upload";
+
+const app = new Hono()
+  .use(authMiddleware)
+
+  // GET /bookmarks
+  .get(
+    "/",
+    zValidator(
+      "query",
+      z
+        .object({
+          favourited: zStringBool.optional(),
+          archived: zStringBool.optional(),
+        })
+        .and(zGetBookmarkQueryParamsSchema)
+        .and(zPagination),
+    ),
+    async (c) => {
+      const searchParams = c.req.valid("query");
+      const bookmarks = await c.var.api.bookmarks.getBookmarks(searchParams);
+      return c.json(adaptPagination(bookmarks), 200);
+    },
+  )
+
+  // POST /bookmarks
+  .post("/", zValidator("json", zNewBookmarkRequestSchema), async (c) => {
+    const body = c.req.valid("json");
+    const bookmark = await c.var.api.bookmarks.createBookmark(body);
+    return c.json(bookmark, 201);
+  })
+
+  // GET /bookmarks/search
+  .get(
+    "/search",
+    zValidator(
+      "query",
+      z
+        .object({
+          q: z.string(),
+          limit: z.coerce.number().optional(),
+          cursor: z
+            .string()
+            .optional()
+            .transform((val) =>
+              val ? { ver: 1 as const, offset: parseInt(val) } : undefined,
+            ),
+        })
+        .and(zGetBookmarkSearchParamsSchema),
+    ),
+    async (c) => {
+      const searchParams = c.req.valid("query");
+      const bookmarks = await c.var.api.bookmarks.searchBookmarks({
+        text: searchParams.q,
+        cursor: searchParams.cursor,
+        limit: searchParams.limit,
+        includeContent: searchParams.includeContent,
+      });
+      return c.json(
+        {
+          bookmarks: bookmarks.bookmarks,
+          nextCursor: bookmarks.nextCursor
+            ? `${bookmarks.nextCursor.offset}`
+            : null,
+        },
+        200,
+      );
+    },
+  )
+  .post(
+    "/singlefile",
+    zValidator(
+      "form",
+      z.object({
+        url: z.string(),
+        file: z.instanceof(File),
+      }),
+    ),
+    async (c) => {
+      const form = c.req.valid("form");
+      const up = await uploadAsset(c.var.ctx.user, c.var.ctx.db, form);
+      if ("error" in up) {
+        return c.json({ error: up.error }, up.status);
+      }
+      const bookmark = await c.var.api.bookmarks.createBookmark({
+        type: BookmarkTypes.LINK,
+        url: form.url,
+        precrawledArchiveId: up.assetId,
+      });
+      return c.json(bookmark, 201);
+    },
+  )
+
+  // GET /bookmarks/[bookmarkId]
+  .get(
+    "/:bookmarkId",
+    zValidator("query", zIncludeContentSearchParamsSchema),
+    async (c) => {
+      const bookmarkId = c.req.param("bookmarkId");
+      const searchParams = c.req.valid("query");
+      const bookmark = await c.var.api.bookmarks.getBookmark({
+        bookmarkId,
+        includeContent: searchParams.includeContent,
+      });
+      return c.json(bookmark, 200);
+    },
+  )
+
+  // PATCH /bookmarks/[bookmarkId]
+  .patch(
+    "/:bookmarkId",
+    zValidator(
+      "json",
+      zUpdateBookmarksRequestSchema.omit({ bookmarkId: true }),
+    ),
+    async (c) => {
+      const bookmarkId = c.req.param("bookmarkId");
+      const body = c.req.valid("json");
+      const bookmark = await c.var.api.bookmarks.updateBookmark({
+        bookmarkId,
+        ...body,
+      });
+      return c.json(bookmark, 200);
+    },
+  )
+
+  // DELETE /bookmarks/[bookmarkId]
+  .delete("/:bookmarkId", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    await c.var.api.bookmarks.deleteBookmark({ bookmarkId });
+    return c.body(null, 204);
+  })
+
+  // GET /bookmarks/[bookmarkId]/lists
+  .get("/:bookmarkId/lists", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const resp = await c.var.api.lists.getListsOfBookmark({ bookmarkId });
+    return c.json(resp, 200);
+  })
+
+  // GET /bookmarks/[bookmarkId]/assets
+  .get("/:bookmarkId/assets", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const resp = await c.var.api.bookmarks.getBookmark({ bookmarkId });
+    return c.json({ assets: resp.assets }, 200);
+  })
+
+  // POST /bookmarks/[bookmarkId]/assets
+  .post("/:bookmarkId/assets", zValidator("json", zAssetSchema), async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const body = c.req.valid("json");
+    const asset = await c.var.api.assets.attachAsset({
+      bookmarkId,
+      asset: body,
+    });
+    return c.json(asset, 201);
+  })
+
+  // PUT /bookmarks/[bookmarkId]/assets/[assetId]
+  .put(
+    "/:bookmarkId/assets/:assetId",
+    zValidator("json", z.object({ assetId: z.string() })),
+    async (c) => {
+      const bookmarkId = c.req.param("bookmarkId");
+      const assetId = c.req.param("assetId");
+      const body = c.req.valid("json");
+      await c.var.api.assets.replaceAsset({
+        bookmarkId,
+        oldAssetId: assetId,
+        newAssetId: body.assetId,
+      });
+      return c.body(null, 204);
+    },
+  )
+
+  // DELETE /bookmarks/[bookmarkId]/assets/[assetId]
+  .delete("/:bookmarkId/assets/:assetId", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const assetId = c.req.param("assetId");
+    await c.var.api.assets.detachAsset({ bookmarkId, assetId });
+    return c.body(null, 204);
+  })
+
+  // POST /bookmarks/[bookmarkId]/tags
+  .post(
+    "/:bookmarkId/tags",
+    zValidator("json", z.object({ tags: z.array(zManipulatedTagSchema) })),
+    async (c) => {
+      const bookmarkId = c.req.param("bookmarkId");
+      const body = c.req.valid("json");
+      const resp = await c.var.api.bookmarks.updateTags({
+        bookmarkId,
+        attach: body.tags,
+        detach: [],
+      });
+      return c.json({ attached: resp.attached }, 200);
+    },
+  )
+
+  // DELETE /bookmarks/[bookmarkId]/tags
+  .delete(
+    "/:bookmarkId/tags",
+    zValidator("json", z.object({ tags: z.array(zManipulatedTagSchema) })),
+    async (c) => {
+      const bookmarkId = c.req.param("bookmarkId");
+      const body = c.req.valid("json");
+      const resp = await c.var.api.bookmarks.updateTags({
+        bookmarkId,
+        detach: body.tags,
+        attach: [],
+      });
+      return c.json({ detached: resp.detached }, 200);
+    },
+  )
+
+  // POST /bookmarks/[bookmarkId]/summarize
+  .post("/:bookmarkId/summarize", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const bookmark = await c.var.api.bookmarks.summarizeBookmark({
+      bookmarkId,
+    });
+    return c.json(bookmark, 200);
+  })
+
+  // GET /bookmarks/[bookmarkId]/highlights
+  .get("/:bookmarkId/highlights", async (c) => {
+    const bookmarkId = c.req.param("bookmarkId");
+    const resp = await c.var.api.highlights.getForBookmark({ bookmarkId });
+    return c.json(resp, 200);
+  });
+
+export default app;