@tellescope/sdk 1.245.1 → 1.246.2

package/src/tests/api_tests/beluga_pharmacy_mappings.test.ts

@@ -0,0 +1,351 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  async_test,
+  log_header,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+import { evaluate_conditional_logic } from "@tellescope/utilities"
+import { CompoundFilter, BelugaPharmacyMapping } from "@tellescope/types-models"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// Helper mimicking resolve_beluga_pharmacy_mapping evaluator
+const evaluate_mapping_conditions = (
+  conditions: CompoundFilter<string>,
+  responses: { externalId?: string, value?: string }[]
+) => evaluate_conditional_logic(conditions, (key, value) => {
+  const responseValue = responses.find(r => r.externalId === key)?.value
+
+  if (typeof value === 'string') {
+    return responseValue === value
+  }
+  if (typeof value === 'object' && value !== null) {
+    const operator = Object.keys(value)[0]
+    const operand = Object.values(value)[0]
+
+    if (operator === '$contains') {
+      return typeof responseValue === 'string' && responseValue.includes(String(operand))
+    }
+    if (operator === '$doesNotContain') {
+      return typeof responseValue === 'string' && !responseValue.includes(String(operand))
+    }
+    if (operator === '$exists') {
+      return operand ? responseValue !== undefined : responseValue === undefined
+    }
+    if (operator === '$ne') {
+      return responseValue !== String(operand)
+    }
+  }
+
+  return false
+})
+
+// Helper to resolve first matching mapping
+const resolve_mapping = (
+  mappings: BelugaPharmacyMapping[],
+  responses: { externalId?: string, value?: string }[]
+): BelugaPharmacyMapping | undefined => {
+  for (const mapping of mappings) {
+    if (!mapping.conditions) continue
+    if (evaluate_mapping_conditions(mapping.conditions, responses)) {
+      return mapping
+    }
+  }
+  return undefined
+}
+
+export const beluga_pharmacy_mappings_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Beluga Pharmacy Mappings Tests")
+
+  // --- 6a. CRUD Tests ---
+
+  let testFormId: string | undefined
+
+  try {
+    await async_test(
+      "Create form with belugaPharmacyMappings",
+      async () => {
+        const mappings: BelugaPharmacyMapping[] = [
+          {
+            pharmacyId: "pharmacy-001",
+            patientPreference: JSON.stringify([{ name: "Med A", strength: "10mg", quantity: "30", refills: "3", daysSupply: "30", sig: "Take once daily", dispenseUnit: "Tablet", medId: "med-001" }]),
+            conditions: { $and: [{ condition: { "state": "CA" } }, { condition: { "med_type": "weightLoss" } }] },
+          },
+        ]
+
+        const form = await sdk.api.forms.createOne({
+          title: 'Beluga Pharmacy Mappings Test Form',
+          belugaPharmacyMappings: mappings,
+        })
+        testFormId = form.id
+
+        const fetched = await sdk.api.forms.getOne(form.id)
+        return (
+          fetched.belugaPharmacyMappings?.length === 1
+          && fetched.belugaPharmacyMappings[0].pharmacyId === "pharmacy-001"
+          && !!fetched.belugaPharmacyMappings[0].conditions?.$and
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Update belugaPharmacyMappings on existing form",
+      async () => {
+        if (!testFormId) throw new Error("No test form")
+
+        const updatedMappings: BelugaPharmacyMapping[] = [
+          {
+            pharmacyId: "pharmacy-002",
+            patientPreference: JSON.stringify([{ name: "Med B", strength: "20mg", quantity: "60", refills: "2", daysSupply: "30", sig: "Take twice daily", dispenseUnit: "Capsule", medId: "med-002" }]),
+            conditions: { condition: { "state": "NY" } },
+          },
+          {
+            pharmacyId: "pharmacy-003",
+            patientPreference: "[]",
+            conditions: { $or: [{ condition: { "state": "TX" } }, { condition: { "state": "FL" } }] },
+          },
+        ]
+
+        await sdk.api.forms.updateOne(testFormId, { belugaPharmacyMappings: updatedMappings }, { replaceObjectFields: true })
+        const fetched = await sdk.api.forms.getOne(testFormId)
+        return (
+          fetched.belugaPharmacyMappings?.length === 2
+          && fetched.belugaPharmacyMappings[0].pharmacyId === "pharmacy-002"
+          && fetched.belugaPharmacyMappings[1].pharmacyId === "pharmacy-003"
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Save with nested CompoundFilter structure",
+      async () => {
+        if (!testFormId) throw new Error("No test form")
+
+        const nestedMappings: BelugaPharmacyMapping[] = [
+          {
+            pharmacyId: "pharmacy-nested",
+            patientPreference: "[]",
+            conditions: {
+              $and: [
+                { $or: [{ condition: { "state": "CA" } }, { condition: { "state": "NY" } }] },
+                { condition: { "med_type": "weightLoss" } },
+              ]
+            },
+          },
+        ]
+
+        await sdk.api.forms.updateOne(testFormId, { belugaPharmacyMappings: nestedMappings }, { replaceObjectFields: true })
+        const fetched = await sdk.api.forms.getOne(testFormId)
+        return (
+          fetched.belugaPharmacyMappings?.length === 1
+          && fetched.belugaPharmacyMappings[0].pharmacyId === "pharmacy-nested"
+          && !!fetched.belugaPharmacyMappings[0].conditions?.$and
+        )
+      },
+      { expectedResult: true }
+    )
+
+    // --- 6b. Conditional logic evaluation tests ---
+
+    await async_test(
+      "Simple equality: condition matches response",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "state": "CA" } },
+          [{ externalId: "state", value: "CA" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Simple equality miss: condition does not match response",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "state": "CA" } },
+          [{ externalId: "state", value: "NY" }]
+        )
+      },
+      { expectedResult: false }
+    )
+
+    await async_test(
+      "$and: two conditions, both match",
+      async () => {
+        return evaluate_mapping_conditions(
+          { $and: [{ condition: { "state": "CA" } }, { condition: { "med_type": "weightLoss" } }] },
+          [{ externalId: "state", value: "CA" }, { externalId: "med_type", value: "weightLoss" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$and: two conditions, one misses",
+      async () => {
+        return evaluate_mapping_conditions(
+          { $and: [{ condition: { "state": "CA" } }, { condition: { "med_type": "weightLoss" } }] },
+          [{ externalId: "state", value: "CA" }, { externalId: "med_type", value: "skincare" }]
+        )
+      },
+      { expectedResult: false }
+    )
+
+    await async_test(
+      "$or: two conditions, one matches",
+      async () => {
+        return evaluate_mapping_conditions(
+          { $or: [{ condition: { "state": "CA" } }, { condition: { "state": "NY" } }] },
+          [{ externalId: "state", value: "NY" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$or: two conditions, neither matches",
+      async () => {
+        return evaluate_mapping_conditions(
+          { $or: [{ condition: { "state": "CA" } }, { condition: { "state": "NY" } }] },
+          [{ externalId: "state", value: "TX" }]
+        )
+      },
+      { expectedResult: false }
+    )
+
+    await async_test(
+      "$contains: value includes substring",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "meds": { $contains: "GLP" } as any } },
+          [{ externalId: "meds", value: "GLP-1 agonist" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$ne: value does not equal",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "state": { $ne: "CA" } as any } },
+          [{ externalId: "state", value: "NY" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$exists: field present",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "pharmacyOverride": { $exists: true } as any } },
+          [{ externalId: "pharmacyOverride", value: "some-value" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$exists: field absent",
+      async () => {
+        return evaluate_mapping_conditions(
+          { condition: { "pharmacyOverride": { $exists: true } as any } },
+          [{ externalId: "other_field", value: "some-value" }]
+        )
+      },
+      { expectedResult: false }
+    )
+
+    await async_test(
+      "Nested compound: $and with $or",
+      async () => {
+        return evaluate_mapping_conditions(
+          {
+            $and: [
+              { $or: [{ condition: { "state": "CA" } }, { condition: { "state": "NY" } }] },
+              { condition: { "med_type": "weightLoss" } },
+            ]
+          },
+          [{ externalId: "state", value: "NY" }, { externalId: "med_type", value: "weightLoss" }]
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "First-match-wins: multiple mappings, first matching returned",
+      async () => {
+        const mappings: BelugaPharmacyMapping[] = [
+          {
+            pharmacyId: "pharmacy-first",
+            patientPreference: "[]",
+            conditions: { condition: { "state": "CA" } },
+          },
+          {
+            pharmacyId: "pharmacy-second",
+            patientPreference: "[]",
+            conditions: { condition: { "state": "CA" } },
+          },
+        ]
+
+        const result = resolve_mapping(
+          mappings,
+          [{ externalId: "state", value: "CA" }]
+        )
+        return result?.pharmacyId === "pharmacy-first"
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "No match: no mappings match, returns undefined",
+      async () => {
+        const mappings: BelugaPharmacyMapping[] = [
+          {
+            pharmacyId: "pharmacy-ca",
+            patientPreference: "[]",
+            conditions: { condition: { "state": "CA" } },
+          },
+        ]
+
+        const result = resolve_mapping(
+          mappings,
+          [{ externalId: "state", value: "TX" }]
+        )
+        return result === undefined
+      },
+      { expectedResult: true }
+    )
+  } finally {
+    // Cleanup
+    if (testFormId) {
+      await sdk.api.forms.deleteOne(testFormId).catch(console.error)
+    }
+  }
+}
+
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await beluga_pharmacy_mappings_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("Beluga pharmacy mappings test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("Beluga pharmacy mappings test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/api_tests/calendar_event_limits.test.ts

@@ -685,6 +685,201 @@ export const calendar_event_limits_unit_tests = () => {
     }
   })
 
+  // === otherTemplateIds (OR logic) tests ===
+
+  const TEMPLATE_B = "templateB456"
+  const TEMPLATE_C = "templateC789"
+
+  // Test 21: otherTemplateIds - booking a secondary template should count toward the limit
+  tests.push({
+    name: 'otherTemplateIds - secondary template counts toward limit',
+    fn: () => {
+      const oct1 = new Date('2025-10-01T18:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        otherTemplateIds: [TEMPLATE_B],
+        period: 1,
+        limit: 1,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1, TEMPLATE_ID), // 1 event of primary template
+      ]
+
+      // Booking template B should be blocked because the shared limit is reached
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1,
+        templateId: TEMPLATE_B,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, true, 'Should block secondary template when shared limit reached')
+    }
+  })
+
+  // Test 22: otherTemplateIds - events of secondary template count toward primary booking
+  tests.push({
+    name: 'otherTemplateIds - secondary template events count when booking primary',
+    fn: () => {
+      const oct1 = new Date('2025-10-01T18:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        otherTemplateIds: [TEMPLATE_B],
+        period: 1,
+        limit: 1,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1, TEMPLATE_B), // 1 event of secondary template
+      ]
+
+      // Booking primary template should be blocked because a secondary template event used the limit
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1,
+        templateId: TEMPLATE_ID,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, true, 'Should block primary template when secondary events fill limit')
+    }
+  })
+
+  // Test 23: otherTemplateIds - mixed events from both templates count together
+  tests.push({
+    name: 'otherTemplateIds - mixed events count toward shared limit',
+    fn: () => {
+      const oct1_9am = new Date('2025-10-01T13:00:00.000Z').getTime()
+      const oct1_2pm = new Date('2025-10-01T18:00:00.000Z').getTime()
+      const oct1_5pm = new Date('2025-10-01T21:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        otherTemplateIds: [TEMPLATE_B],
+        period: 1,
+        limit: 2,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1_9am, TEMPLATE_ID),  // 1 primary
+        createEvent(oct1_2pm, TEMPLATE_B),   // 1 secondary
+      ]
+
+      // Both count toward limit of 2, so a 3rd should be blocked
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1_5pm,
+        templateId: TEMPLATE_ID,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, true, 'Should block when mixed events reach shared limit')
+    }
+  })
+
+  // Test 24: otherTemplateIds - unrelated template should NOT be affected
+  tests.push({
+    name: 'otherTemplateIds - unrelated template not affected by shared limit',
+    fn: () => {
+      const oct1 = new Date('2025-10-01T18:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        otherTemplateIds: [TEMPLATE_B],
+        period: 1,
+        limit: 1,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1, TEMPLATE_ID), // Limit reached for A+B group
+      ]
+
+      // Template C is not part of the group, should be allowed
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1,
+        templateId: TEMPLATE_C,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, false, 'Should allow unrelated template even when shared limit reached')
+    }
+  })
+
+  // Test 25: otherTemplateIds - under limit should allow
+  tests.push({
+    name: 'otherTemplateIds - under shared limit should allow',
+    fn: () => {
+      const oct1_9am = new Date('2025-10-01T13:00:00.000Z').getTime()
+      const oct1_2pm = new Date('2025-10-01T18:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        otherTemplateIds: [TEMPLATE_B],
+        period: 1,
+        limit: 3,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1_9am, TEMPLATE_ID),  // 1 event
+        createEvent(oct1_9am, TEMPLATE_B),   // 1 event, total = 2
+      ]
+
+      // Under limit of 3, should allow
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1_2pm,
+        templateId: TEMPLATE_B,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, false, 'Should allow when under shared limit')
+    }
+  })
+
+  // Test 26: No otherTemplateIds - backward compatibility
+  tests.push({
+    name: 'No otherTemplateIds - backward compatible single-template behavior',
+    fn: () => {
+      const oct1 = new Date('2025-10-01T18:00:00.000Z').getTime()
+
+      const limits: CalendarEventLimit[] = [{
+        templateId: TEMPLATE_ID,
+        period: 1,
+        limit: 1,
+      }]
+
+      const existingEvents = [
+        createEvent(oct1, TEMPLATE_B), // Event of different template
+      ]
+
+      // Without otherTemplateIds, template B events should NOT count toward template A's limit
+      const result = slot_violates_calendar_event_limits({
+        slotStartTimeInMS: oct1,
+        templateId: TEMPLATE_ID,
+        userId: USER_ID,
+        calendarEventLimits: limits,
+        existingEvents,
+        timezone: 'America/New_York',
+      })
+
+      assertEqual(result, false, 'Should not count other template events without otherTemplateIds')
+    }
+  })
+
   return tests
 }