vintasend-medplum 0.4.0

package/dist/medplum-attachment-manager.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MedplumAttachmentFile = exports.MedplumAttachmentManager = void 0;
+const base_attachment_manager_1 = require("vintasend/dist/services/attachment-manager/base-attachment-manager");
+/**
+ * Medplum AttachmentManager implementation.
+ *
+ * This implementation uses FHIR resources for file storage:
+ * - Binary resources store the actual file data
+ * - Media resources store file metadata and link to Binary resources
+ *
+ * Files are uploaded to Medplum's storage and can be accessed via URLs.
+ */
+class MedplumAttachmentManager extends base_attachment_manager_1.BaseAttachmentManager {
+    constructor(medplum) {
+        super();
+        this.medplum = medplum;
+    }
+    /**
+     * Upload a file to Medplum storage using Binary and Media resources.
+     *
+     * @param file - The file data (Buffer, ReadableStream, or file path)
+     * @param filename - The filename to use for storage
+     * @param contentType - Optional MIME type (auto-detected if not provided)
+     * @returns AttachmentFileRecord with metadata about the uploaded file
+     */
+    async uploadFile(file, filename, contentType) {
+        var _a, _b;
+        // Convert file to Buffer
+        const buffer = await this.fileToBuffer(file);
+        // Calculate checksum for deduplication
+        const checksum = this.calculateChecksum(buffer);
+        // Detect content type if not provided
+        const finalContentType = contentType || this.detectContentType(filename);
+        // Create Binary resource with the file data
+        const binary = {
+            resourceType: 'Binary',
+            contentType: finalContentType,
+            data: buffer.toString('base64'),
+        };
+        const createdBinary = await this.medplum.createResource(binary);
+        const binaryUrl = `Binary/${createdBinary.id}`;
+        // Create Media resource with metadata
+        const media = {
+            resourceType: 'Media',
+            status: 'completed',
+            content: {
+                contentType: finalContentType,
+                url: binaryUrl,
+                size: buffer.length,
+                title: filename,
+                creation: new Date().toISOString(),
+            },
+            identifier: [
+                {
+                    system: 'http://vintasend.com/fhir/attachment-checksum',
+                    value: checksum,
+                },
+            ],
+            meta: {
+                tag: [
+                    { code: 'attachment-file' },
+                ],
+            },
+        };
+        const createdMedia = await this.medplum.createResource(media);
+        return {
+            id: createdMedia.id,
+            filename,
+            contentType: finalContentType,
+            size: buffer.length,
+            checksum,
+            storageMetadata: {
+                url: binaryUrl,
+                creation: createdMedia.content.creation,
+            },
+            createdAt: ((_a = createdMedia.meta) === null || _a === void 0 ? void 0 : _a.lastUpdated) ? new Date(createdMedia.meta.lastUpdated) : new Date(),
+            updatedAt: ((_b = createdMedia.meta) === null || _b === void 0 ? void 0 : _b.lastUpdated) ? new Date(createdMedia.meta.lastUpdated) : new Date(),
+        };
+    }
+    /**
+     * Retrieve a file record by its Media resource ID.
+     *
+     * @param fileId - The Media resource ID
+     * @returns The file record or null if not found
+     */
+    async getFile(fileId) {
+        var _a, _b, _c, _d;
+        try {
+            const media = await this.medplum.readResource('Media', fileId);
+            if (!media.content || !media.id) {
+                return null;
+            }
+            return {
+                id: media.id,
+                filename: media.content.title || 'untitled',
+                contentType: media.content.contentType || 'application/octet-stream',
+                size: media.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: media.content.url,
+                    creation: media.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(),
+            };
+        }
+        catch (_e) {
+            return null;
+        }
+    }
+    /**
+     * Delete a file from Medplum storage.
+     *
+     * Deletes both the Media resource (metadata) and Binary resource (file data).
+     *
+     * @param fileId - The Media resource ID
+     */
+    async deleteFile(fileId) {
+        var _a;
+        // Get Media resource to find the Binary URL
+        const media = await this.medplum.readResource('Media', fileId);
+        // Extract Binary ID from URL
+        const binaryUrl = (_a = media.content) === null || _a === void 0 ? void 0 : _a.url;
+        if (binaryUrl) {
+            const match = binaryUrl.match(/Binary\/([^/]+)/);
+            if (match) {
+                const binaryId = match[1];
+                // Delete Binary resource
+                try {
+                    await this.medplum.deleteResource('Binary', binaryId);
+                }
+                catch (error) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`Failed to delete Binary resource ${binaryId}:`, error);
+                }
+            }
+        }
+        // Delete Media resource
+        await this.medplum.deleteResource('Media', fileId);
+    }
+    /**
+     * Reconstruct an AttachmentFile from storage metadata.
+     *
+     * @param storageMetadata - Metadata containing either 'url' (Binary URL) or 'binaryId'
+     * @returns AttachmentFile instance for accessing the file
+     */
+    reconstructAttachmentFile(storageMetadata) {
+        // Support both 'url' (from upload) and 'binaryId' (direct ID)
+        let binaryUrl;
+        if (storageMetadata.binaryId && typeof storageMetadata.binaryId === 'string') {
+            // Direct Binary ID format
+            binaryUrl = `Binary/${storageMetadata.binaryId}`;
+        }
+        else if (storageMetadata.url && typeof storageMetadata.url === 'string') {
+            // Binary URL format (from uploadFile)
+            binaryUrl = storageMetadata.url;
+        }
+        else {
+            throw new Error('Storage metadata must contain binaryId for Medplum files');
+        }
+        return new MedplumAttachmentFile(this.medplum, binaryUrl);
+    }
+}
+exports.MedplumAttachmentManager = MedplumAttachmentManager;
+/**
+ * Medplum AttachmentFile implementation.
+ *
+ * Provides access to files stored in Medplum Binary resources.
+ */
+class MedplumAttachmentFile {
+    constructor(medplum, binaryUrl) {
+        this.medplum = medplum;
+        // Extract Binary ID from URL (format: "Binary/{id}")
+        const match = binaryUrl.match(/Binary\/([^/]+)/);
+        if (!match) {
+            throw new Error(`Invalid Binary URL format: ${binaryUrl}`);
+        }
+        this.binaryId = match[1];
+    }
+    /**
+     * Read the entire file into memory as a Buffer.
+     */
+    async read() {
+        const binary = await this.medplum.readResource('Binary', this.binaryId);
+        if (!binary.data) {
+            throw new Error('Binary resource has no data');
+        }
+        return Buffer.from(binary.data, 'base64');
+    }
+    /**
+     * Get a readable stream for the file.
+     *
+     * Note: For Medplum, we read the entire file and convert to stream.
+     * For true streaming, you'd need to use Medplum's binary download API.
+     */
+    async stream() {
+        const buffer = await this.read();
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(buffer);
+                controller.close();
+            },
+        });
+    }
+    /**
+     * Generate a URL for accessing the file.
+     *
+     * For Medplum, this returns the Binary resource URL.
+     * In production, you might want to generate a presigned URL.
+     *
+     * @param expiresIn - Seconds until the URL expires (not used for Medplum)
+     * @returns URL for file access
+     */
+    async url(expiresIn = 3600) {
+        // For Medplum, we can use the Binary resource URL
+        // In a production setup, you might want to use Medplum's authentication
+        // or generate a time-limited access token
+        return `Binary/${this.binaryId}`;
+    }
+    /**
+     * Delete this file from storage.
+     */
+    async delete() {
+        await this.medplum.deleteResource('Binary', this.binaryId);
+    }
+}
+exports.MedplumAttachmentFile = MedplumAttachmentFile;

