generator-jhipster 7.6.0 → 7.8.1

package/generators/server/templates/src/main/java/package/web/rest/KafkaResource.java.ejs

@@ -18,133 +18,85 @@
 -%>
 package <%= packageName %>.web.rest;
 
-import <%= packageName %>.config.KafkaProperties;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-<%_ if (!reactive) { _%>
-import org.apache.kafka.clients.consumer.ConsumerRecords;
-import org.apache.kafka.clients.consumer.KafkaConsumer;
-import org.apache.kafka.clients.producer.KafkaProducer;
-import org.apache.kafka.clients.producer.ProducerRecord;
-import org.apache.kafka.clients.producer.RecordMetadata;
-<%_ }  _%>
+import static org.springframework.web.servlet.mvc.method.annotation.SseEmitter.event;
+
+import java.io.IOException;
+import java.security.Principal;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cloud.stream.annotation.StreamListener;
+import org.springframework.http.MediaType;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.util.MimeTypeUtils;
+
 import org.springframework.web.bind.annotation.*;
-<%_ if (reactive) { _%>
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.kafka.receiver.KafkaReceiver;
-import reactor.kafka.receiver.ReceiverOptions;
-import reactor.kafka.sender.KafkaSender;
-import reactor.kafka.sender.SenderOptions;
-import reactor.kafka.sender.SenderRecord;
-import reactor.kafka.sender.SenderResult;
-<%_ }  _%>
-<%_ if (!reactive) { _%>
+import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyEmitter;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
-<%_ }  _%>
 
