Promote dashboard service impls to rqueue-web; introduce MessageBrowsingRepository

Eliminate per-backend stub classes for the dashboard's web services. Move all
single-impl-capable service classes to rqueue-web and push the genuinely
backend-shaped storage primitives behind a new repository abstraction.

- Define MessageBrowsingRepository (rqueue-core/repository): three methods —
  getDataSize / getDataSizes (with bulk pipelining contract) / viewData. Replaces
  direct RqueueRedisTemplate access from RqueueQDetailServiceImpl.

- Implement RedisMessageBrowsingRepository (rqueue-redis): wraps
  RqueueRedisTemplate, pipelines getDataSizes via RedisUtils.executePipeLine for
  the home-dashboard size tables, renders all four viewData paths
  (LIST / ZSET / SET / KEY).

- Implement NatsMessageBrowsingRepository (rqueue-nats): sizes return 0; viewData
  throws BackendCapabilityException("nats", "viewData", ...) — JetStream KV does
  not model arbitrary keyed reads. RqueueWebExceptionAdvice maps that to HTTP 501.

- Promote 4 service impls from rqueue-redis to rqueue-web (single shared impl,
  no @conditional gating, no per-backend stub):
  - RqueueDashboardChartServiceImpl (already pure RqueueQStatsDao consumer)
  - RqueueJobServiceImpl (already pure RqueueJobDao consumer)
  - RqueueSystemManagerServiceImpl (drop RqueueStringDao for queue-name set;
    use EndpointRegistry instead. RqueueStringDao kept as required=false for the
    Redis-only deleteQueue hard-cleanup path; on NATS that returns code=1
    "not supported".)
  - RqueueQDetailServiceImpl (replace 14 stringRqueueRedisTemplate calls with
    repository calls; collapse 4 pipelined-size methods into one helper)

- Add NatsRqueueQStatsDao (no-op) so the now-unconditional
  RqueueJobMetricsAggregatorService boots on NATS without a missing-bean failure.

- Drop RedisBackendCondition from controllers + aggregator + view-controller
  service impl. The dashboard now wires on both backends; capability gaps surface
  as 501s from BackendCapabilityException, not as bean-graph failures.

- Wire the new MessageBrowsingRepository bean in both RqueueRedisListenerConfig
  and RqueueNatsAutoConfig.

- Move 5 unit-test files alongside the impls. Update mocks to target the
  repository's higher-level methods; add EndpointRegistry.delete() to test setup
  to prevent state leaks across the static singleton.

Verified: ./gradlew compileJava compileTestJava clean across all modules;
./gradlew :rqueue-{core,web,redis,nats}:test -DincludeTags=unit all green.

Assisted-By: Claude Code

Author: sonus21

rqueue-core/src/main/java/com/github/sonus21/rqueue/repository/MessageBrowsingRepository.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024-2026 Sonu Kumar
+ *
+ * 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 com.github.sonus21.rqueue.repository;
+
+import com.github.sonus21.rqueue.models.enums.DataType;
+import com.github.sonus21.rqueue.models.response.DataViewResponse;
+import java.util.List;
+
+/**
+ * Backend-shaped browsing primitives consumed by the dashboard's queue-detail and data-explorer
+ * pages. Replaces direct {@code RqueueRedisTemplate} access from
+ * {@code RqueueQDetailServiceImpl}, allowing a single backend-neutral service impl in
+ * {@code rqueue-web}.
+ *
+ * <p>The interface deliberately exposes Redis-shaped operations on arbitrary keys (LIST / ZSET /
+ * SET / KEY); it is the storage-layer abstraction, not a feature contract. Backends without an
+ * equivalent (e.g. NATS JetStream KV) throw {@code BackendCapabilityException} from
+ * {@link #viewData} and return {@code 0} from the size queries; the dashboard either hides the
+ * panel (via capability flags) or surfaces the 501 cleanly.
+ */
+public interface MessageBrowsingRepository {
+
+  /**
+   * Size of a single data structure addressed by {@code name}. Returns {@code 0} when the key
+   * does not exist or the backend cannot model the structure.
+   */
+  long getDataSize(String name, DataType type);
+
+  /**
+   * Bulk size — same semantics as {@link #getDataSize} per element, but Redis impls are
+   * expected to pipeline the round-trips. {@code names} and {@code types} must be the same
+   * length; the returned list is the same length and order.
+   */
+  List<Long> getDataSizes(List<String> names, List<DataType> types);
+
+  /**
+   * Raw data-explorer browser used by the dashboard's "Data" page. Reads paginated rows out of
+   * a backing data structure (LIST / ZSET / SET) or returns a single keyed value (KEY / single
+   * ZSET member score). Backends without arbitrary keyed reads throw
+   * {@code BackendCapabilityException}.
+   *
+   * @param name the storage key to read.
+   * @param type the structure type at {@code name}.
+   * @param key  optional sub-key (e.g. ZSET member name to fetch a single score). Empty / null
+   *             returns a paginated range.
+   * @param pageNumber zero-based page index.
+   * @param itemPerPage page size.
+   */
+  DataViewResponse viewData(
+      String name, DataType type, String key, int pageNumber, int itemPerPage);
+}

