Optimized the progress/[tmdb_id]/ endpoint to be less verbose

server/routes/users/[id]/progress/[tmdb_id]/index.ts

@@ -12,8 +12,8 @@ const progressMetaSchema = z.object({
 const progressItemSchema = z.object({
   meta: progressMetaSchema,
   tmdbId: z.string(),
-  duration: z.number().transform(n => Math.round(n)),
+  duration: z.number().transform(Math.round),
-  watched: z.number().transform(n => Math.round(n)),
+  watched: z.number().transform(Math.round),
   seasonId: z.string().optional(),
   episodeId: z.string().optional(),
   seasonNumber: z.number().optional(),
@@ -24,139 +24,97 @@ const progressItemSchema = z.object({
 // 13th July 2021 - movie-web epoch
 const minEpoch = 1626134400000;
 
-function defaultAndCoerceDateTime(dateTime: string | undefined) {
+const coerceDateTime = (dateTime?: string) => {
   const epoch = dateTime ? new Date(dateTime).getTime() : Date.now();
-  const clampedEpoch = Math.max(minEpoch, Math.min(epoch, Date.now()));
+  return new Date(Math.max(minEpoch, Math.min(epoch, Date.now())));
-  return new Date(clampedEpoch);
+};
-}
 
-export default defineEventHandler(async event => {
+const normalizeIds = (metaType: string, seasonId?: string, episodeId?: string) => ({
-  const userId = event.context.params?.id;
+  seasonId: metaType === 'movie' ? '\n' : seasonId || null,
-  const tmdbId = event.context.params?.tmdb_id;
+  episodeId: metaType === 'movie' ? '\n' : episodeId || null,
+});
+
+const formatProgressItem = (item: any) => ({
+  id: item.id,
+  tmdbId: item.tmdb_id,
+  userId: item.user_id,
+  seasonId: item.season_id === '\n' ? null : item.season_id,
+  episodeId: item.episode_id === '\n' ? null : item.episode_id,
+  seasonNumber: item.season_number,
+  episodeNumber: item.episode_number,
+  meta: item.meta,
+  duration: Number(item.duration),
+  watched: Number(item.watched),
+  updatedAt: item.updated_at,
+});
+
+export default defineEventHandler(async (event) => {
+  const { id: userId, tmdb_id: tmdbId } = event.context.params!;
   const method = event.method;
 
   const session = await useAuth().getCurrentSession();
-
   if (session.user !== userId) {
-    throw createError({
+    throw createError({ statusCode: 403, message: 'Unauthorized' });
-      statusCode: 403,
-      message: 'Different userId than authenticated session',
-    });
   }
 
   if (method === 'PUT') {
     const body = await readBody(event);
-    const validatedBody = progressItemSchema.parse(body);
+    let parsedBody;
+    try {
+      parsedBody = progressItemSchema.parse(body);
+    } catch (error) {
+      throw createError({ statusCode: 400, message: error.message });
+    }
+    const { meta, tmdbId: duration, watched, seasonId, episodeId, seasonNumber, episodeNumber, updatedAt } = parsedBody;
 
-    const now = defaultAndCoerceDateTime(validatedBody.updatedAt);
+    const now = coerceDateTime(updatedAt);
+    const { seasonId: normSeasonId, episodeId: normEpisodeId } = normalizeIds(meta.type, seasonId, episodeId);
 
-    const isMovie = validatedBody.meta.type === 'movie';
+    const existing = await prisma.progress_items.findUnique({
-    const seasonId = isMovie ? '\n' : validatedBody.seasonId || null;
+      where: { tmdb_id_user_id_season_id_episode_id: { tmdb_id: tmdbId, user_id: userId, season_id: normSeasonId, episode_id: normEpisodeId } },
-    const episodeId = isMovie ? '\n' : validatedBody.episodeId || null;
-
-    const existingItem = await prisma.progress_items.findUnique({
-      where: {
-        tmdb_id_user_id_season_id_episode_id: {
-          tmdb_id: tmdbId,
-          user_id: userId,
-          season_id: seasonId,
-          episode_id: episodeId,
-        },
-      },
     });
 
-    let progressItem;
+    const data = {
-
+      duration: BigInt(duration),
-    if (existingItem) {
+      watched: BigInt(watched),
-      progressItem = await prisma.progress_items.update({
+      meta,
-        where: {
+      updated_at: now,
-          id: existingItem.id,
-        },
-        data: {
-          duration: BigInt(validatedBody.duration),
-          watched: BigInt(validatedBody.watched),
-          meta: validatedBody.meta,
-          updated_at: now,
-        },
-      });
-    } else {
-      progressItem = await prisma.progress_items.create({
-        data: {
-          id: randomUUID(),
-          tmdb_id: tmdbId,
-          user_id: userId,
-          season_id: seasonId,
-          episode_id: episodeId,
-          season_number: validatedBody.seasonNumber || null,
-          episode_number: validatedBody.episodeNumber || null,
-          duration: BigInt(validatedBody.duration),
-          watched: BigInt(validatedBody.watched),
-          meta: validatedBody.meta,
-          updated_at: now,
-        },
-      });
-    }
-
-    return {
-      id: progressItem.id,
-      tmdbId: progressItem.tmdb_id,
-      userId: progressItem.user_id,
-      seasonId: progressItem.season_id === '\n' ? null : progressItem.season_id,
-      episodeId: progressItem.episode_id === '\n' ? null : progressItem.episode_id,
-      seasonNumber: progressItem.season_number,
-      episodeNumber: progressItem.episode_number,
-      meta: progressItem.meta,
-      duration: Number(progressItem.duration),
-      watched: Number(progressItem.watched),
-      updatedAt: progressItem.updated_at,
-    };
-  } else if (method === 'DELETE') {
-    const body = await readBody(event).catch(() => ({}));
-
-    const whereClause: any = {
-      user_id: userId,
-      tmdb_id: tmdbId,
     };
 
-    if (body.seasonId) {
+    const progressItem = existing
-      whereClause.season_id = body.seasonId;
+      ? await prisma.progress_items.update({ where: { id: existing.id }, data })
-    } else if (body.meta?.type === 'movie') {
+      : await prisma.progress_items.create({
-      whereClause.season_id = '\n';
+          data: {
-    }
+            id: randomUUID(),
+            tmdb_id: tmdbId,
+            user_id: userId,
+            season_id: normSeasonId,
+            episode_id: normEpisodeId,
+            season_number: seasonNumber || null,
+            episode_number: episodeNumber || null,
+            ...data,
+          },
+        });
 
-    if (body.episodeId) {
+    return formatProgressItem(progressItem);
-      whereClause.episode_id = body.episodeId;
-    } else if (body.meta?.type === 'movie') {
-      whereClause.episode_id = '\n';
-    }
-
-    const itemsToDelete = await prisma.progress_items.findMany({
-      where: whereClause,
-    });
-
-    if (itemsToDelete.length === 0) {
-      return {
-        count: 0,
-        tmdbId,
-        episodeId: body.episodeId,
-        seasonId: body.seasonId,
-      };
-    }
-
-    await prisma.progress_items.deleteMany({
-      where: whereClause,
-    });
-
-    return {
-      count: itemsToDelete.length,
-      tmdbId,
-      episodeId: body.episodeId,
-      seasonId: body.seasonId,
-    };
   }
 
-  throw createError({
+  if (method === 'DELETE') {
-    statusCode: 405,
+    const body = await readBody(event).catch(() => ({}));
-    message: 'Method not allowed',
+    const where: any = { user_id: userId, tmdb_id: tmdbId };
-  });
+
+    if (body.seasonId) where.season_id = body.seasonId;
+    else if (body.meta?.type === 'movie') where.season_id = '\n';
+
+    if (body.episodeId) where.episode_id = body.episodeId;
+    else if (body.meta?.type === 'movie') where.episode_id = '\n';
+
+    const items = await prisma.progress_items.findMany({ where });
+    if (items.length === 0) return { count: 0, tmdbId, episodeId: body.episodeId, seasonId: body.seasonId };
+
+    await prisma.progress_items.deleteMany({ where });
+    return { count: items.length, tmdbId, episodeId: body.episodeId, seasonId: body.seasonId };
+  }
+
+  throw createError({ statusCode: 405, message: 'Method not allowed' });
 });