-<%_ if (!reactive) { _%>
-import java.time.Duration;
-<%_ }  _%>
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-<%_ if (!reactive) { _%>
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-<%_ }  _%>
+import <%= packageName %>.config.KafkaSseConsumer;
+import <%= packageName %>.config.KafkaSseProducer;
 
 @RestController
 @RequestMapping("/api/<%= dasherizedBaseName %>-kafka")
 public class <%= upperFirstCamelCase(baseName) %>KafkaResource {
 
     private final Logger log = LoggerFactory.getLogger(<%= upperFirstCamelCase(baseName) %>KafkaResource.class);
+    private final MessageChannel output;
+
+    // TODO implement state of the art emitter repository to become 12 factor
+    private Map<String, SseEmitter> emitters = new HashMap<>();
 
-    private final KafkaProperties kafkaProperties;
-<%_ if (reactive) { _%>
-    private KafkaSender<String, String> sender;
-<%_ } else { _%>
-    private KafkaProducer<String, String> producer;
-    private ExecutorService sseExecutorService = Executors.newCachedThreadPool();
-<%_ }  _%>
-
-    public <%= upperFirstCamelCase(baseName) %>KafkaResource(KafkaProperties kafkaProperties) {
-        this.kafkaProperties = kafkaProperties;
-<%_ if (reactive) { _%>
-        this.sender = KafkaSender.create(SenderOptions.create(kafkaProperties.getProducerProps()));
-<%_ } else { _%>
-        this.producer = new KafkaProducer<>(kafkaProperties.getProducerProps());
-<%_ }  _%>
+    public <%= upperFirstCamelCase(baseName) %>KafkaResource(@Qualifier(KafkaSseProducer.CHANNELNAME) MessageChannel output) {
+        this.output = output;
     }
 
-    @PostMapping("/publish/{topic}")
-    public <% if (reactive) { %>Mono<PublishResult><% } else { %>PublishResult<% }  %> publish(@PathVariable String topic, @RequestParam String message, @RequestParam(required = false) String key)<% if (!reactive) { %> throws ExecutionException, InterruptedException<% } %> {
-        log.debug("REST request to send to Kafka topic {} with key {} the message : {}", topic, key, message);
-<%_ if (reactive) { _%>
-        return Mono.just(SenderRecord.create(topic, null, null, key, message, null))
-            .as(sender::send)
-            .next()
-            .map(SenderResult::recordMetadata)
-            .map(metadata -> new PublishResult(metadata.topic(), metadata.partition(), metadata.offset(), Instant.ofEpochMilli(metadata.timestamp())));
-<%_ } else { _%>
-        RecordMetadata metadata = producer.send(new ProducerRecord<>(topic, key, message)).get();
-        return new PublishResult(metadata.topic(), metadata.partition(), metadata.offset(), Instant.ofEpochMilli(metadata.timestamp()));
-<%_ }  _%>
+    @PostMapping("/publish")
+    public void publish(@RequestParam String message) {
+        log.debug("REST request the message : {} to send to Kafka topic ", message);
+        Map<String, Object> map = new HashMap<>();
+        map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN_VALUE);
+        MessageHeaders headers = new MessageHeaders(map);
+        output.send(new GenericMessage<>(message, headers));
     }
 
-    @GetMapping("/consume")
-    public <% if (reactive) { %>Flux<String><% } else { %>SseEmitter<% }  %> consume(@RequestParam("topic") List<String> topics, @RequestParam Map<String, String> consumerParams) {
-        log.debug("REST request to consume records from Kafka topics {}", topics);
-        Map<String, Object> consumerProps = kafkaProperties.getConsumerProps();
-        consumerProps.putAll(consumerParams);
-        consumerProps.remove("topic");
-
-<%_ if (reactive) { _%>
-        ReceiverOptions<String, String> receiverOptions = ReceiverOptions.<String, String>create(consumerProps)
-            .subscription(topics);
-        return KafkaReceiver.create(receiverOptions)
-            .receive()
-            .map(ConsumerRecord::value);
-<%_ } else { _%>
-        SseEmitter emitter = new SseEmitter(0L);
-        sseExecutorService.execute(() -> {
-            KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps);
-            emitter.onCompletion(consumer::close);
-            consumer.subscribe(topics);
-            boolean exitLoop = false;
-            while(!exitLoop) {
+    @GetMapping("/register")
+    public ResponseBodyEmitter register(Principal principal) {
+        log.debug("Registering sse client for {}", principal.getName());
+        SseEmitter emitter = new SseEmitter();
+        emitter.onCompletion(() -> emitters.remove(emitter));
+        emitters.put(principal.getName(), emitter);
+        return emitter;
+    }
+
+    @GetMapping("/unregister")
+    public void unregister(Principal principal) {
+        String user = principal.getName();
+        log.debug("Unregistering sse emitter for user: {}", user);
+        Optional.ofNullable(emitters.get(user))
+            .ifPresent(ResponseBodyEmitter::complete);
+    }
+
+    @StreamListener(value = KafkaSseConsumer.CHANNELNAME, copyHeaders = "false")
+    public void consume(Message<String> message) {
+        log.debug("Got message from kafka stream: {}", message.getPayload());
+        emitters.entrySet().stream().map(Map.Entry::getValue)
+            .forEach((SseEmitter emitter) -> {
                 try {
-                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(5));
-                    for (ConsumerRecord<String, String> record : records) {
-                        emitter.send(record.value());
-                    }
-                    emitter.send(SseEmitter.event().comment(""));
-                } catch (Exception ex) {
-                    log.trace("Complete with error {}", ex.getMessage(), ex);
-                    emitter.completeWithError(ex);
-                    exitLoop = true;
-                }
+                    emitter.send(event().data(message.getPayload(), MediaType.TEXT_PLAIN));
+                } catch (IOException e) {
+                log.debug("error sending sse message, {}", message.getPayload());
             }
-            consumer.close();
-            emitter.complete();
         });
-        return emitter;
-<%_ }  _%>
     }
 
-    private static class PublishResult {
-        public final String topic;
-        public final int partition;
-        public final long offset;
-        public final Instant timestamp;
-
-        private PublishResult(String topic, int partition, long offset, Instant timestamp) {
-            this.topic = topic;
-            this.partition = partition;
-            this.offset = offset;
-            this.timestamp = timestamp;
-        }
-    }
+
 }
+

package/generators/server/templates/src/main/java/package/web/rest/KafkaResource_reactive.java.ejs

@@ -0,0 +1,74 @@
+<%#
+ Copyright 2013-2022 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.web.rest;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cloud.stream.annotation.StreamListener;
+import org.springframework.http.ResponseEntity;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.util.MimeTypeUtils;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.publisher.Sinks;
+import <%= packageName %>.config.KafkaSseConsumer;
+import <%= packageName %>.config.KafkaSseProducer;
+
+@RestController
+@RequestMapping("/api/<%= dasherizedBaseName %>-kafka")
+public class <%= upperFirstCamelCase(baseName) %>KafkaResource {
+
+    private final Logger log = LoggerFactory.getLogger(<%= upperFirstCamelCase(baseName) %>KafkaResource.class);
+
+    private final MessageChannel output;
+    private Sinks.Many<Message<String>> sink = Sinks.many().unicast().onBackpressureBuffer();
+
+    public <%= upperFirstCamelCase(baseName) %>KafkaResource(@Qualifier(KafkaSseProducer.CHANNELNAME) MessageChannel output) {
+        this.output = output;
+    }
+
+    @PostMapping("/publish")
+    public Mono<ResponseEntity<Void>> publish(@RequestParam String message) {
+        log.debug("REST request the message : {} to send to Kafka topic", message);
+        Map<String, Object> map = new HashMap<>();
+        map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN_VALUE);
+        MessageHeaders headers = new MessageHeaders(map);
+        output.send(new GenericMessage<>(message, headers));
+        return Mono.just(ResponseEntity.noContent().build());
+    }
+
+    @GetMapping("/consume")
+    public Flux<String> consume() {
+        log.debug("REST request to consume records from Kafka topics");
+        return sink.asFlux().map(m -> m.getPayload());
+    }
+
+    @StreamListener(value = KafkaSseConsumer.CHANNELNAME, copyHeaders = "false")
+    public void consume(Message<String> message) {
+        log.debug("Got message from kafka stream: {}", message.getPayload());
+        sink.emitNext(message, Sinks.EmitFailureHandler.FAIL_FAST);
+    }
+}

package/generators/server/templates/src/main/java/package/web/rest/LogoutResource_reactive.java.ejs

@@ -1,5 +1,5 @@
 <%#
- Copyright 2013-2021 the original author or authors from the JHipster project.
+ Copyright 2013-2022 the original author or authors from the JHipster project.
 
  This file is part of the JHipster project, see https://www.jhipster.tech/
  for more information.

package/generators/server/templates/src/main/java/package/web/rest/PublicUserResource.java.ejs

@@ -194,10 +194,10 @@ public class PublicUserResource {
     <%_ } _%>
   <%_ } else { _%>
      <%_ if (reactive) { _%>
-        return userRepository.search(User.PREFIX, query).map(<%= asDto('User') %>::new).collectList();
+        return userRepository.search(query).map(<%= asDto('User') %>::new).collectList();
      <%_ } else { _%>
         return StreamSupport
-            .stream(userRepository.search(User.PREFIX, query).spliterator(), false)
+            .stream(userRepository.search(query).spliterator(), false)
             .map(<%= asDto('User') %>::new)
             .collect(Collectors.toList());
      <%_ } _%>

package/generators/server/templates/src/main/resources/config/application-dev.yml.ejs

@@ -255,6 +255,11 @@ spring:
     cache: false
 <%_ if (serviceDiscoveryType || applicationTypeGateway || applicationTypeMicroservice) { _%>
   sleuth:
+    # https://github.com/spring-projects/spring-framework/issues/27844#issuescomment-1002866885
+    # https://github.com/spring-cloud/spring-cloud-sleuth/issues/2094
+    async:
+      enabled: false
+    enabled: false
     sampler:
       probability: 1 # report 100% of traces
   zipkin: # Use the "zipkin" Maven profile to have the Spring Cloud Zipkin dependencies
@@ -290,6 +295,7 @@ jhipster:
   database:
     couchbase:
       bucket-name: <%= baseName %>
+      scope-name: <%= camelizedBaseName %>
 <%_ } _%>
 <%_ if (!cacheProviderNo) { _%>
   cache: # Cache configuration
@@ -350,6 +356,8 @@ jhipster:
   cors:
     # Allow Ionic for JHipster by default (* no longer allowed in Spring Boot 2.4+)
     allowed-origins: "http://localhost:8100,https://localhost:8100,http://localhost:9000,https://localhost:9000<%_ if (!skipClient) { _%>,http://localhost:<%= devServerPort %>,https://localhost:<%= devServerPort %><%_ if (applicationTypeGateway && microfrontend) { for ({applicationIndex, devServerPort: microserviceDevServerPort = devServerPort + applicationIndex} of Object.values(jhipsterConfig.applications || {})) { _%>,http://localhost:<%= microserviceDevServerPort %>,https://localhost:<%= microserviceDevServerPort %><%_ } } _%><%_ } _%>"
+    # Enable CORS when running in GitHub Codespaces
+    allowed-origin-patterns: 'https://*.githubpreview.dev'
     allowed-methods: "*"
     allowed-headers: "*"
   <%_ if (authenticationTypeSession) { _%>

package/generators/server/templates/src/main/resources/config/application-prod.yml.ejs

@@ -209,6 +209,11 @@ spring:
     cache: true
 <%_ if (serviceDiscoveryType || applicationTypeGateway || applicationTypeMicroservice) { _%>
   sleuth:
+    # https://github.com/spring-projects/spring-framework/issues/27844#issuescomment-1002866885
+    # https://github.com/spring-cloud/spring-cloud-sleuth/issues/2094
+    async:
+      enabled: false
+    enabled: false
     sampler:
       probability: 1 # report 100% of traces
   zipkin: # Use the "zipkin" Maven profile to have the Spring Cloud Zipkin dependencies
@@ -269,6 +274,7 @@ jhipster:
   database:
     couchbase:
       bucket-name: <%= baseName %>
+      scope-name: <%= camelizedBaseName %>
 <%_ } _%>
 <%_ if (!cacheProviderNo) { _%>
   cache: # Cache configuration

package/generators/server/templates/src/main/resources/config/application.yml.ejs

@@ -113,6 +113,8 @@ management:
   info:
     git:
       mode: full
+    env:
+      enabled: true
   health:
     mail:
       enabled: false # When using the MailService, configure an SMTP server and set this to true
@@ -154,7 +156,7 @@ spring:
 <%_ } _%>
   application:
     name: <%= baseName %>
-<%_ if (serviceDiscoveryConsul || (applicationTypeGateway && reactive)) { _%>
+<%_ if (serviceDiscoveryConsul || (applicationTypeGateway && reactive) || messageBrokerKafka) { _%>
   cloud:
   <%_ if (serviceDiscoveryConsul) { _%>
     consul:
@@ -187,6 +189,23 @@ spring:
         pool:
           max-connections: 1000
   <%_ } _%>
+  <%_ if (messageBrokerKafka) { _%>
+    stream:
+      kafka:
+        binder:
+          replicationFactor: 1
+          auto-create-topics: true
+          brokers: localhost:9092
+      bindings:
+        binding-in-sse:
+          destination: sse-topic
+          content-type: text/plain
+          group: <%= dasherizedBaseName %>
+        binding-out-sse:
+          destination: sse-topic
+          content-type: text/plain
+          group: <%= dasherizedBaseName %>
+  <%_ } _%>
 <%_ } _%>
   profiles:
     # The commented value for `active` can be replaced with valid Spring profiles to load.
@@ -250,7 +269,6 @@ spring:
     basename: i18n/messages
   main:
     allow-bean-definition-overriding: true
-    allow-circular-references: true
 <%_ if (!reactive) { _%>
   mvc:
     pathmatch:
@@ -297,7 +315,7 @@ spring:
             client-id: web_app
             client-secret: web_app
   <%_ } _%>
-            scope: openid,profile,email
+            scope: openid, profile, email, offline_access # last one for refresh tokens
 <%_ } _%>
 
 server:
@@ -328,11 +346,11 @@ jhipster:
   #   allowed-origins: "http://localhost:8100,http://localhost:9000"
   #   allowed-methods: "*"
   #   allowed-headers: "*"
-  <%_ if (authenticationType === 'session') { _%>
+<%_ if (authenticationTypeSession) { _%>
   #   exposed-headers: "Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
-  <%_ } else { _%>
+<%_ } else { _%>
   #   exposed-headers: "Authorization,Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
-  <%_ } _%>
+<%_ } _%>
   #   allow-credentials: true
   #   max-age: 1800
   mail:
@@ -350,28 +368,16 @@ jhipster:
     license: unlicensed
     license-url:
   security:
-    <%_ if (clientTheme !== 'none') { _%>
+<%_ if (clientTheme !== 'none') { _%>
     content-security-policy: "default-src 'self'; frame-src 'self' data:; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://storage.googleapis.com; style-src 'self' https://fonts.googleapis.com 'unsafe-inline'; img-src 'self' data:; font-src 'self' https://fonts.gstatic.com data:"
-    <%_ } else { _%>
+<%_ } else { _%>
     content-security-policy: "default-src 'self'; frame-src 'self' data:; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://storage.googleapis.com; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:"
-    <%_ } _%>
-    <%_ if (authenticationType === 'oauth2') { _%>
+<%_ } _%>
+<%_ if (authenticationTypeOauth2) { _%>
     oauth2:
       audience:
         - account
         - api://default
-  <%_ } _%>
-<%_ if (messageBroker === 'kafka') { _%>
-kafka:
-  bootstrap-servers: localhost:9092
-  consumer:
-    key.deserializer: org.apache.kafka.common.serialization.StringDeserializer
-    value.deserializer: org.apache.kafka.common.serialization.StringDeserializer
-    group.id: <%= dasherizedBaseName %>
-    auto.offset.reset: earliest
-  producer:
-    key.serializer: org.apache.kafka.common.serialization.StringSerializer
-    value.serializer: org.apache.kafka.common.serialization.StringSerializer
 <%_ } _%>
 
 # ===================================================================

package/generators/server/templates/src/test/java/package/CassandraKeyspaceIT.java.ejs

@@ -18,17 +18,16 @@
 -%>
 package <%= packageName %>;
 
-import <%= packageName %>.IntegrationTest;
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.metadata.Metadata;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
+import org.cassandraunit.CQLDataLoader;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @IntegrationTest
-public class CassandraKeyspaceIT extends AbstractCassandraTest {
+public class CassandraKeyspaceIT {
 
     @Autowired
     private CqlSession session;
@@ -36,6 +35,6 @@ public class CassandraKeyspaceIT extends AbstractCassandraTest {
     @Test
     void shouldListCassandraUnitKeyspace() {
         Metadata metadata = session.getMetadata();
-        assertThat(metadata.getKeyspace(CASSANDRA_UNIT_KEYSPACE)).isNotNull();
+        assertThat(metadata.getKeyspace(CQLDataLoader.DEFAULT_KEYSPACE_NAME)).isNotNull();
     }
 }

package/generators/server/templates/src/test/java/package/IntegrationTest.java.ejs

@@ -20,13 +20,17 @@ package <%= packageName %>;
 
 import <%= packageName %>.<%= mainClass %>;
 <%_ if (databaseTypeCouchbase) { _%>
-import <%= packageName %>.CouchbaseTestContainerExtension;
+import org.springframework.test.context.ActiveProfiles;
+import tech.jhipster.config.JHipsterConstants;
 <%_ } _%>
 <%_ if (databaseTypeNeo4j) { _%>
 import <%= packageName %>.AbstractNeo4jIT;
 <%_ } _%>
 <%_ if (databaseTypeMongodb) { _%>
-    import <%= packageName %>.MongoDbTestContainerExtension;
+import <%= packageName %>.config.EmbeddedMongo;
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+import <%= packageName %>.config.EmbeddedCassandra;
 <%_ } _%>
 <%_ if (reactiveSqlTestContainers) { _%>
 import <%= packageName %>.ReactiveSqlTestContainerExtension;
@@ -37,7 +41,7 @@ import <%= packageName %>.RedisTestContainerExtension;
 <%_ if (authenticationTypeOauth2) { _%>
 import <%= packageName %>.config.TestSecurityConfiguration;
 <%_ } _%>
-<%_ if (cacheProviderRedis || databaseTypeNeo4j || databaseTypeCouchbase || reactiveSqlTestContainers || databaseTypeMongodb) { _%>
+<%_ if (cacheProviderRedis || databaseTypeNeo4j || databaseTypeCouchbase || reactiveSqlTestContainers) { _%>
 import org.junit.jupiter.api.extension.ExtendWith;
 <%_ } _%>
 
@@ -63,9 +67,13 @@ import java.lang.annotation.Target;
 <%_ } _%>
 <%_ if (databaseTypeCouchbase) { _%>
 @ExtendWith(CouchbaseTestContainerExtension.class)
+@ActiveProfiles(JHipsterConstants.SPRING_PROFILE_TEST)
 <%_ } _%>
 <%_ if (databaseTypeMongodb) { _%>
-@ExtendWith(MongoDbTestContainerExtension.class)
+@EmbeddedMongo
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+@EmbeddedCassandra
 <%_ } _%>
 <%_ if (databaseTypeNeo4j) { _%>
 @ExtendWith(AbstractNeo4jIT.class)

package/generators/server/templates/src/test/java/package/TechnicalStructureTest.java.ejs

@@ -27,6 +27,11 @@ import static com.tngtech.archunit.base.DescribedPredicate.alwaysTrue;
 import static com.tngtech.archunit.core.domain.JavaClass.Predicates.belongToAnyOf;
 import static com.tngtech.archunit.library.Architectures.layeredArchitecture;
 
+<%_
+  const hasClientLayer = !reactive && (applicationTypeMicroservice || applicationTypeGateway);
+  const hasDomainLayer = !databaseTypeNo;
+  const hasConstants = !skipUserManagement || databaseTypeSql || databaseTypeMongodb || databaseTypeCouchbase || databaseTypeNeo4j;
+_%>
 @AnalyzeClasses(packagesOf = <%= mainClass %>.class, importOptions = DoNotIncludeTests.class)
 class TechnicalStructureTest {
 
@@ -34,36 +39,34 @@ class TechnicalStructureTest {
     @ArchTest
     static final ArchRule respectsTechnicalArchitectureLayers = layeredArchitecture()
         .layer("Config").definedBy("..config..")
-<%_ if (applicationTypeMicroservice) { _%>
+<%_ if (hasClientLayer) { _%>
         .layer("Client").definedBy("..client..")
 <%_ } _%>
         .layer("Web").definedBy("..web..")
-<%_ if (!databaseTypeNo || authenticationTypeOauth2) { _%>
-        .layer("Service").definedBy("..service..")
-<%_ } _%>
+        .optionalLayer("Service").definedBy("..service..")
         .layer("Security").definedBy("..security..")
-<%_ if (!databaseTypeNo) { _%>
+<%_ if (hasDomainLayer) { _%>
         .layer("Persistence").definedBy("..repository..")
         .layer("Domain").definedBy("..domain..")
 <%_ } _%>
 
-<%_ if (messageBrokerKafka) { _%>
-        .whereLayer("Config").mayOnlyBeAccessedByLayers("Web")
-<%_ } else { _%>
         .whereLayer("Config").mayNotBeAccessedByAnyLayer()
-<%_ } _%>
-<%_ if (applicationTypeMicroservice) { _%>
+<%_ if (hasClientLayer) { _%>
         .whereLayer("Client").mayNotBeAccessedByAnyLayer()
 <%_ } _%>
         .whereLayer("Web").mayOnlyBeAccessedByLayers("Config")
-<%_ if (!databaseTypeNo || authenticationTypeOauth2) { _%>
         .whereLayer("Service").mayOnlyBeAccessedByLayers("Web", "Config")
-<%_ } _%>
-        .whereLayer("Security").mayOnlyBeAccessedByLayers(<% if (applicationTypeMicroservice) { %>"Client", <% } %>"Web"<% if (!databaseTypeNo || authenticationTypeOauth2) { %>, "Service"<% } %>, "Config")
-<%_ if (!databaseTypeNo) { _%>
+        .whereLayer("Security").mayOnlyBeAccessedByLayers("Config", <% if (hasClientLayer) { %>"Client", <% } %>"Service", "Web")
+<%_ if (hasDomainLayer) { _%>
         .whereLayer("Persistence").mayOnlyBeAccessedByLayers("Service", "Security", "Web", "Config")
         .whereLayer("Domain").mayOnlyBeAccessedByLayers("Persistence", "Service", "Security", "Web", "Config")
 <%_ } _%>
 
-        .ignoreDependency(belongToAnyOf(<%= mainClass %>.class), alwaysTrue());
+        .ignoreDependency(belongToAnyOf(<%= mainClass %>.class), alwaysTrue())
+        .ignoreDependency(alwaysTrue(), belongToAnyOf(
+<%_ if (hasConstants) { _%>
+            <%= packageName %>.config.Constants.class,
+<%_ } _%>
+            <%= packageName %>.config.ApplicationProperties.class
+        ));
 }