@tellescope/sdk 1.254.0 → 1.255.0

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

@@ -0,0 +1,414 @@
+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, evaluate_string_field_comparison } from "@tellescope/utilities"
+import { CompoundFilter } from "@tellescope/types-models"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+type MDIOffering = { offering_id: string, conditions?: CompoundFilter<string> }
+
+// Local replica of the API's resolve_case_offerings (md_integrations.ts), built
+// from the same shared @tellescope/utilities helpers it uses, so we can assert
+// the resolution behavior from the SDK test harness.
+const is_empty_conditions = (conditions: CompoundFilter<string>): boolean => {
+  if (!conditions || !Object.keys(conditions).length) return true
+  const condition = (conditions as { condition?: Record<string, unknown> }).condition
+  if (condition !== undefined) return !Object.keys(condition).length
+  return false
+}
+
+const resolve_case_offerings = (
+  offerings: MDIOffering[],
+  responses: { externalId?: string, value?: string }[],
+): MDIOffering[] => (
+  offerings.filter(o => {
+    if (!o.conditions || is_empty_conditions(o.conditions)) return true
+    return evaluate_conditional_logic(o.conditions, (key, value) =>
+      evaluate_string_field_comparison(responses.find(r => r.externalId === key)?.value, value)
+    )
+  })
+)
+
+// Local replicas of the API's patient-mapping helpers (md_integrations.ts).
+// SDK tests cannot import the private API package, so we mirror the conversion
+// helpers + exclusion set here to assert the same behavior.
+type GenericQuantityWithUnit = { value: number | string, unit: string }
+
+const to_number = (v: unknown): number | undefined => {
+  const n = typeof v === 'number' ? v : parseFloat(String(v ?? ''))
+  return Number.isFinite(n) ? n : undefined
+}
+const enduser_height_to_cm = (h?: GenericQuantityWithUnit): number | undefined => {
+  const inches = to_number(h?.value); if (inches === undefined) return undefined
+  return Math.round(inches * 2.54)
+}
+const enduser_weight_to_kg = (w?: GenericQuantityWithUnit): number | undefined => {
+  const lbs = to_number(w?.value); if (lbs === undefined) return undefined
+  return Math.round(lbs * 0.45359237 * 100) / 100
+}
+
+const PATIENT_MAPPED_EXTERNAL_IDS = new Set([
+  'fname', 'first_name', 'lname', 'last_name',
+  'email', 'dateOfBirth', 'gender', 'phone', 'address',
+  'height', 'weight',
+  'allergies', 'current_medications', 'medical_conditions', 'special_necessities', 'pregnancy',
+  'intro_video_id',
+])
+
+// Mirrors the externalId exclusion step in form_response_to_case_questions:
+// patient-mapped fields are dropped, everything else survives.
+const case_question_external_ids = (responses: { externalId?: string }[]): string[] => (
+  responses
+    .filter(r => !(r.externalId && PATIENT_MAPPED_EXTERNAL_IDS.has(r.externalId)))
+    .map(r => r.externalId)
+    .filter((id): id is string => id !== undefined)
+)
+
+// Local replica of form_response_to_case_questions' displayed_options logic
+// (md_integrations.ts). SDK tests cannot import the private API package, so we
+// mirror the field lookup (_id first, externalId fallback) + the multiple_choice
+// / Dropdown gate, and assert displayed_options is populated only when applicable.
+type ReplicaField = { _id: string, externalId?: string, options?: { choices?: string[] } }
+type ReplicaResponse = { fieldId?: string, externalId?: string, answer: { type?: string } }
+
+const resolve_displayed_options = (
+  response: ReplicaResponse,
+  formFields: ReplicaField[] = [],
+): string[] | undefined => {
+  const field = (
+       formFields.find(f => f._id.toString() === response.fieldId)
+    || formFields.find(f => response.externalId && f.externalId === response.externalId)
+  )
+  return (
+    (response.answer.type === 'multiple_choice' || response.answer.type === 'Dropdown')
+    && field?.options?.choices?.length
+  ) ? field.options.choices : undefined
+}
+
+export const mdi_case_offerings_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("MDI Case Offerings Tests")
+
+  let testFormId: string | undefined
+
+  try {
+    // --- Schema round-trip tests ---
+
+    await async_test(
+      "Create form with mdiCaseOfferings mixing unconditional and conditional entries",
+      async () => {
+        const offerings: MDIOffering[] = [
+          { offering_id: "offering-always" }, // unconditional
+          { offering_id: "offering-ca", conditions: { condition: { state: "CA" } } },
+          {
+            offering_id: "offering-ca-glp",
+            conditions: { $and: [{ condition: { state: "CA" } }, { condition: { med_type: "weightLoss" } }] },
+          },
+        ]
+
+        const form = await sdk.api.forms.createOne({
+          title: 'MDI Case Offerings Test Form',
+          mdiCaseOfferings: offerings,
+        })
+        testFormId = form.id
+
+        const fetched = await sdk.api.forms.getOne(form.id)
+        return (
+          fetched.mdiCaseOfferings?.length === 3
+          && fetched.mdiCaseOfferings[0].offering_id === "offering-always"
+          && fetched.mdiCaseOfferings[0].conditions === undefined
+          && !!fetched.mdiCaseOfferings[1].conditions?.condition
+          && !!fetched.mdiCaseOfferings[2].conditions?.$and
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Backwards-compat: existing flat { offering_id } config still validates",
+      async () => {
+        if (!testFormId) throw new Error("No test form")
+
+        // mirrors a pre-existing config with no conditions
+        const flat: MDIOffering[] = [
+          { offering_id: "legacy-1" },
+          { offering_id: "legacy-2" },
+        ]
+        await sdk.api.forms.updateOne(testFormId, { mdiCaseOfferings: flat }, { replaceObjectFields: true })
+        const fetched = await sdk.api.forms.getOne(testFormId)
+        return (
+          fetched.mdiCaseOfferings?.length === 2
+          && fetched.mdiCaseOfferings.every(o => o.conditions === undefined)
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Save nested CompoundFilter conditions on an offering and read back",
+      async () => {
+        if (!testFormId) throw new Error("No test form")
+
+        const nested: MDIOffering[] = [
+          {
+            offering_id: "offering-nested",
+            conditions: {
+              $and: [
+                { $or: [{ condition: { state: "CA" } }, { condition: { state: "NY" } }] },
+                { condition: { med_type: "weightLoss" } },
+              ],
+            },
+          },
+        ]
+        await sdk.api.forms.updateOne(testFormId, { mdiCaseOfferings: nested }, { replaceObjectFields: true })
+        const fetched = await sdk.api.forms.getOne(testFormId)
+        return (
+          fetched.mdiCaseOfferings?.length === 1
+          && !!fetched.mdiCaseOfferings[0].conditions?.$and
+        )
+      },
+      { expectedResult: true }
+    )
+
+    // --- resolve_case_offerings behavior tests ---
+
+    const MIXED: MDIOffering[] = [
+      { offering_id: "always" }, // unconditional → always sent
+      { offering_id: "ca-only", conditions: { condition: { state: "CA" } } },
+      { offering_id: "ny-only", conditions: { condition: { state: "NY" } } },
+    ]
+
+    await async_test(
+      "Resolver returns exactly the matching subset plus unconditional offerings",
+      async () => {
+        const resolved = resolve_case_offerings(MIXED, [{ externalId: "state", value: "CA" }])
+        return (
+          resolved.length === 2
+          && resolved.some(o => o.offering_id === "always")
+          && resolved.some(o => o.offering_id === "ca-only")
+          && !resolved.some(o => o.offering_id === "ny-only")
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Send none: when conditions match nothing, only unconditional offerings remain",
+      async () => {
+        // a config where every offering carries a condition that fails
+        const allConditional: MDIOffering[] = [
+          { offering_id: "ca-only", conditions: { condition: { state: "CA" } } },
+          { offering_id: "ny-only", conditions: { condition: { state: "NY" } } },
+        ]
+        const resolved = resolve_case_offerings(allConditional, [{ externalId: "state", value: "TX" }])
+        return resolved.length === 0
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Backwards compat: all-unconditional config sends everything",
+      async () => {
+        const allUnconditional: MDIOffering[] = [
+          { offering_id: "a" },
+          { offering_id: "b" },
+          { offering_id: "c" },
+        ]
+        const resolved = resolve_case_offerings(allUnconditional, [{ externalId: "state", value: "TX" }])
+        return resolved.length === 3
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Empty/blank conditions object is treated as unconditional (always sent)",
+      async () => {
+        const withBlank: MDIOffering[] = [
+          { offering_id: "blank", conditions: { condition: {} } },
+        ]
+        // even with no matching response, the blank-condition offering is sent
+        const resolved = resolve_case_offerings(withBlank, [])
+        return resolved.length === 1 && resolved[0].offering_id === "blank"
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$or conditions: offering sent when any branch matches",
+      async () => {
+        const offerings: MDIOffering[] = [
+          { offering_id: "ca-or-ny", conditions: { $or: [{ condition: { state: "CA" } }, { condition: { state: "NY" } }] } },
+        ]
+        const resolved = resolve_case_offerings(offerings, [{ externalId: "state", value: "NY" }])
+        return resolved.length === 1
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "$contains operator narrows offerings by substring match",
+      async () => {
+        const offerings: MDIOffering[] = [
+          { offering_id: "glp", conditions: { condition: { meds: { $contains: "GLP" } as any } } },
+        ]
+        const matches = resolve_case_offerings(offerings, [{ externalId: "meds", value: "GLP-1 agonist" }])
+        const misses = resolve_case_offerings(offerings, [{ externalId: "meds", value: "Semaglutide" }])
+        return matches.length === 1 && misses.length === 0
+      },
+      { expectedResult: true }
+    )
+
+    // --- height/weight conversion tests ---
+
+    await async_test(
+      "enduser_height_to_cm converts Inches → integer centimeters",
+      async () => (
+        enduser_height_to_cm({ value: 70, unit: 'Inches' }) === 178
+        && enduser_height_to_cm({ value: '70', unit: 'Inches' }) === 178 // string value parsed
+        && enduser_height_to_cm(undefined) === undefined // absent → omitted
+        && enduser_height_to_cm({ value: '', unit: 'Inches' }) === undefined
+      ),
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "enduser_weight_to_kg converts Pounds → kilograms (float, 2dp)",
+      async () => (
+        enduser_weight_to_kg({ value: 200, unit: 'Pounds' }) === 90.72
+        && enduser_weight_to_kg({ value: '200', unit: 'Pounds' }) === 90.72 // string value parsed
+        && enduser_weight_to_kg(undefined) === undefined // absent → omitted
+        && enduser_weight_to_kg({ value: 'not-a-number', unit: 'Pounds' }) === undefined
+      ),
+      { expectedResult: true }
+    )
+
+    // --- case_questions exclusion tests ---
+
+    await async_test(
+      "case_questions exclude patient-mapped fields but keep non-mapped clinical answers",
+      async () => {
+        const responses = [
+          { externalId: 'fname' },
+          { externalId: 'email' },
+          { externalId: 'dateOfBirth' },
+          { externalId: 'gender' },
+          { externalId: 'phone' },
+          { externalId: 'address' },
+          { externalId: 'height' },
+          { externalId: 'weight' },
+          { externalId: 'allergies' },
+          { externalId: 'special_necessities' },
+          { externalId: 'symptoms' }, // non-mapped clinical field → survives
+          { externalId: 'duration' }, // non-mapped clinical field → survives
+        ]
+        const kept = case_question_external_ids(responses)
+        const excluded = ['fname', 'email', 'dateOfBirth', 'gender', 'phone', 'address', 'height', 'weight', 'allergies', 'special_necessities']
+        return (
+          kept.length === 2
+          && kept.includes('symptoms')
+          && kept.includes('duration')
+          && excluded.every(id => !kept.includes(id))
+        )
+      },
+      { expectedResult: true }
+    )
+
+    // --- displayed_options tests ---
+
+    await async_test(
+      "multiple_choice response + matching field by _id → displayed_options equals field choices",
+      async () => {
+        const fields: ReplicaField[] = [
+          { _id: 'field-1', options: { choices: ['Yes', 'No', 'Maybe'] } },
+        ]
+        const response: ReplicaResponse = { fieldId: 'field-1', answer: { type: 'multiple_choice' } }
+        const opts = resolve_displayed_options(response, fields)
+        return (
+          !!opts
+          && opts.length === 3
+          && opts[0] === 'Yes' && opts[1] === 'No' && opts[2] === 'Maybe'
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "Dropdown response + matching field by externalId → displayed_options equals field choices",
+      async () => {
+        const fields: ReplicaField[] = [
+          { _id: 'field-2', externalId: 'state', options: { choices: ['CA', 'NY', 'TX'] } },
+        ]
+        // fieldId does not match any field; externalId fallback resolves the field
+        const response: ReplicaResponse = { fieldId: '', externalId: 'state', answer: { type: 'Dropdown' } }
+        const opts = resolve_displayed_options(response, fields)
+        return !!opts && opts.length === 3 && opts.join(',') === 'CA,NY,TX'
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "string/number response → displayed_options undefined even with field choices present",
+      async () => {
+        const fields: ReplicaField[] = [
+          { _id: 'field-3', options: { choices: ['Yes', 'No'] } },
+        ]
+        const stringResponse: ReplicaResponse = { fieldId: 'field-3', answer: { type: 'string' } }
+        const numberResponse: ReplicaResponse = { fieldId: 'field-3', answer: { type: 'number' } }
+        return (
+          resolve_displayed_options(stringResponse, fields) === undefined
+          && resolve_displayed_options(numberResponse, fields) === undefined
+        )
+      },
+      { expectedResult: true }
+    )
+
+    await async_test(
+      "multiple_choice response with no matching field → displayed_options undefined (question still kept)",
+      async () => {
+        const fields: ReplicaField[] = [
+          { _id: 'field-4', externalId: 'other', options: { choices: ['A', 'B'] } },
+        ]
+        // neither fieldId nor externalId matches any field
+        const noMatch: ReplicaResponse = { fieldId: 'field-unknown', externalId: 'unknown', answer: { type: 'multiple_choice' } }
+        // matching field but empty choices → also undefined
+        const emptyChoices: ReplicaResponse = { fieldId: 'field-5', answer: { type: 'multiple_choice' } }
+        const fieldsEmpty: ReplicaField[] = [{ _id: 'field-5', options: { choices: [] } }]
+        return (
+          resolve_displayed_options(noMatch, fields) === undefined
+          && resolve_displayed_options(emptyChoices, fieldsEmpty) === undefined
+        )
+      },
+      { expectedResult: true }
+    )
+  } finally {
+    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 mdi_case_offerings_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("MDI case offerings test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("MDI case offerings test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -0,0 +1,207 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert,
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// fields that the admin org-wide list endpoint is allowed to return
+const ALLOWED_FIELDS = ['id', 'creator', 'businessId', 'updatedAt'].sort()
+
+export const organization_api_keys_tests = async (
+  { sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }
+) => {
+  log_header("Organization API Keys (admin org-wide management)")
+
+  // We never mutate sdkNonAdmin's roles here (throwaway-user rule). Instead we create a
+  // dedicated throwaway user in the SAME org that DOES have api_keys access (via a custom
+  // role), so it can create its own key (the offboarded-employee scenario) and so the
+  // admin-gating negative tests below exercise the adminOnly gate (401) rather than the
+  // access-permission gate (403) — a non-admin without api_keys access is rejected with
+  // "Inaccessible" before adminOnly is ever reached.
+  const adminKeyIds: string[] = []
+  let otherKeyId: string | undefined
+  let otherUserId: string | undefined
+  let apiKeysRoleId: string | undefined
+
+  try {
+    // A custom role that grants api_keys access (merged over PROVIDER_PERMISSIONS server-side)
+    const apiKeysRole = await sdk.api.role_based_access_permissions.createOne({
+      role: 'api-keys-test-role',
+      permissions: { api_keys: { create: 'All', read: 'All', update: 'All', delete: 'All' } },
+    })
+    apiKeysRoleId = apiKeysRole.id
+
+    // A throwaway non-admin user in the same org, holding that role
+    const otherUser = (
+      await sdk.api.users.getOne({ email: 'api.keys.other.user@tellescope.com' }).catch(() => null)
+    ) || (
+      await sdk.api.users.createOne({ email: 'api.keys.other.user@tellescope.com', notificationEmailsDisabled: true, verifiedEmail: true })
+    )
+    otherUserId = otherUser.id
+    await sdk.api.users.updateOne(otherUser.id, { roles: [apiKeysRole.role] }, { replaceObjectFields: true })
+    await wait(undefined, 2000) // wait for the role change to propagate before authenticating
+
+    const otherSdk = new Session({
+      host,
+      authToken: (await sdk.api.users.generate_auth_token({ id: otherUser.id })).authToken,
+    })
+
+    // A key created by the admin...
+    const adminKey = await sdk.api.api_keys.createOne({})
+    adminKeyIds.push(adminKey.id)
+
+    // ...and a key created by ANOTHER user in the org (the offboarded-employee scenario)
+    const otherKey = await otherSdk.api.api_keys.createOne({})
+    otherKeyId = otherKey.id
+
+    // =============================================
+    // CORE: admin sees keys created by other users
+    // =============================================
+    const { apiKeys } = await sdk.api.api_keys.get_organization_api_keys()
+
+    assert(
+      apiKeys.some(k => k.id === otherKeyId),
+      `admin list did not include another user's key ${otherKeyId}`,
+      "admin get_organization_api_keys returns keys created by other users in the org"
+    )
+    assert(
+      apiKeys.some(k => k.id === adminKey.id),
+      "admin list did not include the admin's own key",
+      "admin get_organization_api_keys returns the admin's own keys"
+    )
+    assert(
+      !!apiKeys.find(k => k.id === otherKeyId && k.creator === otherUser.id),
+      "creator on the other user's key did not match",
+      "returned key reports the correct creator"
+    )
+
+    // =============================================
+    // SECRET REDACTION (server-side, allowlist)
+    // =============================================
+    assert(
+      apiKeys.every(k => (k as any).key === undefined),
+      "a returned record exposed a plaintext `key`",
+      "no returned record exposes a plaintext key (legacy field)"
+    )
+    assert(
+      apiKeys.every(k => (k as any).hashedKey === undefined),
+      "a returned record exposed `hashedKey`",
+      "no returned record exposes hashedKey"
+    )
+    // Strict allowlist: every returned field must be in the allowlist (no extra/sensitive field
+    // ever leaks). We can't require all allowlisted fields to be PRESENT — never-updated keys
+    // have no `updatedAt`, and res.json() drops undefined values — so this is a subset check.
+    const offending = apiKeys
+      .map(k => Object.keys(k).filter(key => !ALLOWED_FIELDS.includes(key)))
+      .find(extra => extra.length > 0)
+    assert(
+      offending === undefined,
+      `a returned record exposed non-allowlisted fields: ${JSON.stringify(offending)}`,
+      "returned records contain only allowlisted fields (subset of id, creator, businessId, updatedAt)"
+    )
+
+    // =============================================
+    // CROSS-ORG ISOLATION (no leakage across businesses)
+    // =============================================
+    assert(
+      apiKeys.every(k => k.businessId === sdk.userInfo.businessId),
+      "a returned key belonged to a different business",
+      "all returned keys are scoped to the admin's businessId"
+    )
+
+    // =============================================
+    // ADMIN GATING (negative tests)
+    // =============================================
+    await async_test(
+      "non-admin get_organization_api_keys is rejected (401)",
+      () => otherSdk.api.api_keys.get_organization_api_keys(),
+      { shouldError: true, onError: (e: any) => e.statusCode === 401 || /admin access only/i.test(e.message || '') }
+    )
+    await async_test(
+      "non-admin delete_organization_api_key is rejected (401)",
+      () => otherSdk.api.api_keys.delete_organization_api_key({ id: adminKey.id }),
+      { shouldError: true, onError: (e: any) => e.statusCode === 401 || /admin access only/i.test(e.message || '') }
+    )
+
+    // confirm the gating did not delete the key
+    const afterGating = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      afterGating.apiKeys.some(k => k.id === adminKey.id),
+      "rejected non-admin delete still removed the key",
+      "rejected non-admin delete left the key intact"
+    )
+
+    // =============================================
+    // ADMIN DELETE another user's key
+    // =============================================
+    await async_test(
+      "admin delete_organization_api_key deletes another user's key",
+      () => sdk.api.api_keys.delete_organization_api_key({ id: otherKeyId! }),
+      { shouldError: false, onResult: () => true }
+    )
+
+    const afterDelete = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      !afterDelete.apiKeys.some(k => k.id === otherKeyId),
+      "deleted key still present in org-wide list",
+      "deleted key no longer appears in the org-wide list"
+    )
+    otherKeyId = undefined // successfully deleted; nothing to clean up
+
+    // deleting a key in a different org (fabricated id) must be a no-op for our org
+    await async_test(
+      "admin delete of a non-existent/cross-org key id is a safe no-op",
+      () => sdk.api.api_keys.delete_organization_api_key({ id: '000000000000000000000000' }),
+      { shouldError: false, onResult: () => true }
+    )
+    const afterNoop = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      afterNoop.apiKeys.some(k => k.id === adminKey.id),
+      "no-op delete removed an unrelated key",
+      "no-op cross-org delete left our org's keys intact"
+    )
+  } finally {
+    // cleanup: remove any keys we created (creator-only default delete)
+    for (const id of adminKeyIds) {
+      await sdk.api.api_keys.deleteOne(id).catch(() => {})
+    }
+    // the admin can clean up the throwaway user's key org-wide; fall through is harmless
+    if (otherKeyId) {
+      await sdk.api.api_keys.delete_organization_api_key({ id: otherKeyId }).catch(() => {})
+    }
+    if (otherUserId) {
+      await sdk.api.users.deleteOne(otherUserId).catch(() => {})
+    }
+    if (apiKeysRoleId) {
+      await sdk.api.role_based_access_permissions.deleteOne(apiKeysRoleId).catch(() => {})
+    }
+  }
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await organization_api_keys_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Organization API keys test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Organization API keys test suite failed:", error)
+      process.exit(1)
+    })
+}