vintasend-prisma 0.2.3 → 0.3.0

package/dist/implementations/vintasend-prisma/src/index.d.ts

@@ -0,0 +1,2 @@
+export { PrismaNotificationBackendFactory } from './prisma-notification-backend';
+export type { PrismaNotificationBackend } from './prisma-notification-backend';

package/dist/implementations/vintasend-prisma/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaNotificationBackendFactory = void 0;
+var prisma_notification_backend_1 = require("./prisma-notification-backend");
+Object.defineProperty(exports, "PrismaNotificationBackendFactory", { enumerable: true, get: function () { return prisma_notification_backend_1.PrismaNotificationBackendFactory; } });

package/dist/implementations/vintasend-prisma/src/prisma-notification-backend.d.ts

@@ -0,0 +1,190 @@
+import type { BaseNotificationBackend } from '../../../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 { DatabaseOneOffNotification, OneOffNotificationInput, AnyDatabaseNotification } from '../../../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';
+export declare const NotificationStatusEnum: {
+    readonly PENDING_SEND: "PENDING_SEND";
+    readonly SENT: "SENT";
+    readonly FAILED: "FAILED";
+    readonly READ: "READ";
+    readonly CANCELLED: "CANCELLED";
+};
+export declare const NotificationTypeEnum: {
+    readonly EMAIL: "EMAIL";
+    readonly PUSH: "PUSH";
+    readonly SMS: "SMS";
+    readonly IN_APP: "IN_APP";
+};
+export interface PrismaNotificationModel<IdType, UserId> {
+    id: IdType;
+    userId: UserId | null;
+    emailOrPhone: string | null;
+    firstName: string | null;
+    lastName: string | null;
+    notificationType: NotificationType;
+    title: string | null;
+    bodyTemplate: string;
+    contextName: string;
+    contextParameters: JsonValue;
+    sendAfter: Date | null;
+    subjectTemplate: string | null;
+    status: NotificationStatus;
+    contextUsed: JsonValue | null;
+    extraParams: JsonValue | null;
+    adapterUsed: string | null;
+    sentAt: Date | null;
+    readAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: {
+        email: string;
+    };
+}
+export interface NotificationPrismaClientInterface<NotificationIdType, UserIdType> {
+    notification: {
+        findMany(args: {
+            where?: {
+                status?: NotificationStatus | {
+                    not: NotificationStatus;
+                };
+                sendAfter?: {
+                    lte: Date;
+                } | null;
+                userId?: UserIdType | null;
+                readAt?: null;
+                emailOrPhone?: string | {
+                    not: null;
+                };
+            };
+            skip?: number;
+            take?: number;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>[]>;
+        create(args: {
+            data: BaseNotificationCreateInput<UserIdType>;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
+        createMany(args: {
+            data: BaseNotificationCreateInput<UserIdType>[];
+        }): Promise<NotificationIdType[]>;
+        update(args: {
+            where: {
+                id: NotificationIdType;
+            };
+            data: Partial<BaseNotificationUpdateInput<UserIdType>>;
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType>>;
+        findUnique(args: {
+            where: {
+                id: NotificationIdType;
+            };
+            include?: {
+                user?: boolean;
+            };
+        }): Promise<PrismaNotificationModel<NotificationIdType, UserIdType> | null>;
+    };
+}
+type NoExpand<T> = T extends unknown ? T : never;
+type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
+    [P in K]: O[P];
+} & O : O) | ({
+    [P in keyof O as P extends K ? K : never]-?: O[P];
+} & O) : never>;
+export interface BaseNotificationCreateInput<UserIdType> {
+    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;
+    contextName: string;
+    contextParameters: InputJsonValue;
+    sendAfter?: Date | null;
+    subjectTemplate?: string | null;
+    status?: NotificationStatus;
+    contextUsed?: InputJsonValue;
+    extraParams?: InputJsonValue;
+    adapterUsed?: string | null;
+    sentAt?: Date | null;
+    readAt?: Date | null;
+}
+export interface BaseNotificationUpdateInput<UserIdType> {
+    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;
+    contextName?: string;
+    contextParameters?: InputJsonValue;
+    sendAfter?: Date | null;
+    subjectTemplate?: string | null;
+    status?: NotificationStatus;
+    contextUsed?: InputJsonValue;
+    extraParams?: InputJsonValue;
+    adapterUsed?: string | null;
+    sentAt?: Date | null;
+    readAt?: Date | null;
+}
+export declare class PrismaNotificationBackend<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>, Config extends BaseNotificationTypeConfig> implements BaseNotificationBackend<Config> {
+    private prismaClient;
+    constructor(prismaClient: Client);
+    /**
+     * Serialize a Prisma notification model to either DatabaseNotification or DatabaseOneOffNotification
+     * based on whether it has a userId or not
+     */
+    serializeNotification(notification: NonNullable<Awaited<ReturnType<typeof this.prismaClient.notification.findUnique>>>): AnyDatabaseNotification<Config>;
+    deserializeNotification(notification: NotificationInput<Config>): BaseNotificationCreateInput<Config['UserIdType']>;
+    deserializeNotificationForUpdate(notification: Partial<Notification<Config>>): Partial<Parameters<typeof this.prismaClient.notification.update>[0]['data']>;
+    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<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>>;
+    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<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'][]>;
+}
+export declare class PrismaNotificationBackendFactory<Config extends BaseNotificationTypeConfig> {
+    create<Client extends NotificationPrismaClientInterface<Config['NotificationIdType'], Config['UserIdType']>>(prismaClient: Client): PrismaNotificationBackend<Client, Config>;
+}
+export {};

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

@@ -0,0 +1,399 @@
+"use strict";
+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',
+};
+exports.NotificationTypeEnum = {
+    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.');
+}
+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);
+    }
+    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;
+        }
+        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)),
+        });
+    }
+}
+exports.PrismaNotificationBackend = PrismaNotificationBackend;
+class PrismaNotificationBackendFactory {
+    create(prismaClient) {
+        return new PrismaNotificationBackend(prismaClient);
+    }
+}
+exports.PrismaNotificationBackendFactory = PrismaNotificationBackendFactory;