@medplum/fhir-router 2.0.16 → 2.0.18

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import { OperationOutcomeError, badRequest, normalizeOperationOutcome, parseSearchUrl, getReferenceString, getStatus, isOk, allOk, LRUCache, forbidden, getResourceTypes, getResourceTypeSchema, isResourceTypeSchema, getElementDefinition, buildTypeName, capitalize, getSearchParameters, Operator, parseSearchRequest, notFound, created, deepClone, matchesSearchRequest, globalSchema, evalFhirPath } from '@medplum/core';
+import { OperationOutcomeError, badRequest, normalizeOperationOutcome, parseSearchUrl, getReferenceString, resolveId, getStatus, isOk, allOk, LRUCache, forbidden, getResourceTypes, getResourceTypeSchema, isResourceTypeSchema, getElementDefinition, buildTypeName, capitalize, isLowerCase, globalSchema, getSearchParameters, DEFAULT_SEARCH_COUNT, toJsBoolean, evalFhirPathTyped, toTypedValue, Operator, parseSearchRequest, notFound, created, deepClone, matchesSearchRequest, evalFhirPath } from '@medplum/core';
 import DataLoader from 'dataloader';
 import { applyPatch } from 'rfc6902';
 
@@ -53,6 +53,11 @@ class BatchProcessor {
         const resultEntries = [];
         for (const entry of entries) {
             const rewritten = this.rewriteIdsInObject(entry);
+            // If the resource 'id' element is specified, we want to replace teh `urn:uuid:*` string and
+            // remove the `resourceType` prefix
+            if (entry?.resource?.id) {
+                rewritten.resource.id = this.rewriteIdsInString(entry.resource.id, true);
+            }
             try {
                 resultEntries.push(await this.processBatchEntry(rewritten));
             }
@@ -156,13 +161,17 @@ class BatchProcessor {
     rewriteIdsInObject(input) {
         return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, this.rewriteIds(v)]));
     }
