enforce_referential_integrity_on_delete.disable_for_paths ignored for expunge (#7142)

* [7139] fix delete expunge with disableForPaths being set

* [7139] update changelog

Author: YalingPeiS

hapi-fhir-docs/src/main/resources/ca/uhn/hapi/fhir/changelog/8_4_0/7139-allow-delete-expunge-when-disable-for-paths-set.yaml

@@ -0,0 +1,7 @@
+---
+type: fix
+issue: 7139
+jira: SMILE-9692
+title: "This change allows resources to be deleted using the Delete with Expunge operation when the property 
+`enforceReferentialIntegrityOnDeleteDisableForPaths` is set to one or more FHIRPath expressions that link other 
+resources to the target resources."

hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/delete/batch2/DeleteExpungeSqlBuilder.java

@@ -132,6 +132,12 @@ public void validateOkToDeleteAndExpunge(Set<JpaPid> thePids, boolean theCascade
 					break;
 				}
 			}
+		} else {
+			// check if the user has configured any paths to ignore
+			Set<String> pathsToIgnore = myStorageSettings.getEnforceReferentialIntegrityOnDeleteDisableForPaths();
+			if (conflictResourceLinks.stream().anyMatch(link -> pathsToIgnore.contains(link.getSourcePath()))) {
+				return;
+			}
 		}
 
 		ResourceLink firstConflict = conflictResourceLinks.get(0);

hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/batch2/DeleteExpungeSqlBuilderTest.java

@@ -7,41 +7,42 @@
 import ca.uhn.fhir.jpa.delete.batch2.DeleteExpungeSqlBuilder;
 import ca.uhn.fhir.jpa.model.config.PartitionSettings;
 import ca.uhn.fhir.jpa.model.dao.JpaPid;
+import ca.uhn.fhir.jpa.model.entity.ResourceLink;
+import ca.uhn.fhir.jpa.model.entity.ResourceTable;
 import ca.uhn.fhir.jpa.util.QueryChunker;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.util.List;
+import java.util.Set;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyCollection;
+import static org.mockito.ArgumentMatchers.anyList;
 import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
 
-public class DeleteExpungeSqlBuilderTest {
-	@Autowired
-	private ResourceTableFKProvider theResourceTableFKProvider;
-	private JpaStorageSettings myStorageSettings = new JpaStorageSettings();
+@ExtendWith(MockitoExtension.class)
+class DeleteExpungeSqlBuilderTest {
+	@Mock
+	private ResourceTableFKProvider myResourceTableFKProvider;
+	@Mock
+	private JpaStorageSettings myStorageSettings;
+	@Mock
 	private IIdHelperService<JpaPid> myIdHelper;
 	@Mock
-	private IResourceLinkDao theResourceLinkDao;
-	private PartitionSettings thePartitionSettings = new PartitionSettings();
+	private IResourceLinkDao myResourceLinkDao;
+	@Mock
+	private PartitionSettings myPartitionSettings;
+	@InjectMocks
 	private DeleteExpungeSqlBuilder myDeleteExpungeSqlBuilderTest;
 
-	@BeforeEach
-	public void beforeEach() {
-		myDeleteExpungeSqlBuilderTest = new DeleteExpungeSqlBuilder(
-			theResourceTableFKProvider,
-			myStorageSettings,
-			myIdHelper,
-			theResourceLinkDao,
-			thePartitionSettings
-		);
-	}
-
 	@Test
 	public void testQueryChunkingWhenFindingChildResources(){
 		//Given: We have a list of pids.
@@ -57,4 +58,29 @@ public void testQueryChunkingWhenFindingChildResources(){
 			queryChunker.verify(() -> QueryChunker.chunk(anyCollection(), any()), times(1));
 		}
 	}
+
+	@Test
+	void testValidateOkToDeleteAndExpunge_whenEnforceReferentialIntegrityDisableForPaths_noException() {
+		// Set up
+		String path = "Encounter.subject";
+		when(myStorageSettings.getEnforceReferentialIntegrityOnDeleteDisableForPaths()).thenReturn(Set.of(path));
+		when(myStorageSettings.isEnforceReferentialIntegrityOnDelete()).thenReturn(true);
+
+		ResourceTable sourceRes = new ResourceTable();
+		sourceRes.setId(JpaPid.fromIdAndResourceType(20L, "Encounter"));
+
+		ResourceLink resLink = new ResourceLink();
+		resLink.setSourceResource(sourceRes);
+		resLink.setSourcePath(path);
+
+		List<ResourceLink> conflictResourceLinks = List.of(resLink);
+		when(myResourceLinkDao.findWithTargetPidIn(anyList())).thenReturn(conflictResourceLinks);
+
+		Set<JpaPid> pids = Set.of(JpaPid.fromIdAndResourceType(10L, "Patient"));
+
+		// Execute & Verify
+		assertDoesNotThrow(() -> {
+			myDeleteExpungeSqlBuilderTest.validateOkToDeleteAndExpunge(pids, false, null);
+		});
+	}
 }

hapi-fhir-storage/src/main/java/ca/uhn/fhir/jpa/api/config/JpaStorageSettings.java

@@ -165,6 +165,7 @@ public class JpaStorageSettings extends StorageSettings {
 
 	private boolean myDeleteStaleSearches = true;
 	private boolean myEnforceReferentialIntegrityOnDelete = true;
+	private Set<String> myEnforceReferentialIntegrityOnDeleteDisableForPaths = Collections.emptySet();
 	private boolean myUniqueIndexesEnabled = true;
 	private boolean myUniqueIndexesCheckedBeforeSave = true;
 	private boolean myEnforceReferentialIntegrityOnWrite = true;
@@ -1423,6 +1424,33 @@ public void setEnforceReferentialIntegrityOnDelete(boolean theEnforceReferential
 		myEnforceReferentialIntegrityOnDelete = theEnforceReferentialIntegrityOnDelete;
 	}
 
+	/**
+	 * When {@link #setEnforceReferentialIntegrityOnDelete(boolean)} is set to <code>true</code>, this setting may
+	 * be used to selectively disable the referential integrity checking only for specific paths. It applies to
+	 * both Delete and Delete with Expunge operations.
+	 * <p>
+	 * For example, if the property contains the FHIR path expression <code>Encounter.subject</code> , deleting
+	 * the Patient referenced by an Encounter's subject is allowed without deleting the Encounter first.
+	 * </p>
+	 */
+	public Set<String> getEnforceReferentialIntegrityOnDeleteDisableForPaths() {
+		return myEnforceReferentialIntegrityOnDeleteDisableForPaths;
+	}
+
+	/**
+	 * When {@link #setEnforceReferentialIntegrityOnDelete(boolean)} is set to <code>true</code>, this setting
+	 * allows you to selectively disable integrity checks for specific paths. It applies to both Delete and
+	 * Delete with Expunge operations.
+	 * <p>
+	 * For example, if the property contains the FHIR path expression <code>Encounter.subject</code> , deleting
+	 * the Patient referenced by an Encounter's subject is allowed without deleting the Encounter first.
+	 * </p>
+	 */
+	public void setEnforceReferentialIntegrityOnDeleteDisableForPaths(
+			Set<String> theEnforceReferentialIntegrityOnDeleteDisableForPaths) {
+		myEnforceReferentialIntegrityOnDeleteDisableForPaths = theEnforceReferentialIntegrityOnDeleteDisableForPaths;
+	}
+
 	/**
 	 * If set to <code>false</code> (default is <code>true</code>) resources will be permitted to be
 	 * created or updated even if they contain references to local resources that do not exist.