vintasend-prisma 0.2.3 → 0.4.0

package/dist/prisma-notification-backend.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrismaNotificationBackendFactory = exports.PrismaNotificationBackend = exports.NotificationTypeEnum = exports.NotificationStatusEnum = void 0;
+const attachment_1 = require("vintasend/dist/types/attachment");
 exports.NotificationStatusEnum = {
     PENDING_SEND: 'PENDING_SEND',
     SENT: 'SENT',
@@ -14,6 +15,14 @@ exports.NotificationTypeEnum = {
     SMS: 'SMS',
     IN_APP: 'IN_APP',
 };
+// Centralized attachment include shape for DRY
+const notificationWithAttachmentsInclude = {
+    attachments: {
+        include: {
+            attachmentFile: true,
+        },
+    },
+};
 function convertJsonValueToRecord(jsonValue) {
     if (typeof jsonValue === 'object' && !Array.isArray(jsonValue)) {
         return jsonValue;
@@ -21,13 +30,35 @@ function convertJsonValueToRecord(jsonValue) {
     throw new Error('Invalid JSON value. It should be an object.');
 }
 class PrismaNotificationBackend {
-    constructor(prismaClient) {
+    constructor(prismaClient, attachmentManager) {
         this.prismaClient = prismaClient;
+        this.attachmentManager = attachmentManager;
     }
-    serializeNotification(notification) {
-        return {
+    /**
+     * Inject attachment manager (called by VintaSend when both service and backend exist)
+     */
+    injectAttachmentManager(manager) {
+        this.attachmentManager = manager;
+    }
+    /**
+     * 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,
@@ -47,15 +78,65 @@ class PrismaNotificationBackend {
             readAt: notification.readAt,
             createdAt: notification.createdAt,
             updatedAt: notification.updatedAt,
+            // Serialize attachments if present and attachmentManager is available
+            attachments: notification.attachments && this.attachmentManager
+                ? notification.attachments.map((att) => this.serializeStoredAttachment(att))
+                : undefined,
         };
-    }
-    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,
@@ -64,7 +145,245 @@ class PrismaNotificationBackend {
             sendAfter: notification.sendAfter,
             subjectTemplate: notification.subjectTemplate,
             extraParams: notification.extraParams,
+            // Only include one-off fields if this is actually a one-off notification
+            ...(isOneOff && {
+                emailOrPhone: 'emailOrPhone' in notification ? notification.emailOrPhone : null,
+                firstName: 'firstName' in notification ? (_a = notification.firstName) !== null && _a !== void 0 ? _a : null : null,
+                lastName: 'lastName' in notification ? (_b = notification.lastName) !== null && _b !== void 0 ? _b : null : null,
+            }),
         };
+        if (isOneOff) {
+            return {
+                ...base,
+                userId: null,
+                status: exports.NotificationStatusEnum.PENDING_SEND,
+                user: undefined,
+            };
+        }
+        // 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,
+            userId,
+            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;
+    }
+    /**
+     * Get or create file record for attachment upload with deduplication (transaction-aware)
+     * @private
+     */
+    async getOrCreateFileRecordForUploadInTransaction(tx, att) {
+        const manager = this.getAttachmentManager();
+        const buffer = await manager.fileToBuffer(att.file);
+        const checksum = manager.calculateChecksum(buffer);
+        let fileRecord = await this.findAttachmentFileByChecksumInTransaction(tx, checksum);
+        if (!fileRecord) {
+            fileRecord = await manager.uploadFile(att.file, att.filename, att.contentType);
+            await tx.attachmentFile.create({
+                data: {
+                    id: fileRecord.id,
+                    filename: fileRecord.filename,
+                    contentType: fileRecord.contentType,
+                    size: fileRecord.size,
+                    checksum: fileRecord.checksum,
+                    storageMetadata: fileRecord.storageMetadata,
+                },
+            });
+        }
+        return fileRecord;
+    }
+    /**
+     * Get or create file record for attachment upload with deduplication (non-transactional)
+     * @private
+     */
+    async getOrCreateFileRecordForUpload(att) {
+        return this.getOrCreateFileRecordForUploadInTransaction(this.prismaClient, att);
+    }
+    /**
+     * Create notification attachment link (transaction-aware)
+     * @private
+     */
+    async createNotificationAttachmentLinkInTransaction(tx, notificationId, fileId, description) {
+        await tx.notificationAttachment.create({
+            data: {
+                notificationId,
+                fileId,
+                description: description !== null && description !== void 0 ? description : null,
+            },
+        });
+    }
+    /**
+     * Create notification attachment link (non-transactional)
+     * @private
+     */
+    async createNotificationAttachmentLink(notificationId, fileId, description) {
+        return this.createNotificationAttachmentLinkInTransaction(this.prismaClient, notificationId, fileId, description);
+    }
+    /**
+     * Get attachment file by ID (transaction-aware)
+     * @private
+     */
+    async getAttachmentFileInTransaction(tx, fileId) {
+        const file = await tx.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Find attachment file by checksum (transaction-aware)
+     * @private
+     */
+    async findAttachmentFileByChecksumInTransaction(tx, checksum) {
+        const file = await tx.attachmentFile.findUnique({
+            where: { checksum },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Core helper for creating notifications with attachments (both regular and one-off)
+     * Uses transactions to ensure atomicity - if attachment processing fails, the notification won't be created
+     * @private
+     */
+    async createNotificationWithAttachments(input, buildData, serialize) {
+        const { attachments, ...notificationData } = input;
+        // If no attachments, skip transaction overhead
+        if (!attachments || attachments.length === 0) {
+            const created = await this.prismaClient.notification.create({
+                data: buildData(notificationData),
+                include: notificationWithAttachmentsInclude,
+            });
+            return serialize(created);
+        }
+        // Use transaction to ensure atomicity of notification + attachments
+        return await this.prismaClient.$transaction(async (tx) => {
+            const created = await tx.notification.create({
+                data: buildData(notificationData),
+                include: notificationWithAttachmentsInclude,
+            });
+            await this.processAndStoreAttachmentsInTransaction(tx, created.id, attachments);
+            const withAttachments = await tx.notification.findUnique({
+                where: { id: created.id },
+                include: notificationWithAttachmentsInclude,
+            });
+            if (!withAttachments) {
+                throw new Error('Failed to retrieve notification after creating attachments');
+            }
+            return serialize(withAttachments);
+        });
+    }
+    /**
+     * Get attachment manager with null check
+     * @private
+     */
+    getAttachmentManager() {
+        if (!this.attachmentManager) {
+            throw new Error('AttachmentManager is required but not provided');
+        }
+        return this.attachmentManager;
+    }
+    deserializeNotification(notification) {
+        return this.buildCreateData(notification);
     }
     deserializeNotificationForUpdate(notification) {
         return {
@@ -88,46 +407,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 +454,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 +470,118 @@ 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),
-        }));
+        return this.createNotificationWithAttachments(notification, (n) => this.deserializeRegularNotification(n), (db) => this.serializeRegularNotification(db));
     }
     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) {
+        return this.createNotificationWithAttachments(notification, (n) => this.buildOneOffNotificationData(n), (db) => this.serializeOneOffNotification(db));
+    }
+    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 +595,12 @@ class PrismaNotificationBackend {
     }
     async getNotification(notificationId, _forUpdate) {
         const notification = await this.prismaClient.notification.findUnique({
-            where: {
-                id: notificationId,
-            },
+            where: { id: notificationId },
+            include: notificationWithAttachmentsInclude,
         });
-        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 +610,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 +622,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,24 +638,159 @@ 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) {
-        return this.prismaClient.notification.createMany({
+        const created = await this.prismaClient.notification.createManyAndReturn({
             data: notifications.map((notification) => this.deserializeNotification(notification)),
         });
+        return created.map((n) => n.id);
+    }
+    /* Attachment management methods */
+    async getAttachmentFile(fileId) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Find an attachment file by checksum for deduplication.
+     * This allows the backend to check if a file already exists before uploading.
+     */
+    async findAttachmentFileByChecksum(checksum) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { checksum },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    async deleteAttachmentFile(fileId) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        // If there's no DB record, there's nothing to delete
+        if (!file)
+            return;
+        // First delete the underlying stored file so DB and storage stay in sync
+        const manager = this.getAttachmentManager();
+        await manager.deleteFile(fileId);
+        // Only after successful storage deletion, remove the DB record
+        await this.prismaClient.attachmentFile.delete({
+            where: { id: fileId },
+        });
+    }
+    async getOrphanedAttachmentFiles() {
+        const orphanedFiles = await this.prismaClient.attachmentFile.findMany({
+            where: {
+                notificationAttachments: { none: {} },
+            },
+        });
+        return orphanedFiles.map((file) => this.serializeAttachmentFileRecord(file));
+    }
+    async getAttachments(notificationId) {
+        const attachments = await this.prismaClient.notificationAttachment.findMany({
+            where: { notificationId },
+            include: { attachmentFile: true },
+        });
+        this.getAttachmentManager(); // Validate attachment manager exists
+        return attachments.map((att) => this.serializeStoredAttachment(att));
+    }
+    async deleteNotificationAttachment(notificationId, attachmentId) {
+        const result = await this.prismaClient.notificationAttachment.deleteMany({
+            where: {
+                id: attachmentId,
+                notificationId,
+            },
+        });
+        if (result.count === 0) {
+            throw new Error(`Attachment ${attachmentId} not found for notification ${notificationId}`);
+        }
+    }
+    /**
+     * Process and store attachments for a notification within a transaction.
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    async processAndStoreAttachmentsInTransaction(tx, notificationId, attachments) {
+        this.getAttachmentManager(); // Validate attachment manager exists
+        // Process each attachment
+        for (const att of attachments) {
+            if ((0, attachment_1.isAttachmentReference)(att)) {
+                // Reference existing file - just create the notification link
+                const fileRecord = await this.getAttachmentFileInTransaction(tx, att.fileId);
+                if (!fileRecord) {
+                    throw new Error(`Referenced file ${att.fileId} not found`);
+                }
+                await this.createNotificationAttachmentLinkInTransaction(tx, notificationId, att.fileId, att.description);
+            }
+            else {
+                // Upload new file with deduplication
+                const fileRecord = await this.getOrCreateFileRecordForUploadInTransaction(tx, att);
+                await this.createNotificationAttachmentLinkInTransaction(tx, notificationId, fileRecord.id, att.description);
+            }
+        }
+    }
+    /**
+     * Process and store attachments for a notification (non-transactional version).
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    async processAndStoreAttachments(notificationId, attachments) {
+        return this.processAndStoreAttachmentsInTransaction(this.prismaClient, notificationId, attachments);
+    }
+    /**
+     * Serialize a Prisma attachment file model to AttachmentFileRecord
+     * @private
+     */
+    serializeAttachmentFileRecord(file) {
+        return {
+            id: file.id,
+            filename: file.filename,
+            contentType: file.contentType,
+            size: file.size,
+            checksum: file.checksum,
+            storageMetadata: file.storageMetadata,
+            createdAt: file.createdAt,
+            updatedAt: file.updatedAt,
+        };
+    }
+    /**
+     * Serialize a Prisma notification attachment model to StoredAttachment
+     * @private
+     */
+    serializeStoredAttachment(attachment) {
+        var _a;
+        const manager = this.getAttachmentManager();
+        if (!attachment.attachmentFile) {
+            throw new Error('AttachmentFile is required to reconstruct stored attachment');
+        }
+        const fileRecord = this.serializeAttachmentFileRecord(attachment.attachmentFile);
+        const attachmentFile = manager.reconstructAttachmentFile(fileRecord.storageMetadata);
+        return {
+            id: attachment.id,
+            fileId: attachment.fileId,
+            filename: fileRecord.filename,
+            contentType: fileRecord.contentType,
+            size: fileRecord.size,
+            checksum: fileRecord.checksum,
+            createdAt: attachment.createdAt,
+            file: attachmentFile,
+            description: (_a = attachment.description) !== null && _a !== void 0 ? _a : undefined,
+            storageMetadata: fileRecord.storageMetadata,
+        };
     }
 }
 exports.PrismaNotificationBackend = PrismaNotificationBackend;
 class PrismaNotificationBackendFactory {
-    create(prismaClient) {
-        return new PrismaNotificationBackend(prismaClient);
+    create(prismaClient, attachmentManager) {
+        return new PrismaNotificationBackend(prismaClient, attachmentManager);
     }
 }
 exports.PrismaNotificationBackendFactory = PrismaNotificationBackendFactory;