constructor()

in src/FHIRSearchParametersRegistry/index.ts [95:161]
52 lines of code
5 McCabe index (conditional complexity)

    constructor(fhirVersion: FhirVersion, compiledImplementationGuides?: any[]) {
        let compiledSearchParams: SearchParam[];
        if (fhirVersion === '4.0.1') {
            compiledSearchParams = compiledSearchParamsV4 as SearchParam[];
        } else {
            compiledSearchParams = compiledSearchParamsV3 as SearchParam[];
        }
        if (compiledImplementationGuides !== undefined) {
            // order is important. params from IGs are added last so that they overwrite base FHIR params with the same name
            compiledSearchParams = [...compiledSearchParams, ...compiledImplementationGuides];
        }

        this.includeMap = {};
        this.revincludeMap = {};
        this.typeNameMap = {};
        this.capabilityStatement = {};

        compiledSearchParams.forEach((searchParam) => {
            this.typeNameMap[searchParam.base] = this.typeNameMap[searchParam.base] ?? {};
            this.typeNameMap[searchParam.base][searchParam.name] = searchParam;

            if (searchParam.type === 'reference') {
                this.includeMap[searchParam.base] = this.includeMap[searchParam.base] ?? [];
                this.includeMap[searchParam.base].push(searchParam);

                // eslint-disable-next-line no-unused-expressions
                searchParam.target?.forEach((target) => {
                    this.revincludeMap[target] = this.revincludeMap[target] ?? [];
                    this.revincludeMap[target].push(searchParam);
                });
            }
        });

        Object.entries(this.typeNameMap).forEach(([resourceType, searchParams]) => {
            if (resourceType === 'Resource') {
                // search params of type Resource are handled separately since they must appear on ALL resource types
                return;
            }

            this.capabilityStatement[resourceType] = this.capabilityStatement[resourceType] ?? {};
            this.capabilityStatement[resourceType].searchParam = Object.values(searchParams).map(toCapabilityStatement);

            this.capabilityStatement[resourceType].searchInclude = [
                '*',
                ...(this.includeMap[resourceType]?.map((searchParam) => `${searchParam.base}:${searchParam.name}`) ??
                    []),
            ];

            this.capabilityStatement[resourceType].searchRevInclude = [
                '*',
                ...(this.revincludeMap[resourceType]?.map((searchParam) => `${searchParam.base}:${searchParam.name}`) ??
                    []),
            ];
        });

        const resourceSearchParams = Object.values(this.typeNameMap.Resource).map(toCapabilityStatement);

        // For each resource type, add all search params that have "Resource" as base, except when there is already
        // a more specific search parameter with the same name.
        Object.entries(this.capabilityStatement).forEach(([resourceType, searchCapabilities]) => {
            searchCapabilities.searchParam.push(
                ...resourceSearchParams.filter(
                    (resourceSearchParam) => !this.typeNameMap?.[resourceType]?.[resourceSearchParam.name],
                ),
            );
        });
    }