rqueue-nats/src/main/java/com/github/sonus21/rqueue/nats/dao/NatsRqueueQStatsDao.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024-2026 Sonu Kumar
+ *
+ * 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
+ */
+
+package com.github.sonus21.rqueue.nats.dao;
+
+import com.github.sonus21.rqueue.config.NatsBackendCondition;
+import com.github.sonus21.rqueue.dao.RqueueQStatsDao;
+import com.github.sonus21.rqueue.models.db.QueueStatistics;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import org.springframework.context.annotation.Conditional;
+import org.springframework.stereotype.Repository;
+
+/**
+ * NATS-backend stub for {@link RqueueQStatsDao}. The Redis impl persists per-queue daily
+ * aggregates as serialized {@link QueueStatistics} objects driving the dashboard charts; on
+ * NATS we no-op writes and return empty reads in v1 so that
+ * {@code RqueueJobMetricsAggregatorService} can boot without a missing-bean failure even
+ * though the chart panel is empty.
+ *
+ * <p>Replace with a NATS-native impl (a dedicated {@code rqueue-queue-stats} KV bucket
+ * mirroring the pattern of {@code NatsRqueueSystemConfigDao}) when chart support lands for
+ * NATS.
+ */
+@Repository
+@Conditional(NatsBackendCondition.class)
+public class NatsRqueueQStatsDao implements RqueueQStatsDao {
+
+  @Override
+  public QueueStatistics findById(String id) {
+    return null;
+  }
+
+  @Override
+  public List<QueueStatistics> findAll(Collection<String> ids) {
+    return Collections.emptyList();
+  }
+
+  @Override
+  public void save(QueueStatistics queueStatistics) {
+    // intentionally no-op until a NATS-native chart store lands
+  }
+}

rqueue-nats/src/main/java/com/github/sonus21/rqueue/nats/repository/NatsMessageBrowsingRepository.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2024-2026 Sonu Kumar
+ *
+ * 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 com.github.sonus21.rqueue.nats.repository;
+
+import com.github.sonus21.rqueue.exception.BackendCapabilityException;
+import com.github.sonus21.rqueue.models.enums.DataType;
+import com.github.sonus21.rqueue.models.response.DataViewResponse;
+import com.github.sonus21.rqueue.repository.MessageBrowsingRepository;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * NATS-backend impl of {@link MessageBrowsingRepository}. JetStream KV doesn't expose the
+ * positional list / sorted-set primitives the dashboard's data-explorer panel requires, so
+ * {@link #viewData} throws {@link BackendCapabilityException} (mapped to HTTP 501 by the web
+ * advice). The size queries return {@code 0} — total in-flight / pending counts on a NATS
+ * backend are surfaced through {@code MessageBroker.size(QueueDetail)} elsewhere; the raw
+ * dashboard counts here represent Redis-data-structure sizes that have no NATS counterpart.
+ */
+public class NatsMessageBrowsingRepository implements MessageBrowsingRepository {
+
+  @Override
+  public long getDataSize(String name, DataType type) {
+    return 0L;
+  }
+
+  @Override
+  public List<Long> getDataSizes(List<String> names, List<DataType> types) {
+    if (names == null || names.isEmpty()) {
+      return new ArrayList<>();
+    }
+    List<Long> out = new ArrayList<>(names.size());
+    for (int i = 0; i < names.size(); i++) {
+      out.add(0L);
+    }
+    return out;
+  }
+
+  @Override
+  public DataViewResponse viewData(
+      String name, DataType type, String key, int pageNumber, int itemPerPage) {
+    throw new BackendCapabilityException(
+        "nats",
+        "viewData",
+        "JetStream does not expose positional reads on arbitrary keys; the dashboard's"
+            + " data-explorer panel is Redis-only in v1.");
+  }
+}

