@typespec/http-server-js 0.58.0-alpha.12-dev.1 → 0.58.0-alpha.12-dev.2

package/.testignore

@@ -0,0 +1,26 @@
+# Failed on initial run
+special-words
+authentication/oauth2
+authentication/union
+encode/bytes
+encode/datetime
+encode/duration
+encode/numeric
+payload/content-negotiation
+payload/media-type
+payload/multipart
+payload/xml
+response/status-code-range
+streaming/jsonl
+type/array
+type/dictionary
+type/enum/extensible
+type/enum/fixed
+type/model/inheritance/enum-discriminator
+type/property/additional-properties
+type/property/nullable
+type/property/optionality
+type/property/value-types
+type/scalar
+type/union
+versioning/returnTypeChangedFrom

package/eng/scripts/emit-e2e.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+import { run } from "@typespec/internal-build-utils";
+import pkg from "fs-extra";
+import { copyFile, mkdir, rm } from "fs/promises";
+import { globby } from "globby";
+import inquirer from "inquirer";
+import ora from "ora";
+import pLimit from "p-limit";
+import { basename, dirname, join, resolve } from "path";
+import pc from "picocolors";
+import { fileURLToPath } from "url";
+import { hideBin } from "yargs/helpers";
+import yargs from "yargs/yargs";
+
+const { pathExists, stat, readFile, writeFile } = pkg;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const projectRoot = join(__dirname, "../..");
+const tspConfig = join(__dirname, "tspconfig.yaml");
+
+const basePath = join(projectRoot, "node_modules", "@typespec", "http-specs", "specs");
+const ignoreFilePath = join(projectRoot, ".testignore");
+const logDirRoot = join(projectRoot, "temp", "emit-e2e-logs");
+const reportFilePath = join(logDirRoot, "report.txt");
+
+// Remove the log directory if it exists.
+async function clearLogDirectory() {
+  if (await pathExists(logDirRoot)) {
+    await rm(logDirRoot, { recursive: true, force: true });
+  }
+}
+
+// Parse command-line arguments.
+const argv = yargs(hideBin(process.argv))
+  .option("interactive", {
+    type: "boolean",
+    describe: "Enable interactive mode",
+    default: false,
+  })
+  .positional("paths", {
+    describe: "Optional list of specific file or directory paths to process (relative to basePath)",
+    type: "string",
+    array: true,
+    default: [],
+  })
+  .option("build", {
+    type: "boolean",
+    describe: "Build the generated projects",
+    default: false,
+  })
+  .help().argv;
+
+// Read and parse the ignore file.
+async function getIgnoreList() {
+  try {
+    const content = await readFile(ignoreFilePath, "utf8");
+    return content
+      .split(/\r?\n/)
+      .filter((line) => line.trim() && !line.startsWith("#"))
+      .map((line) => line.trim());
+  } catch {
+    console.warn(pc.yellow("No ignore file found."));
+    return [];
+  }
+}
+
+// Recursively process paths (files or directories relative to basePath).
+async function processPaths(paths, ignoreList) {
+  const results = [];
+  for (const relativePath of paths) {
+    const fullPath = resolve(basePath, relativePath);
+
+    if (!(await pathExists(fullPath))) {
+      console.warn(pc.yellow(`Path not found: ${relativePath}`));
+      continue;
+    }
+
+    const stats = await stat(fullPath);
+    if (stats.isFile() && fullPath.endsWith("main.tsp")) {
+      if (ignoreList.some((ignore) => relativePath.startsWith(ignore))) continue;
+      results.push({ fullPath, relativePath });
+    } else if (stats.isDirectory()) {
+      const patterns = ["**/main.tsp"];
+      const discoveredPaths = await globby(patterns, { cwd: fullPath });
+      const validFiles = discoveredPaths
+        .map((p) => ({
+          fullPath: join(fullPath, p),
+          relativePath: join(relativePath, p),
+        }))
+        .filter((file) => !ignoreList.some((ignore) => file.relativePath.startsWith(ignore)));
+      results.push(...validFiles);
+    } else {
+      console.warn(pc.yellow(`Skipping unsupported path: ${relativePath}`));
+    }
+  }
+
+  // Deduplicate.
+  const filesByDir = new Map();
+  for (const file of results) {
+    const dir = dirname(file.relativePath);
+    const existing = filesByDir.get(dir);
+    if (!existing) {
+      filesByDir.set(dir, file);
+    }
+  }
+  return Array.from(filesByDir.values());
+}
+
+// Run a shell command silently.
+async function runCommand(command, args, options = {}) {
+  // Remove clutter by not printing anything; capture output by setting stdio to 'pipe'.
+  return await run(command, args, {
+    stdio: "pipe",
+    env: { NODE_ENV: "test", ...process.env },
+    silent: true,
+    ...options,
+  });
+}
+
+// Process a single file.
+async function processFile(file, options) {
+  const { fullPath, relativePath } = file;
+  const { build, interactive } = options;
+  const outputDir = join("test", "e2e", "generated", dirname(relativePath));
+  const specCopyPath = join(outputDir, "spec.tsp");
+  const logDir = join(projectRoot, "temp", "emit-e2e-logs", dirname(relativePath));
+
+  let spinner;
+  if (interactive) {
+    spinner = ora({ text: `Processing: ${relativePath}`, color: "cyan" }).start();
+  }
+
+  try {
+    if (await pathExists(outputDir)) {
+      if (spinner) spinner.text = `Clearing directory: ${outputDir}`;
+      await rm(outputDir, { recursive: true, force: true });
+    }
+    if (spinner) spinner.text = `Creating directory: ${outputDir}`;
+    await mkdir(outputDir, { recursive: true });
+
+    if (spinner) spinner.text = `Copying spec to: ${specCopyPath}`;
+    await copyFile(fullPath, specCopyPath);
+
+    if (spinner) spinner.text = `Compiling: ${relativePath}`;
+    await runCommand("npx", [
+      "tsp",
+      "compile",
+      fullPath,
+      "--emit",
+      resolve(import.meta.dirname, "../.."),
+      "--config",
+      tspConfig,
+      "--output-dir",
+      outputDir,
+    ]);
+
+    if (spinner) spinner.text = `Formatting with Prettier: ${relativePath}`;
+    await runCommand("npx", ["prettier", outputDir, "--write"]);
+
+    if (build) {
+      if (spinner) spinner.text = `Building project: ${relativePath}`;
+      await runCommand("npm", ["run", "build"], { cwd: outputDir });
+    }
+
+    if (spinner) {
+      spinner.succeed(`Finished processing: ${relativePath}`);
+    }
+    return { status: "succeeded", relativePath };
+  } catch (error) {
+    if (spinner) {
+      spinner.fail(`Failed processing: ${relativePath}`);
+    }
+    const errorDetails = error.stdout || error.stderr || error.message;
+
+    // Write error details to a log file.
+    await mkdir(logDir, { recursive: true });
+    const logFilePath = join(logDir, `${basename(relativePath, ".tsp")}-error.log`);
+    await writeFile(logFilePath, errorDetails, "utf8");
+
+    if (interactive) {
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: `Processing failed for ${relativePath}. What would you like to do?`,
+          choices: [
+            { name: "Retry", value: "retry" },
+            { name: "Skip to next file", value: "next" },
+            { name: "Abort processing", value: "abort" },
+          ],
+        },
+      ]);
+
+      if (action === "retry") {
+        if (spinner) spinner.start(`Retrying: ${relativePath}`);
+        return await processFile(file, options);
+      } else if (action === "next") {
+        console.log(pc.yellow(`Skipping: ${relativePath}`));
+      } else if (action === "abort") {
+        console.log(pc.red("Aborting processing."));
+        throw new Error("Processing aborted by user");
+      }
+    }
+    return { status: "failed", relativePath, errorDetails };
+  }
+}
+
+// Process all files.
+async function processFiles(files, options) {
+  const { interactive } = options;
+  const succeeded = [];
+  const failed = [];
+
+  if (interactive) {
+    // Sequential processing so each spinner is visible.
+    for (const file of files) {
+      try {
+        const result = await processFile(file, options);
+        if (result.status === "succeeded") {
+          succeeded.push(result.relativePath);
+        } else {
+          failed.push({ relativePath: result.relativePath, errorDetails: result.errorDetails });
+        }
+      } catch (err) {
+        break;
+      }
+    }
+  } else {
+    // Global progress spinner.
+    const total = files.length;
+    let completed = 0;
+    const globalSpinner = ora({ text: `Processing 0/${total} files...`, color: "cyan" }).start();
+    const limit = pLimit(4);
+    const tasks = files.map((file) =>
+      limit(() =>
+        processFile(file, options).then((result) => {
+          completed++;
+          globalSpinner.text = `Processing ${completed}/${total} files...`;
+          return result;
+        }),
+      ),
+    );
+    const results = await Promise.all(tasks);
+    globalSpinner.succeed(`Processed ${total} files`);
+    for (const result of results) {
+      if (result.status === "succeeded") {
+        succeeded.push(result.relativePath);
+      } else {
+        failed.push({ relativePath: result.relativePath, errorDetails: result.errorDetails });
+      }
+    }
+  }
+
+  console.log(pc.bold(pc.green("\nProcessing Complete:")));
+  console.log(pc.green(`Succeeded: ${succeeded.length}`));
+  console.log(pc.red(`Failed: ${failed.length}`));
+
+  if (failed.length > 0) {
+    console.log(pc.red("\nFailed Specs:"));
+    failed.forEach((f) => {
+      console.log(pc.red(`  - ${f.relativePath}`));
+    });
+    console.log(pc.blue(`\nLogs available at: ${logDirRoot}`));
+  }
+
+  // Ensure the log directory exists before writing the report.
+  await mkdir(logDirRoot, { recursive: true });
+  const report = [
+    "Succeeded Files:",
+    ...succeeded.map((f) => `  - ${f}`),
+    "Failed Files:",
+    ...failed.map((f) => `  - ${f.relativePath}\n    Error: ${f.errorDetails}`),
+  ].join("\n");
+  await writeFile(reportFilePath, report, "utf8");
+  console.log(pc.blue(`Report written to: ${reportFilePath}`));
+}
+// Main execution function
+async function main() {
+  const startTime = process.hrtime.bigint(); // ✅ High precision time tracking
+  let exitCode = 0; // ✅ Track success/failure
+
+  try {
+    await clearLogDirectory(); // ✅ Clear logs at the start
+
+    const ignoreList = await getIgnoreList();
+    const paths = argv._.length
+      ? await processPaths(argv._, ignoreList)
+      : await processPaths(["."], ignoreList);
+
+    if (paths.length === 0) {
+      console.log(pc.yellow("⚠️ No files to process."));
+      return;
+    }
+
+    await processFiles(paths, {
+      interactive: argv.interactive,
+      build: argv.build,
+    });
+  } catch (error) {
+    console.error(pc.red(`❌ Fatal Error: ${error.message}`));
+    exitCode = 1; // ✅ Ensure graceful failure handling
+  } finally {
+    // ✅ Always log execution time before exit
+    const endTime = process.hrtime.bigint();
+    const duration = Number(endTime - startTime) / 1e9; // Convert nanoseconds to seconds
+    console.log(pc.blue(`⏱️ Total execution time: ${duration.toFixed(2)} seconds`));
+
+    process.exit(exitCode); // ✅ Ensures proper exit handling
+  }
+}
+
+await main();

