vintasend-medplum 0.4.0

package/dist/medplum-backend.js

@@ -0,0 +1,831 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedplumNotificationBackendFactory = exports.MedplumNotificationBackend = void 0;
+class MedplumNotificationBackend {
+    constructor(medplum, options = {
+        emailNotificationSubjectExtensionUrl: 'http://vintasend.com/fhir/StructureDefinition/email-notification-subject',
+    }) {
+        this.medplum = medplum;
+        this.options = options;
+    }
+    /**
+     * Inject attachment manager (called by VintaSend when both service and backend exist)
+     */
+    injectAttachmentManager(manager) {
+        this.attachmentManager = manager;
+    }
+    /**
+     * Get attachment manager with null check
+     */
+    getAttachmentManager() {
+        if (!this.attachmentManager) {
+            throw new Error('AttachmentManager is required');
+        }
+        return this.attachmentManager;
+    }
+    mapToDatabaseNotification(communication) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        const notificationId = communication.id;
+        const referenceString = (_b = (_a = communication.recipient) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.reference;
+        // Extract subjectTemplate from payload extension
+        const subjectTemplateExtension = (_e = (_d = (_c = communication.payload) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.extension) === null || _e === void 0 ? void 0 : _e.find((ext) => ext.url === this.options.emailNotificationSubjectExtensionUrl);
+        const subjectTemplate = (subjectTemplateExtension === null || subjectTemplateExtension === void 0 ? void 0 : subjectTemplateExtension.valueString) || null;
+        // Extract one-off notification fields from extensions
+        const emailOrPhoneExtension = (_f = communication.extension) === null || _f === void 0 ? void 0 : _f.find((ext) => ext.url === 'http://vintasend.com/fhir/StructureDefinition/emailOrPhone');
+        const firstNameExtension = (_g = communication.extension) === null || _g === void 0 ? void 0 : _g.find((ext) => ext.url === 'http://vintasend.com/fhir/StructureDefinition/firstName');
+        const lastNameExtension = (_h = communication.extension) === null || _h === void 0 ? void 0 : _h.find((ext) => ext.url === 'http://vintasend.com/fhir/StructureDefinition/lastName');
+        const emailOrPhone = emailOrPhoneExtension === null || emailOrPhoneExtension === void 0 ? void 0 : emailOrPhoneExtension.valueString;
+        const firstName = firstNameExtension === null || firstNameExtension === void 0 ? void 0 : firstNameExtension.valueString;
+        const lastName = lastNameExtension === null || lastNameExtension === void 0 ? void 0 : lastNameExtension.valueString;
+        const baseNotification = {
+            id: notificationId,
+            notificationType: (_l = (_k = (_j = communication.meta) === null || _j === void 0 ? void 0 : _j.tag) === null || _k === void 0 ? void 0 : _k[2]) === null || _l === void 0 ? void 0 : _l.code,
+            title: ((_m = communication.topic) === null || _m === void 0 ? void 0 : _m.text) || null,
+            contextName: (_q = (_p = (_o = communication.meta) === null || _o === void 0 ? void 0 : _o.tag) === null || _p === void 0 ? void 0 : _p[1]) === null || _q === void 0 ? void 0 : _q.code,
+            contextParameters: JSON.parse(((_s = (_r = communication.note) === null || _r === void 0 ? void 0 : _r[0]) === null || _s === void 0 ? void 0 : _s.text) || '{}'),
+            sendAfter: communication.sent ? new Date(communication.sent) : null,
+            bodyTemplate: ((_u = (_t = communication.payload) === null || _t === void 0 ? void 0 : _t[0]) === null || _u === void 0 ? void 0 : _u.contentString) || '',
+            subjectTemplate: subjectTemplate,
+            extraParams: {},
+            status: communication.status === 'completed' ? 'SENT' : communication.status === 'stopped' ? 'FAILED' : 'PENDING_SEND',
+            contextUsed: null,
+            adapterUsed: null,
+            sentAt: communication.status === 'completed' ? new Date(communication.sent || new Date()) : null,
+            readAt: null,
+            createdAt: new Date(((_v = communication.meta) === null || _v === void 0 ? void 0 : _v.lastUpdated) || new Date()),
+            updatedAt: new Date(((_w = communication.meta) === null || _w === void 0 ? void 0 : _w.lastUpdated) || new Date()),
+        };
+        // Check if this is a one-off notification
+        if (emailOrPhone && firstName && lastName) {
+            return {
+                ...baseNotification,
+                emailOrPhone,
+                firstName,
+                lastName,
+            };
+        }
+        // Regular notification
+        return {
+            ...baseNotification,
+            userId: referenceString,
+        };
+    }
+    async getAllPendingNotifications() {
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getPendingNotifications(page, pageSize) {
+        const now = new Date().toISOString();
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+            'sent:le': now,
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getAllFutureNotifications() {
+        const now = new Date().toISOString();
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+            'sent:gt': now,
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getFutureNotifications(page, pageSize) {
+        const now = new Date().toISOString();
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+            'sent:gt': now,
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getAllFutureNotificationsFromUser(referenceString) {
+        const now = new Date().toISOString();
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+            'sent:gt': now,
+            recipient: referenceString,
+        });
+        return communications
+            .map((comm) => this.mapToDatabaseNotification(comm))
+            .filter((n) => 'userId' in n);
+    }
+    async getFutureNotificationsFromUser(referenceString, page, pageSize) {
+        const now = new Date().toISOString();
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'in-progress',
+            _tag: 'notification',
+            'sent:gt': now,
+            recipient: referenceString,
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications
+            .map((comm) => this.mapToDatabaseNotification(comm))
+            .filter((n) => 'userId' in n);
+    }
+    async persistNotification(notification) {
+        var _a;
+        // Build base payload with body template
+        const payload = notification.bodyTemplate
+            ? [
+                {
+                    contentString: notification.bodyTemplate,
+                    extension: notification.subjectTemplate && this.options.emailNotificationSubjectExtensionUrl
+                        ? [{ url: this.options.emailNotificationSubjectExtensionUrl, valueString: notification.subjectTemplate }]
+                        : undefined,
+                },
+            ]
+            : [];
+        // Handle attachments if present
+        if (notification.attachments && notification.attachments.length > 0) {
+            const attachmentPayload = await this.processAttachments(notification.attachments);
+            if (attachmentPayload) {
+                payload.push(...attachmentPayload);
+            }
+        }
+        const communication = {
+            resourceType: 'Communication',
+            status: 'in-progress',
+            sent: (_a = notification.sendAfter) === null || _a === void 0 ? void 0 : _a.toISOString(),
+            topic: { text: notification.title || undefined },
+            payload,
+            recipient: [{ reference: notification.userId }],
+            note: [{ text: JSON.stringify(notification.contextParameters) }],
+            meta: {
+                tag: [
+                    { code: 'notification' },
+                    { code: notification.contextName },
+                    { code: notification.notificationType },
+                ],
+            },
+        };
+        const created = await this.medplum.createResource(communication);
+        return this.mapToDatabaseNotification(created);
+    }
+    async persistNotificationUpdate(notificationId, notification) {
+        const existing = await this.medplum.readResource('Communication', notificationId);
+        const updated = {
+            ...existing,
+            ...(notification.status === 'SENT' && { status: 'completed' }),
+            ...(notification.status === 'FAILED' && { status: 'stopped' }),
+            meta: {
+                ...existing.meta,
+                lastUpdated: new Date().toISOString(),
+            },
+        };
+        const result = await this.medplum.updateResource(updated);
+        return this.mapToDatabaseNotification(result);
+    }
+    async getAllNotifications() {
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification',
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getNotifications(page, pageSize) {
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification',
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async bulkPersistNotifications(notifications) {
+        var _a;
+        const ids = [];
+        for (const notification of notifications) {
+            const communication = {
+                resourceType: 'Communication',
+                status: 'in-progress',
+                sent: (_a = notification.sendAfter) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                topic: { text: notification.title || undefined },
+                payload: notification.bodyTemplate
+                    ? [
+                        {
+                            contentString: notification.bodyTemplate,
+                            extension: notification.subjectTemplate && this.options.emailNotificationSubjectExtensionUrl
+                                ? [{ url: this.options.emailNotificationSubjectExtensionUrl, valueString: notification.subjectTemplate }]
+                                : undefined,
+                        },
+                    ]
+                    : [],
+                recipient: [{ reference: notification.userId }],
+                note: [{ text: JSON.stringify(notification.contextParameters) }],
+                meta: {
+                    tag: [
+                        { code: 'notification' },
+                        { code: notification.contextName },
+                        { code: notification.notificationType },
+                    ],
+                },
+            };
+            const created = await this.medplum.createResource(communication);
+            ids.push(created.id);
+        }
+        return ids;
+    }
+    async markAsSent(notificationId, checkIsPending = true) {
+        const notification = await this.getNotification(notificationId, false);
+        if (checkIsPending && (notification === null || notification === void 0 ? void 0 : notification.status) !== 'PENDING_SEND') {
+            throw new Error('Notification is not pending');
+        }
+        // Use internal update that returns AnyDatabaseNotification
+        const existing = await this.medplum.readResource('Communication', notificationId);
+        const updated = {
+            ...existing,
+            status: 'completed',
+            meta: {
+                ...existing.meta,
+                lastUpdated: new Date().toISOString(),
+            },
+        };
+        const result = await this.medplum.updateResource(updated);
+        return this.mapToDatabaseNotification(result);
+    }
+    async markAsFailed(notificationId, checkIsPending = true) {
+        const notification = await this.getNotification(notificationId, false);
+        if (checkIsPending && (notification === null || notification === void 0 ? void 0 : notification.status) !== 'PENDING_SEND') {
+            throw new Error('Notification is not pending');
+        }
+        // Use internal update that returns AnyDatabaseNotification
+        const existing = await this.medplum.readResource('Communication', notificationId);
+        const updated = {
+            ...existing,
+            status: 'stopped',
+            meta: {
+                ...existing.meta,
+                lastUpdated: new Date().toISOString(),
+            },
+        };
+        const result = await this.medplum.updateResource(updated);
+        return this.mapToDatabaseNotification(result);
+    }
+    async markAsRead(notificationId, checkIsSent = true) {
+        const notification = await this.getNotification(notificationId, false);
+        if (checkIsSent && (notification === null || notification === void 0 ? void 0 : notification.status) !== 'SENT') {
+            throw new Error('Notification is not sent');
+        }
+        // Ensure it's a regular notification (not one-off)
+        if (notification && !('userId' in notification)) {
+            throw new Error('Cannot mark one-off notification as read');
+        }
+        return this.persistNotificationUpdate(notificationId, { readAt: new Date() });
+    }
+    async cancelNotification(notificationId) {
+        await this.medplum.deleteResource('Communication', notificationId);
+    }
+    async getNotification(notificationId, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _forUpdate) {
+        try {
+            const communication = await this.medplum.readResource('Communication', notificationId);
+            return this.mapToDatabaseNotification(communication);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    async filterAllInAppUnreadNotifications(refenrenceString) {
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'completed',
+            _tag: 'notification,in-app',
+            recipient: refenrenceString,
+        });
+        return communications
+            .map((comm) => this.mapToDatabaseNotification(comm))
+            .filter((notif) => 'userId' in notif && !notif.readAt);
+    }
+    async filterInAppUnreadNotifications(refenrenceString, page, pageSize) {
+        const communications = await this.medplum.searchResources('Communication', {
+            status: 'completed',
+            _tag: 'notification,in-app',
+            recipient: refenrenceString,
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications
+            .map((comm) => this.mapToDatabaseNotification(comm))
+            .filter((notif) => 'userId' in notif && !notif.readAt);
+    }
+    async getUserEmailFromNotification(notificationId) {
+        var _a, _b, _c, _d;
+        try {
+            const communication = await this.medplum.readResource('Communication', notificationId);
+            const practitionerRef = (_b = (_a = communication.recipient) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.reference;
+            if (!practitionerRef) {
+                return undefined;
+            }
+            const [resourceType, id] = practitionerRef.split('/');
+            if (!id) {
+                // eslint-disable-next-line no-console
+                console.error('[getUserEmailFromNotification] Invalid reference format - no ID found');
+                return undefined;
+            }
+            const resource = await this.medplum.readResource(resourceType, id);
+            return (_d = (_c = resource.telecom) === null || _c === void 0 ? void 0 : _c.find((t) => t.system === 'email')) === null || _d === void 0 ? void 0 : _d.value;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('[getUserEmailFromNotification] Error fetching user email:', error);
+            return undefined;
+        }
+    }
+    async storeContextUsed(notificationId, context) {
+        const communication = await this.medplum.readResource('Communication', notificationId);
+        const updated = {
+            ...communication,
+            note: [{ text: JSON.stringify(context) }],
+        };
+        await this.medplum.updateResource(updated);
+    }
+    /* One-off notification methods */
+    async persistOneOffNotification(notification) {
+        var _a;
+        // Build base payload with body template
+        const payload = notification.bodyTemplate
+            ? [
+                {
+                    contentString: notification.bodyTemplate,
+                    extension: notification.subjectTemplate && this.options.emailNotificationSubjectExtensionUrl
+                        ? [{ url: this.options.emailNotificationSubjectExtensionUrl, valueString: notification.subjectTemplate }]
+                        : undefined,
+                },
+            ]
+            : [];
+        // Handle attachments if present
+        if (notification.attachments && notification.attachments.length > 0) {
+            const attachmentPayload = await this.processAttachments(notification.attachments);
+            if (attachmentPayload) {
+                payload.push(...attachmentPayload);
+            }
+        }
+        const communication = {
+            resourceType: 'Communication',
+            status: 'in-progress',
+            sent: (_a = notification.sendAfter) === null || _a === void 0 ? void 0 : _a.toISOString(),
+            topic: { text: notification.title || undefined },
+            payload,
+            note: [{ text: JSON.stringify(notification.contextParameters) }],
+            extension: [
+                { url: 'http://vintasend.com/fhir/StructureDefinition/emailOrPhone', valueString: notification.emailOrPhone },
+                { url: 'http://vintasend.com/fhir/StructureDefinition/firstName', valueString: notification.firstName },
+                { url: 'http://vintasend.com/fhir/StructureDefinition/lastName', valueString: notification.lastName },
+            ],
+            meta: {
+                tag: [
+                    { code: 'notification' },
+                    { code: notification.contextName },
+                    { code: notification.notificationType },
+                    { code: 'one-off' },
+                ],
+            },
+        };
+        const created = await this.medplum.createResource(communication);
+        return this.mapToDatabaseNotification(created);
+    }
+    async persistOneOffNotificationUpdate(notificationId, notification) {
+        const existing = await this.medplum.readResource('Communication', notificationId);
+        const updated = {
+            ...existing,
+            ...(notification.status === 'SENT' && { status: 'completed' }),
+            ...(notification.status === 'FAILED' && { status: 'stopped' }),
+            meta: {
+                ...existing.meta,
+                lastUpdated: new Date().toISOString(),
+            },
+        };
+        const result = await this.medplum.updateResource(updated);
+        return this.mapToDatabaseNotification(result);
+    }
+    async getOneOffNotification(notificationId, forUpdate) {
+        const notification = await this.getNotification(notificationId, forUpdate);
+        if (!notification)
+            return null;
+        // Check if it's a one-off notification
+        if ('emailOrPhone' in notification) {
+            return notification;
+        }
+        return null;
+    }
+    async getAllOneOffNotifications() {
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification,one-off',
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    async getOneOffNotifications(page, pageSize) {
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification,one-off',
+            _count: pageSize.toString(),
+            _offset: (page * pageSize).toString(),
+        });
+        return communications.map((comm) => this.mapToDatabaseNotification(comm));
+    }
+    /* Attachment management methods */
+    /**
+     * Helper: Convert FileAttachment to Buffer
+     */
+    async fileToBuffer(file, filename) {
+        if (Buffer.isBuffer(file)) {
+            return file;
+        }
+        if (typeof file === 'string') {
+            // File path - read from filesystem
+            const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+            return await fs.readFile(file);
+        }
+        // ReadableStream or Readable
+        const chunks = [];
+        if ('getReader' in file) {
+            // Web ReadableStream
+            const reader = file.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    chunks.push(Buffer.from(value));
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        else {
+            // Node.js Readable
+            for await (const chunk of file) {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+        }
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Helper: Convert FHIR Media resource to AttachmentFileRecord
+     */
+    mediaToAttachmentFileRecord(media) {
+        var _a, _b, _c, _d;
+        const content = media.content;
+        if (!content || !media.id) {
+            throw new Error('Invalid Media resource: missing content or id');
+        }
+        return {
+            id: media.id,
+            filename: content.title || 'untitled',
+            contentType: content.contentType || 'application/octet-stream',
+            size: content.size || 0,
+            checksum: ((_b = (_a = media.identifier) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value) || '',
+            storageMetadata: {
+                url: content.url,
+                creation: content.creation,
+            },
+            createdAt: ((_c = media.meta) === null || _c === void 0 ? void 0 : _c.lastUpdated) ? new Date(media.meta.lastUpdated) : new Date(),
+            updatedAt: ((_d = media.meta) === null || _d === void 0 ? void 0 : _d.lastUpdated) ? new Date(media.meta.lastUpdated) : new Date(),
+        };
+    }
+    /**
+     * Helper: Create FHIR Attachment from file record
+     */
+    async createFhirAttachment(fileRecord) {
+        var _a;
+        const url = (_a = fileRecord.storageMetadata) === null || _a === void 0 ? void 0 : _a.url;
+        return {
+            contentType: fileRecord.contentType,
+            url: url,
+            size: fileRecord.size,
+            title: fileRecord.filename,
+            creation: fileRecord.createdAt.toISOString(),
+        };
+    }
+    /**
+     * Helper: Create MedplumAttachmentFile from storage metadata
+     */
+    createMedplumAttachmentFile(fileRecord) {
+        const manager = this.getAttachmentManager();
+        return manager.reconstructAttachmentFile(fileRecord.storageMetadata);
+    }
+    async getAttachmentFile(fileId) {
+        try {
+            const media = await this.medplum.readResource('Media', fileId);
+            return this.mediaToAttachmentFileRecord(media);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    async findAttachmentFileByChecksum(checksum) {
+        try {
+            const results = await this.medplum.searchResources('Media', `identifier=${checksum}&_tag=attachment-file`);
+            if (results.length === 0) {
+                return null;
+            }
+            return this.mediaToAttachmentFileRecord(results[0]);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    /**
+     * Find multiple attachment files by their checksums in a single query
+     */
+    async findAttachmentFilesByChecksums(checksums) {
+        var _a, _b;
+        if (checksums.length === 0) {
+            return new Map();
+        }
+        try {
+            // Build query with all checksums
+            const identifierQuery = checksums.join(',');
+            const results = await this.medplum.searchResources('Media', `identifier=${identifierQuery}&_tag=attachment-file`);
+            // Map results by checksum
+            const filesByChecksum = new Map();
+            for (const media of results) {
+                const checksum = (_b = (_a = media.identifier) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value;
+                if (checksum) {
+                    filesByChecksum.set(checksum, this.mediaToAttachmentFileRecord(media));
+                }
+            }
+            return filesByChecksum;
+        }
+        catch (_c) {
+            return new Map();
+        }
+    }
+    /**
+     * Helper: Process attachments and return payload items
+     * Optimizes by batching checksum lookups
+     */
+    async processAttachments(attachments) {
+        const manager = this.getAttachmentManager();
+        const payload = [];
+        // Separate attachments by type: file references vs new uploads
+        const fileReferences = [];
+        const newUploads = [];
+        for (let i = 0; i < attachments.length; i++) {
+            const attachment = attachments[i];
+            if ('fileId' in attachment) {
+                fileReferences.push({
+                    index: i,
+                    fileId: attachment.fileId,
+                    description: attachment.description
+                });
+            }
+            else if ('file' in attachment) {
+                newUploads.push({
+                    index: i,
+                    file: attachment.file,
+                    filename: attachment.filename,
+                    contentType: attachment.contentType || 'application/octet-stream',
+                    description: attachment.description
+                });
+            }
+        }
+        // Fetch all referenced files in parallel
+        const referencedFiles = await Promise.all(fileReferences.map(async ({ fileId }) => ({
+            fileId,
+            record: await this.getAttachmentFile(fileId)
+        })));
+        // Calculate checksums for new uploads
+        const uploadsWithChecksums = await Promise.all(newUploads.map(async (upload) => {
+            const buffer = await this.fileToBuffer(upload.file, upload.filename);
+            const checksum = await manager.calculateChecksum(buffer);
+            return { ...upload, buffer, checksum };
+        }));
+        // Batch lookup existing files by checksums
+        const checksums = uploadsWithChecksums.map(u => u.checksum);
+        const existingFilesByChecksum = await this.findAttachmentFilesByChecksums(checksums);
+        // Process file references
+        const fileRecords = [];
+        for (let i = 0; i < fileReferences.length; i++) {
+            const { index, description } = fileReferences[i];
+            const { record } = referencedFiles[i];
+            if (!record) {
+                throw new Error(`Attachment file not found: ${fileReferences[i].fileId}`);
+            }
+            fileRecords.push({
+                index,
+                record,
+                description
+            });
+        }
+        // Process new uploads (using cached checksum lookups or uploading)
+        for (const upload of uploadsWithChecksums) {
+            let fileRecord;
+            const existingFile = existingFilesByChecksum.get(upload.checksum);
+            if (existingFile) {
+                // File already exists, reuse it
+                fileRecord = existingFile;
+            }
+            else {
+                // Upload new file
+                fileRecord = await manager.uploadFile(upload.file, upload.filename, upload.contentType);
+            }
+            fileRecords.push({
+                index: upload.index,
+                record: fileRecord,
+                description: upload.description
+            });
+        }
+        // Sort by original index and build payload
+        fileRecords.sort((a, b) => a.index - b.index);
+        for (const { record, description } of fileRecords) {
+            const fhirAttachment = await this.createFhirAttachment(record);
+            payload.push({
+                contentAttachment: {
+                    ...fhirAttachment,
+                    url: `Media/${record.id}`,
+                    title: description || record.filename,
+                },
+            });
+        }
+        return payload;
+    }
+    async deleteAttachmentFile(fileId) {
+        var _a;
+        // Check if file exists first
+        const fileRecord = await this.getAttachmentFile(fileId);
+        if (!fileRecord) {
+            // File not found, return early
+            return;
+        }
+        // Check if file is still referenced by any notifications
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification',
+        });
+        const isReferenced = communications.some((comm) => { var _a; return (_a = comm.payload) === null || _a === void 0 ? void 0 : _a.some((p) => { var _a, _b; return (_b = (_a = p.contentAttachment) === null || _a === void 0 ? void 0 : _a.url) === null || _b === void 0 ? void 0 : _b.includes(fileId); }); });
+        if (isReferenced) {
+            throw new Error('Cannot delete attachment file: still referenced by notifications');
+        }
+        // Delete from storage backend
+        if (fileRecord && this.attachmentManager) {
+            await this.attachmentManager.deleteFile(fileId);
+        }
+        // Delete Binary resource if it exists
+        if ((_a = fileRecord.storageMetadata) === null || _a === void 0 ? void 0 : _a.url) {
+            const binaryId = fileRecord.storageMetadata.url.replace('Binary/', '');
+            try {
+                await this.medplum.deleteResource('Binary', binaryId);
+            }
+            catch (_b) {
+                // Binary may not exist or already deleted
+            }
+        }
+        // Delete Media resource
+        await this.medplum.deleteResource('Media', fileId);
+    }
+    async getOrphanedAttachmentFiles() {
+        var _a;
+        // Get all Media resources tagged as attachment-files
+        const allMedia = await this.medplum.searchResources('Media', {
+            _tag: 'attachment-file',
+        });
+        // Get all notifications
+        const communications = await this.medplum.searchResources('Communication', {
+            _tag: 'notification',
+        });
+        // Build set of referenced file IDs
+        const referencedIds = new Set();
+        for (const comm of communications) {
+            for (const payload of comm.payload || []) {
+                const url = (_a = payload.contentAttachment) === null || _a === void 0 ? void 0 : _a.url;
+                if (url) {
+                    // Extract Media ID from URL (assuming format like Media/{id})
+                    const match = url.match(/Media\/([^/]+)/);
+                    if (match)
+                        referencedIds.add(match[1]);
+                }
+            }
+        }
+        // Filter orphaned media
+        const orphaned = allMedia.filter((media) => media.id && !referencedIds.has(media.id));
+        return orphaned.map((media) => this.mediaToAttachmentFileRecord(media));
+    }
+    async getAttachments(notificationId) {
+        this.getAttachmentManager(); // Ensure attachment manager is injected
+        try {
+            const communication = await this.medplum.readResource('Communication', notificationId);
+            const attachments = [];
+            // Extract all Media IDs from payload
+            const mediaIds = [];
+            const payloadMap = new Map();
+            for (const payload of communication.payload || []) {
+                const attachment = payload.contentAttachment;
+                if (!attachment || !attachment.url)
+                    continue;
+                // Extract Media ID from URL
+                const match = attachment.url.match(/Media\/([^/]+)/);
+                if (!match)
+                    continue;
+                const mediaId = match[1];
+                mediaIds.push(mediaId);
+                payloadMap.set(mediaId, { description: attachment.title });
+            }
+            // Fetch all Media resources in a single query
+            if (mediaIds.length === 0) {
+                return [];
+            }
+            const mediaResources = await this.medplum.searchResources('Media', {
+                _id: mediaIds.join(','),
+            });
+            // Build attachments from the fetched Media resources
+            for (const media of mediaResources) {
+                if (!media.id)
+                    continue;
+                const fileRecord = this.mediaToAttachmentFileRecord(media);
+                const attachmentFile = this.createMedplumAttachmentFile(fileRecord);
+                const payloadData = payloadMap.get(media.id);
+                attachments.push({
+                    id: `${notificationId}-${media.id}`,
+                    fileId: media.id,
+                    filename: fileRecord.filename,
+                    contentType: fileRecord.contentType,
+                    size: fileRecord.size,
+                    checksum: fileRecord.checksum,
+                    createdAt: fileRecord.createdAt,
+                    file: attachmentFile,
+                    description: payloadData === null || payloadData === void 0 ? void 0 : payloadData.description,
+                    storageMetadata: fileRecord.storageMetadata,
+                });
+            }
+            return attachments;
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    async deleteNotificationAttachment(notificationId, attachmentId) {
+        const communication = await this.medplum.readResource('Communication', notificationId);
+        // Check if attachment exists
+        const hasAttachment = (communication.payload || []).some((p) => {
+            var _a;
+            const url = (_a = p.contentAttachment) === null || _a === void 0 ? void 0 : _a.url;
+            return url && url.includes(attachmentId);
+        });
+        if (!hasAttachment) {
+            throw new Error(`Attachment ${attachmentId} not found for notification ${notificationId}`);
+        }
+        // Filter out the attachment from payload
+        const updatedPayload = (communication.payload || []).filter((p) => {
+            var _a;
+            const url = (_a = p.contentAttachment) === null || _a === void 0 ? void 0 : _a.url;
+            if (!url)
+                return true;
+            return !url.includes(attachmentId);
+        });
+        const updated = {
+            ...communication,
+            payload: updatedPayload,
+        };
+        await this.medplum.updateResource(updated);
+    }
+}
+exports.MedplumNotificationBackend = MedplumNotificationBackend;
+class MedplumNotificationBackendFactory {
+    create(medplum) {
+        return new MedplumNotificationBackend(medplum);
+    }
+}
+exports.MedplumNotificationBackendFactory = MedplumNotificationBackendFactory;