row-count-cache.ts

import { getPlatformCacheVersion } from "@/lib/platform/cache";

const ROW_COUNT_TTL_MS = 5 * 60_000;
const ROW_COUNT_MAX_ENTRIES = 200;

interface RowCountEntry {
  cacheVersion: number;
  expiresAt: number;
  promise: Promise<number>;
}

const rowCountCache = new Map<string, RowCountEntry>();

function buildKey(sourceId: string, tableKey: string) {
  return `${sourceId}::${tableKey}`;
}

function isFresh(entry: RowCountEntry, now: number, version: number) {
  return entry.cacheVersion === version && entry.expiresAt > now;
}

function trimCache() {
  while (rowCountCache.size > ROW_COUNT_MAX_ENTRIES) {
    const oldestKey = rowCountCache.keys().next().value;
    if (oldestKey === undefined) {
      break;
    }
    rowCountCache.delete(oldestKey);
  }
}

export async function getCachedRowCount(
  sourceId: string,
  tableKey: string,
  fetchCount: () => Promise<number>,
): Promise<number> {
  const key = buildKey(sourceId, tableKey);
  const version = getPlatformCacheVersion();
  const now = Date.now();
  const existing = rowCountCache.get(key);

  if (existing && isFresh(existing, now, version)) {
    rowCountCache.delete(key);
    rowCountCache.set(key, existing);
    return existing.promise;
  }

  if (existing) {
    rowCountCache.delete(key);
  }

  const countPromise = fetchCount();
  const entry: RowCountEntry = {
    cacheVersion: version,
    expiresAt: now + ROW_COUNT_TTL_MS,
    promise: countPromise,
  };

  countPromise.catch(() => {
    const current = rowCountCache.get(key);
    if (current === entry) {
      rowCountCache.delete(key);
    }
  });

  rowCountCache.set(key, entry);
  trimCache();

  return countPromise;
}

export function clearRowCountCacheForTests() {
  rowCountCache.clear();
}