vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/bots/handlers/send-pending-notifications-bot.ts

@@ -0,0 +1,39 @@
+import { BotEvent, MedplumClient } from '@medplum/core';
+import { MedplumSingleton } from '../../lib/medplum-singleton';
+import { buildSendGridConfig, getNotificationService } from '../../lib/notification-service';
+
+/**
+ * Medplum Bot: Send Pending Notifications
+ * 
+ * This bot runs periodically (every 5 minutes) to process and send
+ * all pending scheduled notifications that are due to be sent.
+ * 
+ * It uses VintaSend's notification service to check for notifications
+ * where sendAfter <= current time and triggers their delivery.
+ * 
+ * Cron: every 5 minutes
+ */
+
+export async function handler(medplum: MedplumClient, event: BotEvent): Promise<any> {
+  console.log('[SendPendingNotificationsBot] Starting to process pending notifications');
+  const sendgridConfig = buildSendGridConfig(event);
+
+  try {
+    MedplumSingleton.setInstance(medplum);
+    const vintasend = getNotificationService(medplum, sendgridConfig);
+
+    // Send all pending notifications that are ready to be sent
+    const result = await vintasend.sendPendingNotifications();
+
+    console.log('[SendPendingNotificationsBot] Completed processing pending notifications');
+    console.log('[SendPendingNotificationsBot] Result:', JSON.stringify(result, null, 2));
+
+    return {
+      message: 'Pending notifications processed',
+      result,
+    };
+  } catch (error) {
+    console.error('[SendPendingNotificationsBot] Error processing pending notifications:', error);
+    throw error;
+  }
+}

package/dist/examples/vintasend-medplum-example/bots/handlers/send-task-assignment-email.ts

@@ -0,0 +1,41 @@
+import { BotEvent, MedplumClient } from '@medplum/core';
+import { Task } from '@medplum/fhirtypes';
+import { sendTaskAssignmentEmail } from '../services/emails/send-task-assignment-email';
+import { buildSendGridConfig } from '../../lib/notification-service';
+
+/**
+ * Medplum Bot: Task Assignment Email Notification
+ *
+ * This bot is triggered by a subscription when a Task is created or updated
+ * with an owner. It sends an email notification to the assigned practitioner.
+ *
+ * Subscription Criteria: Task?owner:exists=true
+ * Triggers: create, update
+ */
+
+export async function handler(medplum: MedplumClient, event: BotEvent): Promise<Task> {
+  const task = event.input as Task;
+  const sendGridVariables = buildSendGridConfig(event);
+
+  console.log(`[TaskAssignmentBot] Processing task: ${task.id}`);
+  console.log(`[TaskAssignmentBot] Owner: ${task.owner?.reference}`);
+
+  // Only send email if task has an owner
+  if (task.owner?.reference) {
+    const appBaseUrl = process.env.APP_BASE_URL || 'https://your-app-url.com';
+
+    try {
+      await sendTaskAssignmentEmail(medplum, task, appBaseUrl, sendGridVariables);
+      console.log(`[TaskAssignmentBot] Email notification sent successfully for task: ${task.id}`);
+    } catch (error) {
+      console.error(`[TaskAssignmentBot] Failed to send email for task: ${task.id}`, error);
+      // Don't throw - we don't want the subscription to fail
+      // The notification will be logged in Medplum as failed
+    }
+  } else {
+    console.log(`[TaskAssignmentBot] Task ${task.id} has no owner, skipping email notification`);
+  }
+
+  // Return the task unchanged
+  return task;
+}

package/dist/examples/vintasend-medplum-example/bots/handlers/task-due-soon-notification-bot.ts

