.

Author: bitnimble

.claude/settings.local.json

@@ -23,6 +23,7 @@
       "Bash(bun run build *)",
       "Bash(bun typecheck *)",
       "Bash(bun run typecheck *)",
+      "Bash(bun run typecheck:e2e *)",
       "Bash(bun lint *)",
       "Bash(bun run lint *)",
       "Bash(bun format *)",

AGENTS.md

@@ -70,7 +70,7 @@ The codebase uses Docker to run third-party services locally (Minio for a local
 - `bun format` will format the codebase with Prettier
 - `bun typecheck` will typecheck the codebase, and `bun lint` will lint it
 - `bun run test:unit` runs the pure unit tests (`*.unit.test.ts`)
-- `bun run test:integration` runs the integration suite. It needs no live services: the database is an ephemeral in-memory PGlite (started by `tools/test.sh`, with the schema loaded from `supabase/config.toml`'s `schema_paths`), and Supabase, S3, and Axiom are faked (see `.env.test`). Do not run `bun test` (Bun's built-in runner); it's intercepted with a pointer to these scripts.
+- `bun run test:integration` runs the integration suite. It needs no live services: the database is an ephemeral in-memory PGlite (started by `tools/test.sh`, with the real `supabase/migrations` applied by `tools/load_schema.ts` so it matches production), and Supabase, S3, and Axiom are faked (see `.env.test`). Do not run `bun test` (Bun's built-in runner); it's intercepted with a pointer to these scripts.
 
 # How you should work
 

e2e/helpers/seed.ts

@@ -1,63 +1,62 @@
-import { Pool } from 'pg';
-import { IdDomain, generateId } from '../../src/services/db/id_gen';
+import { Page } from '@playwright/test';
+import { buildMapZip } from '../../src/services/maps/tests/map_generator';
 
-// Direct Postgres access to the running Supabase DB (connection comes from .env.e2e, layered in by
-// tools/e2e.sh). Used to seed many maps quickly: uploading 20+ through the real submit flow would
-// be far too slow just to populate a list for the pagination test.
-let pool: Pool | undefined;
-function getPool(): Pool {
-  if (pool == null) {
-    pool = new Pool({
-      host: process.env.PGHOST,
-      port: Number(process.env.PGPORT),
-      user: process.env.PGUSER,
-      database: process.env.PGDATABASE,
-      password: process.env.PGPASSWORD,
-    });
-  }
-  return pool;
-}
+// Seeds maps through the real submit flow over HTTP (presigned PUT to S3 + server-side validation +
+// publish), rather than writing rows directly: it's slower than a raw insert but goes through the
+// exact code path production does, so it can't drift from the schema the way hand-written SQL can.
+// Uses `page.request` so it shares the (authenticated) browser context's cookies; the caller must
+// have logged the page in first.
 
 export type SeededMap = { id: string; title: string };
 
 /**
- * Inserts `count` public, valid maps that all share one (caller-supplied, run-unique) artist, so a
- * search for that artist isolates exactly this run's maps from anything else in the persisted DB.
+ * Uploads `count` valid maps, all under one (caller-supplied, run-unique) artist so a search for it
+ * isolates exactly this run's maps. Returns the published map ids.
  */
-export async function seedPublicMaps(opts: {
-  artist: string;
-  count: number;
-}): Promise<SeededMap[]> {
+export async function seedPublicMaps(
+  page: Page,
+  opts: { artist: string; count: number }
+): Promise<SeededMap[]> {
   const { artist, count } = opts;
   const maps: SeededMap[] = [];
   for (let i = 0; i < count; i++) {
-    const title = `Infinite Scroll Map ${String(i).padStart(3, '0')}`;
-    const id = await generateId(
-      IdDomain.MAPS,
-      async (candidate) =>
-        ((await getPool().query('SELECT 1 FROM maps WHERE id = $1', [candidate])).rowCount ?? 0) > 0
-    );
-    if (id == null) {
-      throw new Error('Could not generate a unique map id for seeding');
+    const n = String(i).padStart(3, '0');
+    const title = `Infinite Scroll Map ${n}`;
+    const zip = buildMapZip({ folder: `IScroll${n}`, title, artist });
+
+    // 1. Reserve a map id + presigned S3 upload URL.
+    const submit = await page.request.post('/api/maps/submit', { data: { title: `${title}.zip` } });
+    const submitBody = await submit.json();
+    if (!submitBody.success) {
+      throw new Error(`submit failed for "${title}": ${submitBody.errorMessage}`);
+    }
+    const { id, url } = submitBody as { id: string; url: string };
+
+    // 2. Upload the archive to the presigned URL (real S3 / Minio).
+    const put = await page.request.put(url, {
+      data: zip,
+      headers: { 'Content-Type': 'application/zip' },
+    });
+    if (!put.ok()) {
+      throw new Error(`S3 upload failed for "${title}": ${put.status()}`);
+    }
+
+    // 3. Validate + publish.
+    const complete = await page.request.post('/api/maps/submit/complete', {
+      data: { id, isReupload: false },
+    });
+    const completeBody = await complete.json();
+    if (!completeBody.success) {
+      throw new Error(`complete failed for "${title}": ${completeBody.errorMessage}`);
     }
-    await getPool().query(
-      `INSERT INTO maps
-         (id, visibility, validity, submission_date, title, artist, uploader, download_count, complexity)
-       VALUES ($1, 'public', 'valid', $2, $3, $4, 'e2e', 0, 1)`,
-      [id, new Date(Date.now() + i * 1000).toISOString(), title, artist]
-    );
     maps.push({ id, title });
   }
   return maps;
 }
 
-export async function deleteSeededMaps(artist: string): Promise<void> {
-  await getPool().query('DELETE FROM maps WHERE artist = $1', [artist]);
-}
-
-export async function closeSeedPool(): Promise<void> {
-  if (pool != null) {
-    await pool.end();
-    pool = undefined;
+/** Deletes the seeded maps via the real delete endpoint (cascades difficulties/favorites + S3). */
+export async function deleteSeededMaps(page: Page, ids: string[]): Promise<void> {
+  for (const id of ids) {
+    await page.request.post(`/api/maps/${id}/delete`);
   }
 }

e2e/infinite_scroll.e2e.ts

@@ -1,21 +1,15 @@
 import { expect, Locator, Page, test } from '@playwright/test';
-import { closeSeedPool, deleteSeededMaps, seedPublicMaps } from './helpers/seed';
+import { makeUser, signUpAndConfirm } from './helpers/auth';
+import { deleteSeededMaps, seedPublicMaps } from './helpers/seed';
 
 // SEARCH_LIMIT in src/app/map_list_presenter.ts.
 const PAGE_SIZE = 20;
 const TOTAL = 25;
 
-const seededArtists: string[] = [];
-
-// Seeds TOTAL maps under a process-unique artist so re-runs against the persisted Supabase DB
-// never see each other's maps, and each test's set is isolated from the other's.
-async function seedRun(): Promise<string> {
-  const unique = `${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
-  const artist = `infscroll${unique}`;
-  seededArtists.push(artist);
-  await seedPublicMaps({ artist, count: TOTAL });
-  return artist;
-}
+// Process-unique artist so re-runs against the persisted Supabase DB never collide; one seeded set
+// is shared by both tests.
+const unique = `${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
+const artist = `infscroll${unique}`;
 
 // One row per map (each row links to /map/{id}); excludes the header and loading skeleton.
 const mapRows = (page: Page) => page.locator('tr', { has: page.locator('a[href^="/map/"]') });
@@ -32,7 +26,6 @@ const nextPageResponse = (page: Page) =>
 // Opens the list scoped (by the run-unique artist) to exactly this run's maps and asserts the
 // first page rendered with "Load more" on offer.
 async function openFirstPage(page: Page): Promise<{ rows: Locator; loadMore: Locator }> {
-  const artist = await seedRun();
   const rows = mapRows(page);
   await page.goto(`/?q=${artist}`);
   await page.waitForResponse(
@@ -89,11 +82,19 @@ async function wheelUntilButtonDisabled(page: Page, loadMore: Locator): Promise<
 }
 
 test.describe('home page infinite scroll', () => {
+  // A dedicated, authenticated page seeds the maps once over the real API; both tests share them.
+  let seedPage: Page;
+  let seededIds: string[];
+
+  test.beforeAll(async ({ browser }) => {
+    seedPage = await browser.newPage();
+    await signUpAndConfirm(seedPage, makeUser('isscroll'));
+    seededIds = (await seedPublicMaps(seedPage, { artist, count: TOTAL })).map((m) => m.id);
+  });
+
   test.afterAll(async () => {
-    for (const artist of seededArtists) {
-      await deleteSeededMaps(artist);
-    }
-    await closeSeedPool();
+    await deleteSeededMaps(seedPage, seededIds);
+    await seedPage.close();
   });
 
   test('appends the next page when "Load more" is clicked', async ({ page }) => {

src/app/api/api.ts

@@ -2,6 +2,8 @@ import * as qs from 'qs';
 import { ApiResponse } from 'schema/api';
 import { encodeFilter } from 'schema/map_filter';
 import {
+  CompleteUploadRequest,
+  CompleteUploadResponse,
   DeleteMapResponse,
   FindMapsResponse,
   GetMapResponse,
@@ -34,6 +36,7 @@ export interface Api {
   getMap(id: string): Promise<GetMapResponse>;
   deleteMap(id: string): Promise<DeleteMapResponse>;
   submitMap(req: SubmitMapRequest): Promise<SubmitMapResponse>;
+  completeMapUpload(req: CompleteUploadRequest): Promise<CompleteUploadResponse>;
 }
 
 export class HttpApi implements Api {
@@ -88,6 +91,11 @@ export class HttpApi implements Api {
     const resp = await post(path(this.apiBase, 'maps', 'submit'), req);
     return SubmitMapResponse.parse(resp);
   }
+
+  async completeMapUpload(req: CompleteUploadRequest): Promise<CompleteUploadResponse> {
+    const resp = await post(path(this.apiBase, 'maps', 'submit', 'complete'), req);
+    return CompleteUploadResponse.parse(resp);
+  }
 }
 
 function path(...parts: string[]) {

src/app/api/fake_api.ts

@@ -1,5 +1,7 @@
 import { ApiResponse } from 'schema/api';
 import {
+  CompleteUploadRequest,
+  CompleteUploadResponse,
   DeleteMapResponse,
   FindMapsResponse,
   GetMapResponse,
@@ -75,6 +77,11 @@ export class FakeApi implements Api {
     await delay();
     return { success: true, id: allStar.id, url: '' };
   }
+
+  async completeMapUpload(_req: CompleteUploadRequest): Promise<CompleteUploadResponse> {
+    await delay();
+    return { success: true, map: allStar };
+  }
 }
 
 const allStar: PDMap = {