created backend for notifications

ErlendSae · ErlendSae · commit 64d43fd80b07 · 2026-04-20T18:14:37.000+02:00
diff --git a/apps/rpc/src/modules/core.ts b/apps/rpc/src/modules/core.ts
@@ -53,7 +53,8 @@ import { getMembershipService } from "./user/membership-service"
 import { getUserRepository } from "./user/user-repository"
 import { getUserService } from "./user/user-service"
 import { getWorkspaceService } from "./workspace-sync/workspace-service"
-
+import { getNotificationRepository } from "./notification/notification-repository"
+import { getNotificationService } from "./notification/notification-service"
 export type ServiceLayer = Awaited<ReturnType<typeof createServiceLayer>>
 
 const WORKSPACE_SERVICE_ACCOUNT_SCOPES = [
@@ -154,6 +155,7 @@ export async function createServiceLayer(
   const feideGroupsRepository = getFeideGroupsRepository()
   const feedbackFormRepository = getFeedbackFormRepository()
   const feedbackFormAnswerRepository = getFeedbackFormAnswerRepository()
+  const notificationRepository = getNotificationRepository()
 
   const membershipService = getMembershipService()
   const emailService = isAmazonSesEmailFeatureEnabled(configuration)
@@ -184,6 +186,7 @@ export async function createServiceLayer(
     attendanceRepository
   )
   const feedbackFormAnswerService = getFeedbackFormAnswerService(feedbackFormAnswerRepository, feedbackFormService)
+  const notificationService = getNotificationService(notificationRepository)
   const taskDiscoveryService = getLocalTaskDiscoveryService(clients.prisma, taskService, recurringTaskService)
   const attendanceService = getAttendanceService(
     eventEmitter,
@@ -248,6 +251,7 @@ export async function createServiceLayer(
     paymentWebhookService,
     recurringTaskService,
     workspaceService,
+    notificationService,
     executeTransaction: clients.prisma.$transaction.bind(clients.prisma),
     // Do not use this directly, it is here for repl/script purposes only
     prisma: clients.prisma,
diff --git a/apps/rpc/src/modules/notification/notification-repository.ts b/apps/rpc/src/modules/notification/notification-repository.ts
@@ -0,0 +1,105 @@
+import { DBHandle } from "@dotkomonline/db"
+import { Notification, NotificationId, NotificationWrite, UserId, NotificationRecipientId, NotificationRecipient } from "@dotkomonline/types"
+
+export interface NotificationRepository {
+
+  findById(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+  create(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
+  update(handle: DBHandle, notificationId: NotificationId, notificationData: Partial<NotificationWrite>): Promise<Notification>
+  delete(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+
+  addRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
+  removeRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
+
+  findRecipient(handle: DBHandle, recipientId: NotificationRecipientId, userId: UserId): Promise<NotificationRecipient | null>
+  findAllforUser(handle: DBHandle, userId: UserId): Promise<Notification[]>
+  getUnreadCountforUser(handle: DBHandle, userId: UserId): Promise<number>
+  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<void>
+  markAllAsRead(handle: DBHandle, userId: UserId): Promise<void>
+}
+
+export function getNotificationRepository(): NotificationRepository {
+  return {
+    async findById(handle, notificationId) {
+      const notification = await handle.notification.findUnique({
+        where: { id: notificationId },
+      })
+      return notification
+    },
+
+    async create(handle, notificationData) {
+      const { recipientIds, ...data } = notificationData
+      const notification = await handle.notification.create({ data })
+      return notification
+    },
+    async update(handle, notificationId, notificationData) {
+      const { recipientIds, ...data } = notificationData
+      const notification = await handle.notification.update({
+        where: { id: notificationId },
+        data, 
+      })
+      return notification
+      
+    },
+    async delete(handle, notificationId) {
+      const notification = await handle.notification.findUnique({
+        where: { id: notificationId },
+      })
+      await handle.notification.delete({
+        where: { id: notificationId },
+      })
+      return notification
+    },
+    async findRecipient(handle, recipientId, userId) {
+      const recipient = await handle.notificationRecipient.findFirst({
+        where: {
+          id: recipientId,
+          userId,
+        },
+      })
+      return recipient
+    },
+    async addRecipients(handle, notificationId, recipientIds) {
+      await handle.notificationRecipient.createMany({
+        data: recipientIds.map((userId) => ({
+          notificationId,
+          userId,
+        })),
+      })
+    },
+    async removeRecipients(handle, notificationId, recipientIds) {
+        await handle.notificationRecipient.deleteMany({
+          where: {
+            notificationId,
+            userId: { in: recipientIds },
+          },
+        })
+    },
+
+    async findAllForUser(handle, userId) {
+      return handle.notificationRecipient.findMany({
+        where: { userId },
+        include: { notification: true },
+      })
+    },
+
+    async getUnreadCountforUser(handle, userId) {
+      await handle.notificationRecipient.count({
+        where: { userId, readAt: null },
+      })
+    },
+
+    async getUnreadCountForUser(handle, userId) {
+      return handle.notificationRecipient.count({
+        where: { userId, readAt: null },
+      })
+    },
+
+    async markAllAsRead(handle, userId) {
+      await handle.notificationRecipient.updateMany({
+        where: { userId, readAt: null },
+        data: { readAt: new Date() },
+      })
+    },
+  }
+}
diff --git a/apps/rpc/src/modules/notification/notification-router.ts b/apps/rpc/src/modules/notification/notification-router.ts
@@ -0,0 +1,102 @@
+import { NotificationSchema, NotificationWriteSchema, UserNotificationSchema } from "@dotkomonline/types"
+import type { inferProcedureInput, inferProcedureOutput } from "@trpc/server"
+import { z } from "zod"
+import { isEditor } from "../../authorization"
+import { withAuditLogEntry, withAuthentication, withAuthorization, withDatabaseTransaction } from "../../middlewares"
+import { procedure, t } from "../../trpc"
+
+export type GetNotificationInput = inferProcedureInput<typeof getNotificationProcedure>
+export type GetNotificationOutput = inferProcedureOutput<typeof getNotificationProcedure>
+const getNotificationProcedure = procedure
+  .input(NotificationSchema.shape.id)
+  .use(withDatabaseTransaction())
+  .query(async ({ input, ctx }) => {
+    return ctx.notificationService.findById(ctx.handle, input)
+  })
+
+export type CreateNotificationInput = inferProcedureInput<typeof createNotificationProcedure>
+export type CreateNotificationOutput = inferProcedureOutput<typeof createNotificationProcedure>
+const createNotificationProcedure = procedure
+  .input(NotificationWriteSchema)
+  .use(withAuthentication())
+  .use(withAuthorization(isEditor()))
+  .use(withDatabaseTransaction())
+  .use(withAuditLogEntry())
+  .mutation(async ({ input, ctx }) => {
+    return ctx.notificationService.create(ctx.handle, input)
+  })
+
+export type EditNotificationInput = inferProcedureInput<typeof editNotificationProcedure>
+export type EditNotificationOutput = inferProcedureOutput<typeof editNotificationProcedure>
+const editNotificationProcedure = procedure
+  .input(z.object({
+    id: NotificationSchema.shape.id,
+    input: NotificationWriteSchema.partial(),
+  }))
+  .use(withAuthentication())
+  .use(withAuthorization(isEditor()))
+  .use(withDatabaseTransaction())
+  .use(withAuditLogEntry())
+  .mutation(async ({ input: changes, ctx }) => {
+    return ctx.notificationService.update(ctx.handle, changes.id, changes.input)
+  })
+
+export type DeleteNotificationInput = inferProcedureInput<typeof deleteNotificationProcedure>
+export type DeleteNotificationOutput = inferProcedureOutput<typeof deleteNotificationProcedure>
+const deleteNotificationProcedure = procedure
+  .input(NotificationSchema.shape.id)
+  .use(withAuthentication())
+  .use(withAuthorization(isEditor()))
+  .use(withDatabaseTransaction())
+  .use(withAuditLogEntry())
+  .mutation(async ({ input, ctx }) => {
+    return ctx.notificationService.delete(ctx.handle, input)
+  })
+
+export type GetMyNotificationsInput = inferProcedureInput<typeof getMyNotificationsProcedure>
+export type GetMyNotificationsOutput = inferProcedureOutput<typeof getMyNotificationsProcedure>
+const getMyNotificationsProcedure = procedure
+  .use(withAuthentication())
+  .use(withDatabaseTransaction())
+  .query(async ({ ctx }) => {
+    return ctx.notificationService.findAllForUser(ctx.handle, ctx.principal.subject)
+  })
+
+export type GetUnreadCountInput = inferProcedureInput<typeof getUnreadCountProcedure>
+export type GetUnreadCountOutput = inferProcedureOutput<typeof getUnreadCountProcedure>
+const getUnreadCountProcedure = procedure
+  .use(withAuthentication())
+  .use(withDatabaseTransaction())
+  .query(async ({ ctx }) => {
+    return ctx.notificationService.getUnreadCountForUser(ctx.handle, ctx.principal.subject)
+  })
+
+export type MarkAsReadInput = inferProcedureInput<typeof markAsReadProcedure>
+export type MarkAsReadOutput = inferProcedureOutput<typeof markAsReadProcedure>
+const markAsReadProcedure = procedure
+  .input(z.object({ notificationId: NotificationSchema.shape.id }))
+  .use(withAuthentication())
+  .use(withDatabaseTransaction())
+  .mutation(async ({ input, ctx }) => {
+    return ctx.notificationService.markAsRead(ctx.handle, input.notificationId, ctx.principal.subject)
+  })
+
+export type MarkAllAsReadInput = inferProcedureInput<typeof markAllAsReadProcedure>
+export type MarkAllAsReadOutput = inferProcedureOutput<typeof markAllAsReadProcedure>
+const markAllAsReadProcedure = procedure
+  .use(withAuthentication())
+  .use(withDatabaseTransaction())
+  .mutation(async ({ ctx }) => {
+    return ctx.notificationService.markAllAsRead(ctx.handle, ctx.principal.subject)
+  })
+
+export const notificationRouter = t.router({
+  get: getNotificationProcedure,
+  create: createNotificationProcedure,
+  edit: editNotificationProcedure,
+  delete: deleteNotificationProcedure,
+  getMyNotifications: getMyNotificationsProcedure,
+  getUnreadCount: getUnreadCountProcedure,
+  markAsRead: markAsReadProcedure,
+  markAllAsRead: markAllAsReadProcedure,
+})
diff --git a/apps/rpc/src/modules/notification/notification-service.ts b/apps/rpc/src/modules/notification/notification-service.ts
@@ -0,0 +1,68 @@
+import type { DBHandle } from "@dotkomonline/db"
+import { NotFoundError } from "../../error"
+import type { Notification, NotificationId } from "@dotkomonline/types"
+import { NotificationRepository } from "./notification-repository"
+
+export interface NotificationService {
+  findById(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+  create(handle: DBHandle, notificationData: NotificationWrite): Promise<Notification>
+  update(handle: DBHandle, notificationId: NotificationId, notificationData: Partial<NotificationWrite>): Promise<Notification>
+  delete(handle: DBHandle, notificationId: NotificationId): Promise<Notification | null>
+
+  addRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
+  removeRecipients(handle: DBHandle, notificationId: NotificationId, recipientIds: UserId[]): Promise<void>
+
+  findRecipient(handle: DBHandle, recipientId: NotificationRecipientId, userId: UserId): Promise<NotificationRecipient | null>
+  findAllforUser(handle: DBHandle, userId: UserId): Promise<Notification[]>
+  getUnreadCountforUser(handle: DBHandle, userId: UserId): Promise<number>
+  markAsRead(handle: DBHandle, notificationId: NotificationId, userId: UserId): Promise<void>
+  markAllAsRead(handle: DBHandle, userId: UserId): Promise<void>
+}
+
+export function getNotificationService(notificationRepository: NotificationRepository): NotificationService {
+  return {
+    async findById(handle, notificationId) {
+      return await notificationRepository.findById(handle, notificationId)
+    },
+    async create(handle, notificationData) {
+      return await notificationRepository.create(handle, notificationData)
+    },
+
+    async update(handle, notificationId, notificationData) {
+      const notification = await notificationRepository.findById(handle, notificationId)
+      return await notificationRepository.update(handle, notificationId, notificationData)
+    },
+
+    async delete(handle, notificationId) {
+      return await notificationRepository.delete(handle, notificationId)
+    },
+
+    async addRecipients(handle, notificationId, recipientIds) {
+      await notificationRepository.addRecipients(handle, notificationId, recipientIds)
+    },
+
+    async removeRecipients(handle, notificationId, recipientIds) {
+      await notificationRepository.removeRecipients(handle, notificationId, recipientIds)
+    },
+
+    async findRecipient(handle, recipientId, userId) {
+      return await notificationRepository.findRecipient(handle, recipientId, userId)
+    },
+
+    async findAllforUser(handle, userId) {
+      return await notificationRepository.findAllforUser(handle, userId)
+    },
+
+    async getUnreadCountforUser(handle, userId) {
+      return await notificationRepository.getUnreadCountforUser(handle, userId)
+    },
+
+    async markAsRead(handle, notificationId, userId) {
+      await notificationRepository.markAsRead(handle, notificationId, userId)
+    },
+
+    async markAllAsRead(handle, userId) {
+      await notificationRepository.markAllAsRead(handle, userId)
+    }
+  }
+}
diff --git a/packages/db/prisma/migrations/20260225191227_change_notification_read_at_to_nullable/migration.sql b/packages/db/prisma/migrations/20260225191227_change_notification_read_at_to_nullable/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "NotificationRecipient" ALTER COLUMN "read_at" DROP NOT NULL;
diff --git a/packages/db/prisma/schema.prisma b/packages/db/prisma/schema.prisma
@@ -782,7 +782,7 @@ model DeregisterReason {
 
 model NotificationRecipient {
   id     String   @id @default(uuid())
-  readAt DateTime @map("read_at") @db.Timestamptz(3)
+  readAt DateTime? @map("read_at") @db.Timestamptz(3)
 
   notificationId String       @map("notification_id")
   notification   Notification @relation(fields: [notificationId], references: [id], onDelete: Cascade)
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
@@ -14,3 +14,4 @@ export * from "./task"
 export * from "./user"
 export * from "./audit-log"
 export * from "./workspace-sync"
+export * from "./notification"
diff --git a/packages/types/src/notification.ts b/packages/types/src/notification.ts
@@ -0,0 +1,38 @@
+import { schemas } from "@dotkomonline/db/schemas"
+import { z } from "zod"
+
+export type Notification = z.infer<typeof NotificationSchema>
+export const NotificationSchema = schemas.NotificationSchema
+export type NotificationId = Notification["id"]
+export type NotificationType = Notification["type"]
+export type NotificationPayloadType = Notification["payloadType"]
+
+export const NotificationTypeSchema = schemas.NotificationTypeSchema
+export const NotificationPayloadTypeSchema = schemas.NotificationPayloadTypeSchema
+
+export const NotificationRecipientSchema = schemas.NotificationRecipientSchema
+export type NotificationRecipient = z.infer<typeof NotificationRecipientSchema>
+
+export type NotificationRecipientId = NotificationRecipient["id"]
+
+
+export type UserNotification = z.infer<typeof UserNotificationSchema>
+export const UserNotificationSchema = schemas.NotificationRecipientSchema.extend({
+  notification: schemas.NotificationSchema,
+})
+
+export type NotificationWrite = z.infer<typeof NotificationWriteSchema>
+export const NotificationWriteSchema = NotificationSchema.pick({
+  title: true,
+  shortDescription: true,
+  content: true,
+  type: true,
+  payload: true,
+  payloadType: true,
+  actorGroupId: true,
+  taskId: true,
+}).extend({
+  recipientIds: z.array(z.string().uuid()).min(1),
+})
+
+

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+-- AlterTable`
	`2`	`+ALTER TABLE "NotificationRecipient" ALTER COLUMN "read_at" DROP NOT NULL;`