@medplum/fhir-router 2.0.22 → 2.0.24

package/dist/cjs/index.cjs

@@ -54,7 +54,7 @@
                 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) {
+                if (entry.resource?.id) {
                     rewritten.resource.id = this.rewriteIdsInString(entry.resource.id, true);
                 }
                 try {
@@ -82,7 +82,7 @@
                 const baseUrl = `https://example.com/${entry.resource.resourceType}`;
                 const searchUrl = new URL('?' + request.ifNoneExist, baseUrl);
                 const searchBundle = await this.repo.search(core.parseSearchUrl(searchUrl));
-                const entries = searchBundle?.entry;
+                const entries = searchBundle.entry;
                 if (entries.length > 1) {
                     return buildBundleResponse(core.badRequest('Multiple matches'));
                 }
@@ -138,7 +138,7 @@
             return JSON.parse(Buffer.from(patchResource.data, 'base64').toString('utf8'));
         }
         addReplacementId(fullUrl, resource) {
-            if (fullUrl?.startsWith('urn:uuid:')) {
+            if (fullUrl.startsWith('urn:uuid:')) {
                 this.ids[fullUrl] = resource;
             }
         }
@@ -13375,152 +13375,188 @@ spurious results.`);
         'http://hl7.org/fhirpath/System.String': GraphQLString,
         'http://hl7.org/fhirpath/System.Time': GraphQLString,
     };
-    const outputTypeCache = {
-        ...typeCache,
-    };
-    const inputTypeCache = {
-        ...typeCache,
-    };
+    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
-     * @param req The request details.
-     * @param repo The current user FHIR repository.
-     * @param router The router for router options.
-     * @returns The response.
+     * 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, 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];
+    function isFieldRequested(info, fieldName) {
+        return info.fieldNodes.some((fieldNode) => fieldNode.selectionSet?.selections.some((selection) => {
+            return selection.kind === 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()) {
-            outputTypeCache[resourceType] = buildGraphQLOutputType(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 = {};
-        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,
+        // 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,
-            }),
-            mutation: new GraphQLObjectType({
-                name: 'MutationType',
-                fields: mutationFields,
-            }),
-        });
+        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;
     }
+
+    const outputTypeCache = {
+        ...typeCache,
+    };
     function getGraphQLOutputType(inputType) {
         let result = outputTypeCache[inputType];
         if (!result) {
@@ -13529,14 +13565,6 @@ spurious results.`);
         }
         return result;
     }
-    function getGraphQLInputType(inputType, nameSuffix) {
-        let result = inputTypeCache[inputType];
-        if (!result) {
-            result = buildGraphQLInputType(inputType, nameSuffix);
-            inputTypeCache[inputType] = result;
-        }
-        return result;
-    }
     function buildGraphQLOutputType(resourceType) {
         if (resourceType === 'ResourceList') {
             return new GraphQLUnionType({
@@ -13554,33 +13582,12 @@ spurious results.`);
             fields: () => buildGraphQLOutputFields(resourceType),
         });
     }
-    function buildGraphQLInputType(resourceType, nameSuffix) {
-        const schema = core.getResourceTypeSchema(resourceType);
-        return new GraphQLInputObjectType({
-            name: resourceType + nameSuffix,
-            description: schema.description,
-            fields: () => buildGraphQLInputFields(resourceType, nameSuffix),
-        });
-    }
     function buildGraphQLOutputFields(resourceType) {
         const fields = {};
         buildOutputPropertyFields(resourceType, fields);
         buildReverseLookupFields(resourceType, fields);
         return fields;
     }
-    function buildGraphQLInputFields(resourceType, nameSuffix) {
-        const fields = {};
-        // Add resourceType field for root resource
-        if (core.isResourceType(resourceType)) {
-            const propertyFieldConfig = {
-                description: 'The type of resource',
-                type: GraphQLString,
-            };
-            fields['resourceType'] = propertyFieldConfig;
-        }
-        buildInputPropertyFields(resourceType, fields, nameSuffix);
-        return fields;
-    }
     function buildOutputPropertyFields(resourceType, fields) {
         const schema = core.getResourceTypeSchema(resourceType);
         const properties = schema.properties;
@@ -13604,16 +13611,6 @@ spurious results.`);
             }
         }
     }
