#3361 S3-backed serve: a poll that pulls one file invalidates the whole data catalog, so the next query re-reads every version

import { assertEquals } from "@std/assert";
import { join } from "@std/path";
import { ensureDirSync } from "@std/fs";
import { stringify as yaml } from "@std/yaml";
import { CatalogStore } from "./src/infrastructure/persistence/catalog_store.ts";
import { FileSystemUnifiedDataRepository } from "./src/infrastructure/persistence/unified_data_repository.ts";
import { DataQueryService } from "./src/domain/data/data_query_service.ts";

const VERSIONS_PER_NAME = 6;

function fixture(totalVersions: number) {
  const dir = Deno.makeTempDirSync({ prefix: "catalog-repro-" });
  const names = Math.ceil(totalVersions / VERSIONS_PER_NAME);
  for (let i = 0; i < names; i++) {
    const modelIndex = Math.floor(i / 24);
    const modelName = `model-${String(modelIndex).padStart(3, "0")}`;
    const modelId = `00000000-0000-4000-8000-${String(modelIndex).padStart(12, "0")}`;
    const name = `record-${String(i).padStart(4, "0")}`;
    const id = crypto.randomUUID();
    const base = join(dir, ".swamp/data/synthetic", modelId, name);
    for (let v = 1; v <= VERSIONS_PER_NAME; v++) {
      const vd = join(base, String(v));
      ensureDirSync(vd);
      Deno.writeTextFileSync(join(vd, "raw"), JSON.stringify({ i, v }));
      Deno.writeTextFileSync(join(vd, "metadata.yaml"), yaml({
        name, id, version: v, contentType: "application/json",
        lifetime: "infinite", garbageCollection: 50, streaming: false,
        tags: { type: "resource", specName: "execution", modelName },
        ownerDefinition: { ownerType: "model-method", ownerRef: modelId },
        createdAt: "2026-01-01T00:00:00.000Z",
      }));
    }
    Deno.writeTextFileSync(join(base, "latest"), String(VERSIONS_PER_NAME));
  }
  const catalog = new CatalogStore(join(dir, ".swamp/data/_catalog.db"));
  const repo = new FileSystemUnifiedDataRepository(dir, undefined, catalog);
  const service = new DataQueryService(catalog, repo);
  const work = { globalWalks: 0, metadataReads: 0 };
  const walk = repo.findAllGlobal.bind(repo);
  const read = repo.findByName.bind(repo);
  repo.findAllGlobal = (...a) => { work.globalWalks++; return walk(...a); };
  repo.findByName = (...a) => { work.metadataReads++; return read(...a); };
  return { dir, catalog, service, work };
}

for (const total of [1200, 7200]) {
  Deno.test(`after invalidate(), one query re-reads all ${total} versions`, async () => {
    const f = fixture(total);
    try {
      const predicate = 'modelName == "model-000" && name == "record-0000"';
      await f.service.query(predicate); // populate
      f.catalog.invalidate(); // what a runtime-data poll that pulled >= 1 file does

      let before = { ...f.work };
      let t = performance.now();
      await f.service.query(predicate);
      console.log(`${total} versions: query after invalidate ${(performance.now() - t).toFixed(1)} ms`);
      assertEquals(f.work.globalWalks - before.globalWalks, 1);
      assertEquals(f.work.metadataReads - before.metadataReads, total); // whole catalog

      f.catalog.invalidate();
      before = { ...f.work };
      t = performance.now();
      const latest = await f.service.getLatestRecord("model-000", "record-0000");
      console.log(`${total} versions: getLatestRecord after invalidate ${(performance.now() - t).toFixed(1)} ms`);
      assertEquals(latest?.version, VERSIONS_PER_NAME);
      assertEquals(f.work.globalWalks - before.globalWalks, 0); // no backfill needed
    } finally {
      f.catalog.close();
      Deno.removeSync(f.dir, { recursive: true });
    }
  });
}