@@ -0,0 +1,86 @@
+import { BotEvent, MedplumClient } from '@medplum/core';
+import { Task } from '@medplum/fhirtypes';
+import { scheduleTaskDueSoonEmail } from '../services/emails/schedule-task-due-soon-email';
+import { buildSendGridConfig } from '../../lib/notification-service';
+import { getTaskDueSoonSchedulingReason } from '../shared/task-due-soon-helpers';
+
+/**
+ * Medplum Bot: Task Due Soon Notification
+ * 
+ * This bot triggers on Task creation/update and schedules email notifications
+ * to be sent 24 hours before the task due date.
+ * 
+ * The bot uses VintaSend's scheduled messages (sendAfter) to ensure
+ * notifications are sent at the appropriate time. The actual sending is
+ * handled by the send-pending-notifications-bot.
+ * 
+ * Subscription: Task (create/update)
+ */
+
+export async function handler(medplum: MedplumClient, event: BotEvent): Promise<any> {
+  const task = event.input as Task;
+  const result = getTaskDueSoonSchedulingReason(task);
+
+  switch (result.kind) {
+    case 'invalidResource':
+      console.warn('[TaskDueSoonNotificationBot] Invalid task resource received');
+      return { message: 'Invalid task resource' };
+    case 'noDueDate':
+      console.log(`[TaskDueSoonNotificationBot] Task ${task?.id} has no due date, skipping`);
+      return { message: 'No due date set', taskId: task?.id };
+    case 'invalidDueDate':
+      console.warn(
+        `[TaskDueSoonNotificationBot] Task ${task?.id} has invalid due date: ${result.dueDate}, skipping`
+      );
+      return { message: 'Invalid due date', taskId: task?.id, dueDate: result.dueDate };
+    case 'finalState':
+      console.log(
+        `[TaskDueSoonNotificationBot] Task ${task?.id} is in final state (${result.status}), skipping`
+      );
+      return { message: `Task in final state: ${result.status}`, taskId: task?.id };
+    case 'noOwner':
+      console.log(`[TaskDueSoonNotificationBot] Task ${task?.id} has no owner, skipping`);
+      return { message: 'No owner assigned', taskId: task?.id };
+    case 'tooSoon':
+      console.log(
+        `[TaskDueSoonNotificationBot] Task ${task?.id} is due in ${result.hoursUntilDue.toFixed(
+          2
+        )} hours (less than 24), skipping`
+      );
+      return {
+        message: 'Due date is less than 24 hours away',
+        taskId: task?.id,
+        hoursUntilDue: result.hoursUntilDue,
+      };
+    case 'ok':
+      break;
+  }
+
+  const appBaseUrl = process.env.APP_BASE_URL;
+  if (!appBaseUrl) {
+    console.error('[TaskDueSoonNotificationBot] APP_BASE_URL environment variable is not set');
+    throw new Error('APP_BASE_URL must be configured');
+  }
+
+  const sendgridConfig = buildSendGridConfig(event);
+
+  try {
+    console.log(
+      `[TaskDueSoonNotificationBot] Scheduling notification for task ${task.id}, due in ${result.hoursUntilDue.toFixed(
+        2
+      )} hours`
+    );
+    await scheduleTaskDueSoonEmail(medplum, task, appBaseUrl, sendgridConfig);
+
+    return {
+      message: 'Notification scheduled successfully',
+      taskId: task.id,
+      dueDate: task.restriction?.period?.end,
+      hoursUntilDue: result.hoursUntilDue.toFixed(2),
+    };
+  } catch (error) {
+    console.error(`[TaskDueSoonNotificationBot] Error scheduling notification for task ${task.id}:`, error);
+    throw error;
+  }
+}
+

package/dist/examples/vintasend-medplum-example/bots/index.ts

@@ -0,0 +1,53 @@
+import { Extension } from '@medplum/fhirtypes';
+
+export interface BotDescription {
+  name: string;
+  criteria?: string;
+  extension?: Extension[];
+  needsAdminMembership?: boolean;
+  runAsUser?: boolean;
+  timeout?: number;
+  cronString?: string;
+}
+
+export const BOTS: BotDescription[] = [
+  {
+    name: 'send-task-assignment-email',
+    needsAdminMembership: true,
+    runAsUser: true,
+    criteria: 'Task?owner:missing=false',
+    extension: [
+      {
+        url: 'https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction',
+        valueCode: 'create',
+      },
+      {
+        url: 'https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction',
+        valueCode: 'update',
+      },
+    ],
+  },
+  {
+    name: 'task-due-soon-notification-bot',
+    needsAdminMembership: true,
+    runAsUser: true,
+    criteria: 'Task?owner:missing=false',
+    extension: [
+      {
+        url: 'https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction',
+        valueCode: 'create',
+      },
+      {
+        url: 'https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction',
+        valueCode: 'update',
+      },
+    ],
+  },
+  {
+    name: 'send-pending-notifications-bot',
+    needsAdminMembership: true,
+    runAsUser: true,
+    cronString: '*/5 * * * *', // Run every 5 minutes
+    timeout: 300, // 5 minutes timeout
+  },
+];

