diff --git a/pom.xml b/pom.xml
index e0d9d65..02d9feb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -32,7 +32,7 @@
     </scm>
 
     <properties>
-        <gridsuite-dependencies.version>37.0.0</gridsuite-dependencies.version>
+        <gridsuite-dependencies.version>38.0.0</gridsuite-dependencies.version>
         <string-template.version>4.3.1</string-template.version>
         <liquibase-hibernate-package>org.gridsuite.mapping.server</liquibase-hibernate-package>
     </properties>
diff --git a/src/main/java/org/gridsuite/mapping/server/controller/MappingController.java b/src/main/java/org/gridsuite/mapping/server/controller/MappingController.java
index 6bf5d9d..b196f7a 100644
--- a/src/main/java/org/gridsuite/mapping/server/controller/MappingController.java
+++ b/src/main/java/org/gridsuite/mapping/server/controller/MappingController.java
@@ -15,9 +15,12 @@
 import org.gridsuite.mapping.server.dto.RenameObject;
 import org.gridsuite.mapping.server.dto.models.Model;
 import org.gridsuite.mapping.server.service.MappingService;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
 
 import java.util.List;
 
@@ -30,6 +33,8 @@
 @AllArgsConstructor
 public class MappingController {
 
+    private static final String CONFLICT_MAPPING_ERROR_MESSAGE = "A mapping already exists with name: ";
+
     private final MappingService mappingService;
 
     @GetMapping(value = "/")
@@ -77,8 +82,15 @@ public ResponseEntity<String> deleteMapping(@PathVariable("mappingName") String
         @ApiResponse(responseCode = "404", description = "Mapping not found"),
         @ApiResponse(responseCode = "500", description = "The storage is down or a mapping with the same name already exists")})
     public ResponseEntity<RenameObject> renameMapping(@PathVariable("oldName") String oldName, @PathVariable("newName") String newName) {
-        RenameObject renamedMapping = mappingService.renameMapping(oldName, newName);
-        return ResponseEntity.ok().body(renamedMapping);
+        return ResponseEntity.ok().body(renameMappingWithUniquenessCheck(oldName, newName));
+    }
+
+    private RenameObject renameMappingWithUniquenessCheck(String oldName, String newName) {
+        try {
+            return mappingService.renameMapping(oldName, newName);
+        } catch (DataIntegrityViolationException ex) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, CONFLICT_MAPPING_ERROR_MESSAGE + newName, ex);
+        }
     }
 
     @PostMapping(value = "/copy/{originalName}/to/{copyName}")
@@ -87,8 +99,15 @@ public ResponseEntity<RenameObject> renameMapping(@PathVariable("oldName") Strin
         @ApiResponse(responseCode = "404", description = "Mapping not found"),
         @ApiResponse(responseCode = "500", description = "The storage is down or a mapping with the same name already exists")})
     public ResponseEntity<InputMapping> copyMapping(@PathVariable("originalName") String originalName, @PathVariable("copyName") String copyName) {
-        InputMapping copiedMapping = mappingService.copyMapping(originalName, copyName);
-        return ResponseEntity.ok().body(copiedMapping);
+        return ResponseEntity.ok().body(copyMappingWithUniquenessCheck(originalName, copyName));
+    }
+
+    private InputMapping copyMappingWithUniquenessCheck(String originalName, String copyName) {
+        try {
+            return mappingService.copyMapping(originalName, copyName);
+        } catch (DataIntegrityViolationException ex) {
+            throw new ResponseStatusException(HttpStatus.CONFLICT, CONFLICT_MAPPING_ERROR_MESSAGE + copyName, ex);
+        }
     }
 
 }
