GQL-118: Add support for retrieving a collection revision

src/datasources/collection.js

@@ -10,7 +10,61 @@ import { findPreviousRevision } from '../utils/findPreviousRevision'
 export const fetchCollections = async (params, context, parsedInfo) => {
   const { headers } = context
 
-  const requestInfo = parseRequestedFields(parsedInfo, collectionKeyMap, 'collection')
+  const { revisionId, conceptId } = params
+
+  // If a specific revisionId is requested, fetch all revisions and filter
+  if (revisionId) {
+    const allRevisionsParams = {
+      ...params,
+      allRevisions: true
+    }
+
+    // Parse requested fields - this determines which fields to fetch
+    const requestInfo = parseRequestedFields(parsedInfo, collectionKeyMap, 'collection', allRevisionsParams)
+
+    // Ensure revisionId is included in the requested fields so we can filter by it
+    const { ummKeys } = requestInfo
+    if (!ummKeys.includes('revisionId')) {
+      ummKeys.push('revisionId')
+    }
+
+    const collection = new Collection(headers, requestInfo, allRevisionsParams)
+
+    // Query CMR for all revisions
+    collection.fetch(allRevisionsParams)
+
+    // Parse the response from CMR
+    await collection.parse(requestInfo)
+
+    // Get all items and filter for the specific revision
+    const allItems = collection.getFormattedResponse()
+
+    // Convert revisionId to string for comparison since CMR returns it as a string
+    const requestedRevisionIdStr = String(revisionId)
+
+    // For a single collection query with revisionId, return just that revision
+    const specificRevision = allItems.find((item) => (
+      String(item.revisionId) === requestedRevisionIdStr
+    ))
+
+    if (!specificRevision) {
+      // Check if the revision exists but is too old (CMR only keeps last 10)
+      const latestRevisionId = allItems.length > 0 ? parseInt(allItems[0].revisionId, 10) : 0
+      const oldestAvailableRevision = Math.max(1, latestRevisionId - 9)
+      const requestedRevisionId = parseInt(revisionId, 10)
+
+      if (requestedRevisionId < oldestAvailableRevision) {
+        throw new Error(`Revision ${revisionId} is no longer stored. Please select an available revision from ${oldestAvailableRevision} to ${latestRevisionId}.`)
+      }
+
+      throw new Error(`Revision ${revisionId} not found for collection ${conceptId}. Available revisions: ${allItems.map((item) => item.revisionId).join(', ')}`)
+    }
+
+    return [specificRevision]
+  }
+
+  // Normal case: no revisionId specified, return latest revision
+  const requestInfo = parseRequestedFields(parsedInfo, collectionKeyMap, 'collection', params)
 
   const collection = new Collection(headers, requestInfo, params)
 

src/resolvers/collection.js

@@ -17,7 +17,58 @@ export default {
     collection: async (source, args, context, info) => {
       const { dataSources } = context
 
-      const result = await dataSources.collectionSourceFetch(args, context, parseResolveInfo(info))
+      // Support both old deprecated syntax (conceptId directly) and new syntax (params object)
+      // Old: collection(conceptId: "C123")
+      // New: collection(params: { conceptId: "C123" })
+      const params = args.params || args
+      const { revisionId } = params
+
+      // Fields that are only available from JSON endpoint and cannot be retrieved for old revisions
+      const jsonOnlyFields = [
+        'archiveCenter',
+        'boxes',
+        'browseFlag',
+        'cloudHosted',
+        'consortiums',
+        'coordinateSystem',
+        'datasetId',
+        'hasGranules',
+        'lines',
+        'onlineAccessFlag',
+        'organizations',
+        'points',
+        'polygons',
+        'revisions',
+        'tagDefinitions',
+        'tags',
+        'timeEnd',
+        'timeStart'
+      ]
+
+      // If querying a specific revision, check if any JSON-only fields are requested
+      if (revisionId) {
+        const parsedInfo = parseResolveInfo(info)
+        const { fieldsByTypeName } = parsedInfo
+        const { Collection: collectionFields = {} } = fieldsByTypeName
+
+        const requestedFields = Object.keys(collectionFields)
+        const requestedJsonOnlyFields = requestedFields.filter(
+          (field) => jsonOnlyFields.includes(field)
+        )
+
+        if (requestedJsonOnlyFields.length > 0) {
+          throw new Error(
+            `The following fields are not available when querying a specific revision: ${requestedJsonOnlyFields.join(', ')}. `
+            + 'These fields are only available from the JSON endpoint which does not support historical revisions.'
+          )
+        }
+      }
+
+      const result = await dataSources.collectionSourceFetch(
+        params,
+        context,
+        parseResolveInfo(info)
+      )
 
       const [firstResult] = result
 

src/types/collection.graphql

@@ -882,6 +882,9 @@ input CollectionInput {
   "The unique concept id assigned to the collection."
   conceptId: String!
 
+  "The revision id of the Collection."
+  revisionId: String
+
   "If this parameter is set to 'true' this will include a flag indicating true or false if the collection has any granules at all."
   includeHasGranules: Boolean
 

src/utils/parseRequestedFields.js

@@ -10,8 +10,9 @@ import { CONCEPT_TYPES, PSEUDO_FIELDS } from '../constants'
  * @param {Array} requestedFields Fields requested
  * @param {Object} keyMap Mappings of UMM fields to requestable fields
  * @param {String} conceptName Name of the concept () to lookup requested fields in the query
+ * @param {Object} params Query parameters that may affect key routing
  */
-export const parseRequestedFields = (parsedInfo, keyMap, conceptName) => {
+export const parseRequestedFields = (parsedInfo, keyMap, conceptName, params = {}) => {
   let { fieldsByTypeName } = parsedInfo
 
   const { name } = parsedInfo
@@ -236,7 +237,10 @@ export const parseRequestedFields = (parsedInfo, keyMap, conceptName) => {
   ))
 
   // If all requested keys are available in json, use json because its all indexed in CMR
-  if (difference(ummKeys, sharedKeys).length === 0) {
+  // UNLESS allRevisions=true, in which case JSON endpoint doesn't support it
+  const { allRevisions } = params
+
+  if (difference(ummKeys, sharedKeys).length === 0 && !allRevisions) {
     return {
       jsonKeys: requestedFields,
       metaKeys,
@@ -247,12 +251,29 @@ export const parseRequestedFields = (parsedInfo, keyMap, conceptName) => {
   }
 
   // Requested keys that are not UMM and not CONCEPT_TYPES keys must be json
-  const jsonKeys = requestedFields.filter((field) => (
+  let jsonKeys = requestedFields.filter((field) => (
     !ummKeys.includes(field)
     && !CONCEPT_TYPES.includes(field)
     && !PSEUDO_FIELDS.includes(field)
   ))
 
+  // When allRevisions=true, ALL data must come from UMM endpoint (JSON endpoint doesn't support it)
+  // Check if any JSON-only fields were requested and throw an error
+  if (allRevisions && jsonKeys.length > 0) {
+    const jsonOnlyFields = jsonKeys.filter((field) => !sharedKeys.includes(field))
+
+    if (jsonOnlyFields.length > 0) {
+      throw new Error(
+        `The following fields are not available when querying with allRevisions: ${jsonOnlyFields.join(', ')}. `
+        + 'These fields are only available from the JSON endpoint which does not support historical revisions.'
+      )
+    }
+
+    // If only shared keys are in jsonKeys, move them to ummKeys for allRevisions queries
+    ummKeys = [...ummKeys, ...jsonKeys]
+    jsonKeys = []
+  }
+
   // If we already have to go to the json endpoint get as much info from there as possible
   if (jsonKeys.length > 0) {
     // Move any requested key that is shared over to the jsonKeys
@@ -267,8 +288,16 @@ export const parseRequestedFields = (parsedInfo, keyMap, conceptName) => {
   }
 
   // If facets were requested, we need to ensure we have at least 1 json key
-  // some do because facets are not available from the umm endpoint
+  // because facets are not available from the umm endpoint
+  // However, if allRevisions=true, we cannot use the JSON endpoint at all
   if (metaKeys.includes('collectionFacets') && jsonKeys.length === 0) {
+    if (allRevisions) {
+      throw new Error(
+        'Facets are not available when querying with allRevisions. '
+        + 'Facets are only available from the JSON endpoint which does not support historical revisions.'
+      )
+    }
+
     jsonKeys.push('conceptId')
 
     // Remove the concept id from the ummKeys (if it exists) because we just moved it to the jsonKeys

src/utils/umm/collectionKeyMap.json

@@ -8,6 +8,7 @@
     "hasTransforms",
     "hasVariables",
     "processingLevelId",
+    "provider",
     "shortName",
     "title",
     "versionId"
@@ -52,6 +53,7 @@
     "processingLevel": "umm.ProcessingLevel",
     "processingLevelId": "umm.ProcessingLevel.Id",
     "projects": "umm.Projects",
+    "provider": "meta.provider-id",
     "providerId": "meta.provider-id",
     "publicationReferences": "umm.PublicationReferences",
     "purpose": "umm.Purpose",