@medplum/fhir-router 2.0.16 → 2.0.17

package/dist/cjs/index.cjs

@@ -55,6 +55,11 @@
             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));
                 }
@@ -158,13 +163,17 @@
         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, core.getReferenceString(resource));
+                    let referenceString = core.getReferenceString(resource);
+                    if (removeResourceType) {
+                        referenceString = core.resolveId({ reference: referenceString });
+                    }
+                    return referenceString ? input.replaceAll(fullUrl, referenceString) : input;
                 }
             }
             return input;
@@ -13524,17 +13533,95 @@ spurious results.`);
         for (const key of Object.keys(properties)) {
             const elementDefinition = core.getElementDefinition(resourceType, key);
             for (const type of elementDefinition.type) {
-                let typeName = type.code;
-                if (typeName === 'Element' || typeName === 'BackboneElement') {
-                    typeName = core.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 = core.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]', core.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 (!core.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 = core.globalSchema.types[fieldTypeName];
+            if (fieldTypeSchema.properties) {
+                for (const fieldKey of Object.keys(fieldTypeSchema.properties)) {
+                    const fieldElementDefinition = core.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]', core.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]', core.capitalize(type.code));
-                fields[propertyName] = fieldConfig;
-            }
+                break;
         }
     }
     /**
@@ -13708,6 +13795,38 @@ spurious results.`);
         }
         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) => core.toJsBoolean(core.evalFhirPathTyped(fhirpath, [core.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) {