chore(e2e-coverage): add c8 one-shot runner and external URL support

apps/server/package.json

···
     "start": "node dist/main.js",
     "dev": "nodemon --watch src -e ts --exec \"ts-node -r tsconfig-paths/register src/main.ts\"",
     "lint": "biome check .",
-    "test": "jest",
+    "test": "jest --config ./test/jest-unit.json",
+    "test:unit": "jest --config ./test/jest-unit.json",
     "test:e2e": "jest --config ./test/jest-e2e.json",
+    "e2e:coverage:c8:start": "npm run prisma:deploy && npm run build && npx c8 -r text -r lcov node dist/main.js",
+    "e2e:coverage:c8:report": "npx c8 report -r text -r lcov",
+    "e2e:coverage:c8": "E2E_EXTERNAL_URL=http://localhost:3000 npm run test:e2e && npm run e2e:coverage:c8:report",
+    "e2e:coverage:c8:stop": "pkill -f 'node dist/main.js' || true",
+    "e2e:coverage:all": "node src/scripts/e2e-coverage-all.cjs",
     "prisma:generate": "prisma generate --schema=./prisma/schema.prisma",
     "prisma:migrate": "prisma migrate dev --schema=./prisma/schema.prisma",
     "prisma:deploy": "prisma migrate deploy --schema=./prisma/schema.prisma",
     "prisma:studio": "prisma studio --schema=./prisma/schema.prisma",
-    "seed": "ts-node -r tsconfig-paths/register src/scripts/seed.ts"
+    "seed": "ts-node -r tsconfig-paths/register src/scripts/seed.ts",
+    "seed:test": "ts-node -r tsconfig-paths/register src/scripts/seed-test.ts"
   },
   "dependencies": {
     "@cv/utils": "^0.0.0",

apps/server/src/scripts/e2e-coverage-all.cjs

···
+/* eslint-disable no-console */
+const { execSync, spawn } = require("node:child_process");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+  execSync("npm run prisma:deploy", { stdio: "inherit" });
+  execSync("npm run build", { stdio: "inherit" });
+
+  const fs = require("node:fs");
+  const path = require("node:path");
+  function findMain() {
+    const direct = path.join(process.cwd(), "dist", "main.js");
+    if (fs.existsSync(direct)) return direct;
+    const candidates = [
+      path.join(process.cwd(), "dist", "src", "main.js"),
+      path.join(process.cwd(), "dist", "apps", "server", "src", "main.js"),
+    ];
+    for (const c of candidates) if (fs.existsSync(c)) return c;
+    return null;
+  }
+
+  let mainPath = findMain();
+  let retries = 10;
+  while (!mainPath && retries > 0) {
+    await sleep(300);
+    retries--;
+    mainPath = findMain();
+  }
+  if (!mainPath) {
+    throw new Error("dist/main.js not found after build; aborting c8 run");
+  }
+
+  const server = spawn(
+    "npx",
+    [
+      "c8",
+      "--include",
+      "dist/**/*.js",
+      "--exclude",
+      "dist/**/test/**",
+      "-r",
+      "text",
+      "-r",
+      "lcov",
+      "node",
+      mainPath,
+    ],
+    { stdio: "inherit" },
+  );
+
+  await sleep(1500);
+
+  execSync("npm run seed:test", { stdio: "inherit" });
+
+  const env = { ...process.env, E2E_EXTERNAL_URL: "http://localhost:3000" };
+  execSync("npm run test:e2e -- --maxWorkers=50%", { stdio: "inherit", env });
+
+  try {
+    server.kill("SIGTERM");
+  } catch {}
+  await sleep(1000);
+  execSync(
+    "npx c8 report --include 'dist/**/*.js' --exclude 'dist/**/test/**' -r text -r lcov",
+    { stdio: "inherit", shell: "/bin/sh" },
+  );
+}
+
+main().catch(() => {
+  process.exit(1);
+});
+
+

apps/server/test/test-utils.ts

···
  * Sets up a test application with proper configuration
  */
 export async function setupTestApp(): Promise<INestApplication> {
+  // When targeting an external running server (c8 coverage mode),
+  // skip spinning up an in-memory Nest application.
+  if (process.env["E2E_EXTERNAL_URL"]) {
+    return {
+      // Provide a no-op close to satisfy tests calling app.close()
+      close: async () => undefined,
+    } as unknown as INestApplication;
+  }
   // Set test environment variables
   process.env.JWT_SECRET = "test-secret-key-for-testing-only";
   process.env.PORT = "3001";
···
     password: "password123",
   };
 
-  const registerResponse = await request(app.getHttpServer()).post("/graphql").send({
+  const registerResponse = await getRequester(app).post("/graphql").send({
     query: REGISTER_MUTATION,
     variables: testUser,
   });
 
-  if (registerResponse.status !== 200 || !registerResponse.body.data?.register) {
-    throw new Error(`Registration failed: ${JSON.stringify(registerResponse.body)}`);
+  if (
+    registerResponse.status !== 200 ||
+    !registerResponse.body.data?.register
+  ) {
+    throw new Error(
+      `Registration failed: ${JSON.stringify(registerResponse.body)}`,
+    );
   }
 
   return {
···
   skillId: string;
 }> {
   const timestamp = Date.now();
-  
+
   // Create company
   const createCompanyMutation = `
     mutation CreateCompany($name: String!, $description: String) {
···
     }
   `;
 
-  const companyResponse = await request(app.getHttpServer())
+  const companyResponse = await getRequester(app)
     .post("/graphql")
     .send({
       query: createCompanyMutation,
···
     }
   `;
 
-  const roleResponse = await request(app.getHttpServer())
+  const roleResponse = await getRequester(app)
     .post("/graphql")
     .send({
       query: createRoleMutation,
···
     }
   `;
 
-  const levelResponse = await request(app.getHttpServer())
+  const levelResponse = await getRequester(app)
     .post("/graphql")
     .send({
       query: createLevelMutation,
···
     }
   `;
 
-  const skillResponse = await request(app.getHttpServer())
+  const skillResponse = await getRequester(app)
     .post("/graphql")
     .send({
       query: createSkillMutation,
···
 /**
  * Makes an authenticated GraphQL request
  */
-export function makeAuthenticatedRequest(app: INestApplication, accessToken: string) {
-  return request(app.getHttpServer())
+export function makeAuthenticatedRequest(
+  app: INestApplication,
+  accessToken: string,
+) {
+  return getRequester(app)
     .post("/graphql")
     .set("Authorization", `Bearer ${accessToken}`);
 }
···
  * Makes an unauthenticated GraphQL request
  */
 export function makeUnauthenticatedRequest(app: INestApplication) {
-  return request(app.getHttpServer()).post("/graphql");
+  return getRequester(app).post("/graphql");
+}
+
+/**
+ * Returns a supertest requester. If E2E_EXTERNAL_URL is set, target that URL
+ * so we can run the app under c8 separately and still reuse the test suites.
+ */
+function getRequester(app: INestApplication) {
+  const externalUrl = process.env["E2E_EXTERNAL_URL"];
+  if (externalUrl) {
+    return request(externalUrl);
+  }
+  return request(app.getHttpServer());
 }