Break work

src/server/api/routers/storage.ts

@@ -0,0 +1,71 @@
+
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "~/server/api/trpc";
+import { s3Client } from "~/server/storage";
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { env } from "~/env";
+import { TRPCError } from "@trpc/server";
+import { db } from "~/server/db";
+import { mediaCaptures } from "~/server/db/schema";
+
+export const storageRouter = createTRPCRouter({
+    getUploadPresignedUrl: protectedProcedure
+        .input(
+            z.object({
+                filename: z.string(),
+                contentType: z.string(),
+            })
+        )
+        .mutation(async ({ input }) => {
+            const bucket = env.MINIO_BUCKET_NAME ?? "hristudio-data";
+            const key = input.filename;
+
+            try {
+                const command = new PutObjectCommand({
+                    Bucket: bucket,
+                    Key: key,
+                    ContentType: input.contentType,
+                });
+
+                const url = await getSignedUrl(s3Client, command, { expiresIn: 3600 });
+
+                return {
+                    url,
+                    key,
+                    bucket,
+                };
+            } catch (error) {
+                console.error("Error generating presigned URL:", error);
+                throw new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    message: "Failed to generate upload URL",
+                });
+            }
+        }),
+    saveRecording: protectedProcedure
+        .input(
+            z.object({
+                trialId: z.string(),
+                storagePath: z.string(),
+                fileSize: z.number().optional(),
+                format: z.string().optional(),
+                mediaType: z.enum(["video", "audio", "image"]).default("video"),
+            })
+        )
+        .mutation(async ({ ctx, input }) => {
+            const { db } = ctx;
+
+            await db.insert(mediaCaptures).values({
+                trialId: input.trialId,
+                mediaType: input.mediaType,
+                storagePath: input.storagePath,
+                fileSize: input.fileSize,
+                format: input.format,
+                startTimestamp: new Date(), // Approximate
+                // metadata: { uploadedBy: ctx.session.user.id }
+            });
+
+            return { success: true };
+        }),
+});

src/server/api/routers/trials.ts

@@ -30,6 +30,10 @@ import {
   TrialExecutionEngine,
   type ActionDefinition,
 } from "~/server/services/trial-execution";
+import { s3Client } from "~/server/storage";
+import { GetObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { env } from "~/env";
 
 // Helper function to check if user has access to trial
 async function checkTrialAccess(
@@ -270,15 +274,34 @@ export const trialsRouter = createTRPCRouter({
         .from(trialEvents)
         .where(eq(trialEvents.trialId, input.id));
 
-      const mediaCount = await db
-        .select({ count: count() })
+      const media = await db
+        .select()
         .from(mediaCaptures)
-        .where(eq(mediaCaptures.trialId, input.id));
+        .where(eq(mediaCaptures.trialId, input.id))
+        .orderBy(desc(mediaCaptures.createdAt)); // Get latest first
 
       return {
         ...trial[0],
         eventCount: eventCount[0]?.count ?? 0,
-        mediaCount: mediaCount[0]?.count ?? 0,
+        mediaCount: media.length,
+        media: await Promise.all(media.map(async (m) => {
+          let url = "";
+          try {
+            // Generate Presigned GET URL
+            const command = new GetObjectCommand({
+              Bucket: env.MINIO_BUCKET_NAME ?? "hristudio-data",
+              Key: m.storagePath,
+            });
+            url = await getSignedUrl(s3Client, command, { expiresIn: 3600 });
+          } catch (e) {
+            console.error("Failed to sign URL for media", m.id, e);
+          }
+          return {
+            ...m,
+            url, // Add the signed URL to the response
+            contentType: m.format === 'webm' ? 'video/webm' : 'application/octet-stream', // Infer or store content type
+          };
+        })),
       };
     }),