vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "medplum-provider",
+  "version": "5.0.10",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc && vite build",
+    "dev": "vite",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf dist && rm -f compiled-notification-templates.json",
+    "compile-templates": "compile-pug-templates ./notification-templates ./compiled-notification-templates.json",
+    "bots:build": "npm run clean && npm run compile-templates && tsc --project tsconfig.bots.json && node --no-warnings esbuild-script.mjs",
+    "bots:deploy": "tsx scripts/deploy-bots.ts",
+    "bots:build:dev": "npm run clean && npm run compile-templates && node --no-warnings esbuild-script.mjs"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "devDependencies": {
+    "@mantine/core": "8.3.11",
+    "@mantine/hooks": "8.3.11",
+    "@mantine/notifications": "8.3.11",
+    "@mantine/spotlight": "8.3.11",
+    "@medplum/bot-layer": "^5.0.12",
+    "@medplum/core": "5.0.10",
+    "@medplum/dosespot-react": "5.0.10",
+    "@medplum/eslint-config": "5.0.10",
+    "@medplum/fhirtypes": "5.0.10",
+    "@medplum/health-gorilla-core": "5.0.10",
+    "@medplum/health-gorilla-react": "5.0.10",
+    "@medplum/mock": "^5.0.12",
+    "@medplum/react": "5.0.10",
+    "@sentry/esbuild-plugin": "^4.7.0",
+    "@tabler/icons-react": "3.36.1",
+    "@testing-library/dom": "10.4.1",
+    "@testing-library/jest-dom": "6.9.1",
+    "@testing-library/react": "16.3.1",
+    "@testing-library/user-event": "14.6.1",
+    "@types/node": "22.19.3",
+    "@types/react": "19.2.7",
+    "@types/react-big-calendar": "1.16.3",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "5.1.2",
+    "dayjs": "1.11.19",
+    "dotenv": "^17.2.3",
+    "fast-glob": "^3.3.3",
+    "jsdom": "27.4.0",
+    "postcss": "8.5.6",
+    "postcss-preset-mantine": "1.18.0",
+    "react": "19.2.3",
+    "react-big-calendar": "1.19.4",
+    "react-dom": "19.2.3",
+    "react-router": "7.12.0",
+    "tsx": "^4.21.0",
+    "typescript": "5.9.3",
+    "uuid": "11.1.0",
+    "vite": "7.3.1",
+    "vitest": "4.0.16"
+  },
+  "packageManager": "npm@10.9.4",
+  "engines": {
+    "node": "^22.18.0 || >=24.2.0"
+  },
+  "dependencies": {
+    "vintasend": "^0.4.3",
+    "vintasend-medplum": "^0.4.5",
+    "vintasend-sendgrid": "^0.4.3"
+  }
+}

package/dist/examples/vintasend-medplum-example/plugins/gql-plugin.mjs

@@ -0,0 +1,31 @@
+import fs from 'fs/promises';
+
+/**
+ * esbuild plugin for handling GraphQL files.
+ * Automatically exports all named operations (queries, mutations) and fragments.
+ */
+export const gqlPlugin = {
+  name: 'gql',
+  setup(build) {
+    build.onLoad({ filter: /\.gql$/ }, async (args) => {
+      const contents = await fs.readFile(args.path, 'utf8');
+      
+      // Simple regex to find all named operations and fragments
+      const operationRegex = /(query|mutation|fragment)\s+([a-zA-Z][a-zA-Z0-9_]*)/g;
+      const matches = [...contents.matchAll(operationRegex)];
+      
+      const exports = matches
+        .map(([, , name]) => `export const ${name} = doc;`)
+        .join('\n');
+
+      return {
+        contents: `
+          const doc = \`${contents}\`;
+          ${exports}
+          export default doc;
+        `,
+        loader: 'js',
+      };
+    });
+  },
+}; 

