@medplum/fhir-router 2.0.15 → 2.0.17

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, 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;
@@ -13522,17 +13531,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;
     }
 }
 /**
@@ -13706,6 +13793,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) {