vintasend-prisma 0.2.2 → 0.3.0

package/dist/prisma-notification-backend.d.ts

@@ -1,6 +1,7 @@
 import type { BaseNotificationBackend } from 'vintasend/dist/services/notification-backends/base-notification-backend';
 import type { InputJsonValue, JsonValue } from 'vintasend/dist/types/json-values';
-import type { DatabaseNotification, Notification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { AnyNotificationInput, DatabaseNotification, Notification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { DatabaseOneOffNotification, OneOffNotificationInput, AnyNotification, AnyDatabaseNotification } from 'vintasend/dist/types/notification';
 import type { NotificationStatus } from 'vintasend/dist/types/notification-status';
 import type { NotificationType } from 'vintasend/dist/types/notification-type';
 import type { BaseNotificationTypeConfig } from 'vintasend/dist/types/notification-type-config';
@@ -19,7 +20,10 @@ export declare const NotificationTypeEnum: {
 };
 export interface PrismaNotificationModel<IdType, UserId> {
     id: IdType;
-    userId: UserId;
+    userId: UserId | null;
+    emailOrPhone: string | null;
+    firstName: string | null;
+    lastName: string | null;
     notificationType: NotificationType;
     title: string | null;
     bodyTemplate: string;
@@ -49,8 +53,11 @@ export interface NotificationPrismaClientInterface<NotificationIdType, UserIdTyp
                 sendAfter?: {
                     lte: Date;
                 } | null;
-                userId?: UserIdType;
+                userId?: UserIdType | null;
                 readAt?: null;
+                emailOrPhone?: string | {
+                    not: null;
+                };
             };
             skip?: number;
             take?: number;
@@ -93,12 +100,16 @@ type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ?
     [P in keyof O as P extends K ? K : never]-?: O[P];
 } & O) : never>;
 export interface BaseNotificationCreateInput<UserIdType> {
-    user: {
+    user?: {
         connect?: AtLeast<{
             id?: UserIdType;
             email?: string;
         }, 'id' | 'email'>;
     };
+    userId?: UserIdType | null;
+    emailOrPhone?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
     notificationType: NotificationType;
     title?: string | null;
     bodyTemplate: string;
@@ -114,12 +125,15 @@ export interface BaseNotificationCreateInput<UserIdType> {
     readAt?: Date | null;
 }
 export interface BaseNotificationUpdateInput<UserIdType> {
-    user: {
+    user?: {
         connect?: AtLeast<{
             id?: UserIdType;
             email?: string;
         }, 'id' | 'email'>;
     };
+    emailOrPhone?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
     notificationType?: NotificationType;
     title?: string | null;
     bodyTemplate?: string;
@@ -137,29 +151,72 @@ export interface BaseNotificationUpdateInput<UserIdType> {
 export declare class PrismaNotificationBackend<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>, Config extends BaseNotificationTypeConfig> implements BaseNotificationBackend<Config> {
     private prismaClient;
     constructor(prismaClient: Client);
-    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): DatabaseNotification<Config>;
-    deserializeNotification(notification: NotificationInput<Config>): BaseNotificationCreateInput<Config['UserIdType']>;
+    /**
+     * Build a where clause for status-based updates
+     */
+    private buildStatusWhere;
+    /**
+     * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+     * based on whether it has a userId or not (internal implementation)
+     */
+    private serializeAnyNotification;
+    /**
+     * Serialize a Prisma notification model to DatabaseNotification
+     */
+    private serializeRegularNotification;
+    /**
+     * Serialize a Prisma notification model to DatabaseOneOffNotification
+     */
+    private serializeOneOffNotification;
+    /**
+     * Public accessor for serialization - primarily for testing
+     * @internal
+     */
+    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): AnyDatabaseNotification<Config>;
+    /**
+     * Core internal builder for creating notification data
+     * Validates that notification has either userId or emailOrPhone (but not neither)
+     */
+    private buildCreateData;
+    /**
+     * Deserialize a regular notification input for creation
+     */
+    private deserializeRegularNotification;
+    /**
+     * Build one-off notification data for creation
+     */
+    private buildOneOffNotificationData;
+    /**
+     * Core internal builder for update data (supports both regular and one-off)
+     */
+    private buildUpdateData;
+    deserializeNotification(notification: AnyNotificationInput<Config> | Omit<AnyNotificationInput<Config>, 'id'>): BaseNotificationCreateInput<Config['UserIdType']>;
     deserializeNotificationForUpdate(notification: Partial<Notification<Config>>): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
-    getAllPendingNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getPendingNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getAllFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getFutureNotifications(): Promise<DatabaseNotification<Config>[]>;
+    getAllPendingNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+    getPendingNotifications(page?: number, pageSize?: number): Promise<AnyDatabaseNotification<Config>[]>;
+    getAllFutureNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+    getFutureNotifications(page?: number, pageSize?: number): Promise<AnyDatabaseNotification<Config>[]>;
     getAllFutureNotificationsFromUser(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId']): Promise<DatabaseNotification<Config>[]>;
     getFutureNotificationsFromUser(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
-    getAllNotifications(): Promise<DatabaseNotification<Config>[]>;
-    getNotifications(page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
+    getAllNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+    getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
     persistNotification(notification: NotificationInput<Config>): Promise<DatabaseNotification<Config>>;
     persistNotificationUpdate(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], notification: Partial<Omit<DatabaseNotification<Config>, 'id'>>): Promise<DatabaseNotification<Config>>;
-    markAsSent(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): Promise<DatabaseNotification<Config>>;
-    markAsFailed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): Promise<DatabaseNotification<Config>>;
+    persistOneOffNotification(notification: OneOffNotificationInput<Config>): Promise<DatabaseOneOffNotification<Config>>;
+    persistOneOffNotificationUpdate(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], notification: Partial<Omit<DatabaseOneOffNotification<Config>, 'id'>>): Promise<DatabaseOneOffNotification<Config>>;
+    getOneOffNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], _forUpdate: boolean): Promise<DatabaseOneOffNotification<Config> | null>;
+    getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
+    getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
+    markAsSent(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): Promise<AnyDatabaseNotification<Config>>;
+    markAsFailed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsPending?: boolean): Promise<AnyDatabaseNotification<Config>>;
     markAsRead(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], checkIsSent?: boolean): Promise<DatabaseNotification<Config>>;
     cancelNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<void>;
