@medplum/fhir-router 2.0.16 → 2.0.18

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;
@@ -13466,6 +13475,12 @@ spurious results.`);
                 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({
@@ -13524,17 +13539,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;
         }
     }
     /**
@@ -13640,6 +13733,30 @@ spurious results.`);
         }
         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").
@@ -13653,11 +13770,41 @@ spurious results.`);
      */
     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 || core.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.
@@ -13708,6 +13855,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) {
@@ -13774,6 +13953,17 @@ spurious results.`);
     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.