package/dist/examples/vintasend-medplum-example/postcss.config.mjs

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import mantinePreset from 'postcss-preset-mantine';
+import simpleVars from 'postcss-simple-vars';
+
+const config = {
+  plugins: [
+    mantinePreset(),
+    simpleVars({
+      variables: {
+        'mantine-breakpoint-xs': '36em',
+        'mantine-breakpoint-sm': '48em',
+        'mantine-breakpoint-md': '62em',
+        'mantine-breakpoint-lg': '75em',
+        'mantine-breakpoint-xl': '88em',
+      },
+    }),
+  ],
+};
+
+export default config;

package/dist/examples/vintasend-medplum-example/scripts/README.md

@@ -0,0 +1,162 @@
+# Scripts
+
+This directory contains automation scripts for setting up and managing your Medplum environment.
+
+## setup-task-assignment-subscription.ts
+
+Creates or updates the FHIR Subscription that triggers the task assignment email bot.
+
+### What it does:
+
+1. **Authenticates** with Medplum using client credentials
+2. **Creates/finds** the Task Assignment Email Bot resource
+3. **Creates/updates** a Subscription with criteria: `Task?owner:exists=true`
+4. **Configures** the subscription to trigger on Task create and update events
+
+### Prerequisites:
+
+Create a `.env` file with your Medplum credentials:
+
+```bash
+MEDPLUM_BASE_URL=https://api.medplum.com
+MEDPLUM_CLIENT_ID=your-client-id
+MEDPLUM_CLIENT_SECRET=your-client-secret
+APP_BASE_URL=https://your-app-url.com
+```
+
+### Usage:
+
+```bash
+npm run setup:subscription
+```
+
+### Expected Output:
+
+```
+✅ Successfully authenticated with Medplum
+✅ Found existing bot: abc-123
+✅ Updated subscription: def-456
+
+📋 Subscription Details:
+   ID: def-456
+   Status: active
+   Criteria: Task?owner:exists=true
+   Bot: abc-123 (Task Assignment Email Bot)
+   Triggers: Task create, update (when owner exists)
+
+✅ Setup complete!
+
+📝 Next steps:
+   1. Deploy your bot code: npm run bots:deploy
+   2. Test by creating/updating a Task with an owner
+   3. Check bot logs in Medplum console for execution details
+
+✨ Script completed successfully
+```
+
+### When to run:
+
+- **Initial setup**: When first deploying your application
+- **After bot changes**: If you modify the bot or subscription criteria
+- **Environment changes**: When setting up a new environment (dev, staging, prod)
+- **CI/CD**: Include in your deployment pipeline
+
+### Idempotent Design:
+
+This script is safe to run multiple times. It will:
+- Use existing Bot if found (by identifier)
+- Update existing Subscription if found (by identifier)
+- Create new resources only if they don't exist
+
+### Troubleshooting:
+
+**Authentication Error:**
+```
+❌ Error setting up subscription: Authentication failed
+```
+- Verify your `MEDPLUM_CLIENT_ID` and `MEDPLUM_CLIENT_SECRET` in `.env`
+- Ensure the client has permission to create Bot and Subscription resources
+
+**Resource Creation Failed:**
+```
+❌ Error creating Bot: Forbidden
+```
+- Check that your client has the necessary permissions in Medplum
+- You may need to grant `Bot` and `Subscription` resource creation permissions
+
+**Subscription Not Triggering:**
+- Verify the bot code is deployed: `npm run bots:deploy`
+- Check subscription status in Medplum console (should be "active")
+- Review bot logs for execution errors
+- Ensure Task resources have the `owner` field populated
+
+### FHIR Resources Created:
+
+#### Bot Resource:
+```json
+{
+  "resourceType": "Bot",
+  "identifier": [
+    {
+      "system": "https://your-domain.com/bot-identifier",
+      "value": "task-assignment-email-bot"
+    }
+  ],
+  "name": "Task Assignment Email Bot",
+  "description": "Sends email notifications when tasks are assigned to practitioners"
+}
+```
+
+#### Subscription Resource:
+```json
+{
+  "resourceType": "Subscription",
+  "identifier": [
+    {
+      "system": "https://your-domain.com/subscription-identifier",
+      "value": "task-assignment-email-subscription"
+    }
+  ],
+  "status": "active",
+  "reason": "Trigger email notification when a task is assigned",
+  "criteria": "Task?owner:exists=true",
+  "channel": {
+    "type": "rest-hook",
+    "endpoint": "Bot/bot-id-here"
+  },
+  "extension": [
+    {
+      "url": "https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction",
+      "valueCode": "create"
+    },
+    {
+      "url": "https://medplum.com/fhir/StructureDefinition/subscription-supported-interaction",
+      "valueCode": "update"
+    }
+  ]
+}
+```
+
+### Understanding the Subscription:
+
+- **criteria**: `Task?owner:exists=true` matches any Task with an owner
+- **channel.type**: `rest-hook` invokes a bot endpoint
+- **channel.endpoint**: Points to the Bot resource
+- **extension**: Specifies to trigger on both create and update operations
+
+### Testing the Subscription:
+
+After running the setup, test it by creating a Task:
+
+```typescript
+const task = await medplum.createResource({
+  resourceType: 'Task',
+  status: 'requested',
+  intent: 'order',
+  code: { text: 'Test task' },
+  owner: { reference: 'Practitioner/123' }, // This triggers the subscription
+  requester: { reference: 'Practitioner/456' },
+});
+```
+
+Check the bot logs in Medplum console to verify execution.

