refactor: Move the list logic into a separate model

2 files changed, 24 insertions, 194 deletions

diff --git a/packages/trpc/routers/bookmarks.ts b/packages/trpc/routers/bookmarks.ts
index 3b2d23ce..63d20625 100644
--- a/packages/trpc/routers/bookmarks.ts
+++ b/packages/trpc/routers/bookmarks.ts
@@ -26,7 +26,6 @@ import {
   AssetTypes,
   bookmarkAssets,
   bookmarkLinks,
-  bookmarkLists,
   bookmarks,
   bookmarksInLists,
   bookmarkTags,
@@ -70,6 +69,7 @@ import type { AuthedContext, Context } from "../index";
 import { authedProcedure, router } from "../index";
 import { mapDBAssetTypeToUserType } from "../lib/attachments";
 import { getBookmarkIdsFromMatcher } from "../lib/search";
+import { List } from "../models/lists";
 import { ensureAssetOwnership } from "./assets";
 
 export const ensureBookmarkOwnership = experimental_trpcMiddleware<{
@@ -652,31 +652,10 @@ export const bookmarksAppRouter = router({
         input.limit = DEFAULT_NUM_BOOKMARKS_PER_PAGE;
       }
       if (input.listId) {
-        const list = await ctx.db.query.bookmarkLists.findFirst({
-          where: and(
-            eq(bookmarkLists.id, input.listId),
-            eq(bookmarkLists.userId, ctx.user.id),
-          ),
-        });
-        if (!list) {
-          throw new TRPCError({
-            code: "NOT_FOUND",
-            message: "List not found",
-          });
-        }
+        const list = await List.fromId(ctx, input.listId);
         if (list.type === "smart") {
-          invariant(list.query);
-          const query = parseSearchQuery(list.query);
-          if (query.result !== "full") {
-            throw new TRPCError({
-              code: "INTERNAL_SERVER_ERROR",
-              message: "Found an invalid smart list query",
-            });
-          }
-          if (query.matcher) {
-            input.ids = await getBookmarkIdsFromMatcher(ctx, query.matcher);
-            delete input.listId;
-          }
+          input.ids = await list.getBookmarkIds();
+          delete input.listId;
         }
       }
 
diff --git a/packages/trpc/routers/lists.ts b/packages/trpc/routers/lists.ts
index ec7cb10f..59441879 100644
--- a/packages/trpc/routers/lists.ts
+++ b/packages/trpc/routers/lists.ts
@@ -1,51 +1,28 @@
-import assert from "node:assert";
-import { experimental_trpcMiddleware, TRPCError } from "@trpc/server";
-import { and, eq } from "drizzle-orm";
-import invariant from "tiny-invariant";
+import { experimental_trpcMiddleware } from "@trpc/server";
 import { z } from "zod";
 
-import { SqliteError } from "@hoarder/db";
-import { bookmarkLists, bookmarksInLists } from "@hoarder/db/schema";
 import {
   zBookmarkListSchema,
   zEditBookmarkListSchemaWithValidation,
   zNewBookmarkListSchema,
 } from "@hoarder/shared/types/lists";
 
-import type { Context } from "../index";
+import type { AuthedContext } from "../index";
 import { authedProcedure, router } from "../index";
+import { List } from "../models/lists";
 import { ensureBookmarkOwnership } from "./bookmarks";
 
 export const ensureListOwnership = experimental_trpcMiddleware<{
-  ctx: Context;
+  ctx: AuthedContext;
   input: { listId: string };
 }>().create(async (opts) => {
-  const list = await opts.ctx.db.query.bookmarkLists.findFirst({
-    where: eq(bookmarkLists.id, opts.input.listId),
-    columns: {
-      userId: true,
+  const list = await List.fromId(opts.ctx, opts.input.listId);
+  return opts.next({
+    ctx: {
+      ...opts.ctx,
+      list,
     },
   });
-  if (!opts.ctx.user) {
-    throw new TRPCError({
-      code: "UNAUTHORIZED",
-      message: "User is not authorized",
-    });
-  }
-  if (!list) {
-    throw new TRPCError({
-      code: "NOT_FOUND",
-      message: "List not found",
-    });
-  }
-  if (list.userId != opts.ctx.user.id) {
-    throw new TRPCError({
-      code: "FORBIDDEN",
-      message: "User is not allowed to access resource",
-    });
-  }
-
-  return opts.next();
 });
 
 export const listsAppRouter = router({
@@ -53,59 +30,14 @@ export const listsAppRouter = router({
     .input(zNewBookmarkListSchema)
     .output(zBookmarkListSchema)
     .mutation(async ({ input, ctx }) => {
-      const [result] = await ctx.db
-        .insert(bookmarkLists)
-        .values({
-          name: input.name,
-          icon: input.icon,
-          userId: ctx.user.id,
-          parentId: input.parentId,
-          type: input.type,
-          query: input.query,
-        })
-        .returning();
-      return result;
+      return await List.create(ctx, input).then((l) => l.list);
     }),
   edit: authedProcedure
     .input(zEditBookmarkListSchemaWithValidation)
     .output(zBookmarkListSchema)
     .use(ensureListOwnership)
     .mutation(async ({ input, ctx }) => {
-      if (input.query) {
-        const list = await ctx.db.query.bookmarkLists.findFirst({
-          where: and(
-            eq(bookmarkLists.id, input.listId),
-            eq(bookmarkLists.userId, ctx.user.id),
-          ),
-        });
-        // List must exist given that we passed the ownership check
-        invariant(list);
-        if (list.type !== "smart") {
-          throw new TRPCError({
-            code: "BAD_REQUEST",
-            message: "Manual lists cannot have a query",
-          });
-        }
-      }
-      const result = await ctx.db
-        .update(bookmarkLists)
-        .set({
-          name: input.name,
-          icon: input.icon,
-          parentId: input.parentId,
-          query: input.query,
-        })
-        .where(
-          and(
-            eq(bookmarkLists.id, input.listId),
-            eq(bookmarkLists.userId, ctx.user.id),
-          ),
-        )
-        .returning();
-      if (result.length == 0) {
-        throw new TRPCError({ code: "NOT_FOUND" });
-      }
-      return result[0];
+      return await ctx.list.update(input);
     }),
   delete: authedProcedure
     .input(
@@ -114,18 +46,8 @@ export const listsAppRouter = router({
       }),
     )
     .use(ensureListOwnership)
-    .mutation(async ({ input, ctx }) => {
-      const res = await ctx.db
-        .delete(bookmarkLists)
-        .where(
-          and(
-            eq(bookmarkLists.id, input.listId),
-            eq(bookmarkLists.userId, ctx.user.id),
-          ),
-        );
-      if (res.changes == 0) {
-        throw new TRPCError({ code: "NOT_FOUND" });
-      }
+    .mutation(async ({ ctx }) => {
+      await ctx.list.delete();
     }),
   addToList: authedProcedure
     .input(
@@ -137,38 +59,7 @@ export const listsAppRouter = router({
     .use(ensureListOwnership)
     .use(ensureBookmarkOwnership)
     .mutation(async ({ input, ctx }) => {
-      const list = await ctx.db.query.bookmarkLists.findFirst({
-        where: and(
-          eq(bookmarkLists.id, input.listId),
-          eq(bookmarkLists.userId, ctx.user.id),
-        ),
-      });
-      invariant(list);
-      if (list.type === "smart") {
-        throw new TRPCError({
-          code: "BAD_REQUEST",
-          message: "Smart lists cannot be added to",
-        });
-      }
-      try {
-        await ctx.db.insert(bookmarksInLists).values({
-          listId: input.listId,
-          bookmarkId: input.bookmarkId,
-        });
-      } catch (e) {
-        if (e instanceof SqliteError) {
-          if (e.code == "SQLITE_CONSTRAINT_PRIMARYKEY") {
-            throw new TRPCError({
-              code: "BAD_REQUEST",
-              message: `Bookmark ${input.bookmarkId} is already in the list ${input.listId}`,
-            });
-          }
-        }
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "Something went wrong",
-        });
-      }
+      await ctx.list.addBookmark(input.bookmarkId);
     }),
   removeFromList: authedProcedure
     .input(
@@ -180,20 +71,7 @@ export const listsAppRouter = router({
     .use(ensureListOwnership)
     .use(ensureBookmarkOwnership)
     .mutation(async ({ input, ctx }) => {
-      const deleted = await ctx.db
-        .delete(bookmarksInLists)
-        .where(
-          and(
-            eq(bookmarksInLists.listId, input.listId),
-            eq(bookmarksInLists.bookmarkId, input.bookmarkId),
-          ),
-        );
-      if (deleted.changes == 0) {
-        throw new TRPCError({
-          code: "BAD_REQUEST",
-          message: `Bookmark ${input.bookmarkId} is already not in list ${input.listId}`,
-        });
-      }
+      await ctx.list.removeBookmark(input.bookmarkId);
     }),
   get: authedProcedure
     .input(
@@ -203,25 +81,8 @@ export const listsAppRouter = router({
     )
     .output(zBookmarkListSchema)
     .use(ensureListOwnership)
-    .query(async ({ input, ctx }) => {
-      const res = await ctx.db.query.bookmarkLists.findFirst({
-        where: and(
-          eq(bookmarkLists.id, input.listId),
-          eq(bookmarkLists.userId, ctx.user.id),
-        ),
-      });
-      if (!res) {
-        throw new TRPCError({ code: "NOT_FOUND" });
-      }
-
-      return {
-        id: res.id,
-        name: res.name,
-        icon: res.icon,
-        parentId: res.parentId,
-        type: res.type,
-        query: res.query,
-      };
+    .query(({ ctx }) => {
+      return ctx.list.list;
     }),
   list: authedProcedure
     .output(
@@ -230,11 +91,8 @@ export const listsAppRouter = router({
       }),
     )
     .query(async ({ ctx }) => {
-      const lists = await ctx.db.query.bookmarkLists.findMany({
-        where: and(eq(bookmarkLists.userId, ctx.user.id)),
-      });
-
-      return { lists };
+      const results = await List.getAll(ctx);
+      return { lists: results.map((l) => l.list) };
     }),
   getListsOfBookmark: authedProcedure
     .input(z.object({ bookmarkId: z.string() }))
@@ -245,14 +103,7 @@ export const listsAppRouter = router({
     )
     .use(ensureBookmarkOwnership)
     .query(async ({ input, ctx }) => {
-      const lists = await ctx.db.query.bookmarksInLists.findMany({
-        where: and(eq(bookmarksInLists.bookmarkId, input.bookmarkId)),
-        with: {
-          list: true,
-        },
-      });
-      assert(lists.map((l) => l.list.userId).every((id) => id == ctx.user.id));
-
+      const lists = await List.forBookmark(ctx, input.bookmarkId);
       return { lists: lists.map((l) => l.list) };
     }),
 });