From e234d3535c363664902dffe89a2c61ddbc037da4 Mon Sep 17 00:00:00 2001 From: MohamedBassem Date: Fri, 23 Feb 2024 19:27:31 +0000 Subject: db: Migrate from prisma to drizzle --- packages/web/server/api/routers/apiKeys.ts | 23 ++-- packages/web/server/api/routers/bookmarks.ts | 197 ++++++++++++++++----------- packages/web/server/api/routers/users.ts | 24 ++-- 3 files changed, 137 insertions(+), 107 deletions(-) (limited to 'packages/web/server/api') diff --git a/packages/web/server/api/routers/apiKeys.ts b/packages/web/server/api/routers/apiKeys.ts index 620ca223..eade5eec 100644 --- a/packages/web/server/api/routers/apiKeys.ts +++ b/packages/web/server/api/routers/apiKeys.ts @@ -1,7 +1,9 @@ import { generateApiKey } from "@/server/auth"; import { authedProcedure, router } from "../trpc"; -import { prisma } from "@hoarder/db"; +import { db } from "@hoarder/db"; import { z } from "zod"; +import { apiKeys } from "@hoarder/db/schema"; +import { eq, and } from "drizzle-orm"; export const apiKeysAppRouter = router({ create: authedProcedure @@ -29,13 +31,10 @@ export const apiKeysAppRouter = router({ ) .output(z.object({})) .mutation(async ({ input, ctx }) => { - const resp = await prisma.apiKey.delete({ - where: { - id: input.id, - userId: ctx.user.id, - }, - }); - return resp; + await db + .delete(apiKeys) + .where(and(eq(apiKeys.id, input.id), eq(apiKeys.userId, ctx.user.id))) + .returning(); }), list: authedProcedure .output( @@ -51,11 +50,9 @@ export const apiKeysAppRouter = router({ }), ) .query(async ({ ctx }) => { - const resp = await prisma.apiKey.findMany({ - where: { - userId: ctx.user.id, - }, - select: { + const resp = await db.query.apiKeys.findMany({ + where: eq(apiKeys.userId, ctx.user.id), + columns: { id: true, name: true, createdAt: true, diff --git a/packages/web/server/api/routers/bookmarks.ts b/packages/web/server/api/routers/bookmarks.ts index 65f20ef5..2af81d27 100644 --- a/packages/web/server/api/routers/bookmarks.ts +++ b/packages/web/server/api/routers/bookmarks.ts @@ -3,46 +3,28 @@ import { authedProcedure, router } from "../trpc"; import { ZBookmark, ZBookmarkContent, + zBareBookmarkSchema, zBookmarkSchema, zGetBookmarksRequestSchema, zGetBookmarksResponseSchema, zNewBookmarkRequestSchema, zUpdateBookmarksRequestSchema, } from "@/lib/types/api/bookmarks"; -import { prisma } from "@hoarder/db"; +import { db } from "@hoarder/db"; +import { bookmarkLinks, bookmarks } from "@hoarder/db/schema"; import { LinkCrawlerQueue } from "@hoarder/shared/queues"; import { TRPCError, experimental_trpcMiddleware } from "@trpc/server"; import { User } from "next-auth"; - -const defaultBookmarkFields = { - id: true, - favourited: true, - archived: true, - createdAt: true, - link: { - select: { - url: true, - title: true, - description: true, - imageUrl: true, - favicon: true, - crawledAt: true, - }, - }, - tags: { - include: { - tag: true, - }, - }, -}; +import { and, desc, eq, inArray } from "drizzle-orm"; +import { ZBookmarkTags } from "@/lib/types/api/tags"; const ensureBookmarkOwnership = experimental_trpcMiddleware<{ ctx: { user: User }; input: { bookmarkId: string }; }>().create(async (opts) => { - const bookmark = await prisma.bookmark.findUnique({ - where: { id: opts.input.bookmarkId }, - select: { + const bookmark = await db.query.bookmarks.findFirst({ + where: eq(bookmarks.id, opts.input.bookmarkId), + columns: { userId: true, }, }); @@ -62,17 +44,27 @@ const ensureBookmarkOwnership = experimental_trpcMiddleware<{ return opts.next(); }); -async function dummyPrismaReturnType() { - const x = await prisma.bookmark.findFirstOrThrow({ - select: defaultBookmarkFields, +async function dummyDrizzleReturnType() { + const x = await db.query.bookmarks.findFirst({ + with: { + tagsOnBookmarks: { + with: { + tag: true, + }, + }, + link: true, + }, }); + if (!x) { + throw new Error(); + } return x; } function toZodSchema( - bookmark: Awaited>, + bookmark: Awaited>, ): ZBookmark { - const { tags, link, ...rest } = bookmark; + const { tagsOnBookmarks, link, ...rest } = bookmark; let content: ZBookmarkContent; if (link) { @@ -82,7 +74,7 @@ function toZodSchema( } return { - tags: tags.map((t) => t.tag), + tags: tagsOnBookmarks.map((t) => t.tag), content, ...rest, }; @@ -94,18 +86,37 @@ export const bookmarksAppRouter = router({ .output(zBookmarkSchema) .mutation(async ({ input, ctx }) => { const { url } = input; - const userId = ctx.user.id; - const bookmark = await prisma.bookmark.create({ - data: { - link: { - create: { + const bookmark = await db.transaction(async (tx): Promise => { + const bookmark = ( + await tx + .insert(bookmarks) + .values({ + userId: ctx.user.id, + }) + .returning() + )[0]; + + const link = ( + await tx + .insert(bookmarkLinks) + .values({ + id: bookmark.id, url, - }, - }, - userId, - }, - select: defaultBookmarkFields, + }) + .returning() + )[0]; + + const content: ZBookmarkContent = { + type: "link", + ...link, + }; + + return { + tags: [] as ZBookmarkTags[], + content, + ...bookmark, + }; }); // Enqueue crawling request @@ -113,38 +124,48 @@ export const bookmarksAppRouter = router({ bookmarkId: bookmark.id, }); - return toZodSchema(bookmark); + return bookmark; }), updateBookmark: authedProcedure .input(zUpdateBookmarksRequestSchema) - .output(zBookmarkSchema) + .output(zBareBookmarkSchema) .use(ensureBookmarkOwnership) .mutation(async ({ input, ctx }) => { - const bookmark = await prisma.bookmark.update({ - where: { - id: input.bookmarkId, - userId: ctx.user.id, - }, - data: { + const res = await db + .update(bookmarks) + .set({ archived: input.archived, favourited: input.favourited, - }, - select: defaultBookmarkFields, - }); - return toZodSchema(bookmark); + }) + .where( + and( + eq(bookmarks.userId, ctx.user.id), + eq(bookmarks.id, input.bookmarkId), + ), + ) + .returning(); + if (res.length == 0) { + throw new TRPCError({ + code: "NOT_FOUND", + message: "Bookmark not found", + }); + } + return res[0]; }), deleteBookmark: authedProcedure .input(z.object({ bookmarkId: z.string() })) .use(ensureBookmarkOwnership) .mutation(async ({ input, ctx }) => { - await prisma.bookmark.delete({ - where: { - id: input.bookmarkId, - userId: ctx.user.id, - }, - }); + await db + .delete(bookmarks) + .where( + and( + eq(bookmarks.userId, ctx.user.id), + eq(bookmarks.id, input.bookmarkId), + ), + ); }), recrawlBookmark: authedProcedure .input(z.object({ bookmarkId: z.string() })) @@ -162,12 +183,19 @@ export const bookmarksAppRouter = router({ ) .output(zBookmarkSchema) .query(async ({ input, ctx }) => { - const bookmark = await prisma.bookmark.findUnique({ - where: { - userId: ctx.user.id, - id: input.id, + const bookmark = await db.query.bookmarks.findFirst({ + where: and( + eq(bookmarks.userId, ctx.user.id), + eq(bookmarks.id, input.id), + ), + with: { + tagsOnBookmarks: { + with: { + tag: true, + }, + }, + link: true, }, - select: defaultBookmarkFields, }); if (!bookmark) { throw new TRPCError({ @@ -182,25 +210,28 @@ export const bookmarksAppRouter = router({ .input(zGetBookmarksRequestSchema) .output(zGetBookmarksResponseSchema) .query(async ({ input, ctx }) => { - const bookmarks = ( - await prisma.bookmark.findMany({ - where: { - userId: ctx.user.id, - archived: input.archived, - favourited: input.favourited, - id: input.ids - ? { - in: input.ids, - } - : undefined, - }, - orderBy: { - createdAt: "desc", + const results = await db.query.bookmarks.findMany({ + where: and( + eq(bookmarks.userId, ctx.user.id), + input.archived !== undefined + ? eq(bookmarks.archived, input.archived) + : undefined, + input.favourited !== undefined + ? eq(bookmarks.favourited, input.favourited) + : undefined, + input.ids ? inArray(bookmarks.id, input.ids) : undefined, + ), + orderBy: [desc(bookmarks.createdAt)], + with: { + tagsOnBookmarks: { + with: { + tag: true, + }, }, - select: defaultBookmarkFields, - }) - ).map(toZodSchema); + link: true, + }, + }); - return { bookmarks }; + return { bookmarks: results.map(toZodSchema) }; }), }); diff --git a/packages/web/server/api/routers/users.ts b/packages/web/server/api/routers/users.ts index aecec1d4..032385ac 100644 --- a/packages/web/server/api/routers/users.ts +++ b/packages/web/server/api/routers/users.ts @@ -1,9 +1,10 @@ import { zSignUpSchema } from "@/lib/types/api/users"; import { publicProcedure, router } from "../trpc"; -import { Prisma, prisma } from "@hoarder/db"; +import { SqliteError, db } from "@hoarder/db"; import { z } from "zod"; import { hashPassword } from "@/server/auth"; import { TRPCError } from "@trpc/server"; +import { users } from "@hoarder/db/schema"; export const usersAppRouter = router({ create: publicProcedure @@ -16,20 +17,21 @@ export const usersAppRouter = router({ ) .mutation(async ({ input }) => { try { - return await prisma.user.create({ - data: { + const result = await db + .insert(users) + .values({ name: input.name, email: input.email, password: await hashPassword(input.password), - }, - select: { - name: true, - email: true, - }, - }); + }) + .returning({ + name: users.name, + email: users.email, + }); + return result[0]; } catch (e) { - if (e instanceof Prisma.PrismaClientKnownRequestError) { - if (e.code === "P2002") { + if (e instanceof SqliteError) { + if (e.code == "SQLITE_CONSTRAINT_UNIQUE") { throw new TRPCError({ code: "BAD_REQUEST", message: "Email is already taken", -- cgit v1.2.3-70-g09d2