@medplum/fhir-router 2.0.21 → 2.0.23

package/dist/cjs/index.cjs

@@ -8,7 +8,6 @@
      * 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.
@@ -36,8 +35,6 @@
         }
         /**
          * Processes a FHIR batch request.
-         * @param repo The FHIR repository.
-         * @param bundle The input bundle.
          * @returns The bundle response.
          */
         async processBatch() {
@@ -13378,131 +13375,202 @@ spurious results.`);
         '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: core.Operator.EQUALS,
+                value: core.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 = core.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 core.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 = core.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 [core.badRequest('Must provide query.')];
-        }
-        let document;
-        try {
-            document = parse(query);
-        }
-        catch (err) {
-            return [core.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 [core.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 [core.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 core.getResourceTypes()) {
-            typeCache[resourceType] = buildGraphQLType(resourceType);
-        }
-        // Next, fill in all of the type properties
+    function buildGraphQLInputType(resourceType, nameSuffix) {
+        const schema = core.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 core.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 (core.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 = core.getResourceTypeSchema(resourceType);
+        const properties = schema.properties;
+        for (const key of Object.keys(properties)) {
+            const elementDefinition = core.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 = core.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]', core.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: () => core.getResourceTypes()
-                    .map(getGraphQLType)
+                    .map(getGraphQLOutputType)
                     .filter((t) => !!t),
                 resolveType: resolveTypeByReference,
             });
@@ -13511,16 +13579,16 @@ spurious results.`);
         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 = core.getResourceTypeSchema(resourceType);
         const properties = schema.properties;
         if (core.isResourceTypeSchema(schema)) {
@@ -13532,25 +13600,25 @@ spurious results.`);
         if (resourceType === 'Reference') {
             fields.resource = {
                 description: 'Reference',
-                type: getGraphQLType('ResourceList'),
+                type: getGraphQLOutputType('ResourceList'),
                 resolve: resolveByReference,
             };
         }
         for (const key of Object.keys(properties)) {
             const elementDefinition = core.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 = core.buildTypeName(elementDefinition.path?.split('.'));
         }
         const fieldConfig = {
             description: elementDefinition.short,
-            type: getPropertyType(elementDefinition, typeName),
+            type: getOutputPropertyType(elementDefinition, typeName),
             resolve: resolveField,
         };
         if (elementDefinition.max === '*') {
@@ -13569,7 +13637,6 @@ spurious results.`);
      *   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.
      */
@@ -13654,13 +13721,12 @@ spurious results.`);
      * (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 core.getResourceTypes()) {
-            const childGraphQLType = getGraphQLType(childResourceType);
+            const childGraphQLType = getGraphQLOutputType(childResourceType);
             const childSearchParams = core.getSearchParameters(childResourceType);
             const enumValues = {};
             let count = 0;
@@ -13690,49 +13756,236 @@ spurious results.`);
             }
         }
     }
-    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 = core.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) => core.toJsBoolean(core.evalFhirPathTyped(fhirpath, [core.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 core.OperationOutcomeError(core.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 core.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 [core.badRequest('Must provide query.')];
+        }
+        let document;
+        try {
+            document = parse(query);
+        }
+        catch (err) {
+            return [core.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 [core.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 [core.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 core.getResourceTypes()) {
+            outputTypeCache[resourceType] = buildGraphQLOutputType(resourceType);
+        }
+        // Next, fill in all of the type properties
+        const fields = {};
+        const mutationFields = {};
+        for (const resourceType of core.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',
@@ -13766,25 +14019,6 @@ spurious results.`);
      * @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;
@@ -13814,7 +14048,6 @@ spurious results.`);
      * @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 {
@@ -13825,98 +14058,66 @@ spurious results.`);
         }
     }
     /**
-     * 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 core.OperationOutcomeError(core.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 [core.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 [core.badRequest('Invalid resourceType')];
+        }
+        if (resourceId !== resourceArgs.id) {
+            return [core.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) => 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) {
-            // _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: core.Operator.EQUALS,
-                value: core.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 = core.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.
@@ -13943,42 +14144,6 @@ spurious results.`);
             }
         },
     });
-    /**
-     * 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() {
@@ -14111,8 +14276,9 @@ spurious results.`);
         return [core.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);
@@ -14150,7 +14316,6 @@ spurious results.`);
          * 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.
          */
@@ -14166,7 +14331,6 @@ spurious results.`);
          * 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.
          */