@medplum/fhir-router 2.0.21 → 2.0.23

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-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 { OperationOutcomeError, badRequest, normalizeOperationOutcome, parseSearchUrl, getReferenceString, resolveId, getStatus, isOk, allOk, Operator, parseSearchRequest, getSearchParameters, getResourceTypeSchema, isResourceType, getElementDefinition, buildTypeName, capitalize, getResourceTypes, isResourceTypeSchema, isLowerCase, globalSchema, toJsBoolean, evalFhirPathTyped, toTypedValue, LRUCache, forbidden, DEFAULT_SEARCH_COUNT, notFound, created, deepClone, matchesSearchRequest, evalFhirPath } from '@medplum/core';
 import DataLoader from 'dataloader';
 import { applyPatch } from 'rfc6902';
 
@@ -6,7 +6,6 @@ import { applyPatch } from 'rfc6902';
  * Processes a FHIR batch request.
  *
  * See: https://www.hl7.org/fhir/http.html#transaction
- *
  * @param router The FHIR router.
  * @param repo The FHIR repository.
  * @param bundle The input bundle.
@@ -34,8 +33,6 @@ class BatchProcessor {
     }
     /**
      * Processes a FHIR batch request.
-     * @param repo The FHIR repository.
-     * @param bundle The input bundle.
      * @returns The bundle response.
      */
     async processBatch() {
@@ -13376,131 +13373,202 @@ const typeCache = {
     'http://hl7.org/fhirpath/System.String': GraphQLString,
     'http://hl7.org/fhirpath/System.Time': GraphQLString,
 };
+function parseSearchArgs(resourceType, source, args) {
+    let referenceFilter = undefined;
+    if (source) {
+        // _reference is a required field for reverse lookup searches
+        // The GraphQL parser will validate that it is there.
+        const reference = args['_reference'];
+        delete args['_reference'];
+        referenceFilter = {
+            code: reference,
+            operator: Operator.EQUALS,
+            value: getReferenceString(source),
+        };
+    }
+    // Reverse the transform of dashes to underscores, back to dashes
+    args = Object.fromEntries(Object.entries(args).map(([key, value]) => [graphQLFieldToFhirParam(key), value]));
+    // Parse the search request
+    const searchRequest = parseSearchRequest(resourceType, args);
+    // If a reverse lookup filter was specified,
+    // add it to the search request.
+    if (referenceFilter) {
+        const existingFilters = searchRequest.filters || [];
+        searchRequest.filters = [referenceFilter, ...existingFilters];
+    }
+    return searchRequest;
+}
+function graphQLFieldToFhirParam(code) {
+    return code.startsWith('_') ? code : code.replaceAll('_', '-');
+}
+function fhirParamToGraphQLField(code) {
+    return code.replaceAll('-', '_');
+}
 /**
- * Cache of "introspection" query results.
- * Common case is the standard schema query from GraphiQL and Insomnia.
- * The result is big and somewhat computationally expensive.
+ * 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.
  */
-const introspectionResults = new LRUCache();
+async function resolveBySearch(source, args, ctx, info) {
+    const fieldName = info.fieldName;
+    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);
+}
+function buildSearchArgs(resourceType) {
+    const args = {
+        _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.',
+        },
+        _sort: {
+            type: GraphQLString,
+            description: 'Specify the sort order by comma-separated list of sort rules in priority order.',
+        },
+        _id: {
+            type: GraphQLString,
+            description: 'Select resources based on the logical id of the resource.',
+        },
+        _lastUpdated: {
+            type: GraphQLString,
+            description: 'Select resources based on the last time they were changed.',
+        },
+    };
+    const searchParams = getSearchParameters(resourceType);
+    if (searchParams) {
+        for (const [code, searchParam] of Object.entries(searchParams)) {
+            // GraphQL does not support dashes in argument names
+            // So convert dashes to underscores
+            args[fhirParamToGraphQLField(code)] = {
+                type: GraphQLString,
+                description: searchParam.description,
+            };
+        }
+    }
+    return args;
+}
 /**
- * Cached GraphQL schema.
- * This should be initialized at server startup.
+ * Returns the depth of the GraphQL node in a query.
+ * We use "selections" as the representation of depth.
+ * As a rough approximation, it's the number of indentations in a well formatted query.
+ * @param path The GraphQL node path.
+ * @returns The "depth" of the node.
  */
