@metriport/fhir-sdk 0.30.0-alpha.1

package/dist/__tests__/fhir-bundle-sdk.test.js

@@ -0,0 +1,953 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const fhir_bundles_1 = require("./fixtures/fhir-bundles");
+describe("FhirBundleSdk", () => {
+    describe("Bundle Loading and Initialization", () => {
+        describe("FR-1.1: SDK constructor accepts a FHIR Bundle object", () => {
+            it("should accept a valid FHIR bundle", async () => {
+                await expect(index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle)).resolves.not.toThrow();
+            });
+        });
+        describe("FR-1.2: SDK constructor throws error if bundle.resourceType !== 'Bundle'", () => {
+            it("should throw error for invalid resourceType", async () => {
+                await expect(index_1.FhirBundleSdk.create(fhir_bundles_1.invalidBundleWrongType)).rejects.toThrow();
+            });
+        });
+        describe("FR-1.4: SDK constructor creates internal indexes for O(1) resource lookup", () => {
+            it("should create internal indexes during construction", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const start = performance.now();
+                const patient = sdk.getResourceById("patient-123");
+                const end = performance.now();
+                expect(patient).toBeDefined();
+                expect(patient?.resourceType).toBe("Patient");
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS);
+            });
+        });
+    });
+    describe("Reference Validation", () => {
+        describe("FR-2.1: lookForBrokenReferences() method returns validation result", () => {
+            it("should return validation result for valid bundle", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const result = sdk.lookForBrokenReferences();
+                expect(result).toBeDefined();
+                expect(typeof result.hasBrokenReferences).toBe("boolean");
+                expect(Array.isArray(result.brokenReferences)).toBe(true);
+            });
+            it("should return true for valid references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.hasBrokenReferences).toBe(false);
+                expect(result.brokenReferences).toHaveLength(0);
+            });
+            it("should return false for invalid references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.hasBrokenReferences).toBe(true);
+                expect(result.brokenReferences.length).toBeGreaterThan(0);
+            });
+        });
+        describe("FR-2.2: Validation identifies references by Resource/id pattern and fullUrl references", () => {
+            it("should identify Resource/id pattern references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const result = sdk.lookForBrokenReferences();
+                const brokenSubjectRef = result.brokenReferences.find(ref => ref.reference === "Patient/nonexistent-patient");
+                expect(brokenSubjectRef).toBeDefined();
+            });
+            it("should validate fullUrl references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithFullUrlReferences);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.hasBrokenReferences).toBe(false);
+            });
+        });
+        describe("FR-2.3: Validation handles both relative and absolute references", () => {
+            it("should handle relative references (Patient/123)", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.hasBrokenReferences).toBe(false);
+            });
+            it("should handle absolute references (urn:uuid:123)", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithFullUrlReferences);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.hasBrokenReferences).toBe(false);
+            });
+        });
+        describe("FR-2.4: Validation result includes list of broken references with details", () => {
+            it("should provide detailed broken reference information", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const result = sdk.lookForBrokenReferences();
+                expect(result.brokenReferences.length).toBeGreaterThan(0);
+                const brokenRef = result.brokenReferences[0];
+                expect(brokenRef).toBeDefined();
+                if (brokenRef) {
+                    expect(brokenRef.sourceResourceId).toBeDefined();
+                    expect(brokenRef.sourceResourceType).toBeDefined();
+                    expect(brokenRef.referenceField).toBeDefined();
+                    expect(brokenRef.reference).toBeDefined();
+                }
+            });
+        });
+    });
+    describe("Resource Retrieval by ID", () => {
+        describe("FR-3.1: getResourceById<T>(id: string): T | undefined returns resource matching the ID", () => {
+            it("should return resource by ID", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patient = sdk.getResourceById("patient-123");
+                expect(patient).toBeDefined();
+                expect(patient?.id).toBe("patient-123");
+                expect(patient?.resourceType).toBe("Patient");
+            });
+        });
+        describe("FR-3.2: Method searches both resource.id and entry.fullUrl for matches", () => {
+            it("should find resource by resource.id", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patient = sdk.getResourceById("patient-123");
+                expect(patient?.id).toBe("patient-123");
+            });
+            it("should find resource by fullUrl", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patient = sdk.getResourceById("urn:uuid:patient-123");
+                expect(patient?.id).toBe("patient-123");
+            });
+        });
+        describe("FR-3.3: Method supports type parameter for proper TypeScript return typing", () => {
+            it("should return properly typed resource", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patient = sdk.getResourceById("patient-123");
+                // TypeScript should infer this as Patient | undefined
+                expect(patient?.name).toBeDefined();
+                expect(patient?.birthDate).toBeDefined();
+            });
+        });
+        describe("FR-3.4: Method returns undefined if resource not found", () => {
+            it("should return undefined for nonexistent resource", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const result = sdk.getResourceById("nonexistent-id");
+                expect(result).toBeUndefined();
+            });
+        });
+        describe("FR-3.5: Lookup operates in O(1) time complexity", () => {
+            it("should perform lookup in O(1) time", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const start = performance.now();
+                sdk.getResourceById("patient-123");
+                const end = performance.now();
+                // O(1) lookup should be very fast
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS);
+            });
+        });
+    });
+    describe("Type-Specific Resource Getters", () => {
+        describe("FR-4.1: getPatients(): Patient[] returns all Patient resources", () => {
+            it("should return all patients", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patients = sdk.getPatients();
+                expect(Array.isArray(patients)).toBe(true);
+                expect(patients).toHaveLength(1);
+                expect(patients[0]?.resourceType).toBe("Patient");
+            });
+        });
+        describe("FR-4.2: getObservations(): Observation[] returns all Observation resources", () => {
+            it("should return all observations", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                expect(Array.isArray(observations)).toBe(true);
+                expect(observations).toHaveLength(1);
+                expect(observations[0]?.resourceType).toBe("Observation");
+            });
+        });
+        describe("FR-4.3: getEncounters(): Encounter[] returns all Encounter resources", () => {
+            it("should return all encounters", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const encounters = sdk.getEncounters();
+                expect(Array.isArray(encounters)).toBe(true);
+                expect(encounters).toHaveLength(1);
+                expect(encounters[0]?.resourceType).toBe("Encounter");
+            });
+        });
+        describe("FR-4.4: getPractitioners(): Practitioner[] returns all Practitioner resources", () => {
+            it("should return all practitioners", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const practitioners = sdk.getPractitioners();
+                expect(Array.isArray(practitioners)).toBe(true);
+                expect(practitioners).toHaveLength(1);
+                expect(practitioners[0]?.resourceType).toBe("Practitioner");
+            });
+        });
+        describe("FR-4.5: getDiagnosticReports(): DiagnosticReport[] returns all DiagnosticReport resources", () => {
+            it("should return all diagnostic reports", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const reports = sdk.getDiagnosticReports();
+                expect(Array.isArray(reports)).toBe(true);
+                expect(reports).toHaveLength(1);
+                expect(reports[0]?.resourceType).toBe("DiagnosticReport");
+            });
+        });
+        describe("FR-4.6: All type-specific getters return empty array if no resources of that type exist", () => {
+            it("should return empty array when no resources exist", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.emptyBundle);
+                expect(sdk.getPatients()).toEqual([]);
+                expect(sdk.getObservations()).toEqual([]);
+                expect(sdk.getEncounters()).toEqual([]);
+                expect(sdk.getPractitioners()).toEqual([]);
+                expect(sdk.getDiagnosticReports()).toEqual([]);
+            });
+            it("should return empty array for missing resource types", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.patientsOnlyBundle);
+                expect(sdk.getPatients()).toHaveLength(3);
+                expect(sdk.getObservations()).toEqual([]);
+                expect(sdk.getEncounters()).toEqual([]);
+                expect(sdk.getPractitioners()).toEqual([]);
+                expect(sdk.getDiagnosticReports()).toEqual([]);
+            });
+        });
+        describe("FR-4.7: All methods use @medplum/fhirtypes for return type definitions", () => {
+            it("should return properly typed resources", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const patients = sdk.getPatients();
+                const observations = sdk.getObservations();
+                const encounters = sdk.getEncounters();
+                const practitioners = sdk.getPractitioners();
+                const reports = sdk.getDiagnosticReports();
+                // TypeScript compilation will enforce correct typing
+                expect(patients[0]?.name).toBeDefined();
+                expect(observations[0]?.status).toBeDefined();
+                expect(encounters[0]?.status).toBeDefined();
+                expect(practitioners[0]?.name).toBeDefined();
+                expect(reports[0]?.status).toBeDefined();
+            });
+        });
+    });
+    describe("Smart Reference Resolution", () => {
+        describe("FR-5.1: Resources returned by SDK have additional getter methods for each Reference field", () => {
+            it("should add getter methods for reference fields", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(typeof observation?.getSubject).toBe("function");
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(typeof observation?.getEncounter).toBe("function");
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expect(typeof observation?.getPerformers).toBe("function");
+            });
+        });
+        describe("FR-5.2: For Observation.subject reference, SDK adds getSubject() method", () => {
+            it("should resolve subject reference to Patient", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                const subject = observation?.getSubject();
+                expect(subject).toBeDefined();
+                expect(subject?.resourceType).toBe("Patient");
+                expect(subject?.id).toBe("patient-123");
+            });
+        });
+        describe("FR-5.3: For Observation.encounter reference, SDK adds getEncounter() method", () => {
+            it("should resolve encounter reference to Encounter", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                const encounter = observation?.getEncounter();
+                expect(encounter).toBeDefined();
+                expect(encounter?.resourceType).toBe("Encounter");
+                expect(encounter?.id).toBe("encounter-789");
+            });
+        });
+        describe("FR-5.4: For Observation.performer reference array, SDK adds getPerformer() method", () => {
+            it("should resolve performer references to array of resources", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                const performers = observation?.getPerformers();
+                expect(Array.isArray(performers)).toBe(true);
+                expect(performers).toHaveLength(1);
+                expect(performers?.[0]?.resourceType).toBe("Practitioner");
+                expect(performers?.[0]?.id).toBe("practitioner-456");
+            });
+        });
+        describe("FR-5.5: Reference resolution methods handle both resource.id and fullUrl matching", () => {
+            it("should resolve references by resource.id", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const subject = observations[0]?.getSubject();
+                expect(subject?.id).toBe("patient-123");
+            });
+            it("should resolve references by fullUrl", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithFullUrlReferences);
+                const observations = sdk.getObservations();
+                const subject = observations[0]?.getSubject();
+                expect(subject?.id).toBe("patient-fullurl");
+            });
+        });
+        describe("FR-5.6: Reference resolution methods return undefined for unresolvable references", () => {
+            it("should return undefined for broken references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                expect(observation?.getSubject()).toBeUndefined();
+                expect(observation?.getEncounter()).toBeUndefined();
+                expect(observation?.getPerformers()).toEqual([]);
+            });
+        });
+        describe("FR-5.7: Reference resolution operates in O(1) time complexity per reference", () => {
+            it("should resolve references in O(1) time", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                const start = performance.now();
+                observation?.getSubject();
+                const end = performance.now();
+                // O(1) resolution should be very fast
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS);
+            });
+        });
+        describe("FR-5.8: Original reference fields remain unchanged", () => {
+            it("should preserve original reference fields", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const observation = observations[0];
+                expect(observation?.subject?.reference).toBe("Patient/patient-123");
+                expect(observation?.encounter?.reference).toBe("Encounter/encounter-789");
+                expect(observation?.performer?.[0]?.reference).toBe("Practitioner/practitioner-456");
+            });
+        });
+    });
+    describe("Bundle Export Functionality", () => {
+        describe("FR-6.1: exportSubset(resourceIds: string[]): Bundle creates new bundle with specified resources", () => {
+            it("should export subset of resources by ID", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const subset = sdk.exportSubset(["patient-123", "observation-001"]);
+                expect(subset.resourceType).toBe("Bundle");
+                expect(subset.type).toBe("collection");
+                expect(subset.entry).toHaveLength(2);
+                expect(subset.total).toBe(2);
+            });
+        });
+        describe("FR-6.2: exportByType(resourceType: string): Bundle creates new bundle with all resources of specified type", () => {
+            it("should export all resources of specified type", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.mixedResourceTypesBundle);
+                const patientBundle = sdk.exportByType("Patient");
+                expect(patientBundle.resourceType).toBe("Bundle");
+                expect(patientBundle.type).toBe("collection");
+                expect(patientBundle.entry).toHaveLength(2);
+                expect(patientBundle.total).toBe(2);
+                expect(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                patientBundle.entry?.every((entry) => entry.resource?.resourceType === "Patient")).toBe(true);
+            });
+        });
+        describe("FR-6.3: exportByTypes(resourceTypes: string[]): Bundle creates new bundle with all resources of specified types", () => {
+            it("should export all resources of specified types", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.mixedResourceTypesBundle);
+                const bundle = sdk.exportByTypes(["Patient", "Observation"]);
+                expect(bundle.resourceType).toBe("Bundle");
+                expect(bundle.type).toBe("collection");
+                expect(bundle.entry).toHaveLength(4); // 2 patients + 2 observations
+                expect(bundle.total).toBe(4);
+            });
+        });
+        describe("FR-6.4: Exported bundles maintain original bundle metadata but update total count", () => {
+            it("should maintain metadata and update total", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const subset = sdk.exportSubset(["patient-123"]);
+                expect(subset.resourceType).toBe("Bundle");
+                expect(subset.type).toBe("collection");
+                expect(subset.total).toBe(1); // Updated count
+                expect(subset.id).toBeDefined(); // Metadata preserved
+            });
+        });
+        describe("FR-6.5: Exported bundles include only resources that exist in the original bundle", () => {
+            it("should ignore nonexistent resource IDs", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const subset = sdk.exportSubset(["patient-123", "nonexistent-id"]);
+                expect(subset.entry).toHaveLength(1);
+                expect(subset.total).toBe(1);
+            });
+        });
+        describe("FR-6.6: Exported bundles preserve original entry.fullUrl values", () => {
+            it("should preserve fullUrl values", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const subset = sdk.exportSubset(["patient-123"]);
+                expect(subset.entry?.[0]?.fullUrl).toBe("urn:uuid:patient-123");
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        describe("FR-7.1: All methods handle malformed resource references gracefully", () => {
+            it("should handle malformed references without throwing", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                expect(() => {
+                    const observations = sdk.getObservations();
+                    observations[0]?.getSubject();
+                }).not.toThrow();
+            });
+        });
+        describe("FR-7.2: SDK throws descriptive errors for invalid bundle structure during initialization", () => {
+            it("should throw descriptive error for invalid bundle", async () => {
+                await expect(index_1.FhirBundleSdk.create(fhir_bundles_1.invalidBundleWrongType)).rejects.toThrow("Invalid bundle: resourceType must be 'Bundle'");
+            });
+        });
+        describe("FR-7.3: Reference resolution methods never throw errors, only return undefined for invalid references", () => {
+            it("should return undefined instead of throwing for invalid references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const observations = sdk.getObservations();
+                expect(() => observations[0]?.getSubject()).not.toThrow();
+                expect(observations[0]?.getSubject()).toBeUndefined();
+            });
+        });
+    });
+    describe("Performance Requirements", () => {
+        describe("FR-9.1: Resource lookup by ID completes in O(1) time", () => {
+            it("should perform ID lookup in O(1) time", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const start = performance.now();
+                sdk.getResourceById("patient-123");
+                const end = performance.now();
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS);
+            });
+        });
+        describe("FR-9.2: Type-specific getters complete in O(n) time where n is number of resources of that type", () => {
+            it("should perform type-specific queries efficiently", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.mixedResourceTypesBundle);
+                const start = performance.now();
+                const patients = sdk.getPatients();
+                const end = performance.now();
+                expect(patients).toHaveLength(2);
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS * 2); // Should be fast for small bundles
+            });
+        });
+        describe("FR-9.4: Reference resolution per reference completes in O(1) time", () => {
+            it("should resolve references in O(1) time", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observations = sdk.getObservations();
+                const start = performance.now();
+                observations[0]?.getSubject();
+                const end = performance.now();
+                expect(end - start).toBeLessThan(fhir_bundles_1.CONSTANT_TIME_EXPECTED_THRESHOLD_MS);
+            });
+        });
+    });
+    describe("Reference Walking (BFS)", () => {
+        describe("Basic single-level traversal", () => {
+            it("should walk references from an Observation to related resources", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                expect(result).toBeDefined();
+                expect(result.startResource).toBe(observation);
+                expect(result.allResources).toBeDefined();
+                expect(Array.isArray(result.allResources)).toBe(true);
+                // Should include the observation itself plus referenced resources
+                // Observation references: subject (Patient), encounter (Encounter), performer (Practitioner)
+                expect(result.allResources.length).toBeGreaterThanOrEqual(4);
+                // Check that referenced resources are included
+                const resourceIds = result.allResources.map(r => r.id);
+                expect(resourceIds).toContain("observation-001"); // start resource
+                expect(resourceIds).toContain("patient-123"); // subject
+                expect(resourceIds).toContain("encounter-789"); // encounter
+                expect(resourceIds).toContain("practitioner-456"); // performer
+            });
+            it("should organize resources by depth level", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                expect(result.resourcesByDepth).toBeDefined();
+                expect(result.resourcesByDepth instanceof Map).toBe(true);
+                // Depth 0 should contain the starting resource
+                const depth0 = result.resourcesByDepth.get(0);
+                expect(depth0).toBeDefined();
+                expect(depth0?.length).toBe(1);
+                if (depth0 && depth0[0]) {
+                    expect(depth0[0].id).toBe("observation-001");
+                }
+                // Depth 1 should contain directly referenced resources
+                const depth1 = result.resourcesByDepth.get(1);
+                if (depth1 === undefined) {
+                    throw new Error("Depth 1 not found");
+                }
+                expect(depth1.length).toBeGreaterThan(0);
+            });
+            it("should report the depth reached", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                expect(result.depthReached).toBeGreaterThanOrEqual(0);
+                expect(typeof result.depthReached).toBe("number");
+            });
+        });
+        describe("Multi-level traversal", () => {
+            it("should traverse multiple levels from DiagnosticReport", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const diagnosticReport = sdk.getDiagnosticReportById("diagnostic-report-002");
+                if (diagnosticReport === undefined) {
+                    throw new Error("DiagnosticReport not found");
+                }
+                const result = sdk.walkReferences(diagnosticReport);
+                // DiagnosticReport -> Observation (level 1) -> Patient/Encounter/Practitioner (level 2)
+                expect(result.depthReached).toBeGreaterThanOrEqual(1);
+                const allResourceIds = result.allResources.map(r => r.id);
+                expect(allResourceIds).toContain("diagnostic-report-002"); // start
+                expect(allResourceIds).toContain("observation-001"); // result reference
+                expect(allResourceIds).toContain("patient-123"); // from observation
+            });
+        });
+        describe("Include start resource option", () => {
+            it("should include start resource by default", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                expect(result.allResources.map(r => r.id)).toContain("observation-001");
+            });
+            it("should exclude start resource when includeStartResource is false", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation, { includeStartResource: false });
+                expect(result.allResources.map(r => r.id)).not.toContain("observation-001");
+                // But should still have referenced resources
+                expect(result.allResources.length).toBeGreaterThan(0);
+            });
+        });
+        describe("Max depth limiting", () => {
+            it("should respect maxDepth of 0 (only start resource)", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation, { maxDepth: 0 });
+                expect(result.depthReached).toBe(0);
+                expect(result.allResources.length).toBe(1);
+                if (result.allResources[0]) {
+                    expect(result.allResources[0].id).toBe("observation-001");
+                }
+                expect(result.resourcesByDepth.size).toBe(1);
+            });
+            it("should respect maxDepth of 1 (start + direct references)", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation, { maxDepth: 1 });
+                expect(result.depthReached).toBe(1);
+                // Should have observation + its direct references (patient, encounter, practitioner)
+                expect(result.allResources.length).toBeGreaterThanOrEqual(4);
+                expect(result.resourcesByDepth.size).toBeGreaterThanOrEqual(2);
+                // Should have depth 0 and depth 1
+                expect(result.resourcesByDepth.has(0)).toBe(true);
+                expect(result.resourcesByDepth.has(1)).toBe(true);
+                // Should not have depth 2
+                expect(result.resourcesByDepth.has(2)).toBe(false);
+            });
+            it("should respect maxDepth of 2 from DiagnosticReport", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const diagnosticReport = sdk.getDiagnosticReportById("diagnostic-report-002");
+                if (diagnosticReport === undefined) {
+                    throw new Error("DiagnosticReport not found");
+                }
+                const result = sdk.walkReferences(diagnosticReport, { maxDepth: 2 });
+                // Note: In validCompleteBundle, DiagnosticReport references form a tightly connected graph
+                // where all resources at depth 2 have already been visited at depth 1, so depthReached is 1
+                expect(result.depthReached).toBeGreaterThanOrEqual(1);
+                expect(result.resourcesByDepth.has(0)).toBe(true); // DiagnosticReport
+                expect(result.resourcesByDepth.has(1)).toBe(true); // Observation, Patient, Encounter, Practitioner
+                // Depth 2 may or may not exist depending on the reference structure
+                expect(result.resourcesByDepth.has(3)).toBe(false); // Should not exist
+                // Verify we got all expected resources
+                const allResourceIds = result.allResources.map(r => r.id);
+                expect(allResourceIds).toContain("diagnostic-report-002");
+                expect(allResourceIds).toContain("observation-001");
+                expect(allResourceIds).toContain("patient-123");
+            });
+            it("should handle Infinity maxDepth (default)", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const resultWithInfinity = sdk.walkReferences(observation, { maxDepth: Infinity });
+                const resultWithoutOption = sdk.walkReferences(observation);
+                // Both should traverse all reachable resources
+                expect(resultWithInfinity.allResources.length).toBe(resultWithoutOption.allResources.length);
+                expect(resultWithInfinity.depthReached).toBe(resultWithoutOption.depthReached);
+            });
+        });
+        describe("Circular reference handling", () => {
+            it("should handle circular references without infinite loops", async () => {
+                // Create bundle with circular references
+                const circularBundle = {
+                    resourceType: "Bundle",
+                    type: "collection",
+                    entry: [
+                        {
+                            resource: {
+                                resourceType: "Organization",
+                                id: "org-1",
+                                partOf: { reference: "Organization/org-2" },
+                            },
+                        },
+                        {
+                            resource: {
+                                resourceType: "Organization",
+                                id: "org-2",
+                                partOf: { reference: "Organization/org-1" },
+                            },
+                        },
+                    ],
+                };
+                const sdk = await index_1.FhirBundleSdk.create(circularBundle);
+                const org1 = sdk.getOrganizationById("org-1");
+                // Should complete without hanging
+                if (org1 === undefined) {
+                    throw new Error("Organization not found");
+                }
+                const result = sdk.walkReferences(org1);
+                expect(result).toBeDefined();
+                expect(result.allResources.length).toBe(2); // Both organizations
+                const ids = result.allResources.map(r => r.id);
+                expect(ids).toContain("org-1");
+                expect(ids).toContain("org-2");
+            });
+        });
+        describe("Array reference handling", () => {
+            it("should handle array references correctly", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                // Observation has performer array
+                const practitionerId = "practitioner-456";
+                expect(result.allResources.map(r => r.id)).toContain(practitionerId);
+            });
+            it("should handle DiagnosticReport result array", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const diagnosticReport = sdk.getDiagnosticReportById("diagnostic-report-002");
+                if (diagnosticReport === undefined) {
+                    throw new Error("DiagnosticReport not found");
+                }
+                const result = sdk.walkReferences(diagnosticReport);
+                // DiagnosticReport has result array pointing to Observations
+                expect(result.allResources.map(r => r.id)).toContain("observation-001");
+            });
+        });
+        describe("Edge cases", () => {
+            it("should handle resources with no references", async () => {
+                const bundleWithIsolatedPatient = {
+                    resourceType: "Bundle",
+                    type: "collection",
+                    entry: [
+                        {
+                            resource: {
+                                resourceType: "Patient",
+                                id: "patient-isolated",
+                                name: [{ family: "Isolated", given: ["Patient"] }],
+                            },
+                        },
+                    ],
+                };
+                const sdk = await index_1.FhirBundleSdk.create(bundleWithIsolatedPatient);
+                const patient = sdk.getPatientById("patient-isolated");
+                if (patient === undefined) {
+                    throw new Error("Patient not found");
+                }
+                const result = sdk.walkReferences(patient);
+                expect(result.allResources.length).toBe(1);
+                expect(result.depthReached).toBe(0);
+                expect(result.allResources[0]?.id).toBe("patient-isolated");
+            });
+            it("should handle resources with broken references", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.bundleWithBrokenReferences);
+                const observation = sdk.getObservationById("observation-broken");
+                // Should not throw, just return what's reachable
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation);
+                expect(result).toBeDefined();
+                expect(result.startResource.id).toBe("observation-broken");
+            });
+            it("should handle empty options", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const result = sdk.walkReferences(observation, {});
+                expect(result).toBeDefined();
+                expect(result.allResources.length).toBeGreaterThan(0);
+            });
+        });
+    });
+    describe("LLM Context Generation", () => {
+        describe("stripNonClinicalData", () => {
+            it("should remove meta field", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    meta: {
+                        lastUpdated: "2023-01-01T00:00:00Z",
+                        versionId: "1",
+                        source: "http://example.com",
+                    },
+                    name: [{ family: "Smith", given: ["John"] }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                expect(cleaned.meta).toBeUndefined();
+                expect(cleaned.name).toEqual([{ family: "Smith", given: ["John"] }]);
+                expect(cleaned.id).toBeUndefined();
+            });
+            it("should remove extension field", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    extension: [
+                        {
+                            url: "http://example.com/extension",
+                            valueString: "some extension",
+                        },
+                    ],
+                    name: [{ family: "Smith", given: ["John"] }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                expect(cleaned.extension).toBeUndefined();
+                expect(cleaned.name).toEqual([{ family: "Smith", given: ["John"] }]);
+            });
+            it("should remove text field", () => {
+                const observation = {
+                    resourceType: "Observation",
+                    id: "obs-123",
+                    status: "final",
+                    code: {
+                        coding: [{ system: "http://loinc.org", code: "12345" }],
+                    },
+                    text: {
+                        status: "generated",
+                        div: "<div>Some narrative</div>",
+                    },
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(observation);
+                expect(cleaned.text).toBeUndefined();
+                expect(cleaned.code).toBeDefined();
+                expect(cleaned.status).toBe("final");
+            });
+            it("should not mutate the original resource", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    meta: {
+                        lastUpdated: "2023-01-01T00:00:00Z",
+                    },
+                    name: [{ family: "Smith", given: ["John"] }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                // Original should be unchanged
+                expect(patient.meta).toBeDefined();
+                expect(patient.id).toBe("patient-123");
+                // Cleaned should have removed them
+                expect(cleaned.meta).toBeUndefined();
+                expect(cleaned.id).toBeUndefined();
+            });
+            it("should handle nested extension fields", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    name: [
+                        {
+                            family: "Smith",
+                            given: ["John"],
+                            extension: [
+                                {
+                                    url: "http://example.com/name-extension",
+                                    valueString: "some value",
+                                },
+                            ],
+                        },
+                    ],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                expect(cleaned.name?.[0]?.extension).toBeUndefined();
+                expect(cleaned.name?.[0]?.family).toBe("Smith");
+            });
+            it("should remove id field", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    name: [{ family: "Smith", given: ["John"] }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                expect(cleaned.id).toBeUndefined();
+                expect(cleaned.name).toEqual([{ family: "Smith", given: ["John"] }]);
+            });
+            it("should remove identifier field", () => {
+                const patient = {
+                    resourceType: "Patient",
+                    id: "patient-123",
+                    identifier: [
+                        {
+                            system: "http://hospital.example.org",
+                            value: "123456",
+                        },
+                    ],
+                    name: [{ family: "Smith", given: ["John"] }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(patient);
+                expect(cleaned.identifier).toBeUndefined();
+                expect(cleaned.name).toEqual([{ family: "Smith", given: ["John"] }]);
+            });
+            it("should remove all reference fields from REFERENCE_METHOD_MAPPING", () => {
+                const observation = {
+                    resourceType: "Observation",
+                    id: "obs-123",
+                    status: "final",
+                    code: {
+                        coding: [{ system: "http://loinc.org", code: "12345" }],
+                    },
+                    subject: { reference: "Patient/patient-123" },
+                    encounter: { reference: "Encounter/encounter-456" },
+                    performer: [{ reference: "Practitioner/practitioner-789" }],
+                    basedOn: [{ reference: "ServiceRequest/sr-001" }],
+                };
+                const cleaned = index_1.FhirBundleSdk.stripNonClinicalData(observation);
+                // All reference fields should be removed
+                expect(cleaned.subject).toBeUndefined();
+                expect(cleaned.encounter).toBeUndefined();
+                expect(cleaned.performer).toBeUndefined();
+                expect(cleaned.basedOn).toBeUndefined();
+                // Clinical data should remain
+                expect(cleaned.status).toBe("final");
+                expect(cleaned.code).toBeDefined();
+            });
+        });
+        describe("generateLLMContext", () => {
+            it("should generate structured text format by default", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const context = sdk.generateLLMContext(observation);
+                expect(context).toContain("PRIMARY RESOURCE:");
+                expect(context).toContain("[Type: Observation");
+                expect(context).toContain("DIRECTLY REFERENCED");
+            });
+            it("should respect maxDepth option", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const context = sdk.generateLLMContext(observation, { maxDepth: 0 });
+                expect(context).toContain("PRIMARY RESOURCE:");
+                expect(context).not.toContain("DIRECTLY REFERENCED");
+            });
+            it("should generate JSON format when specified", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const context = sdk.generateLLMContext(observation, { format: "json" });
+                expect(() => JSON.parse(context)).not.toThrow();
+                const parsed = JSON.parse(context);
+                expect(parsed.primaryResource).toBeDefined();
+                expect(parsed.primaryResource.resourceType).toBe("Observation");
+            });
+            it("should strip non-clinical data from all resources", async () => {
+                const bundleWithMeta = {
+                    resourceType: "Bundle",
+                    type: "collection",
+                    entry: [
+                        {
+                            resource: {
+                                resourceType: "Observation",
+                                id: "obs-with-meta",
+                                status: "final",
+                                code: {
+                                    coding: [{ system: "http://loinc.org", code: "12345" }],
+                                },
+                                meta: {
+                                    lastUpdated: "2023-01-01T00:00:00Z",
+                                },
+                                extension: [
+                                    {
+                                        url: "http://example.com/extension",
+                                        valueString: "test",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                };
+                const sdk = await index_1.FhirBundleSdk.create(bundleWithMeta);
+                const observation = sdk.getObservationById("obs-with-meta");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const context = sdk.generateLLMContext(observation, { format: "json" });
+                const parsed = JSON.parse(context);
+                expect(parsed.primaryResource.meta).toBeUndefined();
+                expect(parsed.primaryResource.extension).toBeUndefined();
+                expect(parsed.primaryResource.code).toBeDefined();
+            });
+            it("should group resources by type at each depth", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const diagnosticReport = sdk.getDiagnosticReportById("diagnostic-report-002");
+                if (diagnosticReport === undefined) {
+                    throw new Error("DiagnosticReport not found");
+                }
+                const context = sdk.generateLLMContext(diagnosticReport, { maxDepth: 2 });
+                // Should have resource type groupings
+                expect(context).toContain("---");
+                expect(context).toMatch(/--- \w+ \(\d+\) ---/);
+            });
+            it("should handle includeStartResource option", async () => {
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                const contextWithStart = sdk.generateLLMContext(observation, {
+                    includeStartResource: true,
+                });
+                const contextWithoutStart = sdk.generateLLMContext(observation, {
+                    includeStartResource: false,
+                });
+                expect(contextWithStart).toContain("PRIMARY RESOURCE:");
+                expect(contextWithoutStart).not.toContain("PRIMARY RESOURCE:");
+                expect(contextWithoutStart).toContain("DIRECTLY REFERENCED");
+            });
+            it("should log resource counts to console", async () => {
+                const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+                const sdk = await index_1.FhirBundleSdk.create(fhir_bundles_1.validCompleteBundle);
+                const observation = sdk.getObservationById("observation-001");
+                if (observation === undefined) {
+                    throw new Error("Observation not found");
+                }
+                sdk.generateLLMContext(observation);
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[LLM Context] Total resources discovered:"));
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[LLM Context] Depth"));
+                consoleSpy.mockRestore();
+            });
+        });
+    });
+});
+//# sourceMappingURL=fhir-bundle-sdk.test.js.map