@goscribe/server 1.1.7 → 1.3.0

package/src/routers/podcast.ts

@@ -1,18 +1,15 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
-import { router, authedProcedure } from '../trpc.js';
+import { router, authedProcedure, verifiedProcedure,limitedProcedure } from '../trpc.js';
 import { v4 as uuidv4 } from 'uuid';
 import inference from '../lib/inference.js';
 import { uploadToSupabase, generateSignedUrl, deleteFromSupabase } from '../lib/storage.js';
 import PusherService from '../lib/pusher.js';
 import { aiSessionService } from '../lib/ai-session.js';
-
-// Prisma enum values mapped manually to avoid type import issues in ESM
-const ArtifactType = {
-  PODCAST_EPISODE: 'PODCAST_EPISODE',
-  STUDY_GUIDE: 'STUDY_GUIDE',
-  FLASHCARD_SET: 'FLASHCARD_SET',
-} as const;
+import { ArtifactType } from '../lib/constants.js';
+import { workspaceAccessFilter } from '../lib/workspace-access.js';
+import { logger } from '../lib/logger.js';
+import { notifyArtifactFailed, notifyArtifactReady } from '../lib/notification-service.js';
 
 // Podcast segment schema
 const podcastSegmentSchema = z.object({
@@ -76,11 +73,11 @@ export const podcast = router({
       // Check if workspace exists
 
       if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-      
+
       const artifacts = await ctx.db.artifact.findMany({
-        where: { 
-          workspaceId: input.workspaceId, 
-          type: ArtifactType.PODCAST_EPISODE 
+        where: {
+          workspaceId: input.workspaceId,
+          type: ArtifactType.PODCAST_EPISODE
         },
         include: {
           versions: {
@@ -93,10 +90,10 @@ export const podcast = router({
         },
         orderBy: { updatedAt: 'desc' },
       });
-      
-      console.log(`📻 Found ${artifacts.length} podcast artifacts`);
+
+      logger.debug(`Found ${artifacts.length} podcast artifacts`);
       artifacts.forEach((artifact, i) => {
-        console.log(`  Podcast ${i + 1}: "${artifact.title}" - ${artifact.podcastSegments.length} segments`);
+        logger.debug(`  Podcast ${i + 1}: "${artifact.title}" - ${artifact.podcastSegments.length} segments`);
       });
 
       // Transform to include segments with fresh signed URLs
@@ -109,7 +106,7 @@ export const podcast = router({
           if (artifact.imageObjectKey) {
             objectUrl = await generateSignedUrl(artifact.imageObjectKey, 24);
           }
-          
+
           // Generate fresh signed URLs for all segments
           const segmentsWithUrls = await Promise.all(
             artifact.podcastSegments.map(async (segment) => {
@@ -126,7 +123,7 @@ export const podcast = router({
                     order: segment.order,
                   };
                 } catch (error) {
-                  console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+                  logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
                   return {
                     id: segment.id,
                     title: segment.title,
@@ -154,10 +151,10 @@ export const podcast = router({
           let metadata = null;
           if (latestVersion) {
             try {
-              console.log(latestVersion.data)
+              logger.debug(JSON.stringify(latestVersion.data))
               metadata = podcastMetadataSchema.parse(latestVersion.data);
             } catch (error) {
-              console.error('Failed to parse podcast metadata:', error);
+              logger.error('Failed to parse podcast metadata:', error);
             }
           }
 
@@ -188,10 +185,10 @@ export const podcast = router({
     .input(z.object({ episodeId: z.string() }))
     .query(async ({ ctx, input }) => {
       const episode = await ctx.db.artifact.findFirst({
-        where: { 
+        where: {
           id: input.episodeId,
           type: ArtifactType.PODCAST_EPISODE,
-          workspace: { ownerId: ctx.session.user.id }
+          workspace: workspaceAccessFilter(ctx.session.user.id)
         },
         include: {
           versions: {
@@ -204,23 +201,23 @@ export const podcast = router({
         },
       });
 
-      console.log(episode)
+      logger.debug(JSON.stringify(episode))
 
       if (!episode) throw new TRPCError({ code: 'NOT_FOUND' });
-      
+
       const latestVersion = episode.versions[0];
       if (!latestVersion) throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
-      
-      console.log(latestVersion)
+
+      logger.debug(JSON.stringify(latestVersion))
       try {
         const metadata = podcastMetadataSchema.parse(latestVersion.data);
       } catch (error) {
-        console.error('Failed to parse podcast metadata:', error);
+        logger.error('Failed to parse podcast metadata:', error);
       }
       const metadata = podcastMetadataSchema.parse(latestVersion.data);
 
       const imageUrl = episode.imageObjectKey ? await generateSignedUrl(episode.imageObjectKey, 24) : null;
-  
+
 
       // Generate fresh signed URLs for all segments
       const segmentsWithUrls = await Promise.all(
@@ -240,7 +237,7 @@ export const podcast = router({
                 order: segment.order,
               };
             } catch (error) {
-              console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+              logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
               return {
                 id: segment.id,
                 title: segment.title,
@@ -267,7 +264,7 @@ export const podcast = router({
           };
         })
       );
-      
+
       return {
         id: episode.id,
         title: metadata.title, // Use title from version metadata
@@ -282,7 +279,7 @@ export const podcast = router({
     }),
 
   // Generate podcast episode from text input
-  generateEpisode: authedProcedure
+  generateEpisode: limitedProcedure
     .input(z.object({
       workspaceId: z.string(),
       podcastData: podcastInputSchema,
@@ -292,33 +289,33 @@ export const podcast = router({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id },
       });
       if (!workspace) throw new TRPCError({ code: 'NOT_FOUND' });
-      
-        // Emit podcast generation start notification
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', { 
-          title: input.podcastData.title 
-        });
 
-        const BEGIN_PODCAST_GENERATION_MESSAGE = 'Structuring podcast contents...';
+      // Emit podcast generation start notification
+      await PusherService.emitTaskComplete(input.workspaceId, 'podcast_generation_start', {
+        title: input.podcastData.title
+      });
 
-        const newArtifact = await ctx.db.artifact.create({
-          data: {
-            title: '----',
-            type: ArtifactType.PODCAST_EPISODE,
-            generating: true,
-            generatingMetadata: {
-              message: BEGIN_PODCAST_GENERATION_MESSAGE,
-            },
-            workspace: {
-              connect: {
-                id: input.workspaceId,
-              }
+      const BEGIN_PODCAST_GENERATION_MESSAGE = 'Structuring podcast contents...';
+
+      const newArtifact = await ctx.db.artifact.create({
+        data: {
+          title: '----',
+          type: ArtifactType.PODCAST_EPISODE,
+          generating: true,
+          generatingMetadata: {
+            message: BEGIN_PODCAST_GENERATION_MESSAGE,
+          },
+          workspace: {
+            connect: {
+              id: input.workspaceId,
             }
           }
-        });
+        }
+      });
 
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
-          message: BEGIN_PODCAST_GENERATION_MESSAGE,
-        });
+      await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
+        message: BEGIN_PODCAST_GENERATION_MESSAGE,
+      });
 
       try {
 
@@ -332,9 +329,9 @@ export const podcast = router({
         );
 
         if (!structureResult.success || !structureResult.structure) {
-          throw new TRPCError({ 
-            code: 'INTERNAL_SERVER_ERROR', 
-            message: 'Failed to generate podcast structure' 
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: 'Failed to generate podcast structure'
           });
         }
 
@@ -366,7 +363,7 @@ export const podcast = router({
           }
         });
 
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
           message: `Generating podcast image...`,
         });
 
@@ -409,7 +406,7 @@ export const podcast = router({
               }
             });
 
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
               message: `Generating audio for segment ${i + 1} of ${structure.segments.length}...`,
             });
 
@@ -444,47 +441,56 @@ export const podcast = router({
 
           } catch (audioError) {
             const errorMessage = audioError instanceof Error ? audioError.message : 'Unknown error';
-            console.error(`❌ Error generating audio for segment ${i + 1}:`, {
+            logger.error(`❌ Error generating audio for segment ${i + 1}:`, {
               title: segment.title,
               error: errorMessage,
               stack: audioError instanceof Error ? audioError.stack : undefined,
             });
-            
+
             // Track failed segment
             failedSegments.push({
               index: i + 1,
               title: segment.title || `Segment ${i + 1}`,
               error: errorMessage,
             });
-            
-            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_error', { 
+
+            await PusherService.emitTaskComplete(input.workspaceId, 'podcast_segment_error', {
               segmentIndex: i + 1,
               segmentTitle: segment.title || `Segment ${i + 1}`,
               error: errorMessage,
               successfulSegments: segments.length,
               failedSegments: failedSegments.length,
             });
-            
+
             // Continue with other segments even if one fails
           }
         }
-        
+
         // Check if any segments were successfully generated
         if (segments.length === 0) {
-          console.error('No segments were successfully generated');
-          await PusherService.emitError(input.workspaceId, 
-            `Failed to generate any segments. ${failedSegments.length} segment(s) failed.`, 
+          logger.error('No segments were successfully generated');
+          await PusherService.emitError(input.workspaceId,
+            `Failed to generate any segments. ${failedSegments.length} segment(s) failed.`,
             'podcast'
           );
-          
+
           // Cleanup the artifact
+          await notifyArtifactFailed(ctx.db, {
+            userId: ctx.session.user.id,
+            workspaceId: input.workspaceId,
+            artifactType: ArtifactType.PODCAST_EPISODE,
+            artifactId: newArtifact.id,
+            title: input.podcastData.title,
+            message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`,
+          }).catch(() => {});
+
           await ctx.db.artifact.delete({
             where: { id: newArtifact.id },
           });
-          
-          throw new TRPCError({ 
-            code: 'INTERNAL_SERVER_ERROR', 
-            message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.` 
+
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: `Failed to generate any audio segments. All ${failedSegments.length} attempts failed.`
           });
         }
 
@@ -500,7 +506,7 @@ export const podcast = router({
           }
         });
 
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
           message: `Preparing podcast summary...`,
         });
 
@@ -527,7 +533,7 @@ export const podcast = router({
         Podcast Title: ${structure.episodeTitle}
         Segments: ${JSON.stringify(segments.map(s => ({ title: s.title, keyPoints: s.keyPoints })))}`;
 
-        const summaryResponse = await inference(summaryPrompt);
+        const summaryResponse = await inference([{ role: "user", content: summaryPrompt }]);
         const summaryContent: string = summaryResponse.choices[0].message.content || '';
 
         let episodeSummary;
@@ -539,8 +545,8 @@ export const podcast = router({
           }
           episodeSummary = JSON.parse(jsonMatch[0]);
         } catch (parseError) {
-          console.error('Failed to parse summary response:', summaryContent);
-          await PusherService.emitTaskComplete(input.workspaceId, 'podcast_summary_error', { 
+          logger.error('Failed to parse summary response:', summaryContent);
+          await PusherService.emitTaskComplete(input.workspaceId, 'podcast_summary_error', {
             error: 'Failed to parse summary response'
           });
           episodeSummary = {
@@ -555,13 +561,13 @@ export const podcast = router({
         }
 
         // Emit summary generation completion notification
-        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', { 
+        await PusherService.emitTaskComplete(input.workspaceId, 'podcast_info', {
           message: `Podcast summary generated.`,
         });
 
         // Step 4: Create artifact and initial version
         const episodeTitle = structure.episodeTitle || input.podcastData.title;
-        
+
         await ctx.db.artifact.update({
           where: {
             id: newArtifact.id,
@@ -574,7 +580,7 @@ export const podcast = router({
             createdById: ctx.session.user.id,
           },
         });
-        
+
         const createdSegments = await ctx.db.podcastSegment.createMany({
           data: segments.map(segment => ({
             artifactId: newArtifact.id,
@@ -591,7 +597,7 @@ export const podcast = router({
             },
           })),
         });
-        
+
         const metadata = {
           title: episodeTitle,
           description: input.podcastData.description,
@@ -621,7 +627,14 @@ export const podcast = router({
         });
 
         // Emit podcast generation completion notification
-        await PusherService.emitPodcastComplete(input.workspaceId, {});
+        await PusherService.emitPodcastComplete(input.workspaceId, newArtifact);
+        await notifyArtifactReady(ctx.db, {
+          userId: ctx.session.user.id,
+          workspaceId: input.workspaceId,
+          artifactId: newArtifact.id,
+          artifactType: ArtifactType.PODCAST_EPISODE,
+          title: metadata.title,
+        }).catch(() => {});
 
         return {
           id: newArtifact.id,
@@ -633,7 +646,19 @@ export const podcast = router({
 
       } catch (error) {
 
-        console.error('Error generating podcast episode:', error);
+        logger.error('Error generating podcast episode:', error);
+
+        await notifyArtifactFailed(ctx.db, {
+          userId: ctx.session.user.id,
+          workspaceId: input.workspaceId,
+          artifactType: ArtifactType.PODCAST_EPISODE,
+          artifactId: newArtifact.id,
+          title: input.podcastData.title,
+          message:
+            error instanceof Error
+              ? error.message
+              : 'Podcast generation failed.',
+        }).catch(() => {});
 
         await ctx.db.artifact.delete({
           where: {
@@ -641,9 +666,9 @@ export const podcast = router({
           },
         });
         await PusherService.emitError(input.workspaceId, `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
-        throw new TRPCError({ 
-          code: 'INTERNAL_SERVER_ERROR', 
-          message: `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}` 
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to generate podcast episode: ${error instanceof Error ? error.message : 'Unknown error'}`
         });
       }
     }),
@@ -660,10 +685,10 @@ export const podcast = router({
     .input(z.object({ episodeId: z.string() }))
     .query(async ({ ctx, input }) => {
       const episode = await ctx.db.artifact.findFirst({
-        where: { 
+        where: {
           id: input.episodeId,
           type: ArtifactType.PODCAST_EPISODE,
-          workspace: { ownerId: ctx.session.user.id }
+          workspace: workspaceAccessFilter(ctx.session.user.id)
         },
         include: {
           versions: {
@@ -675,14 +700,14 @@ export const podcast = router({
           },
         },
       });
-      
+
       if (!episode) throw new TRPCError({ code: 'NOT_FOUND' });
-      
+
       const latestVersion = episode.versions[0];
       if (!latestVersion) throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
 
       const metadata = podcastMetadataSchema.parse(latestVersion.data);
-      
+
       return {
         segments: episode.podcastSegments.map(s => ({
           id: s.id,
@@ -711,10 +736,10 @@ export const podcast = router({
     }))
     .mutation(async ({ ctx, input }) => {
       const episode = await ctx.db.artifact.findFirst({
-        where: { 
+        where: {
           id: input.episodeId,
           type: ArtifactType.PODCAST_EPISODE,
-          workspace: { ownerId: ctx.session.user.id }
+          workspace: workspaceAccessFilter(ctx.session.user.id)
         },
         include: {
           versions: {
@@ -723,14 +748,14 @@ export const podcast = router({
           },
         },
       });
-      
+
       if (!episode) throw new TRPCError({ code: 'NOT_FOUND' });
-      
+
       const latestVersion = episode.versions[0];
       if (!latestVersion) throw new TRPCError({ code: 'NOT_FOUND', message: 'No version found' });
 
       const metadata = podcastMetadataSchema.parse(latestVersion.data);
-      
+
       // Update metadata
       if (input.title) metadata.title = input.title;
       if (input.description) metadata.description = input.description;
@@ -746,7 +771,7 @@ export const podcast = router({
           createdById: ctx.session.user.id,
         },
       });
-      
+
       // Update the artifact with basic info for listing/searching
       return ctx.db.artifact.update({
         where: { id: input.episodeId },
@@ -763,10 +788,10 @@ export const podcast = router({
     .input(z.object({ episodeId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const episode = await ctx.db.artifact.findFirst({
-        where: { 
+        where: {
           id: input.episodeId,
           type: ArtifactType.PODCAST_EPISODE,
-          workspace: { ownerId: ctx.session.user.id }
+          workspace: workspaceAccessFilter(ctx.session.user.id)
         },
         include: {
           versions: {
@@ -775,12 +800,12 @@ export const podcast = router({
           },
         },
       });
-      
+
       if (!episode) throw new TRPCError({ code: 'NOT_FOUND' });
 
       try {
         // Emit episode deletion start notification
-        await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_start', { 
+        await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_start', {
           episodeId: input.episodeId,
           episodeTitle: episode.title || 'Untitled Episode'
         });
@@ -796,7 +821,7 @@ export const podcast = router({
             try {
               await deleteFromSupabase(segment.objectKey);
             } catch (error) {
-              console.error(`Failed to delete audio file ${segment.objectKey}:`, error);
+              logger.error(`Failed to delete audio file ${segment.objectKey}:`, error);
             }
           }
         }
@@ -817,7 +842,7 @@ export const podcast = router({
         });
 
         // Emit episode deletion completion notification
-        await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_complete', { 
+        await PusherService.emitTaskComplete(episode.workspaceId, 'podcast_deletion_complete', {
           episodeId: input.episodeId,
           episodeTitle: episode.title || 'Untitled Episode'
         });
@@ -825,11 +850,11 @@ export const podcast = router({
         return true;
 
       } catch (error) {
-        console.error('Error deleting episode:', error);
+        logger.error('Error deleting episode:', error);
         await PusherService.emitError(episode.workspaceId, `Failed to delete episode: ${error instanceof Error ? error.message : 'Unknown error'}`, 'podcast');
-        throw new TRPCError({ 
-          code: 'INTERNAL_SERVER_ERROR', 
-          message: 'Failed to delete episode' 
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to delete episode'
         });
       }
     }),
@@ -839,10 +864,10 @@ export const podcast = router({
     .input(z.object({ segmentId: z.string() }))
     .query(async ({ ctx, input }) => {
       const segment = await ctx.db.podcastSegment.findFirst({
-        where: { 
+        where: {
           id: input.segmentId,
           artifact: {
-            workspace: { ownerId: ctx.session.user.id }
+            workspace: workspaceAccessFilter(ctx.session.user.id)
           }
         },
         include: {
@@ -858,7 +883,7 @@ export const podcast = router({
         try {
           audioUrl = await generateSignedUrl(segment.objectKey, 24); // 24 hours
         } catch (error) {
-          console.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
+          logger.error(`Failed to generate signed URL for segment ${segment.id}:`, error);
         }
       }