Add routine to disconnect all invisible children of subjects.

src/main/java/no/ndla/taxonomy/repositories/NodeRepository.java

@@ -105,6 +105,18 @@ List<Integer> findIdsFiltered(
             """)
     List<Node> findProgrammes();
 
+    @Query(
+            """
+            SELECT DISTINCT n FROM Node n
+            LEFT JOIN FETCH n.resourceResourceTypes rrt
+            LEFT JOIN FETCH rrt.resourceType
+            LEFT JOIN FETCH n.parentConnections pc
+            LEFT JOIN FETCH n.childConnections cc
+            WHERE n.nodeType = "SUBJECT"
+            AND n.context = true
+            """)
+    List<Node> findRootSubjects();
+
     @Query(
             """
             SELECT DISTINCT n FROM Node n

src/main/java/no/ndla/taxonomy/rest/v1/commands/VersionPostPut.java

@@ -18,8 +18,8 @@ public class VersionPostPut implements UpdatableDto<Version> {
     @JsonProperty
     @Schema(
             description =
-                    "If specified, set the id to this value. Must start with urn:subject: and be a valid URI. If omitted, an id will be assigned automatically.",
-            example = "urn:subject:1")
+                    "If specified, set the id to this value. Must start with urn:version: and be a valid URI. If ommitted, an id will be assigned automatically.",
+            example = "urn:version:1")
     public Optional<URI> id = Optional.empty();
 
     @JsonProperty

src/main/java/no/ndla/taxonomy/service/NodeService.java

@@ -436,4 +436,24 @@ public List<TaxonomyContextDTO> getContextByContextId(Optional<String> contextId
                 .filter(c -> c.contextId().equals(contextId.get()))
                 .toList();
     }
+
+    @Transactional
+    public Optional<DomainEntity> disconnectAllInvisibleNodes() {
+        nodeRepository.findRootSubjects().forEach(subject -> {
+            disconnectInvisibleConnections(subject);
+            nodeRepository.save(subject);
+        });
+        return Optional.empty();
+    }
+
+    private Node disconnectInvisibleConnections(Node node) {
+        if (!node.isVisible()) {
+            node.getParentConnections().forEach(nodeConnectionRepository::delete);
+        } else {
+            node.getChildConnections()
+                    .forEach(nodeConnection ->
+                            nodeConnection.getChild().ifPresent(this::disconnectInvisibleConnections));
+        }
+        return node;
+    }
 }

src/main/java/no/ndla/taxonomy/service/VersionService.java

@@ -13,13 +13,18 @@
 import java.time.Instant;
 import java.util.List;
 import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.stream.Collectors;
+import no.ndla.taxonomy.domain.DomainEntity;
 import no.ndla.taxonomy.domain.Version;
 import no.ndla.taxonomy.domain.VersionType;
 import no.ndla.taxonomy.repositories.VersionRepository;
 import no.ndla.taxonomy.rest.v1.commands.VersionPostPut;
 import no.ndla.taxonomy.service.dtos.VersionDTO;
 import no.ndla.taxonomy.service.exceptions.NotFoundServiceException;
