[questions][feat] add encounters transaction for crud

apps/portal/prisma/schema.prisma

@@ -1,7 +1,8 @@
 // Refer to the Prisma schema docs: https://pris.ly/d/prisma-schema
 
 generator client {
-  provider = "prisma-client-js"
+  provider        = "prisma-client-js"
+  previewFeatures = ["interactiveTransactions"]
 }
 
 datasource db {

apps/portal/src/server/router/questions-question-encounter-router.ts

@@ -4,6 +4,8 @@ import { TRPCError } from '@trpc/server';
 import { createProtectedRouter } from './context';
 
 import type { AggregatedQuestionEncounter } from '~/types/questions';
+import { SortOrder } from '~/types/questions';
+
 
 export const questionsQuestionEncounterRouter = createProtectedRouter()
   .query('getAggregatedEncounters', {
@@ -63,11 +65,31 @@ export const questionsQuestionEncounterRouter = createProtectedRouter()
     async resolve({ ctx, input }) {
       const userId = ctx.session?.user?.id;
 
-      return await ctx.prisma.questionsQuestionEncounter.create({
+      return await ctx.prisma.$transaction(async (tx) => {
-        data: {
+        const questionToUpdate = await tx.questionsQuestion.findUnique({
-          ...input,
+          where: {
-          userId,
+            id: input.questionId,
-        },
+          },
+        });
+
+        const questionEncounterCreated = await tx.questionsQuestionEncounter.create({
+          data: {
+            ...input,
+            userId,
+          },
+        });
+
+        if (questionToUpdate < input.seenAt) {
+          await tx.questionsQuestion.update({
+            data: {
+              lastSeenAt : input.seenAt,
+            },
+            where: {
+              id: input.questionId,
+            },
+          });
+        }
+        return questionEncounterCreated;
       });
     },
   })
@@ -96,14 +118,48 @@ export const questionsQuestionEncounterRouter = createProtectedRouter()
         });
       }
 
-      return await ctx.prisma.questionsQuestionEncounter.update({
+      return await ctx.prisma.$transaction(async (tx) => {
-        data: {
+        const questionToUpdate = await tx.questionsQuestion.findUnique({
-          ...input,
+          where: {
-        },
+            id: questionEncounterToUpdate.questionId,
-        where: {
+          },
-          id: input.id,
+        });
-        },
+
+        const questionEncounterUpdated = await ctx.prisma.questionsQuestionEncounter.update({
+          data: {
+            ...input,
+          },
+          where: {
+            id: input.id,
+          },
+        });
+
+        if (questionToUpdate.lastSeenAt === questionEncounterToUpdate.seenAt) {
+          const latestEncounter = await ctx.prisma.questionsQuestionEncounter.findFirst({
+            orderBy: {
+              seenAt: SortOrder.DESC,
+            },
+            where: {
+              questionId: questionToUpdate.questionId,
+            },
+          });
+
+          const lastSeenVal = latestEncounter ? latestEncounter!.seenAt : null;
+
+          await tx.questionsQuestion.update({
+            data: {
+              lastSeenAt : lastSeenVal,
+            },
+            where: {
+              id: questionToUpdate.questionId,
+            },
+          });
+        }
+
+
+        return questionEncounterUpdated;
       });
+
     },
   })
   .mutation('delete', {
@@ -126,10 +182,42 @@ export const questionsQuestionEncounterRouter = createProtectedRouter()
         });
       }
 
-      return await ctx.prisma.questionsQuestionEncounter.delete({
+      return await ctx.prisma.$transaction(async (tx) => {
-        where: {
+        const questionToUpdate = await tx.questionsQuestion.findUnique({
-          id: input.id,
+          where: {
-        },
+            id: questionEncounterToDelete.questionId,
+          },
+        });
+
+        const questionEncounterDeleted = await ctx.prisma.questionsQuestionEncounter.delete({
+          where: {
+            id: input.id,
+          },
+        });
+
+        if (questionToUpdate.lastSeenAt === questionEncounterToDelete.seenAt) {
+          const latestEncounter = await ctx.prisma.questionsQuestionEncounter.findFirst({
+            orderBy: {
+              seenAt: SortOrder.DESC,
+            },
+            where: {
+              questionId: questionToUpdate.questionId,
+            },
+          });
+
+          const lastSeenVal = latestEncounter ? latestEncounter!.seenAt : null;
+
+          await tx.questionsQuestion.update({
+            data: {
+              lastSeenAt : lastSeenVal,
+            },
+            where: {
+              id: questionToUpdate.questionId,
+            },
+          });
+        }
+
+        return questionEncounterDeleted;
       });
     },
   });