vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/lib/file-upload.test.ts

@@ -0,0 +1,389 @@
+// @ts-nocheck - MockClient type compatibility with MedplumClient
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MockClient } from '@medplum/mock';
+import type { MedplumClient } from '@medplum/core';
+import type { Binary, Media, Task } from '@medplum/fhirtypes';
+import {
+  uploadFileToMedplum,
+  attachFileToTask,
+  getTaskAttachments,
+  getBinaryFromMedia,
+} from './file-upload';
+
+describe('File Upload Utilities', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+  });
+
+  // Note: MockClient is compatible at runtime
+  const asMedplum = (): MedplumClient => medplum as unknown as MedplumClient;
+
+  describe('uploadFileToMedplum', () => {
+    it('should upload file and create Binary/Media resources', async () => {
+      const fileContent = Buffer.from('test file content');
+      const filename = 'test.pdf';
+      const contentType = 'application/pdf';
+
+      const result = await uploadFileToMedplum(medplum as unknown as MedplumClient, fileContent, filename, contentType);
+
+      expect(result).toBeDefined();
+      expect(result.binary).toBeDefined();
+      expect(result.media).toBeDefined();
+      expect(result.media.resourceType).toBe('Media');
+      expect(result.media.status).toBe('completed');
+      expect(result.media.content?.contentType).toBe(contentType);
+      expect(result.media.content?.title).toBe(filename);
+      expect(result.media.content?.url).toContain('Binary/');
+    });
+
+    it('should handle different file types', async () => {
+      const testCases = [
+        { filename: 'image.jpg', contentType: 'image/jpeg' },
+        { filename: 'document.docx', contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' },
+        { filename: 'spreadsheet.xlsx', contentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' },
+      ];
+
+      for (const { filename, contentType } of testCases) {
+        const fileContent = Buffer.from(`content of ${filename}`);
+        const result = await uploadFileToMedplum(medplum as unknown as MedplumClient, fileContent, filename, contentType);
+
+        expect(result.media.content?.contentType).toBe(contentType);
+        expect(result.media.content?.title).toBe(filename);
+      }
+    });
+  });
+
+  describe('attachFileToTask', () => {
+    it('should attach media to task', async () => {
+      // Create a test task
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Test task',
+      });
+
+      // Create a test media resource
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'Binary/test-123',
+          title: 'test.pdf',
+        },
+      });
+
+      const mediaReference = { reference: `Media/${media.id}` };
+      const updatedTask = await attachFileToTask(medplum as unknown as MedplumClient, task, mediaReference);
+
+      expect(updatedTask.input).toBeDefined();
+      expect(updatedTask.input?.length).toBe(1);
+      expect(updatedTask.input?.[0].type?.coding?.[0]?.code).toBe('attachment');
+      expect(updatedTask.input?.[0].valueReference?.reference).toBe(mediaReference.reference);
+    });
+
+    it('should preserve existing task inputs when adding attachment', async () => {
+      // Create a task with existing input
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Test task',
+        input: [
+          {
+            type: { text: 'Other Input' },
+            valueString: 'existing value',
+          },
+        ],
+      });
+
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'Binary/test-456',
+          title: 'test2.pdf',
+        },
+      });
+
+      const mediaReference = { reference: `Media/${media.id}` };
+      const updatedTask = await attachFileToTask(medplum as unknown as MedplumClient, task, mediaReference);
+
+      expect(updatedTask.input?.length).toBe(2);
+      expect(updatedTask.input?.[0].valueString).toBe('existing value');
+      expect(updatedTask.input?.[1].valueReference?.reference).toBe(mediaReference.reference);
+    });
+
+    it('should handle task without existing inputs', async () => {
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Test task without inputs',
+      });
+
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'image/jpeg',
+          url: 'Binary/test-789',
+          title: 'image.jpg',
+        },
+      });
+
+      const mediaReference = { reference: `Media/${media.id}` };
+      const updatedTask = await attachFileToTask(medplum as unknown as MedplumClient, task, mediaReference);
+
+      expect(updatedTask.input).toBeDefined();
+      expect(updatedTask.input?.length).toBe(1);
+    });
+  });
+
+  describe('getTaskAttachments', () => {
+    it('should retrieve all Media resources attached to a task', async () => {
+      // Create multiple media resources
+      const media1 = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'Binary/doc1',
+          title: 'document1.pdf',
+        },
+      });
+
+      const media2 = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'image/jpeg',
+          url: 'Binary/img1',
+          title: 'image1.jpg',
+        },
+      });
+
+      // Create task with attachments
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Test task with attachments',
+        input: [
+          {
+            type: {
+              coding: [
+                {
+                  system: 'http://your-app-url.com/task-input-types',
+                  code: 'attachment',
+                  display: 'File Attachment',
+                },
+              ],
+            },
+            valueReference: { reference: `Media/${media1.id}` },
+          },
+          {
+            type: {
+              coding: [
+                {
+                  system: 'http://your-app-url.com/task-input-types',
+                  code: 'attachment',
+                  display: 'File Attachment',
+                },
+              ],
+            },
+            valueReference: { reference: `Media/${media2.id}` },
+          },
+        ],
+      });
+
+      const attachments = await getTaskAttachments(medplum as unknown as MedplumClient, task);
+
+      expect(attachments).toBeDefined();
+      expect(attachments.length).toBe(2);
+      expect(attachments[0].id).toBe(media1.id);
+      expect(attachments[1].id).toBe(media2.id);
+    });
+
+    it('should return empty array for task with no inputs', async () => {
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Task without inputs',
+      });
+
+      const attachments = await getTaskAttachments(medplum as unknown as MedplumClient, task);
+
+      expect(attachments).toBeDefined();
+      expect(attachments.length).toBe(0);
+    });
+
+    it('should filter out non-attachment inputs', async () => {
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'Binary/doc2',
+          title: 'document2.pdf',
+        },
+      });
+
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Test task with mixed inputs',
+        input: [
+          {
+            type: { text: 'Other Input' },
+            valueString: 'not an attachment',
+          },
+          {
+            type: {
+              coding: [
+                {
+                  system: 'http://your-app-url.com/task-input-types',
+                  code: 'attachment',
+                  display: 'File Attachment',
+                },
+              ],
+            },
+            valueReference: { reference: `Media/${media.id}` },
+          },
+        ],
+      });
+
+      const attachments = await getTaskAttachments(medplum as unknown as MedplumClient, task);
+
+      expect(attachments.length).toBe(1);
+      expect(attachments[0].id).toBe(media.id);
+    });
+
+    it('should handle invalid media references gracefully', async () => {
+      const task = await medplum.createResource<Task>({
+        resourceType: 'Task',
+        status: 'requested',
+        intent: 'order',
+        description: 'Task with invalid reference',
+        input: [
+          {
+            type: {
+              coding: [
+                {
+                  system: 'http://your-app-url.com/task-input-types',
+                  code: 'attachment',
+                  display: 'File Attachment',
+                },
+              ],
+            },
+            valueReference: { reference: 'Media/nonexistent-id' },
+          },
+        ],
+      });
+
+      // Mock console.error to prevent test output pollution
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const attachments = await getTaskAttachments(medplum as unknown as MedplumClient, task);
+
+      // Should filter out failed fetches
+      expect(attachments.length).toBe(0);
+      expect(consoleErrorSpy).toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('getBinaryFromMedia', () => {
+    it('should fetch Binary resource from Media reference', async () => {
+      const binary = await medplum.createResource<Binary>({
+        resourceType: 'Binary',
+        contentType: 'application/pdf',
+        data: Buffer.from('test binary content').toString('base64'),
+      });
+
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: `Binary/${binary.id}`,
+          title: 'test.pdf',
+        },
+      });
+
+      const result = await getBinaryFromMedia(medplum as unknown as MedplumClient, media);
+
+      expect(result).toBeDefined();
+      expect(result?.id).toBe(binary.id);
+      expect(result?.contentType).toBe('application/pdf');
+    });
+
+    it('should return null for media without content URL', async () => {
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {} as any,
+      });
+
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getBinaryFromMedia(medplum as unknown as MedplumClient, media);
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '[getBinaryFromMedia] Media resource has no content URL'
+      );
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle invalid Binary reference format', async () => {
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'InvalidFormat',
+          title: 'test.pdf',
+        },
+      });
+
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getBinaryFromMedia(medplum as unknown as MedplumClient, media);
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle non-existent Binary resource', async () => {
+      const media = await medplum.createResource<Media>({
+        resourceType: 'Media',
+        status: 'completed',
+        content: {
+          contentType: 'application/pdf',
+          url: 'Binary/nonexistent-binary-id',
+          title: 'test.pdf',
+        },
+      });
+
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const result = await getBinaryFromMedia(medplum as unknown as MedplumClient, media);
+
+      expect(result).toBeNull();
+      expect(consoleErrorSpy).toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/lib/file-upload.ts