package/dist/examples/vintasend-medplum-example/bots/services/emails/schedule-task-due-soon-email.ts

@@ -0,0 +1,84 @@
+import { MedplumClient } from '@medplum/core';
+import { Task } from '@medplum/fhirtypes';
+import { MedplumSingleton } from '../../../lib/medplum-singleton';
+import { getNotificationService, SendGridConfig } from '../../../lib/notification-service';
+import {
+  assertTaskOwnerReference,
+  getValidTaskDueDate,
+  parseOwnerReference,
+  computeReminderTime,
+} from '../../shared/task-due-soon-helpers';
+
+export async function scheduleTaskDueSoonEmail(
+  medplum: MedplumClient,
+  task: Task,
+  taskLinkBaseUrl: string,
+  sendgridConfig: SendGridConfig
+) {
+  /* sends a task due soon reminder email to a practitioner 24 hours before the task is due */
+
+  const ownerRef = assertTaskOwnerReference(task);
+  const parsedOwner = parseOwnerReference(ownerRef);
+  if (!parsedOwner) {
+    return;
+  }
+
+  const dueDate = getValidTaskDueDate(task);
+
+  if (!task.id) {
+    // eslint-disable-next-line no-console
+    console.error('[scheduleTaskDueSoonEmail] Task has no id');
+    throw new Error('Task must have an id to send task due soon email');
+  }
+
+  const sendAfter = computeReminderTime(dueDate, 24);
+  if (!sendAfter) {
+    return;
+  }
+
+  MedplumSingleton.setInstance(medplum);
+  const vintasend = getNotificationService(medplum, sendgridConfig);
+
+  const taskTitle = task.code?.text || task.description || 'Task';
+  const taskLink = `${taskLinkBaseUrl}/Task/${task.id}`;
+  const taskIsUrgent = task.priority === 'urgent';
+  const formattedDueDate = dueDate.toLocaleString('en-US', {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+
+  try {
+    await vintasend.createNotification({
+      userId: ownerRef,
+      notificationType: 'EMAIL' as const,
+      title: 'Task Due Soon Reminder',
+      contextName: 'taskDueSoon' as const,
+      contextParameters: {
+        userId: ownerRef,
+        taskTitle,
+        taskDescription: task.description || '',
+        taskIsUrgent,
+        taskLink,
+        dueDate: formattedDueDate,
+      },
+      sendAfter,
+      bodyTemplate: 'emails/task-due-soon/body.html.pug',
+      subjectTemplate: 'emails/task-due-soon/subject.txt.pug',
+      extraParams: {},
+    });
+
+    // eslint-disable-next-line no-console
+    console.log(
+      `[scheduleTaskDueSoonEmail] Email scheduled for ${sendAfter.toISOString()} to: ${ownerRef} for task due on ${dueDate.toISOString()}`
+    );
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('[scheduleTaskDueSoonEmail] Error creating/sending notification:', error);
+    throw error;
+  }
+}
+

package/dist/examples/vintasend-medplum-example/bots/services/emails/send-task-assignment-email.test.ts

@@ -0,0 +1,388 @@
+// @ts-nocheck - MockClient type compatibility with MedplumClient
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MockClient } from '@medplum/mock';
+import type { Task, Media, Binary, Practitioner } from '@medplum/fhirtypes';
+import { sendTaskAssignmentEmail } from './send-task-assignment-email';
+import type { SendGridConfig } from '../../../lib/notification-service';
+
+// Mock the notification service
+vi.mock('../../../lib/notification-service', async () => {
+  const actual = await vi.importActual('../../../lib/notification-service');
+  return {
+    ...actual,
+    getNotificationService: vi.fn(() => ({
+      createNotification: vi.fn().mockResolvedValue(undefined),
+    })),
+  };
+});
+
+// Mock the MedplumSingleton
+vi.mock('../../../lib/medplum-singleton', () => ({
+  MedplumSingleton: {
+    setInstance: vi.fn(),
+    getInstance: vi.fn(),
+  },
+}));
+
+describe('sendTaskAssignmentEmail with Attachments', () => {
+  let medplum: MockClient;
+  let sendgridConfig: SendGridConfig;
+  const taskLinkBaseUrl = 'https://example.com';
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    sendgridConfig = {
+      SENDGRID_API_KEY: 'test-api-key',
+      SENDGRID_FROM_EMAIL: 'noreply@example.com',
+      SENDGRID_FROM_NAME: 'Test App',
+    };
+    vi.clearAllMocks();
+  });
+
+  it('should send email with single attachment', async () => {
+    // Create a practitioner
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ given: ['John'], family: 'Doe' }],
+    });
+
+    // Create a binary resource
+    const binary = await medplum.createResource<Binary>({
+      resourceType: 'Binary',
+      contentType: 'application/pdf',
+      data: Buffer.from('test pdf content').toString('base64'),
+    });
+
+    // Create a media resource
+    const media = await medplum.createResource<Media>({
+      resourceType: 'Media',
+      status: 'completed',
+      content: {
+        contentType: 'application/pdf',
+        url: `Binary/${binary.id}`,
+        title: 'test-document.pdf',
+      },
+    });
+
+    // Create a task with attachment
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Test task with attachment',
+      code: { text: 'Review Document' },
+      owner: { reference: `Practitioner/${practitioner.id}` },
+      priority: 'routine',
+      input: [
+        {
+          type: {
+            coding: [
+              {
+                system: 'http://your-app-url.com/task-input-types',
+                code: 'attachment',
+                display: 'File Attachment',
+              },
+            ],
+          },
+          valueReference: { reference: `Media/${media.id}` },
+        },
+      ],
+    });
+
+    const { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    expect(mockCreateNotification).toHaveBeenCalledTimes(1);
+    const callArgs = mockCreateNotification.mock.calls[0][0];
+
+    expect(callArgs.contextParameters.attachmentCount).toBe(1);
+    expect(callArgs.attachments).toBeDefined();
+    expect(callArgs.attachments.length).toBe(1);
+    expect(callArgs.attachments[0].fileId).toBe(media.id);
+    expect(callArgs.attachments[0].description).toBe('test-document.pdf');
+  });
+
+  it('should send email with multiple attachments', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ given: ['Jane'], family: 'Smith' }],
+    });
+
+    // Create multiple binary resources
+    const binary1 = await medplum.createResource<Binary>({
+      resourceType: 'Binary',
+      contentType: 'application/pdf',
+      data: Buffer.from('pdf content').toString('base64'),
+    });
+
+    const binary2 = await medplum.createResource<Binary>({
+      resourceType: 'Binary',
+      contentType: 'image/jpeg',
+      data: Buffer.from('jpeg content').toString('base64'),
+    });
+
+    // Create multiple media resources
+    const media1 = await medplum.createResource<Media>({
+      resourceType: 'Media',
+      status: 'completed',
+      content: {
+        contentType: 'application/pdf',
+        url: `Binary/${binary1.id}`,
+        title: 'document.pdf',
+      },
+    });
+
+    const media2 = await medplum.createResource<Media>({
+      resourceType: 'Media',
+      status: 'completed',
+      content: {
+        contentType: 'image/jpeg',
+        url: `Binary/${binary2.id}`,
+        title: 'image.jpg',
+      },
+    });
+
+    // Create task with multiple attachments
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Task with multiple attachments',
+      code: { text: 'Review Files' },
+      owner: { reference: `Practitioner/${practitioner.id}` },
+      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 { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    expect(mockCreateNotification).toHaveBeenCalledTimes(1);
+    const callArgs = mockCreateNotification.mock.calls[0][0];
+
+    expect(callArgs.contextParameters.attachmentCount).toBe(2);
+    expect(callArgs.attachments).toBeDefined();
+    expect(callArgs.attachments.length).toBe(2);
+    expect(callArgs.attachments[0].fileId).toBe(media1.id);
+    expect(callArgs.attachments[0].description).toBe('document.pdf');
+    expect(callArgs.attachments[1].fileId).toBe(media2.id);
+    expect(callArgs.attachments[1].description).toBe('image.jpg');
+  });
+
+  it('should send email without attachments for task with no files', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ given: ['Bob'], family: 'Johnson' }],
+    });
+
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Task without attachments',
+      code: { text: 'Simple Task' },
+      owner: { reference: `Practitioner/${practitioner.id}` },
+    });
+
+    const { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    expect(mockCreateNotification).toHaveBeenCalledTimes(1);
+    const callArgs = mockCreateNotification.mock.calls[0][0];
+
+    expect(callArgs.contextParameters.attachmentCount).toBe(0);
+    expect(callArgs.attachments).toBeDefined();
+    expect(callArgs.attachments.length).toBe(0);
+  });
+
+  it('should handle attachment conversion failures gracefully', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ given: ['Alice'], family: 'Williams' }],
+    });
+
+    // Create media resource with invalid binary reference
+    const media = await medplum.createResource<Media>({
+      resourceType: 'Media',
+      status: 'completed',
+      content: {
+        contentType: 'application/pdf',
+        url: 'Binary/nonexistent-binary-id',
+        title: 'invalid.pdf',
+      },
+    });
+
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Task with invalid attachment',
+      code: { text: 'Test Task' },
+      owner: { reference: `Practitioner/${practitioner.id}` },
+      input: [
+        {
+          type: {
+            coding: [
+              {
+                system: 'http://your-app-url.com/task-input-types',
+                code: 'attachment',
+                display: 'File Attachment',
+              },
+            ],
+          },
+          valueReference: { reference: `Media/${media.id}` },
+        },
+      ],
+    });
+
+    const { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    // Email should still be sent with the attachment reference
+    // The actual file retrieval happens later when VintaSend processes the notification
+    expect(mockCreateNotification).toHaveBeenCalledTimes(1);
+    const callArgs = mockCreateNotification.mock.calls[0][0];
+
+    expect(callArgs.contextParameters.attachmentCount).toBe(1);
+    expect(callArgs.attachments.length).toBe(1);
+    expect(callArgs.attachments[0].fileId).toBe(media.id);
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should skip email for tasks assigned to groups', async () => {
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Task assigned to group',
+      code: { text: 'Group Task' },
+      owner: { reference: 'Group/test-group-123' },
+    });
+
+    const { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    expect(mockCreateNotification).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[sendTaskAssignmentEmail] Task assigned to Group, skipping email notification'
+    );
+
+    consoleLogSpy.mockRestore();
+  });
+
+  it('should handle urgent tasks with attachments', async () => {
+    const practitioner = await medplum.createResource<Practitioner>({
+      resourceType: 'Practitioner',
+      name: [{ given: ['Charlie'], family: 'Brown' }],
+    });
+
+    const binary = await medplum.createResource<Binary>({
+      resourceType: 'Binary',
+      contentType: 'application/pdf',
+      data: Buffer.from('urgent document').toString('base64'),
+    });
+
+    const media = await medplum.createResource<Media>({
+      resourceType: 'Media',
+      status: 'completed',
+      content: {
+        contentType: 'application/pdf',
+        url: `Binary/${binary.id}`,
+        title: 'urgent.pdf',
+      },
+    });
+
+    const task = await medplum.createResource<Task>({
+      resourceType: 'Task',
+      status: 'requested',
+      intent: 'order',
+      description: 'Urgent task with attachment',
+      code: { text: 'Urgent Review' },
+      owner: { reference: `Practitioner/${practitioner.id}` },
+      priority: 'urgent',
+      input: [
+        {
+          type: {
+            coding: [
+              {
+                system: 'http://your-app-url.com/task-input-types',
+                code: 'attachment',
+                display: 'File Attachment',
+              },
+            ],
+          },
+          valueReference: { reference: `Media/${media.id}` },
+        },
+      ],
+    });
+
+    const { getNotificationService } = await import('../../../lib/notification-service');
+    const mockCreateNotification = vi.fn().mockResolvedValue(undefined);
+    (getNotificationService as any).mockReturnValue({
+      createNotification: mockCreateNotification,
+    });
+
+    await sendTaskAssignmentEmail(medplum, task, taskLinkBaseUrl, sendgridConfig);
+
+    expect(mockCreateNotification).toHaveBeenCalledTimes(1);
+    const callArgs = mockCreateNotification.mock.calls[0][0];
+
+    expect(callArgs.contextParameters.taskIsUrgent).toBe(true);
+    expect(callArgs.contextParameters.attachmentCount).toBe(1);
+    expect(callArgs.attachments.length).toBe(1);
+  });
+});