-    rewriteIdsInString(input) {
+    rewriteIdsInString(input, removeResourceType = false) {
         const matches = input.match(/urn:uuid:\w{8}-\w{4}-\w{4}-\w{4}-\w{12}/);
         if (matches) {
             const fullUrl = matches[0];
             const resource = this.ids[fullUrl];
             if (resource) {
-                return input.replaceAll(fullUrl, getReferenceString(resource));
+                let referenceString = getReferenceString(resource);
+                if (removeResourceType) {
+                    referenceString = resolveId({ reference: referenceString });
+                }
+                return referenceString ? input.replaceAll(fullUrl, referenceString) : input;
             }
         }
         return input;
@@ -13464,6 +13473,12 @@ function buildRootSchema() {
             args: buildSearchArgs(resourceType),
             resolve: resolveBySearch,
         };
+        // FHIR GraphQL Connection API
+        fields[resourceType + 'Connection'] = {
+            type: buildConnectionType(resourceType, graphQLType),
+            args: buildSearchArgs(resourceType),
+            resolve: resolveByConnectionApi,
+        };
     }
     return new GraphQLSchema({
         query: new GraphQLObjectType({
@@ -13522,17 +13537,95 @@ function buildPropertyFields(resourceType, fields) {
     for (const key of Object.keys(properties)) {
         const elementDefinition = getElementDefinition(resourceType, key);
         for (const type of elementDefinition.type) {
-            let typeName = type.code;
-            if (typeName === 'Element' || typeName === 'BackboneElement') {
-                typeName = buildTypeName(elementDefinition.path?.split('.'));
+            buildPropertyField(fields, key, elementDefinition, type);
+        }
+    }
+}
+function buildPropertyField(fields, key, elementDefinition, elementDefinitionType) {
+    let typeName = elementDefinitionType.code;
+    if (typeName === 'Element' || typeName === 'BackboneElement') {
+        typeName = buildTypeName(elementDefinition.path?.split('.'));
+    }
+    const fieldConfig = {
+        description: elementDefinition.short,
+        type: getPropertyType(elementDefinition, typeName),
+        resolve: resolveField,
+    };
+    if (elementDefinition.max === '*') {
+        fieldConfig.args = buildListPropertyFieldArgs(typeName);
+    }
+    const propertyName = key.replace('[x]', capitalize(elementDefinitionType.code));
+    fields[propertyName] = fieldConfig;
+}
+/**
+ * Builds field arguments for a list property.
+ *
+ * The FHIR GraphQL specification defines the following arguments for list properties:
+ *   1. _count: Specify how many elements to return from a repeating list.
+ *   2. _offset: Specify the offset to start at for a repeating element.
+ *   3. fhirpath: A FHIRPath statement selecting which of the subnodes is to be included.
+ *   4. All properties of the list element type.
+ *
+ * See: https://hl7.org/fhir/R4/graphql.html#list
+ *
+ * @param fieldTypeName The type name of the field.
+ * @returns The arguments for the field.
+ */
+function buildListPropertyFieldArgs(fieldTypeName) {
+    const fieldArgs = {
+        _count: {
+            type: GraphQLInt,
+            description: 'Specify how many elements to return from a repeating list.',
+        },
+        _offset: {
+            type: GraphQLInt,
+            description: 'Specify the offset to start at for a repeating element.',
+        },
+    };
+    if (!isLowerCase(fieldTypeName.charAt(0))) {
+        // If this is a backbone element, add "fhirpath" and all properties as arguments
+        fieldArgs.fhirpath = {
+            type: GraphQLString,
+            description: 'A FHIRPath statement selecting which of the subnodes is to be included',
+        };
+        // Add all "string" and "code" properties as arguments
+        const fieldTypeSchema = globalSchema.types[fieldTypeName];
+        if (fieldTypeSchema.properties) {
+            for (const fieldKey of Object.keys(fieldTypeSchema.properties)) {
+                const fieldElementDefinition = getElementDefinition(fieldTypeName, fieldKey);
+                for (const type of fieldElementDefinition.type) {
+                    buildListPropertyFieldArg(fieldArgs, fieldKey, fieldElementDefinition, type);
+                }
             }
-            const fieldConfig = {
+        }
+    }
+    return fieldArgs;
+}
+/**
+ * Builds a field argument for a list property.
+ * @param fieldArgs The output argument map.
+ * @param fieldKey The key of the field.
+ * @param elementDefinition The FHIR element definition of the field.
+ * @param elementDefinitionType The FHIR element definition type of the field.
+ */
+function buildListPropertyFieldArg(fieldArgs, fieldKey, elementDefinition, elementDefinitionType) {
+    const baseType = elementDefinitionType.code;
+    const fieldName = fieldKey.replace('[x]', capitalize(baseType));
+    switch (baseType) {
+        case 'canonical':
+        case 'code':
+        case 'id':
+        case 'oid':
+        case 'string':
+        case 'uri':
+        case 'url':
+        case 'uuid':
+        case 'http://hl7.org/fhirpath/System.String':
+            fieldArgs[fieldName] = {
+                type: GraphQLString,
                 description: elementDefinition.short,
-                type: getPropertyType(elementDefinition, typeName),
             };
-            const propertyName = key.replace('[x]', capitalize(type.code));
-            fields[propertyName] = fieldConfig;
-        }
+            break;
     }
 }
 /**
@@ -13638,6 +13731,30 @@ function getPropertyType(elementDefinition, typeName) {
     }
     return graphqlType;
 }
+function buildConnectionType(resourceType, resourceGraphQLType) {
+    return new GraphQLObjectType({
+        name: resourceType + 'Connection',
+        fields: {
+            count: { type: GraphQLInt },
+            offset: { type: GraphQLInt },
+            pageSize: { type: GraphQLInt },
+            first: { type: GraphQLString },
+            previous: { type: GraphQLString },
+            next: { type: GraphQLString },
+            last: { type: GraphQLString },
+            edges: {
+                type: new GraphQLList(new GraphQLObjectType({
+                    name: resourceType + 'ConnectionEdge',
+                    fields: {
+                        mode: { type: GraphQLString },
+                        score: { type: GraphQLFloat },
+                        resource: { type: resourceGraphQLType },
+                    },
+                })),
+            },
+        },
+    });
+}
 /**
  * GraphQL data loader for search requests.
  * The field name should always end with "List" (i.e., "Patient" search uses "PatientList").
@@ -13651,11 +13768,41 @@ function getPropertyType(elementDefinition, typeName) {
  */
 async function resolveBySearch(source, args, ctx, info) {
     const fieldName = info.fieldName;
-    const resourceType = fieldName.substring(0, fieldName.length - 4); // Remove "List"
+    const resourceType = fieldName.substring(0, fieldName.length - 'List'.length);
     const searchRequest = parseSearchArgs(resourceType, source, args);
     const bundle = await ctx.repo.search(searchRequest);
     return bundle.entry?.map((e) => e.resource);
 }
+/**
+ * GraphQL data loader for search requests.
+ * The field name should always end with "List" (i.e., "Patient" search uses "PatientList").
+ * The search args should be FHIR search parameters.
+ * @param source The source/root.  This should always be null for our top level readers.
+ * @param args The GraphQL search arguments.
+ * @param ctx The GraphQL context.
+ * @param info The GraphQL resolve info.  This includes the schema, and additional field details.
+ * @returns Promise to read the resoures for the query.
+ * @implements {GraphQLFieldResolver}
+ */
+async function resolveByConnectionApi(source, args, ctx, info) {
+    const fieldName = info.fieldName;
+    const resourceType = fieldName.substring(0, fieldName.length - 'Connection'.length);
+    const searchRequest = parseSearchArgs(resourceType, source, args);
+    if (isFieldRequested(info, 'count')) {
+        searchRequest.total = 'accurate';
+    }
+    const bundle = await ctx.repo.search(searchRequest);
+    return {
+        count: bundle.total,
+        offset: searchRequest.offset || 0,
+        pageSize: searchRequest.count || DEFAULT_SEARCH_COUNT,
+        edges: bundle.entry?.map((e) => ({
+            mode: e.search?.mode,
+            score: e.search?.score,
+            resource: e.resource,
+        })),
+    };
+}
 /**
  * GraphQL data loader for ID requests.
  * The field name should always by the resource type.
@@ -13706,6 +13853,38 @@ function resolveTypeByReference(resource) {
     }
     return getGraphQLType(resourceType).name;
 }
+/**
+ * GraphQL resolver for fields.
+ * In the common case, this is just a matter of returning the field value from the source object.
+ * If the field is a list and the user specifies list arguments, then we can apply those arguments here.
+ * @param source The source. This is the object that contains the field.
+ * @param args The GraphQL search arguments.
+ * @param _ctx The GraphQL context.
+ * @param info The GraphQL resolve info.  This includes the field name.
+ * @returns Promise to read the resoure for the query.
+ * @implements {GraphQLFieldResolver}
+ */
+async function resolveField(source, args, _ctx, info) {
+    const fieldValue = source?.[info.fieldName];
+    if (!args || !fieldValue) {
+        return fieldValue;
+    }
+    const { _offset, _count, fhirpath, ...rest } = args;
+    let array = fieldValue;
+    for (const [key, value] of Object.entries(rest)) {
+        array = array.filter((item) => item[key] === value);
+    }
+    if (fhirpath) {
+        array = array.filter((item) => toJsBoolean(evalFhirPathTyped(fhirpath, [toTypedValue(item)])));
+    }
+    if (_offset) {
+        array = array.slice(_offset);
+    }
+    if (_count) {
+        array = array.slice(0, _count);
+    }
+    return array;
+}
 function parseSearchArgs(resourceType, source, args) {
     let referenceFilter = undefined;
     if (source) {
@@ -13772,6 +13951,17 @@ const MaxDepthRule = (context) => ({
 function getDepth(path) {
     return path.filter((p) => p === 'selections').length;
 }
+/**
+ * Returns true if the field is requested in the GraphQL query.
+ * @param info The GraphQL resolve info.  This includes the field name.
+ * @param fieldName The field name to check.
+ * @returns True if the field is requested in the GraphQL query.
+ */
+function isFieldRequested(info, fieldName) {
+    return info.fieldNodes.some((fieldNode) => fieldNode.selectionSet?.selections.some((selection) => {
+        return selection.kind === 'Field' && selection.name.value === fieldName;
+    }));
+}
 /**
  * Returns an OperationOutcome for GraphQL errors.
  * @param errors Array of GraphQL errors.