package/eng/scripts/tspconfig.yaml

@@ -0,0 +1,6 @@
+emitters:
+  "@typespec/http-server-js": true
+
+options:
+  "@typespec/http-server-js":
+    emitter-output-dir: "{output-dir}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/http-server-js",
-  "version": "0.58.0-alpha.12-dev.1",
+  "version": "0.58.0-alpha.12-dev.2",
   "author": "Microsoft Corporation",
   "description": "TypeSpec HTTP server code generator for JavaScript",
   "homepage": "https://github.com/microsoft/typespec",
@@ -47,12 +47,23 @@
     "@types/node": "~22.13.9",
     "@typespec/compiler": "^0.67.1 || >=0.68.0-dev <0.68.0",
     "@typespec/http": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/http-specs": "^0.1.0-alpha.15 || >=0.1.0-alpha.16-dev <0.1.0-alpha.16",
+    "@typespec/internal-build-utils": "^0.67.1 || >=0.68.0-dev <0.68.0",
     "@typespec/openapi3": "^0.67.1 || >=0.68.0-dev <0.68.0",
+    "@typespec/spector": "^0.1.0-alpha.9 || >=0.1.0-alpha.10-dev <0.1.0-alpha.10",
     "@vitest/coverage-v8": "^3.0.7",
     "@vitest/ui": "^3.0.7",