+import no.ndla.taxonomy.service.task.Deleter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
@@ -30,16 +35,19 @@
 @Service
 public class VersionService {
     final Logger logger = LoggerFactory.getLogger(this.getClass());
-    private final VersionRepository versionRepository;
     private final EntityManager entityManager;
+    private final VersionRepository versionRepository;
+    private final NodeService nodeService;
     private final URNValidator validator = new URNValidator();
+    private final ExecutorService executor = Executors.newSingleThreadExecutor();
 
     @Value("${spring.datasource.hikari.schema:taxonomy_api}")
     private String defaultSchema;
 
-    public VersionService(VersionRepository versionRepository, EntityManager entityManager) {
-        this.versionRepository = versionRepository;
+    public VersionService(EntityManager entityManager, VersionRepository versionRepository, NodeService nodeService) {
         this.entityManager = entityManager;
+        this.versionRepository = versionRepository;
+        this.nodeService = nodeService;
     }
 
     @Transactional
@@ -83,6 +91,22 @@ public void publishBetaAndArchiveCurrent(URI id) {
         beta.setLocked(true);
         beta.setPublished(Instant.now());
         versionRepository.save(beta);
+
+        disconnectAllInvisibleNodes(beta.getHash());
+    }
+
+    private void disconnectAllInvisibleNodes(String hash) {
+        // Use a task to run in a separate thread against a specified schema
+        try {
+            Deleter deleter = new Deleter();
+            deleter.setNodeService(nodeService);
+            deleter.setVersion(schemaFromHash(hash));
+            Future<DomainEntity> future = executor.submit(deleter);
+            future.get();
+        } catch (Exception e) {
+            logger.info(e.getMessage(), e);
+            // throw new NotFoundServiceException("Failed to disconnect invisible children in schema", e);
+        }
     }
 
     @Transactional

src/main/java/no/ndla/taxonomy/service/task/Deleter.java

@@ -0,0 +1,25 @@
+/*
+ * Part of NDLA taxonomy-api
+ * Copyright (C) 2022 NDLA
+ *
+ * See LICENSE
+ */
+
+package no.ndla.taxonomy.service.task;
+
+import java.util.Optional;
+import no.ndla.taxonomy.domain.DomainEntity;
+import no.ndla.taxonomy.service.NodeService;
+
+public class Deleter extends Task<DomainEntity> {
+    private NodeService nodeService;
+
+    public void setNodeService(NodeService nodeService) {
+        this.nodeService = nodeService;
+    }
+
+    @Override
+    protected Optional<DomainEntity> execute() {
+        return nodeService.disconnectAllInvisibleNodes();
+    }
+}

src/test/java/no/ndla/taxonomy/rest/v1/RestTest.java

@@ -25,7 +25,7 @@
 @SpringBootTest
 @ActiveProfiles("junit")
 @Transactional
-public abstract class RestTest extends AbstractIntegrationTest {
+public class RestTest extends AbstractIntegrationTest {
 
     @Autowired
     EntityManager entityManager;

src/test/java/no/ndla/taxonomy/rest/v1/VersionsTest.java

@@ -179,10 +179,17 @@ public void can_update_version() throws Exception {
 
     @Test
     public void can_publish_version() throws Exception {
-        Version version = builder.version(); // BETA
-        testUtils.updateResource("/v1/versions/" + version.getPublicId() + "/publish", null);
+        var versionUri = URI.create("urn:version:beta");
+        final var createVersionCommand = new VersionPostPut() {
+            {
+                id = Optional.of(versionUri);
+                name = "Beta";
+            }
+        };
+        testUtils.createResource("/v1/versions", createVersionCommand);
+        testUtils.updateResource("/v1/versions/" + versionUri + "/publish", null);
 
-        Version updated = versionRepository.getByPublicId(version.getPublicId());
+        Version updated = versionRepository.getByPublicId(versionUri);
         assertEquals(VersionType.PUBLISHED, updated.getVersionType());
         assertTrue(updated.isLocked());
         assertNotNull(updated.getPublished());

src/test/java/no/ndla/taxonomy/service/AbstractIntegrationTest.java

@@ -13,18 +13,15 @@
 import org.springframework.test.context.DynamicPropertyRegistry;
 import org.springframework.test.context.DynamicPropertySource;
 import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
 
 @Testcontainers
 @DirtiesContext
 public class AbstractIntegrationTest {
 
-    static final PostgreSQLContainer<?> postgresDB;
-
-    static {
-        postgresDB = new PostgreSQLContainer<>("postgres:13.12");
-        postgresDB.start();
-    }
+    @Container
+    private static final PostgreSQLContainer<?> postgresDB = new PostgreSQLContainer<>("postgres:13.15");
 
     @Autowired
     EntityManager entityManager;