Redis time-ordered index for newest-first listings

const REDIS_KEY = "log-items-connection";
const MS_PER_MINUTE = 60_000;
const TIMESTAMP_PAD = String(Number.MAX_SAFE_INTEGER).length;

const GET_MINUTE_KEY_FN = (connectionKey: string, minute: number) =>
  `${connectionKey}:${String(minute).padStart(TIMESTAMP_PAD, "0")}`;

const GET_FLOOR_KEY_FN = (connectionKey: string) =>
  `${connectionKey}:floor`;

public register = async (objectName: string): Promise<void> => {
  const redis = await getRedis();
  // alignToInterval rounds the current wall-clock time down to the
  // nearest minute boundary — re-registering within a minute
  // deduplicates by SADD construction.
  const minute = alignToInterval(new Date(), "1m").getTime();
  await redis
    .pipeline()
    .sadd(GET_MINUTE_KEY_FN(this.connectionKey, minute), objectName)
    .setnx(GET_FLOOR_KEY_FN(this.connectionKey), String(minute))
    .exec();
};

public listNewest = async (limit: number, prefix = ""): Promise<string[]> => {
  const redis = await getRedis();
  const floorRaw = await redis.get(GET_FLOOR_KEY_FN(this.connectionKey));
  if (!floorRaw) {
    return [];   // index is empty — caller falls back to bucket LIST
  }
  const floor = Number(floorRaw);
  let minute = alignToInterval(new Date(), "1m").getTime();
  const seen = new Set<string>();
  const names: string[] = [];

  while (minute >= floor && names.length < limit) {
    // Build a batch of up to 1 000 minute timestamps to probe
    const batch: number[] = [];
    while (batch.length < 1_000 && minute >= floor) {
      batch.push(minute);
      minute -= MS_PER_MINUTE;
    }

    // Single pipeline: SCARD for each minute in the batch
    // Empty minutes cost zero member transfers
    const cardPipeline = redis.pipeline();
    for (const ts of batch) {
      cardPipeline.scard(GET_MINUTE_KEY_FN(this.connectionKey, ts));
    }
    const cards = await cardPipeline.exec();
    if (!cards) break;

    for (let i = 0; i < batch.length; i++) {
      const [error, card] = cards[i];
      if (error || !card) continue;

      const minuteKey = GET_MINUTE_KEY_FN(this.connectionKey, batch[i]);

      if ((card as number) <= 1_000) {
        // Small set: fetch all members in one SMEMBERS
        if (collect(await redis.smembers(minuteKey))) return names;
        continue;
      }

      // Hot minute: page through SSCAN to avoid a giant SMEMBERS response
      let cursor: string | number = 0;
      while (true) {
        const [nextCursor, members] = await redis.sscan(
          minuteKey, cursor, "COUNT", 1_000
        );
        cursor = nextCursor;
        if (collect(members)) return names;
        if (cursor === "0" || cursor === 0) break;
      }
    }
  }
  return names;
};

public listAll = async (): Promise<ILogRow[]> => {
  const rows: ILogRow[] = [];
  const names = await this.logConnectionService.listNewest(LIST_LIMIT);

  if (names.length) {
    // Fast path: Redis index is warm
    for (const name of names) {
      const row = await this.get<ILogRow>(name);
      if (row) rows.push(row);
    }
  } else {
    // Cold path: Redis was flushed — fall back to bucket LIST
    // Object keys embed an inverted timestamp, so lexicographic listing
    // is already newest-first; re-warm the index while reading
    for await (const value of this.values("", LIST_LIMIT)) {
      const row = value as ILogRow;
      rows.push(row);
      await this.logConnectionService.register(row.id);  // re-warm
      if (rows.length >= LIST_LIMIT) break;
    }
  }

  rows.sort(
    (a, b) => new Date(b.createDate).getTime() - new Date(a.createDate).getTime()
  );
  return rows.slice(0, LIST_LIMIT);
};