package/dist/examples/vintasend-medplum-example/scripts/client.ts

@@ -0,0 +1,18 @@
+import { MedplumClient } from '@medplum/core';
+import { config } from 'dotenv';
+
+// Load environment variables from .env file
+config();
+
+export async function getMedplumClient() {
+  const medplum = new MedplumClient({
+    clientId: process.env.MEDPLUM_CLIENT_ID,
+  });
+
+  await medplum.startClientLogin(
+    process.env.MEDPLUM_CLIENT_ID as string,
+    process.env.MEDPLUM_CLIENT_SECRET as string
+  );
+
+  return medplum;
+}

package/dist/examples/vintasend-medplum-example/scripts/deploy-bots.ts

@@ -0,0 +1,171 @@
+import { ContentType, getReferenceString, MedplumClient, WithId } from '@medplum/core';
+import { Bot, Bundle, BundleEntry, Questionnaire } from '@medplum/fhirtypes';
+import fs from 'fs';
+import { BotDescription, BOTS } from '../bots/index.js';
+import { BOTS_SYSTEM } from '../lib/constants.js';
+import { getMedplumClient } from './client.js';
+
+async function readBotFiles(description: BotDescription, medplum: MedplumClient) {
+  const distFile = fs.readFileSync(`dist/bots/handlers/${description.name}.js`, 'utf-8');
+
+  const [sourceCodeAttachment, executableCodeAttachment] = await Promise.all([
+    medplum.createAttachment({
+      data: distFile,
+      contentType: 'application/javascript',
+    }),
+    medplum.createAttachment({
+      data: distFile,
+      contentType: 'application/javascript',
+    }),
+  ]);
+
+  return { sourceCodeAttachment, executableCodeAttachment };
+}
+
+async function generateBundle(medplum: MedplumClient): Promise<Bundle> {
+  const bundle: Bundle = {
+    resourceType: 'Bundle',
+    type: 'transaction',
+    entry: (
+      await Promise.all(
+        BOTS.map(async (botDescription): Promise<BundleEntry[]> => {
+          const botName = botDescription.name;
+          const botReferencePlaceholder = `$bot-${botName}-reference`;
+          const botIdPlaceholder = `$bot-${botName}-id`;
+          const results: BundleEntry[] = [];
+          const { cronString, timeout, runAsUser, criteria, extension } = botDescription;
+
+          const { executableCodeAttachment, sourceCodeAttachment } = await readBotFiles(botDescription, medplum);
+
+          results.push({
+            request: { method: 'PUT', url: botReferencePlaceholder },
+            resource: {
+              resourceType: 'Bot',
+              id: botIdPlaceholder,
+              identifier: [{ system: BOTS_SYSTEM, value: botName }],
+              name: botName,
+              runtimeVersion: 'awslambda',
+              sourceCode: sourceCodeAttachment,
+              executableCode: executableCodeAttachment,
+              runAsUser: runAsUser ?? false,
+              ...(cronString && { cronString }),
+              ...(timeout && { timeout }),
+            },
+          });
+
+          if (criteria) {
+            results.push({
+              request: {
+                method: 'PUT',
+                url: `Subscription?url=${botReferencePlaceholder}`,
+              },
+              resource: {
+                resourceType: 'Subscription',
+                status: 'active',
+                reason: `${botName}-subscription`,
+                criteria,
+                extension: extension ?? [],
+                channel: {
+                  endpoint: botReferencePlaceholder,
+                  type: 'rest-hook',
+                  payload: 'application/fhir+json',
+                },
+              },
+            });
+          }
+
+          return results;
+        })
+      )
+    ).flat(),
+  };
+
+  return bundle;
+}
+
+async function deployBots(): Promise<void> {
+  // eslint-disable-next-line no-console
+  console.log('\nUploading bots...\n');
+
+  const medplum = await getMedplumClient();
+
+  const profile = await medplum.getProfile();
+  const projectId = profile?.meta?.project;
+
+  const questionnaires: Questionnaire[] = [];
+
+  const bundleData = await generateBundle(medplum);
+
+  let transactionString = JSON.stringify(bundleData);
+  const botEntries: BundleEntry[] =
+    (bundleData as Bundle).entry?.filter((e) => e.resource?.resourceType === 'Bot') || [];
+  const botIds: Record<string, string> = {};
+
+  for (const botDescription of BOTS) {
+    const botName = botDescription.name;
+
+    let existingBot = await medplum.searchOne('Bot', { name: botName });
+    if (!existingBot) {
+      const createBotUrl = new URL(`admin/projects/${projectId as string}/bot`, medplum.getBaseUrl());
+      existingBot = (await medplum.post(createBotUrl, {
+        name: botName,
+      })) as WithId<Bot>;
+    }
+
+    if (!existingBot) {
+      throw new Error(`Bot ${botName} not found`);
+    }
+
+    const botMembership = await medplum.searchOne('ProjectMembership', { user: getReferenceString(existingBot) });
+    if (botMembership && botMembership.admin !== botDescription.needsAdminMembership) {
+      await medplum.post(`admin/projects/${projectId as string}/members/${botMembership.id}`, {
+        ...botMembership,
+        admin: botDescription.needsAdminMembership,
+      });
+    }
+
+    botIds[botName] = existingBot.id as string;
+
+    // Replace the Bot id placeholder in the bundle
+    transactionString = transactionString
+      .replaceAll(`$bot-${botName}-reference`, getReferenceString(existingBot))
+      .replaceAll(`$bot-${botName}-id`, existingBot.id as string);
+  }
+
+  for (const questionnaire of questionnaires) {
+    transactionString = transactionString.replaceAll(
+      `$${questionnaire.name}`,
+      getReferenceString(questionnaire) as string
+    );
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('\nUploading bots bundle...\n');
+
+  // Execute the transaction to upload / update the bot
+  const transaction = JSON.parse(transactionString);
+
+  const batchResponse = await medplum.executeBatch(transaction);
+  // await medplum.executeBatch(transaction);
+
+  const errors = batchResponse.entry?.filter((e) => !['200', '201'].includes(e.response?.status ?? ''));
+  if (errors && errors.length > 0) {
+    throw new Error(`${JSON.stringify(errors, null, 2)}`);
+  }
+
+  // Deploy the bots
+  for (const entry of botEntries) {
+    const botName = (entry?.resource as Bot)?.name as string;
+
+    // eslint-disable-next-line no-console
+    console.log(`Deploying ${botName}...`);
+
+    await medplum.post(medplum.fhirUrl('Bot', botIds[botName], '$deploy'));
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('\nAll bots deployed!\n');
+}
+
+// eslint-disable-next-line no-console
+deployBots().catch(console.error);