Use single Backend enum; drop AUTO

Replaces the rqueue-spring-local Backend enum {AUTO, REDIS, NATS} with
the canonical com.github.sonus21.rqueue.config.Backend {REDIS, NATS}.
@EnableRqueue.backend() now defaults to REDIS; setting NATS pulls in
RqueueNatsListenerConfig alongside the legacy RqueueListenerConfig.
The runtime backend is independently bound from the rqueue.backend
property onto RqueueConfig — that is the source of truth for what
broker is active, regardless of which @configuration classes get
imported here.

ConditionalNatsConfig and the spring-local Backend.java are deleted;
the import selector now branches on REDIS vs NATS only.

Assisted-By: Claude Code

Author: sonus21

rqueue-spring/src/main/java/com/github/sonus21/rqueue/spring/Backend.java

@@ -16,33 +16,33 @@
 
 package com.github.sonus21.rqueue.spring;
 
+import com.github.sonus21.rqueue.config.Backend;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import org.springframework.context.annotation.Import;
 
 /**
- * This annotation can be used to auto configure Rqueue library by providing some sample
- * configuration like by just providing
- * {@link org.springframework.data.redis.connection.RedisConnectionFactory}.
- *
- * <p>All other beans would be created automatically. Though other components of library can be
- * configured as well using
- * {@link com.github.sonus21.rqueue.config.SimpleRqueueListenerContainerFactory}. Even it can be
- * configured at very fine-grained level by creating all individual beans created in
- * {@link RqueueListenerConfig}
+ * Auto-configure Rqueue when {@link
+ * org.springframework.data.redis.connection.RedisConnectionFactory} (or, when {@link
+ * #backend()} is {@link Backend#NATS}, an {@link io.nats.client.Connection}-derived
+ * {@code MessageBroker}) is available. All other beans are created automatically; further
+ * customization happens through {@link
+ * com.github.sonus21.rqueue.config.SimpleRqueueListenerContainerFactory} or by directly defining
+ * the beans created in {@link RqueueListenerConfig}.
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Import({RqueueBackendImportSelector.class})
 public @interface EnableRqueue {
 
   /**
-   * Backend to use. Defaults to {@link Backend#AUTO} which keeps the existing Redis behavior
-   * unless the jnats client is on the classpath and {@code rqueue.backend=nats} is set.
-   *
-   * @return the chosen backend selector
+   * Backend to wire. Defaults to {@link Backend#REDIS}. Set to {@link Backend#NATS} to import the
+   * NATS / JetStream listener configuration. The {@code rqueue.backend} property is independently
+   * read by {@link com.github.sonus21.rqueue.config.RqueueConfig} and remains the source of truth
+   * for the runtime backend; this attribute controls only which {@code @Configuration} class is
+   * pulled into the context.
    */
-  Backend backend() default Backend.AUTO;
+  Backend backend() default Backend.REDIS;
 }

rqueue-spring/src/main/java/com/github/sonus21/rqueue/spring/ConditionalNatsConfig.java

@@ -15,26 +15,23 @@
  */
 package com.github.sonus21.rqueue.spring;
 
-import java.util.ArrayList;
-import java.util.List;
+import com.github.sonus21.rqueue.config.Backend;
 import org.springframework.context.annotation.ImportSelector;
 import org.springframework.core.type.AnnotationMetadata;
 
 /**
  * Selects the listener configuration classes to import based on {@link EnableRqueue#backend()}.
  *
  * <ul>
- *   <li>{@link Backend#REDIS} — only the legacy {@code RqueueListenerConfig}</li>
- *   <li>{@link Backend#NATS} — base config plus {@code RqueueNatsListenerConfig} unconditionally
- *   <li>{@link Backend#AUTO} — base config; the NATS config is gated by
- *       {@link NatsBackendCondition} so it activates only when jnats is on the classpath
- *       <em>and</em> {@code rqueue.backend=nats} is set.
+ *   <li>{@link Backend#REDIS} (default) — only {@code RqueueListenerConfig}.</li>
+ *   <li>{@link Backend#NATS} — both {@code RqueueListenerConfig} and {@code
+ *       RqueueNatsListenerConfig}.</li>
  * </ul>
  */
 public class RqueueBackendImportSelector implements ImportSelector {
   @Override
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
-    Backend backend = Backend.AUTO;
+    Backend backend = Backend.REDIS;
     Object raw =
         importingClassMetadata.getAnnotationAttributes(EnableRqueue.class.getName()) == null
             ? null
@@ -47,17 +44,14 @@ public String[] selectImports(AnnotationMetadata importingClassMetadata) {
       try {
         backend = Backend.valueOf(raw.toString());
       } catch (IllegalArgumentException ignored) {
-        // keep AUTO
+        // keep default
       }
     }
-    List<String> imports = new ArrayList<>();
-    imports.add(RqueueListenerConfig.class.getName());
     if (backend == Backend.NATS) {
-      imports.add(RqueueNatsListenerConfig.class.getName());
-    } else if (backend == Backend.AUTO) {
-      // Conditionally registered via @Conditional in a thin wrapper.
-      imports.add(ConditionalNatsConfig.class.getName());
+      return new String[] {
+        RqueueListenerConfig.class.getName(), RqueueNatsListenerConfig.class.getName()
+      };
     }
-    return imports.toArray(new String[0]);
+    return new String[] {RqueueListenerConfig.class.getName()};
   }
 }