Improve handling of null / uncertain boundaries

Author: cmoesel

src/datatypes/interval.ts

@@ -23,6 +23,8 @@ import {
 import { MIN_FLOAT_VALUE } from '../util/limits';
 import { Quantity } from './quantity';
 
+// TODO: Replace all build.fhir.org URL references with stable references once CQL 2.0 is pulished
+
 export class Interval {
   constructor(
     public low: any,
@@ -308,10 +310,15 @@ export class Interval {
       this.pointType === ELM_DATETIME_TYPE ||
       this.pointType === ELM_TIME_TYPE
     ) {
-      const boundaries = [this.low, this.high, other.low, other.high];
-      const leastPreciseBoundary = boundaries.reduce((least, boundary) =>
-        boundary?.isLessPrecise(least) ? boundary : least
+      const boundaries = [this.low, this.high, other.low, other.high].flatMap(boundary =>
+        boundary?.isUncertainty ? [boundary.low, boundary.high] : [boundary]
       );
+      const leastPreciseBoundary = boundaries
+        .filter(boundary => boundary != null)
+        .reduce(
+          (least, boundary) => (least == null || boundary.isLessPrecise(least) ? boundary : least),
+          null
+        );
       precision = leastPreciseBoundary?.getPrecision();
     }
 
@@ -850,16 +857,16 @@ function getQuantityInstanceForMinMax(ivl?: Interval): Quantity | undefined {
 function performConversionIfNecessary(left: Interval, right: Interval) {
   if (left.pointType === ELM_DATE_TYPE && right.pointType === ELM_DATETIME_TYPE) {
     left = new Interval(
-      left.low?.getDateTime(),
-      left.high?.getDateTime(),
+      convertDateBoundaryToDateTime(left.low),
+      convertDateBoundaryToDateTime(left.high),
       left.lowClosed,
       left.highClosed,
       ELM_DATETIME_TYPE
     );
   } else if (left.pointType === ELM_DATETIME_TYPE && right.pointType === ELM_DATE_TYPE) {
     right = new Interval(
-      right.low?.getDateTime(),
-      right.high?.getDateTime(),
+      convertDateBoundaryToDateTime(right.low),
+      convertDateBoundaryToDateTime(right.high),
       right.lowClosed,
       right.highClosed,
       ELM_DATETIME_TYPE
@@ -868,6 +875,14 @@ function performConversionIfNecessary(left: Interval, right: Interval) {
   return [left, right];
 }
 
+function convertDateBoundaryToDateTime(boundary: any) {
+  const convert = (value: any) => value?.getDateTime() ?? value;
+  if (boundary?.isUncertainty) {
+    return new Uncertainty(convert(boundary.low), convert(boundary.high));
+  }
+  return convert(boundary);
+}
+
 function lowestUncertainty(x: any, y: any) {
   if (!x?.isUncertainty) {
     x = new Uncertainty(x);

test/datatypes/interval-test.ts

@@ -1416,6 +1416,46 @@ describe('DateTimeInterval', () => {
       dateTimeIntervalWithBoundlessLow.sameAs(dateIntervalWithBoundlessLow).should.be.true();
     });
 
+    it('should convert uncertain Date interval boundaries to DateTime', () => {
+      const dateLow = Date.parse('2012-01-01');
+      const dateHigh = Date.parse('2012-12-31');
+      const dateTimeLow = DateTime.parse('2012-01-01');
+      const dateTimeHigh = DateTime.parse('2012-12-31');
+      const dateIntervalWithUncertainLow = new Interval(
+        new Uncertainty(dateLow),
+        dateHigh,
+        true,
+        true,
+        ELM_DATE_TYPE
+      );
+      const dateTimeIntervalWithUncertainLow = new Interval(
+        new Uncertainty(dateTimeLow),
+        dateTimeHigh,
+        true,
+        true,
+        ELM_DATETIME_TYPE
+      );
+      const dateIntervalWithUncertainHigh = new Interval(
+        dateLow,
+        new Uncertainty(dateHigh),
+        true,
+        true,
+        ELM_DATE_TYPE
+      );
+      const dateTimeIntervalWithUncertainHigh = new Interval(
+        dateTimeLow,
+        new Uncertainty(dateTimeHigh),
+        true,
+        true,
+        ELM_DATETIME_TYPE
+      );
+
+      dateIntervalWithUncertainLow.sameAs(dateTimeIntervalWithUncertainLow).should.be.true();
+      dateTimeIntervalWithUncertainLow.sameAs(dateIntervalWithUncertainLow).should.be.true();
+      dateIntervalWithUncertainHigh.sameAs(dateTimeIntervalWithUncertainHigh).should.be.true();
+      dateTimeIntervalWithUncertainHigh.sameAs(dateIntervalWithUncertainHigh).should.be.true();
+    });
+
     it('should properly handle boundless and unknown intervals', () => {
       boundlessInterval(ELM_DATETIME_TYPE)
         .sameAs(boundlessInterval(ELM_DATETIME_TYPE))
@@ -1920,6 +1960,30 @@ describe('DateTimeInterval', () => {
         .should.equalInterval(new Interval(x.toMinute.high, y.toDay.high, false, true));
     });
 
+    it('should handle null temporal boundaries when determining precision', () => {
+      const a = new Interval(null, DateTime.parse('2012-12-31'));
+      const b = new Interval(DateTime.parse('2012-06-01'), DateTime.parse('2013-01-01'));
+      a.except(b).should.equalInterval(
+        new Interval(null, DateTime.parse('2012-06-01'), true, false)
+      );
+    });
+
+    it('should handle uncertain temporal boundaries when determining precision', () => {
+      const a = new Interval(
+        new Uncertainty(DateTime.parse('2012-01-01'), DateTime.parse('2012-01-31')),
+        DateTime.parse('2012-12-31')
+      );
+      const b = new Interval(DateTime.parse('2012-06-01'), DateTime.parse('2013-01-01'));
+      a.except(b).should.equalInterval(
+        new Interval(
+          new Uncertainty(DateTime.parse('2012-01-01'), DateTime.parse('2012-01-31')),
+          DateTime.parse('2012-06-01'),
+          true,
+          false
+        )
+      );
+    });
+
     it('should throw when the argument is a point', () => {
       should(() => d.all2012.closed.except(DateTime.parse('2012-07-01T00:00:00.0'))).throw(Error);
     });