package/dist/medplum-backend.d.ts

@@ -0,0 +1,86 @@
+import { MedplumClient } from '@medplum/core';
+import type { BaseAttachmentManager } from 'vintasend/dist/services/attachment-manager/base-attachment-manager';
+import type { BaseNotificationBackend } from 'vintasend/dist/services/notification-backends/base-notification-backend';
+import type { AttachmentFileRecord, StoredAttachment } from 'vintasend/dist/types/attachment';
+import type { InputJsonValue } from 'vintasend/dist/types/json-values';
+import type { AnyDatabaseNotification, DatabaseNotification, NotificationInput } from 'vintasend/dist/types/notification';
+import type { BaseNotificationTypeConfig } from 'vintasend/dist/types/notification-type-config';
+import type { DatabaseOneOffNotification, OneOffNotificationInput } from 'vintasend/dist/types/one-off-notification';
+type MedplumNotificationBackendOptions = {
+    emailNotificationSubjectExtensionUrl?: string;
+};
+export declare class MedplumNotificationBackend<Config extends BaseNotificationTypeConfig> implements BaseNotificationBackend<Config> {
+    private medplum;
+    private options;
+    private attachmentManager?;
+    constructor(medplum: MedplumClient, options?: MedplumNotificationBackendOptions);
+    /**
+     * Inject attachment manager (called by VintaSend when both service and backend exist)
+     */
+    injectAttachmentManager(manager: BaseAttachmentManager): void;
+    /**
+     * Get attachment manager with null check
+     */
+    private getAttachmentManager;
+    private mapToDatabaseNotification;
+    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(referenceString: Config['UserIdType']): Promise<DatabaseNotification<Config>[]>;
+    getFutureNotificationsFromUser(referenceString: Config['UserIdType'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
+    persistNotification(notification: NotificationInput<Config>): Promise<DatabaseNotification<Config>>;
+    persistNotificationUpdate(notificationId: Config['NotificationIdType'], notification: Partial<Omit<DatabaseNotification<Config>, 'id'>>): Promise<DatabaseNotification<Config>>;
+    getAllNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+    getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+    bulkPersistNotifications(notifications: Omit<NotificationInput<Config>, 'id'>[]): Promise<Config['NotificationIdType'][]>;
+    markAsSent(notificationId: Config['NotificationIdType'], checkIsPending?: boolean): Promise<AnyDatabaseNotification<Config>>;
+    markAsFailed(notificationId: Config['NotificationIdType'], checkIsPending?: boolean): Promise<AnyDatabaseNotification<Config>>;
+    markAsRead(notificationId: Config['NotificationIdType'], checkIsSent?: boolean): Promise<DatabaseNotification<Config>>;
+    cancelNotification(notificationId: Config['NotificationIdType']): Promise<void>;
+    getNotification(notificationId: Config['NotificationIdType'], _forUpdate: boolean): Promise<AnyDatabaseNotification<Config> | null>;
+    filterAllInAppUnreadNotifications(refenrenceString: Config['UserIdType']): Promise<DatabaseNotification<Config>[]>;
+    filterInAppUnreadNotifications(refenrenceString: Config['UserIdType'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
+    getUserEmailFromNotification(notificationId: Config['NotificationIdType']): Promise<string | undefined>;
+    storeContextUsed(notificationId: Config['NotificationIdType'], context: InputJsonValue): Promise<void>;
+    persistOneOffNotification(notification: Omit<OneOffNotificationInput<Config>, 'id'>): Promise<DatabaseOneOffNotification<Config>>;
+    persistOneOffNotificationUpdate(notificationId: Config['NotificationIdType'], notification: Partial<Omit<DatabaseOneOffNotification<Config>, 'id'>>): Promise<DatabaseOneOffNotification<Config>>;
+    getOneOffNotification(notificationId: Config['NotificationIdType'], forUpdate: boolean): Promise<DatabaseOneOffNotification<Config> | null>;
+    getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
+    getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
+    /**
+     * Helper: Convert FileAttachment to Buffer
+     */
+    private fileToBuffer;
+    /**
+     * Helper: Convert FHIR Media resource to AttachmentFileRecord
+     */
+    private mediaToAttachmentFileRecord;
+    /**
+     * Helper: Create FHIR Attachment from file record
+     */
+    private createFhirAttachment;
+    /**
+     * Helper: Create MedplumAttachmentFile from storage metadata
+     */
+    private createMedplumAttachmentFile;
+    getAttachmentFile(fileId: string): Promise<AttachmentFileRecord | null>;
+    findAttachmentFileByChecksum(checksum: string): Promise<AttachmentFileRecord | null>;
+    /**
+     * Find multiple attachment files by their checksums in a single query
+     */
+    private findAttachmentFilesByChecksums;
+    /**
+     * Helper: Process attachments and return payload items
+     * Optimizes by batching checksum lookups
+     */
+    private processAttachments;
+    deleteAttachmentFile(fileId: string): Promise<void>;
+    getOrphanedAttachmentFiles(): Promise<AttachmentFileRecord[]>;
+    getAttachments(notificationId: Config['NotificationIdType']): Promise<StoredAttachment[]>;
+    deleteNotificationAttachment(notificationId: Config['NotificationIdType'], attachmentId: string): Promise<void>;
+}
+export declare class MedplumNotificationBackendFactory<Config extends BaseNotificationTypeConfig> {
+    create(medplum: MedplumClient): MedplumNotificationBackend<Config>;
+}
+export {};