+    "fs-extra": "^11.2.0",
+    "globby": "~14.1.0",
+    "inquirer": "^12.2.0",
+    "ora": "^8.1.1",
+    "p-limit": "^6.2.0",
+    "pathe": "^2.0.3",
+    "picocolors": "~1.1.1",
     "tsx": "^4.19.3",
     "typescript": "~5.8.2",
-    "vitest": "^3.0.7"
+    "vitest": "^3.0.7",
+    "yargs": "~17.7.2"
   },
   "scripts": {
     "clean": "rimraf ./dist ./temp",
@@ -66,6 +77,9 @@
     "test:ci": "vitest run --coverage --reporter=junit --reporter=default",
     "lint": "eslint . --max-warnings=0",
     "lint:fix": "eslint . --fix",
-    "regen-docs": "echo Doc generation disabled for this package."
+    "regen-docs": "echo Doc generation disabled for this package.",
+    "test:e2e": "npm run emit:e2e && npm run run:e2e",
+    "emit:e2e": "node eng/scripts/emit-e2e.js",
+    "run:e2e": "vitest run --config ./vitest.config.e2e.js"
   }
 }

package/test/e2e/helpers.ts

@@ -0,0 +1,59 @@
+import { createServer, IncomingMessage, Server, ServerResponse } from "node:http";
+
+interface BasicRouter {
+  /**
+   * Dispatches the request to the appropriate service based on the request path.
+   *
+   * This member function may be used directly as a handler for a Node HTTP server.
+   *
+   * @param request - The incoming HTTP request.
+   * @param response - The outgoing HTTP response.
+   */
+  dispatch(request: IncomingMessage, response: ServerResponse): void;
+}
+
+export function startServer(router: BasicRouter, abortSignal: AbortSignal): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    if (abortSignal.aborted) {
+      return reject(new Error("Server start cancelled"));
+    }
+    const server = createServer((req, res) => router.dispatch(req, res));
+    const stop = () => {
+      return new Promise<void>((r) => {
+        server.close(() => r);
+        server.closeAllConnections();
+      });
+    };
+    abortSignal.addEventListener("abort", () => {
+      stop().catch(() => {});
+    });
+    server.listen(function (this: Server) {
+      const address = this.address();
+      if (!address) {
+        reject(new Error("Server address not available"));
+        stop().catch(() => {});
+        return;
+      }
+
+      resolve(typeof address === "string" ? address : `http://localhost:${address.port}`);
+    });
+    server.on("error", reject);
+  });
+}
+
+/**
+ * Meant to be used for the `onInternalError` handler in the router
+ * in order to log any failed test assertions from within service handlers.
+ * Purely informational as the test will fail regardless.
+ * @param ctx The HttpContext from the http-server-js router
+ */
+function logAssertionErrors(ctx: any, error: Error): void {
+  // eslint-disable-next-line no-console
+  console.error(error);
+  ctx.response.statusCode = 599;
+  ctx.response.end();
+}
+
+export const testRouterOptions = {
+  onInternalError: logAssertionErrors,
+};