-let rootSchema;
+function getDepth(path) {
+    return path.filter((p) => p === 'selections').length;
+}
 /**
- * Handles FHIR GraphQL requests.
- *
- * See: https://www.hl7.org/fhir/graphql.html
+ * 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.
  */
-async function graphqlHandler(req, repo) {
-    const { query, operationName, variables } = req.body;
-    if (!query) {
-        return [badRequest('Must provide query.')];
-    }
-    let document;
-    try {
-        document = parse(query);
-    }
-    catch (err) {
-        return [badRequest('GraphQL syntax error.')];
-    }
-    const schema = getRootSchema();
-    const validationRules = [...specifiedRules, MaxDepthRule];
-    const validationErrors = validate(schema, document, validationRules);
-    if (validationErrors.length > 0) {
-        return [invalidRequest(validationErrors)];
-    }
-    const introspection = isIntrospectionQuery(query);
-    if (introspection) {
-        return [forbidden];
-    }
-    const dataLoader = new DataLoader((keys) => repo.readReferences(keys));
-    let result = introspection && introspectionResults.get(query);
-    if (!result) {
-        result = await execute({
-            schema,
-            document,
-            contextValue: { repo, dataLoader },
-            operationName,
-            variableValues: variables,
-        });
-    }
-    return [allOk, result];
+function isFieldRequested(info, fieldName) {
+    return info.fieldNodes.some((fieldNode) => fieldNode.selectionSet?.selections.some((selection) => {
+        return selection.kind === 'Field' && selection.name.value === fieldName;
+    }));
 }
 /**
- * Returns true if the query is a GraphQL introspection query.
- *
- * Introspection queries ask for the schema, which is expensive.
- *
- * See: https://graphql.org/learn/introspection/
- *
- * @param query The GraphQL query.
- * @returns True if the query is an introspection query.
+ * Returns an OperationOutcome for GraphQL errors.
+ * @param errors Array of GraphQL errors.
+ * @returns OperationOutcome with the GraphQL errors as OperationOutcome issues.
  */
-function isIntrospectionQuery(query) {
-    return query.includes('query IntrospectionQuery') || query.includes('__schema') || query.includes('__type');
+function invalidRequest(errors) {
+    return {
+        resourceType: 'OperationOutcome',
+        issue: errors.map((error) => ({
+            severity: 'error',
+            code: 'invalid',
+            details: { text: error.message },
+        })),
+    };
 }
-function getRootSchema() {
-    if (!rootSchema) {
-        rootSchema = buildRootSchema();
+
+const inputTypeCache = {
+    ...typeCache,
+};
+function getGraphQLInputType(inputType, nameSuffix) {
+    let result = inputTypeCache[inputType];
+    if (!result) {
+        result = buildGraphQLInputType(inputType, nameSuffix);
+        inputTypeCache[inputType] = result;
     }
-    return rootSchema;
+    return result;
 }
-function buildRootSchema() {
-    // First, create placeholder types
-    // We need this first for circular dependencies
-    for (const resourceType of getResourceTypes()) {
-        typeCache[resourceType] = buildGraphQLType(resourceType);
-    }
-    // Next, fill in all of the type properties
+function buildGraphQLInputType(resourceType, nameSuffix) {
+    const schema = getResourceTypeSchema(resourceType);
+    return new GraphQLInputObjectType({
+        name: resourceType + nameSuffix,
+        description: schema.description,
+        fields: () => buildGraphQLInputFields(resourceType, nameSuffix),
+    });
+}
+function buildGraphQLInputFields(resourceType, nameSuffix) {
     const fields = {};
-    for (const resourceType of getResourceTypes()) {
-        const graphQLType = getGraphQLType(resourceType);
-        // Get resource by ID
-        fields[resourceType] = {
-            type: graphQLType,
-            args: {
-                id: {
-                    type: new GraphQLNonNull(GraphQLID),
-                    description: resourceType + ' ID',
-                },
-            },
-            resolve: resolveById,
-        };
-        // Search resource by search parameters
-        fields[resourceType + 'List'] = {
-            type: new GraphQLList(graphQLType),
-            args: buildSearchArgs(resourceType),
-            resolve: resolveBySearch,
-        };
-        // FHIR GraphQL Connection API
-        fields[resourceType + 'Connection'] = {
-            type: buildConnectionType(resourceType, graphQLType),
-            args: buildSearchArgs(resourceType),
-            resolve: resolveByConnectionApi,
+    // Add resourceType field for root resource
+    if (isResourceType(resourceType)) {
+        const propertyFieldConfig = {
+            description: 'The type of resource',
+            type: GraphQLString,
         };
+        fields['resourceType'] = propertyFieldConfig;
     }
-    return new GraphQLSchema({
-        query: new GraphQLObjectType({
-            name: 'QueryType',
-            fields,
-        }),
-    });
+    buildInputPropertyFields(resourceType, fields, nameSuffix);
+    return fields;
+}
+function buildInputPropertyFields(resourceType, fields, nameSuffix) {
+    const schema = getResourceTypeSchema(resourceType);
+    const properties = schema.properties;
+    for (const key of Object.keys(properties)) {
+        const elementDefinition = getElementDefinition(resourceType, key);
+        for (const type of elementDefinition.type) {
+            buildInputPropertyField(fields, key, elementDefinition, type, nameSuffix);
+        }
+    }
+}
+function buildInputPropertyField(fields, key, elementDefinition, elementDefinitionType, nameSuffix) {
+    let typeName = elementDefinitionType.code;
+    if (typeName === 'Element' || typeName === 'BackboneElement') {
+        typeName = buildTypeName(elementDefinition.path?.split('.'));
+    }
+    const fieldConfig = {
+        description: elementDefinition.short,
+        type: getGraphQLInputType(typeName, nameSuffix),
+    };
+    if (elementDefinition.max === '*') {
+        fieldConfig.type = new GraphQLList(getGraphQLInputType(typeName, nameSuffix));
+    }
+    const propertyName = key.replace('[x]', capitalize(elementDefinitionType.code));
+    fields[propertyName] = fieldConfig;
 }
-function getGraphQLType(resourceType) {
-    let result = typeCache[resourceType];
+
+const outputTypeCache = {
+    ...typeCache,
+};
+function getGraphQLOutputType(inputType) {
+    let result = outputTypeCache[inputType];
     if (!result) {
-        result = buildGraphQLType(resourceType);
-        typeCache[resourceType] = result;
+        result = buildGraphQLOutputType(inputType);
+        outputTypeCache[inputType] = result;
     }
     return result;
 }
-function buildGraphQLType(resourceType) {
+function buildGraphQLOutputType(resourceType) {
     if (resourceType === 'ResourceList') {
         return new GraphQLUnionType({
             name: 'ResourceList',
             types: () => getResourceTypes()
-                .map(getGraphQLType)
+                .map(getGraphQLOutputType)
                 .filter((t) => !!t),
             resolveType: resolveTypeByReference,
         });
@@ -13509,16 +13577,16 @@ function buildGraphQLType(resourceType) {
     return new GraphQLObjectType({
         name: resourceType,
         description: schema.description,
-        fields: () => buildGraphQLFields(resourceType),
+        fields: () => buildGraphQLOutputFields(resourceType),
     });
 }
-function buildGraphQLFields(resourceType) {
+function buildGraphQLOutputFields(resourceType) {
     const fields = {};
-    buildPropertyFields(resourceType, fields);
+    buildOutputPropertyFields(resourceType, fields);
     buildReverseLookupFields(resourceType, fields);
     return fields;
 }
-function buildPropertyFields(resourceType, fields) {
+function buildOutputPropertyFields(resourceType, fields) {
     const schema = getResourceTypeSchema(resourceType);
     const properties = schema.properties;
     if (isResourceTypeSchema(schema)) {
@@ -13530,25 +13598,25 @@ function buildPropertyFields(resourceType, fields) {
     if (resourceType === 'Reference') {
         fields.resource = {
             description: 'Reference',
-            type: getGraphQLType('ResourceList'),
+            type: getGraphQLOutputType('ResourceList'),
             resolve: resolveByReference,
         };
     }
     for (const key of Object.keys(properties)) {
         const elementDefinition = getElementDefinition(resourceType, key);
         for (const type of elementDefinition.type) {
-            buildPropertyField(fields, key, elementDefinition, type);
+            buildOutputPropertyField(fields, key, elementDefinition, type);
         }
     }
 }
-function buildPropertyField(fields, key, elementDefinition, elementDefinitionType) {
+function buildOutputPropertyField(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),
+        type: getOutputPropertyType(elementDefinition, typeName),
         resolve: resolveField,
     };
     if (elementDefinition.max === '*') {
@@ -13567,7 +13635,6 @@ function buildPropertyField(fields, key, elementDefinition, elementDefinitionTyp
  *   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.
  */
@@ -13652,13 +13719,12 @@ function buildListPropertyFieldArg(fieldArgs, fieldKey, elementDefinition, eleme
  * (except that the "id" argument is prohibited here as nonsensical).
  *
  * See: https://www.hl7.org/fhir/graphql.html#reverse
- *
  * @param resourceType The resource type to build fields for.
  * @param fields The fields object to add fields to.
  */
 function buildReverseLookupFields(resourceType, fields) {
     for (const childResourceType of getResourceTypes()) {
-        const childGraphQLType = getGraphQLType(childResourceType);
+        const childGraphQLType = getGraphQLOutputType(childResourceType);
         const childSearchParams = getSearchParameters(childResourceType);
         const enumValues = {};
         let count = 0;
@@ -13688,49 +13754,236 @@ function buildReverseLookupFields(resourceType, fields) {
         }
     }
 }
-function buildSearchArgs(resourceType) {
-    const args = {
-        _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.',
-        },
-        _sort: {
-            type: GraphQLString,
-            description: 'Specify the sort order by comma-separated list of sort rules in priority order.',
-        },
-        _id: {
-            type: GraphQLString,
-            description: 'Select resources based on the logical id of the resource.',
-        },
-        _lastUpdated: {
-            type: GraphQLString,
-            description: 'Select resources based on the last time they were changed.',
-        },
-    };
-    const searchParams = getSearchParameters(resourceType);
-    if (searchParams) {
-        for (const [code, searchParam] of Object.entries(searchParams)) {
-            // GraphQL does not support dashes in argument names
-            // So convert dashes to underscores
-            args[fhirParamToGraphQLField(code)] = {
-                type: GraphQLString,
-                description: searchParam.description,
-            };
-        }
-    }
-    return args;
-}
-function getPropertyType(elementDefinition, typeName) {
-    const graphqlType = getGraphQLType(typeName);
+function getOutputPropertyType(elementDefinition, typeName) {
+    const graphqlType = getGraphQLOutputType(typeName);
     if (elementDefinition.max === '*') {
         return new GraphQLList(graphqlType);
     }
     return graphqlType;
 }
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * GraphQL data loader for Reference requests.
+ * This is a special data loader for following Reference objects.
+ * @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.
+ * @returns Promise to read the resoure(s) for the query.
+ */
+async function resolveByReference(source, _args, ctx) {
+    try {
+        return await ctx.dataLoader.load(source);
+    }
+    catch (err) {
+        throw new OperationOutcomeError(normalizeOperationOutcome(err), err);
+    }
+}
+/**
+ * GraphQL type resolver for resources.
+ * When loading a resource via reference, GraphQL needs to know the type of the resource.
+ * @param resource The loaded resource.
+ * @returns The GraphQL type of the resource.
+ */
+function resolveTypeByReference(resource) {
+    const resourceType = resource?.resourceType;
+    if (!resourceType) {
+        return undefined;
+    }
+    return getGraphQLOutputType(resourceType).name;
+}
+
+/**
+ * Cache of "introspection" query results.
+ * Common case is the standard schema query from GraphiQL and Insomnia.
+ * The result is big and somewhat computationally expensive.
+ */
+const introspectionResults = new LRUCache();
+/**
+ * Cached GraphQL schema.
+ * This should be initialized at server startup.
+ */
+let rootSchema;
+/**
+ * Handles FHIR GraphQL requests.
+ *
+ * See: https://www.hl7.org/fhir/graphql.html
+ * @param req The request details.
+ * @param repo The current user FHIR repository.
+ * @param router The router for router options.
+ * @returns The response.
+ */
+async function graphqlHandler(req, repo, router) {
+    const { query, operationName, variables } = req.body;
+    if (!query) {
+        return [badRequest('Must provide query.')];
+    }
+    let document;
+    try {
+        document = parse(query);
+    }
+    catch (err) {
+        return [badRequest('GraphQL syntax error.')];
+    }
+    const schema = getRootSchema();
+    const validationRules = [...specifiedRules, MaxDepthRule];
+    const validationErrors = validate(schema, document, validationRules);
+    if (validationErrors.length > 0) {
+        return [invalidRequest(validationErrors)];
+    }
+    const introspection = isIntrospectionQuery(query);
+    if (introspection && !router.options?.introspectionEnabled) {
+        return [forbidden];
+    }
+    const dataLoader = new DataLoader((keys) => repo.readReferences(keys));
+    let result = introspection && introspectionResults.get(query);
+    if (!result) {
+        result = await execute({
+            schema,
+            document,
+            contextValue: { repo, dataLoader },
+            operationName,
+            variableValues: variables,
+        });
+    }
+    return [allOk, result];
+}
+/**
+ * Returns true if the query is a GraphQL introspection query.
+ *
+ * Introspection queries ask for the schema, which is expensive.
+ *
+ * See: https://graphql.org/learn/introspection/
+ * @param query The GraphQL query.
+ * @returns True if the query is an introspection query.
+ */
+function isIntrospectionQuery(query) {
+    return query.includes('query IntrospectionQuery') || query.includes('__schema') || query.includes('__type');
+}
+function getRootSchema() {
+    if (!rootSchema) {
+        rootSchema = buildRootSchema();
+    }
+    return rootSchema;
+}
+function buildRootSchema() {
+    // First, create placeholder types
+    // We need this first for circular dependencies
+    for (const resourceType of getResourceTypes()) {
+        outputTypeCache[resourceType] = buildGraphQLOutputType(resourceType);
+    }
+    // Next, fill in all of the type properties
+    const fields = {};
+    const mutationFields = {};
+    for (const resourceType of getResourceTypes()) {
+        const graphQLOutputType = getGraphQLOutputType(resourceType);
+        // Get resource by ID
+        fields[resourceType] = {
+            type: graphQLOutputType,
+            args: {
+                id: {
+                    type: new GraphQLNonNull(GraphQLID),
+                    description: resourceType + ' ID',
+                },
+            },
+            resolve: resolveById,
+        };
+        // Search resource by search parameters
+        fields[resourceType + 'List'] = {
+            type: new GraphQLList(graphQLOutputType),
+            args: buildSearchArgs(resourceType),
+            resolve: resolveBySearch,
+        };
+        // FHIR GraphQL Connection API
+        fields[resourceType + 'Connection'] = {
+            type: buildConnectionType(resourceType, graphQLOutputType),
+            args: buildSearchArgs(resourceType),
+            resolve: resolveByConnectionApi,
+        };
+        // Mutation API
+        mutationFields[resourceType + 'Create'] = {
+            type: graphQLOutputType,
+            args: buildCreateArgs(resourceType),
+            resolve: resolveByCreate,
+        };
+        mutationFields[resourceType + 'Update'] = {
+            type: graphQLOutputType,
+            args: buildUpdateArgs(resourceType),
+            resolve: resolveByUpdate,
+        };
+        mutationFields[resourceType + 'Delete'] = {
+            type: graphQLOutputType,
+            args: {
+                id: {
+                    type: new GraphQLNonNull(GraphQLID),
+                    description: resourceType + ' ID',
+                },
+            },
+            resolve: resolveByDelete,
+        };
+    }
+    return new GraphQLSchema({
+        query: new GraphQLObjectType({
+            name: 'QueryType',
+            fields,
+        }),
+        mutation: new GraphQLObjectType({
+            name: 'MutationType',
+            fields: mutationFields,
+        }),
+    });
+}
+function buildCreateArgs(resourceType) {
+    const args = {
+        res: {
+            type: getGraphQLInputType(resourceType, 'Create'),
+            description: resourceType + ' Create',
+        },
+    };
+    return args;
+}
+function buildUpdateArgs(resourceType) {
+    const args = {
+        id: {
+            type: new GraphQLNonNull(GraphQLID),
+            description: resourceType + ' ID',
+        },
+        res: {
+            type: getGraphQLInputType(resourceType, 'Update'),
+            description: resourceType + ' Update',
+        },
+    };
+    return args;
+}
 function buildConnectionType(resourceType, resourceGraphQLType) {
     return new GraphQLObjectType({
         name: resourceType + 'Connection',
@@ -13764,25 +14017,6 @@ function buildConnectionType(resourceType, resourceGraphQLType) {
  * @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 resolveBySearch(source, args, ctx, info) {
-    const fieldName = info.fieldName;
-    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;
@@ -13812,7 +14046,6 @@ async function resolveByConnectionApi(source, args, ctx, info) {
  * @param ctx The GraphQL context.
  * @param info The GraphQL resolve info.  This includes the schema, and additional field details.
  * @returns Promise to read the resoure for the query.
- * @implements {GraphQLFieldResolver}
  */
 async function resolveById(_source, args, ctx, info) {
     try {
@@ -13823,98 +14056,66 @@ async function resolveById(_source, args, ctx, info) {
     }
 }
 /**
- * GraphQL data loader for Reference requests.
- * This is a special data loader for following Reference objects.
- * @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.
- * @returns Promise to read the resoure(s) for the query.
- * @implements {GraphQLFieldResolver}
- */
-async function resolveByReference(source, _args, ctx) {
-    try {
-        return await ctx.dataLoader.load(source);
-    }
-    catch (err) {
-        throw new OperationOutcomeError(normalizeOperationOutcome(err), err);
-    }
-}
-/**
- * GraphQL type resolver for resources.
- * When loading a resource via reference, GraphQL needs to know the type of the resource.
- * @param resource The loaded resource.
- * @returns The GraphQL type of the resource.
- * @implements {GraphQLTypeResolver}
+ * GraphQL resolver function for create requests.
+ * The field name should end with "Create" (i.e., "PatientCreate" for updating a Patient).
+ * The args should include the data to be created for the specified resource type.
+ * @param _source The source/root object. In the case of creates, this is typically not used and is thus ignored.
+ * @param args The GraphQL arguments, containing the new data for the resource.
+ * @param ctx The GraphQL context. This includes the repository where resources are stored.
+ * @param info The GraphQL resolve info. This includes the schema, field details, and other query-specific information.
+ * @returns A Promise that resolves to the created resource, or undefined if the resource could not be found or updated.
  */
-function resolveTypeByReference(resource) {
-    const resourceType = resource?.resourceType;
-    if (!resourceType) {
-        return undefined;
+async function resolveByCreate(_source, args, ctx, info) {
+    const fieldName = info.fieldName;
+    // 'Create.length'=== 6 && 'Update.length' === 6
+    const resourceType = fieldName.substring(0, fieldName.length - 6);
+    const resourceArgs = args.res;
+    if (resourceArgs.resourceType !== resourceType) {
+        return [badRequest('Invalid resourceType')];
+    }
+    const resource = await ctx.repo.createResource(resourceArgs);
+    return resource;
+}
+// Mutation Resolvers
+/**
+ * GraphQL resolver function for update requests.
+ * The field name should end with "Update" (i.e., "PatientUpdate" for updating a Patient).
+ * The args should include the data to be updated for the specified resource type.
+ * @param _source The source/root object. In the case of updates, this is typically not used and is thus ignored.
+ * @param args The GraphQL arguments, containing the new data for the resource.
+ * @param ctx The GraphQL context. This includes the repository where resources are stored.
+ * @param info The GraphQL resolve info. This includes the schema, field details, and other query-specific information.
+ * @returns A Promise that resolves to the updated resource, or undefined if the resource could not be found or updated.
+ */
+async function resolveByUpdate(_source, args, ctx, info) {
+    const fieldName = info.fieldName;
+    // 'Create.length'=== 6 && 'Update.length' === 6
+    const resourceType = fieldName.substring(0, fieldName.length - 6);
+    const resourceArgs = args.res;
+    const resourceId = args.id;
+    if (resourceArgs.resourceType !== resourceType) {
+        return [badRequest('Invalid resourceType')];
+    }
+    if (resourceId !== resourceArgs.id) {
+        return [badRequest('Incorrect ID')];
     }
-    return getGraphQLType(resourceType).name;
+    const resource = await ctx.repo.updateResource(resourceArgs);
+    return resource;
 }
 /**
- * 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}
+ * GraphQL resolver function for delete requests.
+ * The field name should end with "Delete" (e.g., "PatientDelete" for deleting a Patient).
+ * The args should include the ID of the resource to be deleted.
+ * @param _source The source/root object. In the case of deletions, this is typically not used and is thus ignored.
+ * @param args The GraphQL arguments, containing the ID of the resource to be deleted.
+ * @param ctx The GraphQL context. This includes the repository where resources are stored.
+ * @param info The GraphQL resolve info. This includes the schema, field details, and other query-specific information.
+ * @returns A Promise that resolves when the resource has been deleted. No value is returned.
  */
-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) {
-        // _reference is a required field for reverse lookup searches
-        // The GraphQL parser will validate that it is there.
-        const reference = args['_reference'];
-        delete args['_reference'];
-        referenceFilter = {
-            code: reference,
-            operator: Operator.EQUALS,
-            value: getReferenceString(source),
-        };
-    }
-    // Reverse the transform of dashes to underscores, back to dashes
-    args = Object.fromEntries(Object.entries(args).map(([key, value]) => [graphQLFieldToFhirParam(key), value]));
-    // Parse the search request
-    const searchRequest = parseSearchRequest(resourceType, args);
-    // If a reverse lookup filter was specified,
-    // add it to the search request.
-    if (referenceFilter) {
-        const existingFilters = searchRequest.filters || [];
-        searchRequest.filters = [referenceFilter, ...existingFilters];
-    }
-    return searchRequest;
-}
-function fhirParamToGraphQLField(code) {
-    return code.replaceAll('-', '_');
-}
-function graphQLFieldToFhirParam(code) {
-    return code.startsWith('_') ? code : code.replaceAll('_', '-');
+async function resolveByDelete(_source, args, ctx, info) {
+    const fieldName = info.fieldName;
+    const resourceType = fieldName.substring(0, fieldName.length - 'Delete'.length);
+    await ctx.repo.deleteResource(resourceType, args.id);
 }
 /**
  * Custom GraphQL rule that enforces max depth constraint.
@@ -13941,42 +14142,6 @@ const MaxDepthRule = (context) => ({
         }
     },
 });
-/**
- * Returns the depth of the GraphQL node in a query.
- * We use "selections" as the representation of depth.
- * As a rough approximation, it's the number of indentations in a well formatted query.
- * @param path The GraphQL node path.
- * @returns The "depth" of the node.
- */
-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.
- * @returns OperationOutcome with the GraphQL errors as OperationOutcome issues.
- */
-function invalidRequest(errors) {
-    return {
-        resourceType: 'OperationOutcome',
-        issue: errors.map((error) => ({
-            severity: 'error',
-            code: 'invalid',
-            details: { text: error.message },
-        })),
-    };
-}
 
 class Router {
     constructor() {
@@ -14109,8 +14274,9 @@ async function patchResource(req, repo) {
     return [allOk, resource];
 }
 class FhirRouter {
-    constructor() {
+    constructor(options = {}) {
         this.router = new Router();
+        this.options = options;
         this.router.add('POST', '', batch);
         this.router.add('GET', ':resourceType', search);
         this.router.add('POST', ':resourceType/_search', searchByPost);
@@ -14148,7 +14314,6 @@ class BaseRepository {
      * The return value is the resource, if available; otherwise, undefined.
      *
      * See FHIR search for full details: https://www.hl7.org/fhir/search.html
-     *
      * @param searchRequest The FHIR search request.
      * @returns Promise to the first search result or undefined.
      */
@@ -14164,7 +14329,6 @@ class BaseRepository {
      * The return value is an array of resources.
      *
      * See FHIR search for full details: https://www.hl7.org/fhir/search.html
-     *
      * @param searchRequest The FHIR search request.
      * @returns Promise to the array of search results.
      */