Preserve declared temporal sub-intervals during auto-extent calculation

The automatic temporal extent feature (#999) replaced a collection's entire
extent.temporal.interval array with a single computed interval whenever the
overall extent needed backfilling, discarding any declared sub-intervals
(interval[1..n]). Only compute the overall extent (interval[0]) from items and
preserve declared sub-intervals. Adds a regression test covering a collection
with multiple intervals.

Author: jkeifer

CHANGELOG.md

@@ -8,6 +8,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [Unreleased]
 
 ### Fixed
+- Automatic temporal extent calculation no longer discards a collection's declared
+  temporal sub-intervals. Only the overall extent (`interval[0]`) is computed from
+  items; any finer-grained sub-intervals (`interval[1..n]`) declared on the
+  collection are now preserved instead of being overwritten with a single computed
+  interval. ([1155](https://github.com/stac-utils/stac-server/pull/1155))
 - Post-ingest SNS notifications now report `ingestStatus` as `failed` for any
   ingest error, including errors whose message is empty. Previously the status
   was derived from the truthiness of the error message, so an empty-message

src/lib/api.ts

@@ -1052,16 +1052,23 @@ const populateTemporalExtentIfMissing = async (
   backend: Backend,
   collection: StacCollection
 ): Promise<void> => {
-  const [start, end] = collection.extent?.temporal?.interval?.[0] ?? [null, null]
+  const intervals = collection.extent?.temporal?.interval
+  const [start, end] = intervals?.[0] ?? [null, null]
 
-  // Nothing to do when both bounds are already declared.
+  // Nothing to do when both bounds of the overall extent are already declared.
   if (start != null && end != null) return
 
   const temporalExtent = await backend.getTemporalExtentFromItems(collection.id)
   if (temporalExtent && collection.extent?.temporal) {
     const [computedStart, computedEnd] = temporalExtent[0]
-    // Preserve any declared bound; only fill the missing one(s) from items.
-    collection.extent.temporal.interval = [[start ?? computedStart, end ?? computedEnd]]
+    // Only the overall extent (interval[0]) is computed from items; any declared
+    // sub-intervals (interval[1..n]) are preserved, as is any bound already set
+    // on the overall extent.
+    const rest = intervals?.slice(1) ?? []
+    collection.extent.temporal.interval = [
+      [start ?? computedStart, end ?? computedEnd],
+      ...rest
+    ]
   }
 }
 

tests/system/test-api-temporal-extent.ts

@@ -156,3 +156,67 @@ test('Collection with no items has null temporal extent', async (t) => {
   // but our code should gracefully handle this (return null or keep original)
   t.truthy(response.body.extent)
 })
+
+test('Declared sub-intervals are preserved when the overall extent is computed', async (t) => {
+  // A collection whose overall extent (interval[0]) has a missing end, plus two
+  // declared finer-grained sub-intervals (interval[1..n]). Only the overall
+  // extent should be filled from items; the sub-intervals must survive.
+  const multiIntervalId = randomId('multi-interval-collection')
+  const multiIntervalCollection = await loadFixture(
+    'landsat-8-l1-collection.json',
+    {
+      id: multiIntervalId,
+      extent: {
+        spatial: { bbox: [[-180, -90, 180, 90]] },
+        temporal: {
+          interval: [
+            ['2013-06-01T00:00:00Z', null],
+            ['2015-01-01T00:00:00Z', '2016-01-01T00:00:00Z'],
+            ['2018-01-01T00:00:00Z', '2019-01-01T00:00:00Z']
+          ]
+        }
+      }
+    }
+  )
+
+  await ingestItem({
+    ingestQueueUrl: t.context.ingestQueueUrl,
+    ingestTopicArn: t.context.ingestTopicArn,
+    item: multiIntervalCollection
+  })
+
+  // Give the collection an item so the overall extent's missing end is computed.
+  const item = await loadFixture('stac/LC80100102015050LGN00.json', {
+    collection: multiIntervalId,
+    id: randomId('item'),
+    properties: {
+      datetime: '2020-06-15T10:30:00.000Z'
+    }
+  })
+
+  await ingestItem({
+    ingestQueueUrl: t.context.ingestQueueUrl,
+    ingestTopicArn: t.context.ingestTopicArn,
+    item
+  })
+
+  await refreshIndices()
+
+  const response = await t.context.api.client.get(`collections/${multiIntervalId}`,
+    { resolveBodyOnly: false })
+
+  t.is(response.statusCode, 200)
+  t.is(response.body.id, multiIntervalId)
+
+  const { interval } = response.body.extent.temporal
+
+  // All three intervals must remain — the sub-intervals are not discarded.
+  t.is(interval.length, 3)
+
+  // Overall extent: declared start preserved, missing end computed from items.
+  t.deepEqual(interval[0], ['2013-06-01T00:00:00Z', '2020-06-15T10:30:00.000Z'])
+
+  // Declared sub-intervals are untouched.
+  t.deepEqual(interval[1], ['2015-01-01T00:00:00Z', '2016-01-01T00:00:00Z'])
+  t.deepEqual(interval[2], ['2018-01-01T00:00:00Z', '2019-01-01T00:00:00Z'])
+})