package/test/e2e/http/parameters/basic/main.test.e2e.ts

@@ -0,0 +1,36 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createBasicRouter } from "../../../generated/parameters/basic/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.Basic", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createBasicRouter(
+      {
+        async simple(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async simple(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/basic/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/parameters/body-optionality/main.test.e2e.ts

@@ -0,0 +1,45 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, assert, beforeEach, describe, expect, it } from "vitest";
+import { createBodyOptionalityRouter } from "../../../generated/parameters/body-optionality/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.BodyOptionality", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createBodyOptionalityRouter(
+      {
+        async requiredExplicit(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async requiredImplicit(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async omit(ctx, options) {
+          assert.isUndefined(options?.body);
+          return { statusCode: 204 };
+        },
+        async set(ctx, options) {
+          assert(options?.body);
+          assert.deepStrictEqual(options.body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/body-optionality/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/parameters/spread/main.test.e2e.ts

@@ -0,0 +1,92 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createSpreadRouter } from "../../../generated/parameters/spread/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../helpers.js";
+import { runScenario } from "../../../spector.js";
+
+describe("Parameters.Spread", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createSpreadRouter(
+      {
+        async spreadAsRequestBody(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequest(ctx, name, testHeader, body) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestMix(ctx, name, testHeader, prop) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          deepStrictEqual(prop, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestOnlyWithBody(ctx, body) {
+          deepStrictEqual(body, { name: "foo" });
+          return { statusCode: 204 };
+        },
+        async spreadCompositeRequestWithoutBody(ctx, name, testHeader) {
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(testHeader, "bar");
+          return { statusCode: 204 };
+        },
+      },
+      {
+        async spreadAsRequestBody(ctx, name) {
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadAsRequestParameter(ctx, id, xMsTestHeader, name) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(xMsTestHeader, "bar");
+          deepStrictEqual(name, "foo");
+          return { statusCode: 204 };
+        },
+        async spreadParameterWithInnerAlias(ctx, id, name, age, xMsTestHeader) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(age, 1);
+          deepStrictEqual(xMsTestHeader, "bar");
+          return { statusCode: 204 };
+        },
+        async spreadParameterWithInnerModel(ctx, id, name, xMsTestHeader) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(name, "foo");
+          deepStrictEqual(xMsTestHeader, "bar");
+          return { statusCode: 204 };
+        },
+        async spreadWithMultipleParameters(
+          ctx,
+          id,
+          xMsTestHeader,
+          requiredString,
+          requiredIntList,
+          options,
+        ) {
+          deepStrictEqual(id, "1");
+          deepStrictEqual(xMsTestHeader, "bar");
+          deepStrictEqual(requiredString, "foo");
+          deepStrictEqual(requiredIntList, [1, 2]);
+          deepStrictEqual(options?.optionalInt, 1);
+          deepStrictEqual(options?.optionalStringList, ["foo", "bar"]);
+          return { statusCode: 204 };
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("parameters/spread/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/http/type/model/empty/main.test.e2e.ts

@@ -0,0 +1,35 @@
+import { deepStrictEqual } from "node:assert";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createEmptyRouter } from "../../../../generated/type/model/empty/src/generated/http/router.js";
+import { startServer, testRouterOptions } from "../../../../helpers.js";
+import { runScenario } from "../../../../spector.js";
+
+describe("Type.Model.Empty", () => {
+  let serverAbortController: AbortController;
+  beforeEach(() => {
+    serverAbortController = new AbortController();
+  });
+  afterEach(() => {
+    serverAbortController.abort();
+  });
+
+  it("passes all scenarios", async () => {
+    const router = createEmptyRouter(
+      {
+        async getEmpty(ctx) {
+          return { body: {} };
+        },
+        async postRoundTripEmpty(ctx, body) {
+          return { body };
+        },
+        async putEmpty(ctx, input) {
+          deepStrictEqual(input, {});
+        },
+      },
+      testRouterOptions,
+    );
+    const baseUrl = await startServer(router, serverAbortController.signal);
+    const { status } = await runScenario("type/model/empty/**/*", baseUrl);
+    expect(status).toBe("pass");
+  });
+});

package/test/e2e/spector.ts

@@ -0,0 +1,33 @@
+import { run } from "@typespec/internal-build-utils";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+
+// Root of `http-server-js` package so vscode test integration runs from the correct directory
+const CWD = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+export async function runScenario(
+  scenario: string,
+  baseUrl: string,
+): Promise<{ status: "pass" | "fail" }> {
+  try {
+    await run(
+      "npx",
+      [
+        "tsp-spector",
+        "knock",
+        "./node_modules/@typespec/http-specs/specs",
+        "--filter",
+        scenario,
+        "--baseUrl",
+        baseUrl,
+      ],
+      {
+        shell: true,
+        cwd: CWD,
+      },
+    );
+    return { status: "pass" };
+  } catch (e) {
+    return { status: "fail" };
+  }
+}

package/vitest.config.e2e.ts

@@ -0,0 +1,20 @@
+import { defineConfig, mergeConfig } from "vitest/config";
+import { defaultTypeSpecVitestConfig } from "../../vitest.workspace.js";
+
+export default mergeConfig(
+  defaultTypeSpecVitestConfig,
+  defineConfig({
+    test: {
+      environment: "node",
+      testTimeout: 10_000,
+      isolate: false,
+      coverage: {
+        reporter: ["cobertura", "json", "text"],
+      },
+      outputFile: {
+        junit: "./test-results.xml",
+      },
+      include: ["test/**/*.e2e.ts"],
+    },
+  }),
+);

package/vitest.config.ts

@@ -1,4 +1,11 @@
 import { defineConfig, mergeConfig } from "vitest/config";
 import { defaultTypeSpecVitestConfig } from "../../vitest.workspace.js";
 
-export default mergeConfig(defaultTypeSpecVitestConfig, defineConfig({}));
+export default mergeConfig(
+  defaultTypeSpecVitestConfig,
+  defineConfig({
+    test: {
+      include: ["test/**/*.test.ts"],
+    },
+  }),
+);