REFACTORED - Replace Prisma with Drizzle ORM

- Add lib/db (schema, postgres.js client, enums, seed, migrations) on Drizzle
- Rewrite all lib and admin action queries from Prisma to Drizzle
- Keep existing table/column names so no data migration is needed
- Preserve signed-cookie admin auth unchanged
- Map unique-violation handling from Prisma P2002 to SQLSTATE 23505
- Swap deps, scripts, Makefile, and Dockerfile from Prisma to Drizzle

lib/media.ts

@@ -1,12 +1,9 @@
-import type {
-  MediaAsset,
-  MediaKind,
-  MediaSource,
-  MediaUsage,
-  MediaUsageType,
-} from "@prisma/client";
+import { and, count, desc, eq } from "drizzle-orm";
 
-import { prisma } from "@/lib/prisma";
+import { db } from "@/lib/db";
+import { mediaAsset, mediaUsage } from "@/lib/db/schema";
+import type { MediaAsset, MediaUsage } from "@/lib/db/schema";
+import type { MediaKind, MediaSource, MediaUsageType } from "@/lib/db/enums";
 
 export type MediaAssetView = Pick<
   MediaAsset,
@@ -52,38 +49,38 @@ function mapMediaAsset(
 }
 
 export async function getAdminMediaAssets() {
-  const assets = await prisma.mediaAsset.findMany({
-    include: {
+  const assets = await db.query.mediaAsset.findMany({
+    with: {
       usages: {
-        orderBy: [{ createdAt: "desc" }],
+        orderBy: (usage, { desc: descOrder }) => [descOrder(usage.createdAt)],
       },
     },
-    orderBy: [{ createdAt: "desc" }],
+    orderBy: (asset, { desc: descOrder }) => [descOrder(asset.createdAt)],
   });
 
   return assets.map(mapMediaAsset);
 }
 
 export async function getMediaOptions(filters?: { kind?: MediaKind }) {
-  const assets = await prisma.mediaAsset.findMany({
-    where: filters?.kind ? { kind: filters.kind } : undefined,
-    orderBy: [{ createdAt: "desc" }],
-    select: {
-      id: true,
-      kind: true,
-      url: true,
-      label: true,
-      source: true,
-    },
-  });
+  const assets = await db
+    .select({
+      id: mediaAsset.id,
+      kind: mediaAsset.kind,
+      url: mediaAsset.url,
+      label: mediaAsset.label,
+      source: mediaAsset.source,
+    })
+    .from(mediaAsset)
+    .where(filters?.kind ? eq(mediaAsset.kind, filters.kind) : undefined)
+    .orderBy(desc(mediaAsset.createdAt));
 
   return assets;
 }
 
 export async function getMediaAssetById(id: string) {
-  const asset = await prisma.mediaAsset.findUnique({
-    where: { id },
-    include: {
+  const asset = await db.query.mediaAsset.findFirst({
+    where: eq(mediaAsset.id, id),
+    with: {
       usages: true,
     },
   });
@@ -101,8 +98,9 @@ export async function createMediaAsset(input: {
   mimeType?: string | null;
   size?: number | null;
 }) {
-  return prisma.mediaAsset.create({
-    data: {
+  const [asset] = await db
+    .insert(mediaAsset)
+    .values({
       source: input.source,
       kind: input.kind,
       url: input.url,
@@ -111,8 +109,10 @@ export async function createMediaAsset(input: {
       altText: input.altText ?? null,
       mimeType: input.mimeType ?? null,
       size: input.size ?? null,
-    },
-  });
+    })
+    .returning();
+
+  return asset;
 }
 
 export async function replaceEntityMediaUsages(input: {
@@ -124,51 +124,49 @@ export async function replaceEntityMediaUsages(input: {
     fieldKey: string;
   }>;
 }) {
-  await prisma.$transaction(async (tx) => {
-    await tx.mediaUsage.deleteMany({
-      where: {
-        entityType: input.entityType,
-        entityId: input.entityId,
-      },
-    });
+  await db.transaction(async (tx) => {
+    await tx
+      .delete(mediaUsage)
+      .where(
+        and(
+          eq(mediaUsage.entityType, input.entityType),
+          eq(mediaUsage.entityId, input.entityId),
+        ),
+      );
 
     if (input.usages.length === 0) {
       return;
     }
 
-    await tx.mediaUsage.createMany({
-      data: input.usages.map((usage) => ({
+    await tx.insert(mediaUsage).values(
+      input.usages.map((usage) => ({
         assetId: usage.assetId,
         usageType: usage.usageType,
         entityType: input.entityType,
         entityId: input.entityId,
         fieldKey: usage.fieldKey,
       })),
-    });
+    );
   });
 }
 
 export async function deleteEntityMediaUsages(entityType: string, entityId: string) {
-  await prisma.mediaUsage.deleteMany({
-    where: {
-      entityType,
-      entityId,
-    },
-  });
+  await db
+    .delete(mediaUsage)
+    .where(and(eq(mediaUsage.entityType, entityType), eq(mediaUsage.entityId, entityId)));
 }
 
 export async function getPortfolioMediaBindings(projectId: string): Promise<PortfolioMediaBindings> {
-  const usages = await prisma.mediaUsage.findMany({
-    where: {
-      entityType: "portfolio-project",
-      entityId: projectId,
-    },
-    select: {
-      assetId: true,
-      usageType: true,
-      fieldKey: true,
-    },
-  });
+  const usages = await db
+    .select({
+      assetId: mediaUsage.assetId,
+      usageType: mediaUsage.usageType,
+      fieldKey: mediaUsage.fieldKey,
+    })
+    .from(mediaUsage)
+    .where(
+      and(eq(mediaUsage.entityType, "portfolio-project"), eq(mediaUsage.entityId, projectId)),
+    );
 
   return usages.reduce<PortfolioMediaBindings>(
     (result, usage) => {
@@ -195,9 +193,10 @@ export async function getPortfolioMediaBindings(projectId: string): Promise<Port
 }
 
 export async function countMediaUsageReferences(assetId: string) {
-  return prisma.mediaUsage.count({
-    where: {
-      assetId,
-    },
-  });
+  const [row] = await db
+    .select({ value: count() })
+    .from(mediaUsage)
+    .where(eq(mediaUsage.assetId, assetId));
+
+  return row?.value ?? 0;
 }