-    getNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], _forUpdate: boolean): Promise<DatabaseNotification<Config> | null>;
+    getNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], _forUpdate: boolean): Promise<AnyDatabaseNotification<Config> | null>;
     filterAllInAppUnreadNotifications(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId']): Promise<DatabaseNotification<Config>[]>;
     filterInAppUnreadNotifications(userId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['userId'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
     getUserEmailFromNotification(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id']): Promise<string | undefined>;
     storeContextUsed(notificationId: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>['id'], context: InputJsonValue): Promise<void>;
-    bulkPersistNotifications(notifications: Omit<Notification<Config>, 'id'>[]): Promise<Config['NotificationIdType'][]>;
+    bulkPersistNotifications(notifications: Omit<AnyNotification<Config>, 'id'>[]): Promise<Config['NotificationIdType'][]>;
 }
 export declare class PrismaNotificationBackendFactory<Config extends BaseNotificationTypeConfig> {
     create<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>>(prismaClient: Client): PrismaNotificationBackend<Client, Config>;

package/dist/prisma-notification-backend.js

@@ -24,10 +24,25 @@ class PrismaNotificationBackend {
     constructor(prismaClient) {
         this.prismaClient = prismaClient;
     }
-    serializeNotification(notification) {
-        return {
+    /**
+     * Build a where clause for status-based updates
+     */
+    buildStatusWhere(id, opts = {}) {
+        const where = {
+            id: id,
+        };
+        if (opts.checkStatus) {
+            where.status = opts.checkStatus;
+        }
+        return where;
+    }
+    /**
+     * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+     * based on whether it has a userId or not (internal implementation)
+     */
+    serializeAnyNotification(notification) {
+        const baseData = {
             id: notification.id,
-            userId: notification.userId,
             notificationType: notification.notificationType,
             title: notification.title,
             bodyTemplate: notification.bodyTemplate,
@@ -48,14 +63,60 @@ class PrismaNotificationBackend {
             createdAt: notification.createdAt,
             updatedAt: notification.updatedAt,
         };
-    }
-    deserializeNotification(notification) {
+        // Check if this is a one-off notification (has emailOrPhone but no userId)
+        // Use explicit null checks to avoid misclassification with empty strings or other falsy values
+        if (notification.userId == null && notification.emailOrPhone != null) {
+            return {
+                ...baseData,
+                emailOrPhone: notification.emailOrPhone,
+                firstName: notification.firstName || '',
+                lastName: notification.lastName || '',
+            };
+        }
+        // Regular notification with userId
+        if (notification.userId == null) {
+            throw new Error('Invalid notification: missing both userId and emailOrPhone');
+        }
         return {
-            user: {
-                connect: {
-                    id: notification.userId,
-                },
-            },
+            ...baseData,
+            userId: notification.userId,
+        };
+    }
+    /**
+     * Serialize a Prisma notification model to DatabaseNotification
+     */
+    serializeRegularNotification(notification) {
+        return this.serializeAnyNotification(notification);
+    }
+    /**
+     * Serialize a Prisma notification model to DatabaseOneOffNotification
+     */
+    serializeOneOffNotification(notification) {
+        return this.serializeAnyNotification(notification);
+    }
+    /**
+     * Public accessor for serialization - primarily for testing
+     * @internal
+     */
+    serializeNotification(notification) {
+        return this.serializeAnyNotification(notification);
+    }
+    /**
+     * Core internal builder for creating notification data
+     * Validates that notification has either userId or emailOrPhone (but not neither)
+     */
+    buildCreateData(notification) {
+        var _a, _b;
+        const hasUserId = 'userId' in notification && notification.userId != null;
+        const hasEmailOrPhone = 'emailOrPhone' in notification && notification.emailOrPhone != null;
+        // Validate: must have either userId or emailOrPhone
+        if (!hasUserId && !hasEmailOrPhone) {
+            throw new Error('Invalid notification: missing both userId and emailOrPhone');
+        }
+        // Determine if this is a one-off notification
+        // When both are provided, userId takes precedence (regular notification)
+        const isOneOff = !hasUserId && hasEmailOrPhone;
+        const base = {
             notificationType: notification.notificationType,
             title: notification.title,
             bodyTemplate: notification.bodyTemplate,
@@ -65,6 +126,122 @@ class PrismaNotificationBackend {
             subjectTemplate: notification.subjectTemplate,
             extraParams: notification.extraParams,
         };
+        if (isOneOff) {
+            return {
+                ...base,
+                userId: null,
+                emailOrPhone: 'emailOrPhone' in notification ? notification.emailOrPhone : '',
+                firstName: (_a = ('firstName' in notification ? notification.firstName : null)) !== null && _a !== void 0 ? _a : null,
+                lastName: (_b = ('lastName' in notification ? notification.lastName : null)) !== null && _b !== void 0 ? _b : null,
+                status: exports.NotificationStatusEnum.PENDING_SEND,
+            };
+        }
+        // At this point we know hasUserId is true, so userId exists and is not null
+        const userId = ('userId' in notification ? notification.userId : null);
+        return {
+            ...base,
+            user: {
+                connect: { id: userId },
+            },
+        };
+    }
+    /**
+     * Deserialize a regular notification input for creation
+     */
+    deserializeRegularNotification(notification) {
+        return this.buildCreateData(notification);
+    }
+    /**
+     * Build one-off notification data for creation
+     */
+    buildOneOffNotificationData(notification) {
+        return this.buildCreateData(notification);
+    }
+    /**
+     * Core internal builder for update data (supports both regular and one-off)
+     */
+    buildUpdateData(notification) {
+        const data = {};
+        // Determine if this is transitioning between regular and one-off notification types
+        const hasUserId = 'userId' in notification && notification.userId !== undefined;
+        const hasOneOffFields = 'emailOrPhone' in notification && notification.emailOrPhone !== undefined;
+        // Handle user / one-off fields with mutual exclusion
+        if (hasUserId) {
+            // Converting to regular notification: set user and clear one-off fields
+            data.user = { connect: { id: notification.userId } };
+            // Clear one-off specific fields when transitioning to regular notification
+            data.emailOrPhone = null;
+            data.firstName = null;
+            data.lastName = null;
+        }
+        else if (hasOneOffFields) {
+            // Converting to one-off notification: set one-off fields
+            // Note: We cannot explicitly clear the user relationship via update,
+            // but setting emailOrPhone indicates this is now a one-off notification
+            data.emailOrPhone = notification.emailOrPhone;
+            if ('firstName' in notification && notification.firstName !== undefined) {
+                data.firstName = notification.firstName;
+            }
+            if ('lastName' in notification && notification.lastName !== undefined) {
+                data.lastName = notification.lastName;
+            }
+        }
+        else {
+            // No type transition, just update individual fields if provided
+            if ('emailOrPhone' in notification && notification.emailOrPhone !== undefined) {
+                data.emailOrPhone = notification.emailOrPhone;
+            }
+            if ('firstName' in notification && notification.firstName !== undefined) {
+                data.firstName = notification.firstName;
+            }
+            if ('lastName' in notification && notification.lastName !== undefined) {
+                data.lastName = notification.lastName;
+            }
+        }
+        // Handle common fields
+        if (notification.notificationType !== undefined) {
+            data.notificationType = notification.notificationType;
+        }
+        if (notification.title !== undefined) {
+            data.title = notification.title;
+        }
+        if (notification.bodyTemplate !== undefined) {
+            data.bodyTemplate = notification.bodyTemplate;
+        }
+        if (notification.contextName !== undefined) {
+            data.contextName = notification.contextName;
+        }
+        if (notification.contextParameters !== undefined) {
+            data.contextParameters = notification.contextParameters;
+        }
+        if (notification.sendAfter !== undefined) {
+            data.sendAfter = notification.sendAfter;
+        }
+        if (notification.subjectTemplate !== undefined) {
+            data.subjectTemplate = notification.subjectTemplate;
+        }
+        if (notification.status !== undefined) {
+            data.status = notification.status;
+        }
+        if (notification.contextUsed !== undefined) {
+            data.contextUsed = notification.contextUsed;
+        }
+        if (notification.extraParams !== undefined) {
+            data.extraParams = notification.extraParams;
+        }
+        if (notification.adapterUsed !== undefined) {
+            data.adapterUsed = notification.adapterUsed;
+        }
+        if (notification.sentAt !== undefined) {
+            data.sentAt = notification.sentAt;
+        }
+        if (notification.readAt !== undefined) {
+            data.readAt = notification.readAt;
+        }
+        return data;
+    }
+    deserializeNotification(notification) {
+        return this.buildCreateData(notification);
     }
     deserializeNotificationForUpdate(notification) {
         return {
@@ -88,46 +265,40 @@ class PrismaNotificationBackend {
     }
     async getAllPendingNotifications() {
         const notifications = await this.prismaClient.notification.findMany({
-            where: {
-                status: exports.NotificationStatusEnum.PENDING_SEND,
-            },
+            where: { status: exports.NotificationStatusEnum.PENDING_SEND },
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
-    async getPendingNotifications() {
+    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(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
     async getAllFutureNotifications() {
         const notifications = await this.prismaClient.notification.findMany({
             where: {
-                status: {
-                    not: exports.NotificationStatusEnum.PENDING_SEND,
-                },
-                sendAfter: {
-                    lte: new Date(),
-                },
+                status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+                sendAfter: { lte: new Date() },
             },
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
-    async getFutureNotifications() {
+    async getFutureNotifications(page = 0, pageSize = 100) {
         const notifications = await this.prismaClient.notification.findMany({
             where: {
-                status: {
-                    not: exports.NotificationStatusEnum.PENDING_SEND,
-                },
-                sendAfter: {
-                    lte: new Date(),
-                },
+                status: { not: exports.NotificationStatusEnum.PENDING_SEND },
+                sendAfter: { lte: new Date() },
             },
+            skip: page * pageSize,
+            take: pageSize,
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
     async getAllFutureNotificationsFromUser(userId) {
         const notifications = await this.prismaClient.notification.findMany({
@@ -141,7 +312,7 @@ class PrismaNotificationBackend {
                 },
             },
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeRegularNotification(n));
     }
     async getFutureNotificationsFromUser(userId, page, pageSize) {
         const notifications = await this.prismaClient.notification.findMany({
@@ -157,67 +328,124 @@ class PrismaNotificationBackend {
             skip: page * pageSize,
             take: pageSize,
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeRegularNotification(n));
     }
     async getAllNotifications() {
         const notifications = await this.prismaClient.notification.findMany({});
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
     async getNotifications(page, pageSize) {
         const notifications = await this.prismaClient.notification.findMany({
             skip: page * pageSize,
             take: pageSize,
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeAnyNotification(n));
     }
     async persistNotification(notification) {
-        return this.serializeNotification(await this.prismaClient.notification.create({
-            data: this.deserializeNotification(notification),
-        }));
+        const created = await this.prismaClient.notification.create({
+            data: this.deserializeRegularNotification(notification),
+        });
+        return this.serializeRegularNotification(created);
     }
     async persistNotificationUpdate(notificationId, notification) {
-        return this.serializeNotification(await this.prismaClient.notification.update({
+        const updated = await this.prismaClient.notification.update({
             where: {
                 id: notificationId,
             },
-            data: this.deserializeNotificationForUpdate(notification),
-        }));
+            data: this.buildUpdateData(notification),
+        });
+        return this.serializeRegularNotification(updated);
     }
-    async markAsSent(notificationId, checkIsPending = true) {
-        return this.serializeNotification(await this.prismaClient.notification.update({
+    /* One-off notification persistence and query methods */
+    async persistOneOffNotification(notification) {
+        const created = await this.prismaClient.notification.create({
+            data: this.buildOneOffNotificationData(notification),
+        });
+        return this.serializeOneOffNotification(created);
+    }
+    async persistOneOffNotificationUpdate(notificationId, notification) {
+        const updated = await this.prismaClient.notification.update({
+            where: { id: notificationId },
+            data: this.buildUpdateData(notification),
+        });
+        return this.serializeOneOffNotification(updated);
+    }
+    async getOneOffNotification(notificationId, _forUpdate) {
+        const notification = await this.prismaClient.notification.findUnique({
             where: {
                 id: notificationId,
-                ...(checkIsPending ? { status: exports.NotificationStatusEnum.PENDING_SEND } : {}),
             },
+        });
+        if (!notification || notification.emailOrPhone == null || notification.userId !== null) {
+            return null;
+        }
+        return this.serializeOneOffNotification(notification);
+    }
+    async getAllOneOffNotifications() {
+        const notifications = await this.prismaClient.notification.findMany({
+            where: {
+                userId: null,
+                emailOrPhone: { not: null },
+            },
+        });
+        return notifications.map((n) => this.serializeOneOffNotification(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.map((n) => this.serializeOneOffNotification(n));
+    }
+    async markAsSent(notificationId, checkIsPending = true) {
+        const updated = await this.prismaClient.notification.update({
+            where: this.buildStatusWhere(notificationId, {
+                checkStatus: checkIsPending ? exports.NotificationStatusEnum.PENDING_SEND : undefined,
+            }),
             data: {
                 status: exports.NotificationStatusEnum.SENT,
                 sentAt: new Date(),
             },
-        }));
+        });
+        return this.serializeAnyNotification(updated);
     }
     async markAsFailed(notificationId, checkIsPending = true) {
-        return this.serializeNotification(await this.prismaClient.notification.update({
-            where: {
-                id: notificationId,
-                ...(checkIsPending ? { status: exports.NotificationStatusEnum.PENDING_SEND } : {}),
-            },
+        const updated = await this.prismaClient.notification.update({
+            where: this.buildStatusWhere(notificationId, {
+                checkStatus: checkIsPending ? exports.NotificationStatusEnum.PENDING_SEND : undefined,
+            }),
             data: {
                 status: exports.NotificationStatusEnum.FAILED,
                 sentAt: new Date(),
             },
-        }));
+        });
+        return this.serializeAnyNotification(updated);
     }
     async markAsRead(notificationId, checkIsSent = true) {
-        return this.serializeNotification(await this.prismaClient.notification.update({
-            where: {
-                id: notificationId,
-                ...(checkIsSent ? { status: exports.NotificationStatusEnum.SENT } : {}),
-            },
+        // First fetch to validate it's a regular notification
+        const notification = await this.prismaClient.notification.findUnique({
+            where: { id: notificationId },
+        });
+        if (!notification) {
+            throw new Error('Notification not found');
+        }
+        if (notification.userId == null) {
+            throw new Error('Cannot mark one-off notification as read');
+        }
+        const updated = await this.prismaClient.notification.update({
+            where: this.buildStatusWhere(notificationId, {
+                checkStatus: checkIsSent ? exports.NotificationStatusEnum.SENT : undefined,
+            }),
             data: {
-                status: 'READ',
+                status: exports.NotificationStatusEnum.READ,
                 readAt: new Date(),
             },
-        }));
+        });
+        return this.serializeRegularNotification(updated);
     }
     async cancelNotification(notificationId) {
         await this.prismaClient.notification.update({
@@ -231,14 +459,11 @@ class PrismaNotificationBackend {
     }
     async getNotification(notificationId, _forUpdate) {
         const notification = await this.prismaClient.notification.findUnique({
-            where: {
-                id: notificationId,
-            },
+            where: { id: notificationId },
         });
-        if (!notification) {
+        if (!notification)
             return null;
-        }
-        return this.serializeNotification(notification);
+        return this.serializeAnyNotification(notification);
     }
     async filterAllInAppUnreadNotifications(userId) {
         const notifications = await this.prismaClient.notification.findMany({
@@ -248,7 +473,7 @@ class PrismaNotificationBackend {
                 readAt: null,
             },
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeRegularNotification(n));
     }
     async filterInAppUnreadNotifications(userId, page, pageSize) {
         const notifications = await this.prismaClient.notification.findMany({
@@ -260,7 +485,7 @@ class PrismaNotificationBackend {
             skip: page * pageSize,
             take: pageSize,
         });
-        return notifications.map(this.serializeNotification);
+        return notifications.map((n) => this.serializeRegularNotification(n));
     }
     async getUserEmailFromNotification(notificationId) {
         var _a;
@@ -276,12 +501,8 @@ class PrismaNotificationBackend {
     }
     async storeContextUsed(notificationId, context) {
         await this.prismaClient.notification.update({
-            where: {
-                id: notificationId,
-            },
-            data: {
-                contextUsed: context,
-            },
+            where: { id: notificationId },
+            data: { contextUsed: context }
         });
     }
     async bulkPersistNotifications(notifications) {