First round of NPM package loading functionality for Measures and Libraries

cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/npm/BaseNpmPackageLoaderInMemory.java

@@ -0,0 +1,166 @@
+package org.opencds.cqf.fhir.utility.npm;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
+import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
+import jakarta.annotation.Nonnull;
+import jakarta.annotation.Nullable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+import org.hl7.cql.model.NamespaceInfo;
+import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.hl7.fhir.instance.model.api.IPrimitiveType;
+import org.hl7.fhir.utilities.npm.NpmPackage;
+
+public abstract class BaseNpmPackageLoaderInMemory implements NpmPackageLoader {
+
+ public static final String FAILED_TO_LOAD_RESOURCE_TEMPLATE = "Failed to load resource: %s";
+
+ private final Set<NpmPackage> npmPackages;
+ private final NpmNamespaceManager npmNamespaceManager;
+
+ @Override
+ public Optional<IBaseResource> loadNpmResource(IPrimitiveType<String> resourceUrl) {
+ return npmPackages.stream()
+ .filter(npmPackage -> doesPackageMatch(resourceUrl, npmPackage))
+ .map(npmPackage -> getResource(npmPackage, resourceUrl))
+ .findFirst();
+ }
+
+ private IBaseResource getResource(NpmPackage npmPackage, IPrimitiveType<String> resourceUrl) {
+ try {
+ return tryGetResource(npmPackage, resourceUrl);
+ } catch (IOException exception) {
+ throw new InternalErrorException(
+ FAILED_TO_LOAD_RESOURCE_TEMPLATE.formatted(resourceUrl.getValue()), exception);
+ }
+ }
+
+ private IBaseResource tryGetResource(NpmPackage npmPackage, IPrimitiveType<String> resourceUrl) throws IOException {
+
+ final FhirContext fhirContext = getFhirContext(npmPackage);
+ final String resourceUrlString = resourceUrl.getValue();
+
+ final String[] split = resourceUrlString.split("\\|");
+
+ try (InputStream libraryInputStream = npmPackage.loadByCanonical(split[0])) {
+ return fhirContext.newJsonParser().parseResource(libraryInputStream);
+ }
+ }
+
+ private boolean doesPackageMatch(IPrimitiveType<String> resourceUrl, NpmPackage npmPackage) {
+ try {
+ return npmPackage.hasCanonical(resourceUrl.getValue());
+ } catch (IOException exception) {
+ throw new InternalErrorException(FAILED_TO_LOAD_RESOURCE_TEMPLATE, exception);
+ }
+ }
+
+ @Override
+ public NpmNamespaceManager getNamespaceManager() {
+ return npmNamespaceManager;
+ }
+
+ @Nonnull
+ protected static Set<NpmPackage> buildNpmPackagesFromAbsolutePath(List<Path> tgzPaths) {
+ return tgzPaths.stream()
+ .map(BaseNpmPackageLoaderInMemory::getNpmPackageFromAbsolutePaths)
+ .collect(Collectors.toUnmodifiableSet());
+ }
+
+ @Nonnull
+ protected static Set<NpmPackage> buildNpmPackageFromClasspath(Class<?> clazz, List<Path> tgzPaths) {
+ return tgzPaths.stream()
+ .map(path -> getNpmPackageFromClasspath(clazz, path))
+ .collect(Collectors.toUnmodifiableSet());
+ }
+
+ @Nonnull
+ private static NpmPackage getNpmPackageFromAbsolutePaths(Path tgzPath) {
+ try (final InputStream npmStream = Files.newInputStream(tgzPath)) {
+ return NpmPackage.fromPackage(npmStream);
+ } catch (IOException exception) {
+ throw new InvalidRequestException(FAILED_TO_LOAD_RESOURCE_TEMPLATE.formatted(tgzPath), exception);
+ }
+ }
+
+ @Nonnull
+ private static NpmPackage getNpmPackageFromClasspath(Class<?> clazz, Path tgzClasspathPath) {
+ try (final InputStream simpleAlphaStream = clazz.getResourceAsStream(tgzClasspathPath.toString())) {
+ if (simpleAlphaStream == null) {
+ throw new InvalidRequestException(FAILED_TO_LOAD_RESOURCE_TEMPLATE.formatted(tgzClasspathPath));
+ }
+
+ return NpmPackage.fromPackage(simpleAlphaStream);
+ } catch (IOException exception) {
+ throw new InvalidRequestException(FAILED_TO_LOAD_RESOURCE_TEMPLATE.formatted(tgzClasspathPath), exception);
+ }
+ }
+
+ protected BaseNpmPackageLoaderInMemory(
+ Set<NpmPackage> npmPackages, @Nullable NpmNamespaceManager npmNamespaceManager) {
+
+ if (npmNamespaceManager == null) {
+ var namespaceInfos = npmPackages.stream()
+ .map(npmPackage -> new NamespaceInfo(npmPackage.name(), npmPackage.canonical()))
+ .toList();
+
+ this.npmNamespaceManager = new NpmNamespaceManagerFromList(namespaceInfos);
+ } else {
+ this.npmNamespaceManager = npmNamespaceManager;
+ }
+
+ this.npmPackages = npmPackages;
+ }
+
+ private FhirContext getFhirContext(NpmPackage npmPackage) {
+ return FhirContext.forCached(FhirVersionEnum.forVersionString(npmPackage.fhirVersion()));
+ }
+
+ /**
+ * Meant to test various scenarios involving missing of faulty NamespaceInfo data.
+ */
+ public static class NpmNamespaceManagerFromList implements NpmNamespaceManager {
+
+ private final List<NamespaceInfo> namespaceInfos;
+
+ public NpmNamespaceManagerFromList(List<NamespaceInfo> namespaceInfos) {
+ this.namespaceInfos = List.copyOf(namespaceInfos);
+ }
+
+ @Override
+ public List<NamespaceInfo> getAllNamespaceInfos() {
+ return namespaceInfos;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ NpmNamespaceManagerFromList that = (NpmNamespaceManagerFromList) o;
+ return Objects.equals(namespaceInfos, that.namespaceInfos);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(namespaceInfos);
+ }
+
+ @Override
+ public String toString() {
+ return new StringJoiner(", ", NpmNamespaceManagerFromList.class.getSimpleName() + "[", "]")
+ .add("namespaceInfos=" + namespaceInfos)
+ .toString();
+ }
+ }
+}

cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/npm/NpmConfigDependencySubstitutor.java

@@ -0,0 +1,24 @@
+package org.opencds.cqf.fhir.utility.npm;
+
+import java.util.Optional;
+
+/**
+ * This class is meant to be used from Spring configuration classes, in the case of any missing
+ * NpmPackageLoader bean definitions, which Spring will inject as empty Optionals.
+ * <p/>
+ * Helps implement a migration from the old world of FHIR/Repository based resources for Libraries,
+ * Measures and eventually other clinical intelligence resources (such as PlanDefinitions or
+ * ValueSets), and the new world where they're derived from NPM packages.
+ * If Spring config is missing an instance of {@link NpmPackageLoader}, then * return the default
+ * instance.
+ */
+public class NpmConfigDependencySubstitutor {
+
+ private NpmConfigDependencySubstitutor() {
+ // static utility class
+ }
+
+ public static NpmPackageLoader substituteNpmPackageLoaderIfEmpty(Optional<NpmPackageLoader> optNpmPackageLoader) {
+ return NpmPackageLoader.getDefaultIfEmpty(optNpmPackageLoader.orElse(null));
+ }
+}

cqf-fhir-utility/src/main/java/org/opencds/cqf/fhir/utility/npm/NpmNamespaceManager.java

@@ -0,0 +1,16 @@
+package org.opencds.cqf.fhir.utility.npm;
+
+import java.util.List;
+import org.hl7.cql.model.NamespaceInfo;
+
+/**
+ * Load all {@link NamespaceInfo}s capturing package ID to URL mappings associated with the NPM
+ * packages maintained for clinical-reasoning NPM package users to be used to resolve cross-package
+ * Library/CQL dependencies. See {@link NpmPackageLoader}.
+ */
+public interface NpmNamespaceManager {
+
+ NpmNamespaceManager DEFAULT = List::of;
+
+ List<NamespaceInfo> getAllNamespaceInfos();
+}