diff --git a/src/main/java/org/gridsuite/mapping/server/service/implementation/MappingServiceImpl.java b/src/main/java/org/gridsuite/mapping/server/service/implementation/MappingServiceImpl.java
index 0abaeee..11d2397 100644
--- a/src/main/java/org/gridsuite/mapping/server/service/implementation/MappingServiceImpl.java
+++ b/src/main/java/org/gridsuite/mapping/server/service/implementation/MappingServiceImpl.java
@@ -25,7 +25,6 @@
 import org.gridsuite.mapping.server.service.client.filter.FilterClient;
 import org.gridsuite.mapping.server.utils.Methods;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -44,8 +43,7 @@
 @Service
 public class MappingServiceImpl implements MappingService {
 
-    public static final String CONFLICT_MAPPING_ERROR_MESSAGE = "A mapping already exists with name: ";
-    public static final String MAPPING_NOT_FOUND_ERROR_MESSAGE = "Mapping not found with name: ";
+    private static final String MAPPING_NOT_FOUND_ERROR_MESSAGE = "Mapping not found with name: ";
 
     private final ModelRepository modelRepository;
     private final MappingRepository mappingRepository;
@@ -114,6 +112,7 @@ public InputMapping getMapping(String mappingName) {
     }
 
     @Override
+    @Transactional
     public InputMapping saveMapping(String mappingName, InputMapping mapping) {
         if (!StringUtils.isBlank(mappingName)) {
             mapping.setName(mappingName);
@@ -210,66 +209,55 @@ public String deleteMapping(String mappingName) {
     }
 
     @Override
+    @Transactional
     public RenameObject renameMapping(String oldName, String newName) {
         Optional<MappingEntity> mappingToRename = mappingRepository.findById(oldName);
         if (mappingToRename.isPresent()) {
             MappingEntity mappingToSave = new MappingEntity(newName, mappingToRename.get());
-            try {
-                mappingRepository.deleteById(oldName);
-                mappingRepository.save(mappingToSave);
-                return new RenameObject(oldName, newName);
-            } catch (DataIntegrityViolationException ex) {
-                throw new ResponseStatusException(HttpStatus.CONFLICT, CONFLICT_MAPPING_ERROR_MESSAGE + newName, ex);
-            }
+            mappingRepository.deleteById(oldName);
+            mappingRepository.save(mappingToSave);
+            return new RenameObject(oldName, newName);
         } else if (oldName.equals(DEFAULT_MAPPING_NAME)) {
             // In case of naming of new mapping, save it to db.
-            try {
-                mappingRepository.save(new MappingEntity(newName, new ArrayList<>(), new ArrayList<>(), false));
-                return new RenameObject(DEFAULT_MAPPING_NAME, newName);
-
-            } catch (DataIntegrityViolationException ex) {
-                throw new ResponseStatusException(HttpStatus.CONFLICT, CONFLICT_MAPPING_ERROR_MESSAGE + newName, ex);
-            }
+            mappingRepository.save(new MappingEntity(newName, new ArrayList<>(), new ArrayList<>(), false));
+            return new RenameObject(DEFAULT_MAPPING_NAME, newName);
         } else {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND, MAPPING_NOT_FOUND_ERROR_MESSAGE + oldName);
         }
     }
 
     @Override
+    @Transactional
     public InputMapping copyMapping(String originalName, String copyName) {
         Optional<MappingEntity> mappingToCopyOpt = mappingRepository.findById(originalName);
         MappingEntity mappingToCopy = mappingToCopyOpt.orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, MAPPING_NOT_FOUND_ERROR_MESSAGE + originalName));
 
         MappingEntity copiedMapping = new MappingEntity(copyName, mappingToCopy);
-        try {
-            // --- duplicate filters in filter-server--- //
-            // get all filter uuids that needs to duplicate its corresponding filter
-            List<UUID> filterUuids = copiedMapping.getRules().stream()
-                .map(RuleEntity::getFilterUuid)
-                .filter(Objects::nonNull)
-                .toList();
+        // --- duplicate filters in filter-server--- //
+        // get all filter uuids that needs to duplicate its corresponding filter
+        List<UUID> filterUuids = copiedMapping.getRules().stream()
+            .map(RuleEntity::getFilterUuid)
+            .filter(Objects::nonNull)
+            .toList();
 
-            if (CollectionUtils.isNotEmpty(filterUuids)) {
-                // call filter-server API to duplicate filter
-                Map<UUID, UUID> uuidsMap = filterClient.duplicateFilters(filterUuids);
+        if (CollectionUtils.isNotEmpty(filterUuids)) {
+            // call filter-server API to duplicate filter
+            Map<UUID, UUID> uuidsMap = filterClient.duplicateFilters(filterUuids);
 
-                // replace the old by the new uuid for rule entities
-                copiedMapping.getRules().stream()
-                    .filter(rule -> rule.getFilterUuid() != null)
-                    .forEach(rule -> rule.setFilterUuid(uuidsMap.get(rule.getFilterUuid())));
-            }
+            // replace the old by the new uuid for rule entities
+            copiedMapping.getRules().stream()
+                .filter(rule -> rule.getFilterUuid() != null)
+                .forEach(rule -> rule.setFilterUuid(uuidsMap.get(rule.getFilterUuid())));
+        }
 
-            // --- persist in cascade the mapping in local database --- //
-            MappingEntity savedMappingEntity = mappingRepository.save(copiedMapping);
+        // --- persist in cascade the mapping in local database --- //
+        MappingEntity savedMappingEntity = mappingRepository.save(copiedMapping);
 
-            // --- build mapping dto to return --- //
-            InputMapping mapping = new InputMapping(savedMappingEntity);
-            enrichFiltersForMappings(List.of(mapping));
+        // --- build mapping dto to return --- //
+        InputMapping mapping = new InputMapping(savedMappingEntity);
+        enrichFiltersForMappings(List.of(mapping));
 
-            return mapping;
-        } catch (DataIntegrityViolationException ex) {
-            throw new ResponseStatusException(HttpStatus.CONFLICT, CONFLICT_MAPPING_ERROR_MESSAGE + copyName, ex);
-        }
+        return mapping;
     }
 
     @Transactional(readOnly = true)