-    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 buildOutputPropertyField(fields, key, elementDefinition, elementDefinitionType) {
         let typeName = elementDefinitionType.code;
         if (typeName === 'Element' || typeName === 'BackboneElement') {
@@ -13630,21 +13627,6 @@ spurious results.`);
         const propertyName = key.replace('[x]', core.capitalize(elementDefinitionType.code));
         fields[propertyName] = fieldConfig;
     }
-    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;
-    }
     /**
      * Builds field arguments for a list property.
      *
@@ -13750,7 +13732,7 @@ spurious results.`);
             let count = 0;
             if (childSearchParams) {
                 for (const [code, searchParam] of Object.entries(childSearchParams)) {
-                    if (searchParam.target && searchParam.target.includes(resourceType)) {
+                    if (searchParam.target?.includes(resourceType)) {
                         enumValues[fhirParamToGraphQLField(code)] = { value: code };
                         count++;
                     }
@@ -13774,46 +13756,221 @@ 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,
-                };
-            }
+    function getOutputPropertyType(elementDefinition, typeName) {
+        let graphqlType = getGraphQLOutputType(typeName);
+        if (elementDefinition.max === '*') {
+            graphqlType = new GraphQLList(graphqlType);
+        }
+        if (elementDefinition.min !== 0 && !elementDefinition.path?.endsWith('[x]')) {
+            graphqlType = new GraphQLNonNull(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);
         }
-        return args;
+        // 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'),
+                type: new GraphQLNonNull(getGraphQLInputType(resourceType, 'Create')),
                 description: resourceType + ' Create',
             },
         };
@@ -13826,19 +13983,12 @@ spurious results.`);
                 description: resourceType + ' ID',
             },
             res: {
-                type: getGraphQLInputType(resourceType, 'Update'),
+                type: new GraphQLNonNull(getGraphQLInputType(resourceType, 'Update')),
                 description: resourceType + ' Update',
             },
         };
         return args;
     }
-    function getOutputPropertyType(elementDefinition, typeName) {
-        const graphqlType = getGraphQLOutputType(typeName);
-        if (elementDefinition.max === '*') {
-            return new GraphQLList(graphqlType);
-        }
-        return graphqlType;
-    }
     function buildConnectionType(resourceType, resourceGraphQLType) {
         return new GraphQLObjectType({
             name: resourceType + 'Connection',
@@ -13863,23 +14013,6 @@ spurious results.`);
             },
         });
     }
-    /**
-     * 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.
-     */
-    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").
@@ -13927,66 +14060,6 @@ spurious results.`);
             throw new core.OperationOutcomeError(core.normalizeOperationOutcome(err), err);
         }
     }
-    /**
-     * 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;
-    }
-    /**
-     * 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 resolver function for create requests.
      * The field name should end with "Create" (i.e., "PatientCreate" for updating a Patient).
@@ -14049,37 +14122,6 @@ spurious results.`);
         const resourceType = fieldName.substring(0, fieldName.length - 'Delete'.length);
         await ctx.repo.deleteResource(resourceType, args.id);
     }
-    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('_', '-');
-    }
     /**
      * Custom GraphQL rule that enforces max depth constraint.
      * @param context The validation context.
@@ -14105,42 +14147,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() {
@@ -14350,10 +14356,10 @@ spurious results.`);
             if (!result.meta) {
                 result.meta = {};
             }
-            if (!result.meta?.versionId) {
+            if (!result.meta.versionId) {
                 result.meta.versionId = generateId();
             }
-            if (!result.meta?.lastUpdated) {
+            if (!result.meta.lastUpdated) {
                 result.meta.lastUpdated = new Date().toISOString();
             }
             const { resourceType, id } = result;
@@ -14475,7 +14481,7 @@ spurious results.`);
         }
     }
     const sortComparator = (a, b, sortRule) => {
-        const searchParam = core.globalSchema.types[a.resourceType]?.searchParams?.[sortRule.code];
+        const searchParam = core.globalSchema.types[a.resourceType].searchParams?.[sortRule.code];
         const expression = searchParam?.expression;
         if (!expression) {
             return 0;