REFACTORED - migrate the data layer from Prisma to Drizzle (unify the stack)

- Add lib/db (Drizzle schema: 7 tables + 6 enums + relations, postgres.js client),
  drizzle.config.ts, lib/db/enums.ts (Prisma-compatible enum objects)
- Rewrite all 14 app consumers + 4 admin components to Drizzle
- Move the test DB layer to Drizzle + in-process PGlite; convert all 8 integration
  test files + factories (371 tests green)
- Remove Prisma: deps, prisma/ schema+migrations, lib/prisma.ts, Dockerfile prisma
  generate; wire db:generate/migrate/push/studio to drizzle-kit; update Makefile
- Preserve the old seed as scripts/legacy-prisma-seed.cjs (needs a Drizzle rewrite)

lib/media.ts

@@ -1,20 +1,17 @@
-import type {
-  MediaAsset,
-  MediaKind,
-  MediaSource,
-  MediaUsage,
-  MediaUsageType,
-} from "@prisma/client";
+import { and, desc, eq } from "drizzle-orm";
 
-import { prisma } from "@/lib/prisma";
+import { db } from "@/lib/db";
+import { mediaAsset, mediaUsage } from "@/lib/db/schema";
+import type { MediaKind, MediaSource, MediaUsageType } from "@/lib/db/enums";
+
+type MediaAssetRow = typeof mediaAsset.$inferSelect;
+type MediaUsageRow = typeof mediaUsage.$inferSelect;
 
 export type MediaAssetView = Pick<
-  MediaAsset,
+  MediaAssetRow,
   "id" | "source" | "kind" | "url" | "fileName" | "label" | "altText" | "mimeType" | "size" | "createdAt"
 > & {
-  usages: Array<
-    Pick<MediaUsage, "id" | "usageType" | "entityType" | "entityId" | "fieldKey">
-  >;
+  usages: Array<Pick<MediaUsageRow, "id" | "usageType" | "entityType" | "entityId" | "fieldKey">>;
 };
 
 export type MediaOption = Pick<MediaAssetView, "id" | "kind" | "url" | "label" | "source">;
@@ -25,11 +22,7 @@ export type PortfolioMediaBindings = {
   assetIds: Record<string, string>;
 };
 
-function mapMediaAsset(
-  asset: MediaAsset & {
-    usages: MediaUsage[];
-  },
-): MediaAssetView {
+function mapMediaAsset(asset: MediaAssetRow & { usages: MediaUsageRow[] }): MediaAssetView {
   return {
     id: asset.id,
     source: asset.source,
@@ -52,40 +45,32 @@ function mapMediaAsset(
 }
 
 export async function getAdminMediaAssets() {
-  const assets = await prisma.mediaAsset.findMany({
-    include: {
-      usages: {
-        orderBy: [{ createdAt: "desc" }],
-      },
-    },
-    orderBy: [{ createdAt: "desc" }],
+  const assets = await db.query.mediaAsset.findMany({
+    with: { usages: { orderBy: [desc(mediaUsage.createdAt)] } },
+    orderBy: [desc(mediaAsset.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,
-    },
-  });
-
-  return assets;
+export async function getMediaOptions(filters?: { kind?: MediaKind }): Promise<MediaOption[]> {
+  return 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));
 }
 
 export async function getMediaAssetById(id: string) {
-  const asset = await prisma.mediaAsset.findUnique({
-    where: { id },
-    include: {
-      usages: true,
-    },
+  const asset = await db.query.mediaAsset.findFirst({
+    where: eq(mediaAsset.id, id),
+    with: { usages: true },
   });
 
   return asset ? mapMediaAsset(asset) : null;
@@ -101,8 +86,9 @@ export async function createMediaAsset(input: {
   mimeType?: string | null;
   size?: number | null;
 }) {
-  return prisma.mediaAsset.create({
-    data: {
+  const [created] = await db
+    .insert(mediaAsset)
+    .values({
       source: input.source,
       kind: input.kind,
       url: input.url,
@@ -111,8 +97,10 @@ export async function createMediaAsset(input: {
       altText: input.altText ?? null,
       mimeType: input.mimeType ?? null,
       size: input.size ?? null,
-    },
-  });
+    })
+    .returning();
+
+  return created;
 }
 
 export async function replaceEntityMediaUsages(input: {
@@ -124,51 +112,42 @@ 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 +174,5 @@ export async function getPortfolioMediaBindings(projectId: string): Promise<Port
 }
 
 export async function countMediaUsageReferences(assetId: string) {
-  return prisma.mediaUsage.count({
-    where: {
-      assetId,
-    },
-  });
+  return db.$count(mediaUsage, eq(mediaUsage.assetId, assetId));
 }