rqueue-redis/src/main/java/com/github/sonus21/rqueue/redis/config/RqueueRedisListenerConfig.java

@@ -30,7 +30,9 @@
 import com.github.sonus21.rqueue.redis.dao.RqueueStringDaoImpl;
 import com.github.sonus21.rqueue.redis.lock.RqueueRedisLock;
 import com.github.sonus21.rqueue.redis.metrics.RedisRqueueQueueMetricsProvider;
+import com.github.sonus21.rqueue.redis.repository.RedisMessageBrowsingRepository;
 import com.github.sonus21.rqueue.redis.worker.RedisWorkerRegistryStore;
+import com.github.sonus21.rqueue.repository.MessageBrowsingRepository;
 import com.github.sonus21.rqueue.utils.RedisUtils;
 import com.github.sonus21.rqueue.worker.RqueueWorkerRegistry;
 import com.github.sonus21.rqueue.worker.RqueueWorkerRegistryImpl;
@@ -126,6 +128,14 @@ public WorkerRegistryStore redisWorkerRegistryStore(RqueueConfig rqueueConfig) {
     return new RedisWorkerRegistryStore(rqueueConfig);
   }
 
+  @Bean
+  @Conditional(RedisBackendCondition.class)
+  public MessageBrowsingRepository messageBrowsingRepository(
+      @Qualifier("stringRqueueRedisTemplate")
+          RqueueRedisTemplate<String> stringRqueueRedisTemplate) {
+    return new RedisMessageBrowsingRepository(stringRqueueRedisTemplate);
+  }
+
   @Bean
   @Conditional(RedisBackendCondition.class)
   public RqueueWorkerRegistry rqueueWorkerRegistry(

rqueue-redis/src/main/java/com/github/sonus21/rqueue/redis/repository/RedisMessageBrowsingRepository.java

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2024-2026 Sonu Kumar
+ *
+ * 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 com.github.sonus21.rqueue.redis.repository;
+
+import com.github.sonus21.rqueue.common.RqueueRedisTemplate;
+import com.github.sonus21.rqueue.exception.UnknownSwitchCase;
+import com.github.sonus21.rqueue.models.enums.DataType;
+import com.github.sonus21.rqueue.models.response.DataViewResponse;
+import com.github.sonus21.rqueue.models.response.TableColumn;
+import com.github.sonus21.rqueue.models.response.TableRow;
+import com.github.sonus21.rqueue.repository.MessageBrowsingRepository;
+import com.github.sonus21.rqueue.utils.RedisUtils;
+import com.github.sonus21.rqueue.utils.StringUtils;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
+
+/**
+ * Redis-backed {@link MessageBrowsingRepository}. Wraps {@link RqueueRedisTemplate} for the
+ * size and range primitives; delegates raw {@link org.springframework.data.redis.core.RedisTemplate}
+ * access for the bulk pipelining used by {@link #getDataSizes} (one round-trip for N queues
+ * instead of N).
+ *
+ * <p>This class exists to keep the Redis-shaped storage calls behind a stable interface so the
+ * single {@code RqueueQDetailServiceImpl} in {@code rqueue-web} can serve both backends.
+ */
+public class RedisMessageBrowsingRepository implements MessageBrowsingRepository {
+
+  private final RqueueRedisTemplate<String> stringTemplate;
+
+  public RedisMessageBrowsingRepository(RqueueRedisTemplate<String> stringTemplate) {
+    this.stringTemplate = stringTemplate;
+  }
+
+  @Override
+  public long getDataSize(String name, DataType type) {
+    Long size;
+    switch (type) {
+      case LIST:
+        size = stringTemplate.getListSize(name);
+        break;
+      case ZSET:
+        size = stringTemplate.getZsetSize(name);
+        break;
+      default:
+        // SET / KEY sizes are not used by the dashboard; return 0 rather than throw.
+        return 0L;
+    }
+    return size == null ? 0L : size;
+  }
+
+  @Override
+  public List<Long> getDataSizes(List<String> names, List<DataType> types) {
+    if (names == null || names.isEmpty()) {
+      return Collections.emptyList();
+    }
+    if (types == null || names.size() != types.size()) {
+      throw new IllegalArgumentException(
+          "names and types must be the same length; names=" + names.size()
+              + " types=" + (types == null ? "null" : types.size()));
+    }
+    List<Object> raw = RedisUtils.executePipeLine(
+        stringTemplate.getRedisTemplate(),
+        (connection, keySerializer, valueSerializer) -> {
+          for (int i = 0; i < names.size(); i++) {
+            byte[] key = keySerializer.serialize(names.get(i));
+            switch (types.get(i)) {
+              case LIST:
+                connection.lLen(key);
+                break;
+              case ZSET:
+                connection.zCard(key);
+                break;
+              default:
+                // Unknown size: emit something to keep pipeline alignment with the input.
+                connection.exists(key);
+            }
+          }
+        });
+    List<Long> out = new ArrayList<>(names.size());
+    for (Object o : raw) {
+      if (o instanceof Number) {
+        out.add(((Number) o).longValue());
+      } else {
+        out.add(0L);
+      }
+    }
+    return out;
+  }
+
+  @Override
+  public DataViewResponse viewData(
+      String name, DataType type, String key, int pageNumber, int itemPerPage) {
+    switch (type) {
+      case SET:
+        return responseForSet(name);
+      case ZSET:
+        return responseForZset(name, key, pageNumber, itemPerPage);
+      case LIST:
+        return responseForList(name, pageNumber, itemPerPage);
+      case KEY:
+        return responseForKeyVal(name);
+      default:
+        throw new UnknownSwitchCase(type.name());
+    }
+  }
+
+  private DataViewResponse responseForSet(String name) {
+    List<Object> items = new ArrayList<>(stringTemplate.getMembers(name));
+    DataViewResponse response = new DataViewResponse();
+    response.setHeaders(Collections.singletonList("Item"));
+    List<TableRow> tableRows = new ArrayList<>();
+    for (Object item : items) {
+      tableRows.add(new TableRow(new TableColumn(item.toString())));
+    }
+    response.setRows(tableRows);
+    return response;
+  }
+
+  private DataViewResponse responseForKeyVal(String name) {
+    DataViewResponse response = new DataViewResponse();
+    response.setHeaders(Collections.singletonList("Value"));
+    Object val = stringTemplate.get(name);
+    response.addRow(new TableRow(new TableColumn(String.valueOf(val))));
+    return response;
+  }
+
+  private DataViewResponse responseForZset(
+      String name, String key, int pageNumber, int itemPerPage) {
+    DataViewResponse response = new DataViewResponse();
+    int start = pageNumber * itemPerPage;
+    int end = start + itemPerPage - 1;
+    List<TableRow> tableRows = new ArrayList<>();
+    if (!StringUtils.isEmpty(key)) {
+      Double score = stringTemplate.getZsetMemberScore(name, key);
+      response.setHeaders(Collections.singletonList("Score"));
+      tableRows.add(new TableRow(new TableColumn(score)));
+    } else {
+      response.setHeaders(Arrays.asList("Value", "Score"));
+      for (TypedTuple<String> tuple : stringTemplate.zrangeWithScore(name, start, end)) {
+        tableRows.add(new TableRow(Arrays.asList(
+            new TableColumn(String.valueOf(tuple.getValue())), new TableColumn(tuple.getScore()))));
+      }
+    }
+    response.setRows(tableRows);
+    return response;
+  }
+
+  private DataViewResponse responseForList(String name, int pageNumber, int itemPerPage) {
+    DataViewResponse response = new DataViewResponse();
+    response.setHeaders(Collections.singletonList("Item"));
+    int start = pageNumber * itemPerPage;
+    int end = start + itemPerPage - 1;
+    List<TableRow> tableRows = new ArrayList<>();
+    for (Object s : stringTemplate.lrange(name, start, end)) {
+      tableRows.add(new TableRow(new TableColumn(String.valueOf(s))));
+    }
+    response.setRows(tableRows);
+    return response;
+  }
+}