vintasend-prisma 0.3.0 → 0.4.0

package/dist/implementations/vintasend-prisma/src/prisma-notification-backend.js

@@ -1,399 +1,406 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaNotificationBackendFactory = exports.PrismaNotificationBackend = exports.NotificationTypeEnum = exports.NotificationStatusEnum = void 0;
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.PrismaNotificationBackendFactory =
+  exports.PrismaNotificationBackend =
+  exports.NotificationTypeEnum =
+  exports.NotificationStatusEnum =
+    void 0;
 exports.NotificationStatusEnum = {
-    PENDING_SEND: 'PENDING_SEND',
-    SENT: 'SENT',
-    FAILED: 'FAILED',
-    READ: 'READ',
-    CANCELLED: 'CANCELLED',
+  PENDING_SEND: 'PENDING_SEND',
+  SENT: 'SENT',
+  FAILED: 'FAILED',
+  READ: 'READ',
+  CANCELLED: 'CANCELLED',
 };
 exports.NotificationTypeEnum = {
-    EMAIL: 'EMAIL',
-    PUSH: 'PUSH',
-    SMS: 'SMS',
-    IN_APP: 'IN_APP',
+  EMAIL: 'EMAIL',
+  PUSH: 'PUSH',
+  SMS: 'SMS',
+  IN_APP: 'IN_APP',
 };
 function convertJsonValueToRecord(jsonValue) {
-    if (typeof jsonValue === 'object' && !Array.isArray(jsonValue)) {
-        return jsonValue;
-    }
-    throw new Error('Invalid JSON value. It should be an object.');
+  if (typeof jsonValue === 'object' && !Array.isArray(jsonValue)) {
+    return jsonValue;
+  }
+  throw new Error('Invalid JSON value. It should be an object.');
 }
 class PrismaNotificationBackend {
-    constructor(prismaClient) {
-        this.prismaClient = prismaClient;
-    }
-    /**
-     * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
-     * based on whether it has a userId or not
-     */
-    serializeNotification(notification) {
-        const baseData = {
-            id: notification.id,
-            notificationType: notification.notificationType,
-            title: notification.title,
-            bodyTemplate: notification.bodyTemplate,
-            contextName: notification.contextName,
-            contextParameters: notification.contextParameters
-                ? notification.contextParameters
-                : {},
-            sendAfter: notification.sendAfter,
-            subjectTemplate: notification.subjectTemplate,
-            status: notification.status,
-            contextUsed: notification.contextUsed,
-            extraParams: notification.extraParams
-                ? convertJsonValueToRecord(notification.extraParams)
-                : null,
-            adapterUsed: notification.adapterUsed,
-            sentAt: notification.sentAt,
-            readAt: notification.readAt,
-            createdAt: notification.createdAt,
-            updatedAt: notification.updatedAt,
-        };
-        // Check if this is a one-off notification (has emailOrPhone but no userId)
-        if (notification.emailOrPhone && !notification.userId) {
-            return {
-                ...baseData,
-                emailOrPhone: notification.emailOrPhone,
-                firstName: notification.firstName || '',
-                lastName: notification.lastName || '',
-            };
-        }
-        // Regular notification with userId
-        return {
-            ...baseData,
-            userId: notification.userId,
-        };
-    }
-    deserializeNotification(notification) {
-        return {
-            user: {
-                connect: {
-                    id: notification.userId,
-                },
-            },
-            notificationType: notification.notificationType,
-            title: notification.title,
-            bodyTemplate: notification.bodyTemplate,
-            contextName: notification.contextName,
-            contextParameters: notification.contextParameters,
-            sendAfter: notification.sendAfter,
-            subjectTemplate: notification.subjectTemplate,
-            extraParams: notification.extraParams,
-        };
-    }
-    deserializeNotificationForUpdate(notification) {
-        return {
-            ...(notification.userId ? { user: { connect: { id: notification.userId } } } : {}),
-            ...(notification.notificationType
-                ? {
-                    notificationType: exports.NotificationTypeEnum[notification.notificationType],
-                }
-                : {}),
-            ...(notification.title ? { title: notification.title } : {}),
-            ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
-            ...(notification.contextName ? { contextName: notification.contextName } : {}),
-            ...(notification.contextParameters
-                ? {
-                    contextParameters: notification.contextParameters ? notification.contextParameters : {},
-                }
-                : {}),
-            ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
-            ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
-        };
-    }
-    async getAllPendingNotifications() {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: { status: exports.NotificationStatusEnum.PENDING_SEND },
-        });
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getPendingNotifications(page = 0, pageSize = 100) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                status: exports.NotificationStatusEnum.PENDING_SEND,
-                sendAfter: null,
-            },
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getAllFutureNotifications() {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                status: { not: exports.NotificationStatusEnum.PENDING_SEND },
-                sendAfter: { lte: new Date() },
-            },
-        });
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getFutureNotifications(page = 0, pageSize = 100) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                status: { not: exports.NotificationStatusEnum.PENDING_SEND },
-                sendAfter: { lte: new Date() },
-            },
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getAllFutureNotificationsFromUser(userId) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId,
-                status: {
-                    not: exports.NotificationStatusEnum.PENDING_SEND,
-                },
-                sendAfter: {
-                    lte: new Date(),
-                },
-            },
-        });
-        // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getFutureNotificationsFromUser(userId, page, pageSize) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId,
-                status: {
-                    not: exports.NotificationStatusEnum.PENDING_SEND,
-                },
-                sendAfter: {
-                    lte: new Date(),
-                },
-            },
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getAllNotifications() {
-        const notifications = await this.prismaClient.notification.findMany({});
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getNotifications(page, pageSize) {
-        const notifications = await this.prismaClient.notification.findMany({
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async persistNotification(notification) {
-        const created = await this.prismaClient.notification.create({
-            data: this.deserializeNotification(notification),
-        });
-        // persistNotification takes NotificationInput which always has userId, so this is always a regular notification
-        return this.serializeNotification(created);
+  constructor(prismaClient) {
+    this.prismaClient = prismaClient;
+  }
+  /**
+   * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+   * based on whether it has a userId or not
+   */
+  serializeNotification(notification) {
+    const baseData = {
+      id: notification.id,
+      notificationType: notification.notificationType,
+      title: notification.title,
+      bodyTemplate: notification.bodyTemplate,
+      contextName: notification.contextName,
+      contextParameters: notification.contextParameters ? notification.contextParameters : {},
+      sendAfter: notification.sendAfter,
+      subjectTemplate: notification.subjectTemplate,
+      status: notification.status,
+      contextUsed: notification.contextUsed,
+      extraParams: notification.extraParams
+        ? convertJsonValueToRecord(notification.extraParams)
+        : null,
+      adapterUsed: notification.adapterUsed,
+      sentAt: notification.sentAt,
+      readAt: notification.readAt,
+      createdAt: notification.createdAt,
+      updatedAt: notification.updatedAt,
+    };
+    // Check if this is a one-off notification (has emailOrPhone but no userId)
+    if (notification.emailOrPhone && !notification.userId) {
+      return {
+        ...baseData,
+        emailOrPhone: notification.emailOrPhone,
+        firstName: notification.firstName || '',
+        lastName: notification.lastName || '',
+      };
     }
-    async persistNotificationUpdate(notificationId, notification) {
-        const updated = await this.prismaClient.notification.update({
-            where: {
-                id: notificationId,
-            },
-            data: this.deserializeNotificationForUpdate(notification),
-        });
-        // persistNotificationUpdate takes Partial<DatabaseNotification> which has userId, so this is always a regular notification
-        return this.serializeNotification(updated);
+    // Regular notification with userId
+    return {
+      ...baseData,
+      userId: notification.userId,
+    };
+  }
+  deserializeNotification(notification) {
+    return {
+      user: {
+        connect: {
+          id: notification.userId,
+        },
+      },
+      notificationType: notification.notificationType,
+      title: notification.title,
+      bodyTemplate: notification.bodyTemplate,
+      contextName: notification.contextName,
+      contextParameters: notification.contextParameters,
+      sendAfter: notification.sendAfter,
+      subjectTemplate: notification.subjectTemplate,
+      extraParams: notification.extraParams,
+    };
+  }
+  deserializeNotificationForUpdate(notification) {
+    return {
+      ...(notification.userId ? { user: { connect: { id: notification.userId } } } : {}),
+      ...(notification.notificationType
+        ? {
+            notificationType: exports.NotificationTypeEnum[notification.notificationType],
+          }
+        : {}),
+      ...(notification.title ? { title: notification.title } : {}),
+      ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
+      ...(notification.contextName ? { contextName: notification.contextName } : {}),
+      ...(notification.contextParameters
+        ? {
+            contextParameters: notification.contextParameters ? notification.contextParameters : {},
+          }
+        : {}),
+      ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
+      ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
+    };
+  }
+  async getAllPendingNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: { status: exports.NotificationStatusEnum.PENDING_SEND },
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getPendingNotifications(page = 0, pageSize = 100) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: exports.NotificationStatusEnum.PENDING_SEND,
+        sendAfter: null,
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllFutureNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+        sendAfter: { lte: new Date() },
+      },
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getFutureNotifications(page = 0, pageSize = 100) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+        sendAfter: { lte: new Date() },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllFutureNotificationsFromUser(userId) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: {
+          not: exports.NotificationStatusEnum.PENDING_SEND,
+        },
+        sendAfter: {
+          lte: new Date(),
+        },
+      },
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getFutureNotificationsFromUser(userId, page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: {
+          not: exports.NotificationStatusEnum.PENDING_SEND,
+        },
+        sendAfter: {
+          lte: new Date(),
+        },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getAllNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({});
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getNotifications(page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async persistNotification(notification) {
+    const created = await this.prismaClient.notification.create({
+      data: this.deserializeNotification(notification),
+    });
+    // persistNotification takes NotificationInput which always has userId, so this is always a regular notification
+    return this.serializeNotification(created);
+  }
+  async persistNotificationUpdate(notificationId, notification) {
+    const updated = await this.prismaClient.notification.update({
+      where: {
+        id: notificationId,
+      },
+      data: this.deserializeNotificationForUpdate(notification),
+    });
+    // persistNotificationUpdate takes Partial<DatabaseNotification> which has userId, so this is always a regular notification
+    return this.serializeNotification(updated);
+  }
+  /* One-off notification persistence and query methods */
+  async persistOneOffNotification(notification) {
+    const created = await this.prismaClient.notification.create({
+      data: {
+        userId: null, // One-off notifications don't have a userId
+        emailOrPhone: notification.emailOrPhone,
+        firstName: notification.firstName,
+        lastName: notification.lastName,
+        notificationType: notification.notificationType,
+        title: notification.title,
+        bodyTemplate: notification.bodyTemplate,
+        contextName: notification.contextName,
+        contextParameters: notification.contextParameters,
+        sendAfter: notification.sendAfter,
+        subjectTemplate: notification.subjectTemplate,
+        extraParams: notification.extraParams,
+        status: exports.NotificationStatusEnum.PENDING_SEND,
+      },
+    });
+    return this.serializeNotification(created);
+  }
+  async persistOneOffNotificationUpdate(notificationId, notification) {
+    const data = {
+      ...(notification.emailOrPhone !== undefined
+        ? { emailOrPhone: notification.emailOrPhone }
+        : {}),
+      ...(notification.firstName !== undefined ? { firstName: notification.firstName } : {}),
+      ...(notification.lastName !== undefined ? { lastName: notification.lastName } : {}),
+      ...(notification.notificationType ? { notificationType: notification.notificationType } : {}),
+      ...(notification.title ? { title: notification.title } : {}),
+      ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
+      ...(notification.contextName ? { contextName: notification.contextName } : {}),
+      ...(notification.contextParameters
+        ? { contextParameters: notification.contextParameters }
+        : {}),
+      ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
+      ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
+    };
+    const updated = await this.prismaClient.notification.update({
+      where: { id: notificationId },
+      data,
+    });
+    return this.serializeNotification(updated);
+  }
+  async getOneOffNotification(notificationId, _forUpdate) {
+    const notification = await this.prismaClient.notification.findUnique({
+      where: {
+        id: notificationId,
+      },
+    });
+    if (!notification || !notification.emailOrPhone || notification.userId !== null) {
+      return null;
     }
-    /* One-off notification persistence and query methods */
-    async persistOneOffNotification(notification) {
-        const created = await this.prismaClient.notification.create({
-            data: {
-                userId: null, // One-off notifications don't have a userId
-                emailOrPhone: notification.emailOrPhone,
-                firstName: notification.firstName,
-                lastName: notification.lastName,
-                notificationType: notification.notificationType,
-                title: notification.title,
-                bodyTemplate: notification.bodyTemplate,
-                contextName: notification.contextName,
-                contextParameters: notification.contextParameters,
-                sendAfter: notification.sendAfter,
-                subjectTemplate: notification.subjectTemplate,
-                extraParams: notification.extraParams,
-                status: exports.NotificationStatusEnum.PENDING_SEND,
-            },
-        });
-        return this.serializeNotification(created);
+    return this.serializeNotification(notification);
+  }
+  async getAllOneOffNotifications() {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId: null,
+        emailOrPhone: { not: null },
+      },
+    });
+    return notifications
+      .filter((n) => n.emailOrPhone !== null)
+      .map((n) => this.serializeNotification(n));
+  }
+  async getOneOffNotifications(page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId: null,
+        emailOrPhone: { not: null },
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    return notifications
+      .filter((n) => n.emailOrPhone !== null)
+      .map((n) => this.serializeNotification(n));
+  }
+  async markAsSent(notificationId, checkIsPending = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsPending) {
+      whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
     }
-    async persistOneOffNotificationUpdate(notificationId, notification) {
-        const data = {
-            ...(notification.emailOrPhone !== undefined ? { emailOrPhone: notification.emailOrPhone } : {}),
-            ...(notification.firstName !== undefined ? { firstName: notification.firstName } : {}),
-            ...(notification.lastName !== undefined ? { lastName: notification.lastName } : {}),
-            ...(notification.notificationType ? { notificationType: notification.notificationType } : {}),
-            ...(notification.title ? { title: notification.title } : {}),
-            ...(notification.bodyTemplate ? { bodyTemplate: notification.bodyTemplate } : {}),
-            ...(notification.contextName ? { contextName: notification.contextName } : {}),
-            ...(notification.contextParameters ? { contextParameters: notification.contextParameters } : {}),
-            ...(notification.sendAfter ? { sendAfter: notification.sendAfter } : {}),
-            ...(notification.subjectTemplate ? { subjectTemplate: notification.subjectTemplate } : {}),
-        };
-        const updated = await this.prismaClient.notification.update({
-            where: { id: notificationId },
-            data,
-        });
-        return this.serializeNotification(updated);
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: exports.NotificationStatusEnum.SENT,
+        sentAt: new Date(),
+      },
+    });
+    return this.serializeNotification(updated);
+  }
+  async markAsFailed(notificationId, checkIsPending = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsPending) {
+      whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
     }
-    async getOneOffNotification(notificationId, _forUpdate) {
-        const notification = await this.prismaClient.notification.findUnique({
-            where: {
-                id: notificationId,
-            },
-        });
-        if (!notification || !notification.emailOrPhone || notification.userId !== null) {
-            return null;
-        }
-        return this.serializeNotification(notification);
-    }
-    async getAllOneOffNotifications() {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId: null,
-                emailOrPhone: { not: null },
-            },
-        });
-        return notifications
-            .filter((n) => n.emailOrPhone !== null)
-            .map((n) => this.serializeNotification(n));
-    }
-    async getOneOffNotifications(page, pageSize) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId: null,
-                emailOrPhone: { not: null },
-            },
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        return notifications
-            .filter((n) => n.emailOrPhone !== null)
-            .map((n) => this.serializeNotification(n));
-    }
-    async markAsSent(notificationId, checkIsPending = true) {
-        const whereClause = {
-            id: notificationId,
-        };
-        if (checkIsPending) {
-            whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
-        }
-        const updated = await this.prismaClient.notification.update({
-            where: whereClause,
-            data: {
-                status: exports.NotificationStatusEnum.SENT,
-                sentAt: new Date(),
-            },
-        });
-        return this.serializeNotification(updated);
-    }
-    async markAsFailed(notificationId, checkIsPending = true) {
-        const whereClause = {
-            id: notificationId,
-        };
-        if (checkIsPending) {
-            whereClause.status = exports.NotificationStatusEnum.PENDING_SEND;
-        }
-        const updated = await this.prismaClient.notification.update({
-            where: whereClause,
-            data: {
-                status: exports.NotificationStatusEnum.FAILED,
-                sentAt: new Date(),
-            },
-        });
-        return this.serializeNotification(updated);
-    }
-    async markAsRead(notificationId, checkIsSent = true) {
-        const whereClause = {
-            id: notificationId,
-        };
-        if (checkIsSent) {
-            whereClause.status = exports.NotificationStatusEnum.SENT;
-        }
-        const updated = await this.prismaClient.notification.update({
-            where: whereClause,
-            data: {
-                status: 'READ',
-                readAt: new Date(),
-            },
-        });
-        // markAsRead is only for in-app notifications (which are always regular notifications with userId)
-        return this.serializeNotification(updated);
-    }
-    async cancelNotification(notificationId) {
-        await this.prismaClient.notification.update({
-            where: {
-                id: notificationId,
-            },
-            data: {
-                status: exports.NotificationStatusEnum.CANCELLED,
-            },
-        });
-    }
-    async getNotification(notificationId, _forUpdate) {
-        const notification = await this.prismaClient.notification.findUnique({
-            where: { id: notificationId },
-        });
-        if (!notification)
-            return null;
-        return this.serializeNotification(notification);
-    }
-    async filterAllInAppUnreadNotifications(userId) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId,
-                status: 'SENT',
-                readAt: null,
-            },
-        });
-        // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async filterInAppUnreadNotifications(userId, page, pageSize) {
-        const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                userId,
-                status: 'SENT',
-                readAt: null,
-            },
-            skip: page * pageSize,
-            take: pageSize,
-        });
-        // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
-        return notifications.map((n) => this.serializeNotification(n));
-    }
-    async getUserEmailFromNotification(notificationId) {
-        var _a;
-        const notification = await this.prismaClient.notification.findUnique({
-            where: {
-                id: notificationId,
-            },
-            include: {
-                user: true,
-            },
-        });
-        return (_a = notification === null || notification === void 0 ? void 0 : notification.user) === null || _a === void 0 ? void 0 : _a.email;
-    }
-    async storeContextUsed(notificationId, context) {
-        await this.prismaClient.notification.update({
-            where: { id: notificationId },
-            data: { contextUsed: context }
-        });
-    }
-    async bulkPersistNotifications(notifications) {
-        return this.prismaClient.notification.createMany({
-            data: notifications.map((notification) => this.deserializeNotification(notification)),
-        });
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: exports.NotificationStatusEnum.FAILED,
+        sentAt: new Date(),
+      },
+    });
+    return this.serializeNotification(updated);
+  }
+  async markAsRead(notificationId, checkIsSent = true) {
+    const whereClause = {
+      id: notificationId,
+    };
+    if (checkIsSent) {
+      whereClause.status = exports.NotificationStatusEnum.SENT;
     }
+    const updated = await this.prismaClient.notification.update({
+      where: whereClause,
+      data: {
+        status: 'READ',
+        readAt: new Date(),
+      },
+    });
+    // markAsRead is only for in-app notifications (which are always regular notifications with userId)
+    return this.serializeNotification(updated);
+  }
+  async cancelNotification(notificationId) {
+    await this.prismaClient.notification.update({
+      where: {
+        id: notificationId,
+      },
+      data: {
+        status: exports.NotificationStatusEnum.CANCELLED,
+      },
+    });
+  }
+  async getNotification(notificationId, _forUpdate) {
+    const notification = await this.prismaClient.notification.findUnique({
+      where: { id: notificationId },
+    });
+    if (!notification) return null;
+    return this.serializeNotification(notification);
+  }
+  async filterAllInAppUnreadNotifications(userId) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: 'SENT',
+        readAt: null,
+      },
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async filterInAppUnreadNotifications(userId, page, pageSize) {
+    const notifications = await this.prismaClient.notification.findMany({
+      where: {
+        userId,
+        status: 'SENT',
+        readAt: null,
+      },
+      skip: page * pageSize,
+      take: pageSize,
+    });
+    // These are guaranteed to be regular notifications (not one-off) since we're filtering by userId
+    return notifications.map((n) => this.serializeNotification(n));
+  }
+  async getUserEmailFromNotification(notificationId) {
+    var _a;
+    const notification = await this.prismaClient.notification.findUnique({
+      where: {
+        id: notificationId,
+      },
+      include: {
+        user: true,
+      },
+    });
+    return (_a = notification === null || notification === void 0 ? void 0 : notification.user) ===
+      null || _a === void 0
+      ? void 0
+      : _a.email;
+  }
+  async storeContextUsed(notificationId, context) {
+    await this.prismaClient.notification.update({
+      where: { id: notificationId },
+      data: { contextUsed: context },
+    });
+  }
+  async bulkPersistNotifications(notifications) {
+    return this.prismaClient.notification.createMany({
+      data: notifications.map((notification) => this.deserializeNotification(notification)),
+    });
+  }
 }
 exports.PrismaNotificationBackend = PrismaNotificationBackend;
 class PrismaNotificationBackendFactory {
-    create(prismaClient) {
-        return new PrismaNotificationBackend(prismaClient);
-    }
+  create(prismaClient) {
+    return new PrismaNotificationBackend(prismaClient);
+  }
 }
 exports.PrismaNotificationBackendFactory = PrismaNotificationBackendFactory;