@@ -0,0 +1,222 @@
+import { MedplumClient } from '@medplum/core';
+import { Binary, Media, Reference, Task, TaskInput } from '@medplum/fhirtypes';
+
+export interface FileUploadResult {
+  binary: Binary;
+  media: Media;
+}
+
+/**
+ * Uploads a file to Medplum and creates both Binary and Media resources.
+ * 
+ * The Binary resource stores the actual file content, while the Media resource
+ * provides metadata and a reference to the Binary resource.
+ * 
+ * @param medplum - The Medplum client instance
+ * @param file - The file to upload (File from browser or Buffer from Node.js)
+ * @param filename - The name of the file
+ * @param contentType - The MIME type of the file (e.g., 'application/pdf', 'image/jpeg')
+ * @returns An object containing both the Binary and Media resources
+ * 
+ * @example
+ * const result = await uploadFileToMedplum(
+ *   medplum,
+ *   fileFromInput,
+ *   'document.pdf',
+ *   'application/pdf'
+ * );
+ */
+export async function uploadFileToMedplum(
+  medplum: MedplumClient,
+  file: File | Buffer,
+  filename: string,
+  contentType: string
+): Promise<FileUploadResult> {
+  // Create Binary resource to store the file content
+  const binary = await medplum.createBinary(file, filename, contentType);
+
+  // Create Media resource as metadata wrapper
+  const media = await medplum.createResource<Media>({
+    resourceType: 'Media',
+    status: 'completed',
+    content: {
+      contentType,
+      url: `Binary/${binary.id}`,
+      title: filename,
+    },
+  });
+
+  return { binary, media };
+}
+
+/**
+ * Attaches a Media resource to a Task by adding it to the task's input array.
+ * 
+ * This function follows the FHIR Task resource specification, where attachments
+ * are stored in the task.input array with a specific type code.
+ * 
+ * @param medplum - The Medplum client instance
+ * @param task - The Task resource to attach the file to
+ * @param mediaReference - A reference to the Media resource (e.g., { reference: 'Media/123' })
+ * @returns The updated Task resource with the attachment added
+ * 
+ * @example
+ * const updatedTask = await attachFileToTask(
+ *   medplum,
+ *   task,
+ *   { reference: 'Media/abc-123' }
+ * );
+ */
+export async function attachFileToTask(
+  medplum: MedplumClient,
+  task: Task,
+  mediaReference: Reference<Media>
+): Promise<Task> {
+  // Initialize input array if it doesn't exist
+  const currentInputs = task.input || [];
+
+  // Create new input entry for the attachment
+  const attachmentInput: TaskInput = {
+    type: {
+      coding: [
+        {
+          system: 'http://your-app-url.com/task-input-types',
+          code: 'attachment',
+          display: 'File Attachment',
+        },
+      ],
+    },
+    valueReference: mediaReference,
+  };
+
+  // Update the task with the new attachment
+  const updatedTask = await medplum.updateResource<Task>({
+    ...task,
+    input: [...currentInputs, attachmentInput],
+  });
+
+  return updatedTask;
+}
+
+/**
+ * Retrieves all Media resources attached to a Task.
+ * 
+ * This function filters the task's input array for entries with the 'attachment' type
+ * and fetches the corresponding Media resources.
+ * 
+ * @param medplum - The Medplum client instance
+ * @param task - The Task resource to get attachments from
+ * @returns An array of Media resources attached to the task
+ * 
+ * @example
+ * const attachments = await getTaskAttachments(medplum, task);
+ * console.log(`Task has ${attachments.length} attachments`);
+ */
+export async function getTaskAttachments(
+  medplum: MedplumClient,
+  task: Task
+): Promise<Media[]> {
+  // Return empty array if task has no inputs
+  if (!task.input || task.input.length === 0) {
+    return [];
+  }
+
+  // Filter inputs for attachment types
+  const attachmentInputs = task.input.filter((input) => {
+    const coding = input.type?.coding?.[0];
+    return coding?.code === 'attachment' && input.valueReference?.reference;
+  });
+
+  // Fetch all Media resources
+  const mediaPromises = attachmentInputs.map(async (input): Promise<Media | null> => {
+    const reference = input.valueReference?.reference;
+    if (!reference) {
+      return null;
+    }
+
+    try {
+      // Parse reference string (e.g., "Media/123")
+      const [resourceType, id] = reference.split('/');
+      if (resourceType !== 'Media' || !id) {
+        console.error(`[getTaskAttachments] Invalid reference format: ${reference}`);
+        return null;
+      }
+
+      return await medplum.readResource('Media', id);
+    } catch (error) {
+      console.error(`[getTaskAttachments] Failed to fetch Media resource: ${reference}`, error);
+      return null;
+    }
+  });
+
+  const mediaResources = await Promise.all(mediaPromises);
+
+  // Filter out null values (failed fetches)
+  return mediaResources.filter((media): media is Media => media !== null);
+}
+
+/**
+ * Gets the Binary content from a Media resource.
+ * 
+ * This utility function extracts the file data from the Binary resource
+ * referenced by a Media resource.
+ * 
+ * @param medplum - The Medplum client instance
+ * @param media - The Media resource containing the reference to the Binary
+ * @returns The Binary resource with file content
+ * 
+ * @example
+ * const binary = await getBinaryFromMedia(medplum, media);
+ * console.log(`File size: ${binary.data?.length} bytes`);
+ */
+export async function getBinaryFromMedia(
+  medplum: MedplumClient,
+  media: Media
+): Promise<Binary | null> {
+  const binaryUrl = media.content?.url;
+  if (!binaryUrl) {
+    console.error('[getBinaryFromMedia] Media resource has no content URL');
+    return null;
+  }
+
+  try {
+    // Handle signed URLs (external storage) vs FHIR references
+    if (binaryUrl.startsWith('http://') || binaryUrl.startsWith('https://')) {
+      // For signed URLs, fetch content directly from the URL
+      const response = await fetch(binaryUrl);
+      if (!response.ok) {
+        console.error(`[getBinaryFromMedia] Failed to fetch from signed URL: ${response.status} ${response.statusText}`);
+        return null;
+      }
+
+      // Convert response to base64-encoded data
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      const base64Data = buffer.toString('base64');
+
+      // Extract Binary ID from URL for the resource ID
+      const urlParts = binaryUrl.split('?')[0].split('/');
+      const binaryId = urlParts[urlParts.length - 1];
+
+      // Return a Binary-like object with the fetched data
+      return {
+        resourceType: 'Binary',
+        id: binaryId,
+        contentType: media.content?.contentType || 'application/octet-stream',
+        data: base64Data,
+      } as Binary;
+    } else {
+      // Parse FHIR reference (e.g., "Binary/123")
+      const [resourceType, id] = binaryUrl.split('/');
+      if (resourceType !== 'Binary' || !id) {
+        console.error(`[getBinaryFromMedia] Invalid Binary reference: ${binaryUrl}`);
+        return null;
+      }
+
+      return await medplum.readResource('Binary', id);
+    }
+  } catch (error) {
+    console.error(`[getBinaryFromMedia] Failed to fetch Binary resource: ${binaryUrl}`, error);
+    return null;
+  }
+}

package/dist/examples/vintasend-medplum-example/lib/medplum-singleton.ts

@@ -0,0 +1,18 @@
+import { MedplumClient } from '@medplum/core';
+
+export class MedplumSingleton {
+  private static instance: MedplumClient;
+
+  private constructor() {}
+
+  public static getInstance(): MedplumClient {
+    if (!MedplumSingleton.instance) {
+      throw new Error('MedplumClient instance not set. Please set it before using.');
+    }
+    return MedplumSingleton.instance;
+  }
+
+  public static setInstance(medplum: MedplumClient): void {
+    MedplumSingleton.instance = medplum;
+  }
+}