@@ -291,11 +279,9 @@ public List<Model> getMappedModelsList(String mappingName) {
                 .collect(Collectors.toSet());
 
         // get model by name from db, concat to default models and convert to dtos
-        List<Model> mappedModels = Stream.concat(modelRepository.findAllById(mappedModelNames).stream(),
+        return Stream.concat(modelRepository.findAllById(mappedModelNames).stream(),
                         modelRepository.findAllByDefaultModelTrue().stream())
                 .map(Model::new).toList();
-
-        return mappedModels;
     }
 
 }
diff --git a/src/main/java/org/gridsuite/mapping/server/service/implementation/ModelServiceImpl.java b/src/main/java/org/gridsuite/mapping/server/service/implementation/ModelServiceImpl.java
index 96b83b8..48dbe1e 100644
--- a/src/main/java/org/gridsuite/mapping/server/service/implementation/ModelServiceImpl.java
+++ b/src/main/java/org/gridsuite/mapping/server/service/implementation/ModelServiceImpl.java
@@ -31,7 +31,8 @@
 import org.springframework.util.CollectionUtils;
 import org.springframework.web.client.HttpClientErrorException;
 
-import java.io.*;
+import java.io.IOException;
+import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -171,26 +172,31 @@ public String getAutomatonDefinitions() {
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<SimpleModel> getModels() {
-        return modelRepository.findAll().stream().map(modelEntity -> new SimpleModel(new Model(modelEntity))).collect(Collectors.toList());
+        return modelRepository.findAll().stream().map(modelEntity -> new SimpleModel(new Model(modelEntity))).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ModelParameter> getParameters() {
         return modelParameterRepository.findAll().stream().map(ModelParameter::new).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ParametersSetsGroup> getParametersSetsGroups() {
         return modelSetsGroupRepository.findAll().stream().map(ParametersSetsGroup::new).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ParametersSet> getParametersSets() {
         return modelParameterSetRepository.findAll().stream().map(ParametersSet::new).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ParametersSet> getSetsFromGroup(String modelName, String groupName, SetGroupType groupType) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -201,10 +207,11 @@ public List<ParametersSet> getSetsFromGroup(String modelName, String groupName,
                 .findAny();
         ModelSetsGroupEntity setsGroup = getSetsGroupFromOptional("[" + groupName + "," + groupType.name() + "]", modelSetsGroupOpt);
 
-        return setsGroup.getSets().stream().map(ParametersSet::new).collect(Collectors.toList());
+        return setsGroup.getSets().stream().map(ParametersSet::new).toList();
     }
 
     @Override
+    @Transactional
     public ParametersSetsGroup saveParametersSetsGroup(String modelName, ParametersSetsGroup setsGroup, Boolean strict) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -219,9 +226,7 @@ public ParametersSetsGroup saveParametersSetsGroup(String modelName, ParametersS
             savedGroups.add(groupToAdd);
         } else {
             // If additional checks are required here, ensure that set erasure cannot happen here with sets merging.
-            groupToAdd.getSets().forEach(set ->
-                    previousGroup.addParameterSet(set)
-            );
+            groupToAdd.getSets().forEach(previousGroup::addParameterSet);
         }
 
         if (new Model(modelToUpdate).isParameterSetGroupValid(setsGroup.getName(), strict)) {
@@ -301,6 +306,7 @@ public List<String> deleteModels(List<String> modelNames) {
     }
 
     @Override
+    @Transactional
     public ParametersSetsGroup deleteSet(String modelName, String groupName, SetGroupType groupType, String setName) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -326,17 +332,20 @@ public ParametersSetsGroup deleteSet(String modelName, String groupName, SetGrou
     // --- BEGIN parameter definition-related service methods --- //
 
     @Override
+    @Transactional(readOnly = true)
     public List<String> getParameterDefinitionNames() {
         return modelParameterDefinitionRepository.findAll().stream().map(ModelParameterDefinitionEntity::getName).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ModelParameterDefinition> getParameterDefinitions(List<String> parameterDefinitionNames) {
         return modelParameterDefinitionRepository.findAllById(parameterDefinitionNames).stream()
                 .map(parameterDefinitionEntity -> new ModelParameterDefinition(parameterDefinitionEntity, null, null)).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ModelParameterDefinition> getParameterDefinitionsFromModel(String modelName) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -380,8 +389,8 @@ public Model addExistingParameterDefinitionsToModel(String modelName, List<Strin
             // check whether found all, fail fast
             if (foundParameterDefinitionEntities.size() != parameterDefinitionNames.size()) {
                 List<String> foundNames = foundParameterDefinitionEntities.stream()
-                        .map(ModelParameterDefinitionEntity::getName).collect(Collectors.toList());
-                List<String> notFoundNames = parameterDefinitionNames.stream().filter(name -> !foundNames.contains(name)).collect(Collectors.toList());
+                        .map(ModelParameterDefinitionEntity::getName).toList();
+                List<String> notFoundNames = parameterDefinitionNames.stream().filter(name -> !foundNames.contains(name)).toList();
                 throw new HttpClientErrorException(HttpStatus.NOT_FOUND, "Some parameter definition not found: " + notFoundNames);
             }
 
@@ -428,7 +437,7 @@ public Model removeAllParameterDefinitionsOnModel(String modelName) {
 
         // clear the existing list
         modelToUpdate.removeAllParameterDefinition(modelToUpdate.getParameterDefinitions().stream()
-                .map(ModelModelParameterDefinitionEntity::getParameterDefinition).collect(Collectors.toList()));
+                .map(ModelModelParameterDefinitionEntity::getParameterDefinition).toList());
 
         // save modified existing model entity
         modelRepository.save(modelToUpdate);
@@ -444,7 +453,7 @@ public List<ModelParameterDefinition> saveNewParameterDefinitions(List<ModelPara
                     .map(ModelParameterDefinitionEntity::new)
                     .collect(Collectors.toCollection(LinkedHashSet::new));
             List<ModelParameterDefinitionEntity> savedParameterDefinitionEntities = modelParameterDefinitionRepository.saveAll(parameterDefinitionEntities);
-            return savedParameterDefinitionEntities.stream().map(entity -> new ModelParameterDefinition(entity, null, null)).collect(Collectors.toList());
+            return savedParameterDefinitionEntities.stream().map(entity -> new ModelParameterDefinition(entity, null, null)).toList();
         }
 
         return Collections.emptyList();
@@ -463,6 +472,7 @@ public List<String> deleteParameterDefinitions(List<String> parameterDefinitionN
 
     // --- BEGIN variable-related service methods --- //
     @Override
+    @Transactional(readOnly = true)
     public List<ModelVariableDefinition> getVariableDefinitionsFromModel(String modelName) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -473,10 +483,12 @@ public List<ModelVariableDefinition> getVariableDefinitionsFromModel(String mode
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<String> getVariableDefinitionNames() {
         return modelVariableRepository.findAll().stream().map(ModelVariableDefinitionEntity::getName).toList();
     }
 
+    @Transactional(readOnly = true)
     @Override
     public List<ModelVariableDefinition> getVariableDefinitions(List<String> variableNames) {
         return modelVariableRepository.findAllById(variableNames).stream().map(ModelVariableDefinition::new).toList();
@@ -494,7 +506,7 @@ public Model addNewVariableDefinitionsToModel(String modelName, List<ModelVariab
             // do merge with existing list
             List<ModelVariableDefinitionEntity> variableDefinitionEntities = variableDefinitions.stream()
                     .map(variableDefinition -> new ModelVariableDefinitionEntity(modelToUpdate, null, variableDefinition))
-                    .collect(Collectors.toList());
+                    .toList();
             modelToUpdate.addAllVariableDefinition(variableDefinitionEntities);
             // save modified existing model entity
             modelRepository.save(modelToUpdate);
@@ -519,8 +531,8 @@ public Model addExistingVariableDefinitionsToModel(String modelName, List<String
             // check whether found all, fail fast
             if (foundVariableDefinitionEntities.size() != variableDefinitionNames.size()) {
                 List<String> foundNames = foundVariableDefinitionEntities.stream()
-                        .map(ModelVariableDefinitionEntity::getName).collect(Collectors.toList());
-                List<String> notFoundNames = variableDefinitionNames.stream().filter(name -> !foundNames.contains(name)).collect(Collectors.toList());
+                        .map(ModelVariableDefinitionEntity::getName).toList();
+                List<String> notFoundNames = variableDefinitionNames.stream().filter(name -> !foundNames.contains(name)).toList();
                 throw new HttpClientErrorException(HttpStatus.NOT_FOUND, "Some variable definition not found: " + notFoundNames);
             }
 
@@ -564,7 +576,7 @@ public List<ModelVariableDefinition> saveNewVariableDefinitions(List<ModelVariab
                     .map(variableDefinition -> new ModelVariableDefinitionEntity(null, null, variableDefinition))
                     .collect(Collectors.toCollection(LinkedHashSet::new));
             List<ModelVariableDefinitionEntity> savedVariableDefinitionEntities = modelVariableRepository.saveAll(variableDefinitionEntities);
-            return savedVariableDefinitionEntities.stream().map(ModelVariableDefinition::new).collect(Collectors.toList());
+            return savedVariableDefinitionEntities.stream().map(ModelVariableDefinition::new).toList();
         }
         return Collections.emptyList();
     }
@@ -586,16 +598,19 @@ public Model removeAllVariableDefinitionsOnModel(String modelName) {
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<String> getVariablesSetNames() {
         return modelVariablesSetRepository.findAll().stream().map(ModelVariableSetEntity::getName).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<VariablesSet> getVariablesSets(List<String> variablesSetNames) {
         return modelVariablesSetRepository.findAllById(variablesSetNames).stream().map(VariablesSet::new).toList();
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<VariablesSet> getVariablesSetsFromModel(String modelName) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
@@ -614,6 +629,7 @@ public VariablesSet saveNewVariablesSet(VariablesSet variableSet) {
     }
 
     @Override
+    @Transactional(readOnly = true)
     public List<ModelVariableDefinition> getVariableDefinitionsFromVariablesSet(String variableSetName) {
         Optional<ModelVariableSetEntity> foundVariableSetOpt = modelVariablesSetRepository.findById(variableSetName);
 
@@ -634,7 +650,7 @@ public VariablesSet addNewVariableDefinitionToVariablesSet(String variableSetNam
             // do merge with existing list
             List<ModelVariableDefinitionEntity> variableDefinitionEntities = variableDefinitions.stream()
                     .map(variableDefinition -> new ModelVariableDefinitionEntity(null, variableSetToUpdate, variableDefinition))
-                    .collect(Collectors.toList());
+                    .toList();
             variableSetToUpdate.addAllVariableDefinition(variableDefinitionEntities);
             // save modified existing variables set entity
             modelVariablesSetRepository.save(variableSetToUpdate);
@@ -691,7 +707,7 @@ public Model addNewVariablesSetsToModel(String modelName, List<VariablesSet> var
             // do merge with existing list
             List<ModelVariableSetEntity> variablesSetEntities = variableSets.stream()
                     .map(variablesSet -> new ModelVariableSetEntity(modelToUpdate, variablesSet))
-                    .collect(Collectors.toList());
+                    .toList();
             modelToUpdate.addAllVariablesSet(variablesSetEntities);
             // save modified existing model entity
             modelRepository.save(modelToUpdate);
@@ -714,8 +730,8 @@ public Model addExistingVariablesSetsToModel(String modelName, List<String> vari
 
             // check whether found all
             if (foundVariablesSetEntities.size() != variablesSetNames.size()) {
-                List<String> foundNames = foundVariablesSetEntities.stream().map(ModelVariableSetEntity::getName).collect(Collectors.toList());
-                List<String> notFoundNames = variablesSetNames.stream().filter(name -> !foundNames.contains(name)).collect(Collectors.toList());
+                List<String> foundNames = foundVariablesSetEntities.stream().map(ModelVariableSetEntity::getName).toList();
+                List<String> notFoundNames = variablesSetNames.stream().filter(name -> !foundNames.contains(name)).toList();
                 throw new HttpClientErrorException(HttpStatus.NOT_FOUND, "Some variables set not found: " + notFoundNames);
             }
 
@@ -748,6 +764,7 @@ public Model removeExistingVariablesSetsFromModel(String modelName, List<String>
     }
 
     @Override
+    @Transactional
     public Model removeAllExistingVariablesSetsFromModel(String modelName) {
         Optional<ModelEntity> foundModelOpt = modelRepository.findById(modelName);
 
diff --git a/src/main/java/org/gridsuite/mapping/server/service/implementation/ParameterServiceImpl.java b/src/main/java/org/gridsuite/mapping/server/service/implementation/ParameterServiceImpl.java
index 898b03c..76f6631 100644
--- a/src/main/java/org/gridsuite/mapping/server/service/implementation/ParameterServiceImpl.java
+++ b/src/main/java/org/gridsuite/mapping/server/service/implementation/ParameterServiceImpl.java
@@ -26,6 +26,7 @@
 import org.gridsuite.mapping.server.utils.Templater;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.server.ResponseStatusException;
 
 import java.util.*;
@@ -51,6 +52,7 @@ public ParameterServiceImpl(
     }
 
     @Override
+    @Transactional(readOnly = true)
     public ParameterFile exportParameters(String mappingName) {
         Optional<MappingEntity> foundMapping = mappingRepository.findById(mappingName);
         if (foundMapping.isPresent()) {