quoll-cli 0.2.0__py3-none-any.whl

quoll/languages/node/frameworks/angular/starter.py

@@ -0,0 +1,74 @@
+"""A new Angular application, from the official CLI of the chosen major (`angular@18`), the latest by default."""
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import List
+
+from quoll.languages.base import Starter, StarterOptions
+from quoll.languages.node.ci import QUOLL_FILES
+from quoll.languages.node.starter import NODE_DEFAULT
+from quoll.starters import install_locally, run, write
+
+LATEST = "22"
+# Angular supports its current major and the two before it (https://angular.dev/reference/releases).
+SUPPORTED = 3
+
+
+def create(directory: Path, options: StarterOptions) -> List[str]:
+    major = options.version or LATEST
+    cli = f"@angular/cli@{major}"
+
+    def ng(*args: str) -> None:
+        # Run with the asked Node.js: the CLI checks it supports it, the lockfile matches it.
+        run(["npx", "-y", *args], directory, "node", options.runtime)
+
+    new = [cli, "new", options.name, "--directory", ".", "--defaults", "--skip-git", "--style", "css",
+           "--ssr", "false", "--package-manager", "npm"]
+    if int(major) >= 20:
+        # Options of recent CLIs: no AI tools configuration; Vitest is the default runner since 21.
+        new += ["--ai-config", "none"]
+    ng(*new)
+    # ESLint with Angular's rules: the CI's lint job runs `ng lint`.
+    ng(f"@angular/cli@{major}", "add", f"angular-eslint@{major}", "--skip-confirmation")
+    # The CLI's own files aren't all formatted the way its Prettier config says (when it has one).
+    if "prettier" in (directory / "package.json").read_text():
+        ng("prettier", "--write", ".")
+    ignore = directory / ".prettierignore"
+    existing = ignore.read_text() if ignore.exists() else ""
+    write(directory, {
+        ".nvmrc": f"{options.runtime or NODE_DEFAULT}\n",
+        # quoll's files keep quoll's format when the project's Prettier runs.
+        ".prettierignore": existing + "# Written by quoll: their format is quoll's.\n" + "\n".join(QUOLL_FILES) + "\n",
+    })
+    notes = install_locally(directory, options.runtime, ["npm", "ci"], "node_modules")
+    if int(major) <= int(LATEST) - SUPPORTED:
+        notes.append(
+            f"Angular {major} no longer gets security fixes: the CI's dependency audit will fail on its known "
+            f"vulnerabilities. Supported: {int(LATEST) - SUPPORTED + 1} to {LATEST}."
+        )
+    return notes
+
+
+def proxy(directory: Path, path: str, url: str) -> None:
+    """`ng serve` forwards `path` to the API (https://angular.dev/tools/cli/serve#proxying-to-a-backend-server)."""
+    write(directory, {"proxy.conf.json": json.dumps({path: {"target": url, "secure": False}}, indent=2) + "\n"})
+    config = directory / "angular.json"
+    workspace = json.loads(config.read_text())
+    for project in workspace["projects"].values():
+        serve = project.get("architect", {}).get("serve")
+        if serve:
+            serve.setdefault("options", {})["proxyConfig"] = "proxy.conf.json"
+    config.write_text(json.dumps(workspace, indent=2) + "\n")
+    # In the project's format: the CI checks it.
+    prettier = directory / "node_modules" / ".bin" / "prettier"
+    if prettier.exists():
+        subprocess.run([str(prettier), "--write", "angular.json", "proxy.conf.json"], cwd=directory,
+                       capture_output=True, check=True)
+
+
+starter = Starter(
+    name="angular", label="Angular", role="front", create=create, runtime="node", runtime_default=NODE_DEFAULT,
+    proxy=proxy,
+)

quoll/languages/node/frameworks/astro/__init__.py

@@ -0,0 +1,10 @@
+"""Astro: `astro check` type-checks .astro files too; opt out of telemetry."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.astro.ci import AstroCI
+from quoll.languages.node.frameworks.astro.detect import detect
+from quoll.languages.node.frameworks.astro.docker import AstroImage
+
+framework = Framework(
+    name="astro", language="node", detect=detect, ci=AstroCI(), lint_tools=("astro-check",), docker=AstroImage()
+)

quoll/languages/node/frameworks/astro/ci.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List
+
+from quoll.ci.steps import Item, step
+from quoll.languages.base import FrameworkCI
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+
+class AstroCI(FrameworkCI):
+    def env(self, cfg: CIConfig) -> Dict[str, str]:
+        return {"ASTRO_TELEMETRY_DISABLED": "1"}
+
+    def lint(self, cfg: CIConfig, tool: str) -> List[Item]:
+        return [step("astro check", run=cfg.language.ci.exec(cfg, "astro check"))]

quoll/languages/node/frameworks/astro/detect.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    deps = dependencies(package_json(project))
+    if "astro" not in deps:
+        return False
+    if "@astrojs/check" in deps:
+        det.lint_tools = [t for t in det.lint_tools if t != "tsc"] + ["astro-check"]
+    return True

quoll/languages/node/frameworks/astro/docker.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+
+class AstroImage(NodeImage):
+    # Astro builds one HTML file per page and a 404.html.
+    spa = False
+
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        build = det.build_command or "npm run build"
+        if "@astrojs/node" in dependencies(package_json(project)):
+            return DockerDefaults(port=4321, command="node ./dist/server/entry.mjs", build_command=build)
+        return DockerDefaults(port=8080, build_command=build, output_dir="dist", static=True)

quoll/languages/node/frameworks/nestjs/__init__.py

@@ -0,0 +1,7 @@
+"""NestJS: CI is plain Node; the framework matters for packaging (nest build → dist/main.js)."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.nestjs.detect import detect
+from quoll.languages.node.frameworks.nestjs.docker import NestjsImage
+
+framework = Framework(name="nestjs", language="node", detect=detect, docker=NestjsImage())

quoll/languages/node/frameworks/nestjs/detect.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    return "@nestjs/core" in dependencies(package_json(project))

quoll/languages/node/frameworks/nestjs/docker.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+
+class NestjsImage(NodeImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        return DockerDefaults(port=3000, command="node dist/main", build_command=det.build_command or "npm run build")

quoll/languages/node/frameworks/nextjs/Dockerfile.j2

@@ -0,0 +1,14 @@
+{% extends "node/Dockerfile.j2" %}
+
+{% block app_files %}
+{% if standalone %}
+# output: "standalone" bundles the server with only the dependencies it uses.
+{% if public %}
+COPY --from=build --chown={{ user }}:{{ user }} /app/public ./public
+{% endif %}
+COPY --from=build --chown={{ user }}:{{ user }} /app/.next/standalone ./
+COPY --from=build --chown={{ user }}:{{ user }} /app/.next/static ./.next/static
+{% else %}
+{{ super() }}
+{%- endif %}
+{% endblock %}

quoll/languages/node/frameworks/nextjs/__init__.py

@@ -0,0 +1,8 @@
+"""Next.js: persist the build cache between runs and opt out of telemetry."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.nextjs.ci import NextjsCI
+from quoll.languages.node.frameworks.nextjs.detect import detect
+from quoll.languages.node.frameworks.nextjs.docker import NextjsImage
+
+framework = Framework(name="nextjs", language="node", detect=detect, ci=NextjsCI(), docker=NextjsImage())

quoll/languages/node/frameworks/nextjs/ci.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List
+
+from quoll.ci.steps import Cache, Item
+from quoll.languages.base import FrameworkCI
+from quoll.languages.node.ci import LOCKFILES
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+_SOURCES = ("**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx", "!node_modules/**")
+
+
+class NextjsCI(FrameworkCI):
+    def env(self, cfg: CIConfig) -> Dict[str, str]:
+        return {"NEXT_TELEMETRY_DISABLED": "1"}
+
+    def before_build(self, cfg: CIConfig) -> List[Item]:
+        # https://nextjs.org/docs/app/guides/ci-build-caching
+        return [
+            Cache(
+                "nextjs",
+                (".next/cache",),
+                key_files=(LOCKFILES[cfg.package_manager],),
+                revision_files=_SOURCES,
+                name="Cache Next.js build",
+            )
+        ]

quoll/languages/node/frameworks/nextjs/detect.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    if "next" not in dependencies(package_json(project)):
+        return False
+    # `next build` type-checks, and plain tsc fails without the generated next-env.d.ts.
+    det.lint_tools = [t for t in det.lint_tools if t != "tsc"]
+    return True

quoll/languages/node/frameworks/nextjs/docker.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+if TYPE_CHECKING:
+    from quoll.docker.config import DockerConfig
+
+STANDALONE_DIR = ".next/standalone"
+_CONFIGS = ("next.config.js", "next.config.mjs", "next.config.ts")
+
+
+class NextjsImage(NodeImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        build = det.build_command or "npm run build"
+        if any("standalone" in project.read_text(c) for c in _CONFIGS):
+            return DockerDefaults(port=3000, command="node server.js", build_command=build, output_dir=STANDALONE_DIR)
+        return DockerDefaults(
+            port=3000,
+            command="next start",
+            build_command=build,
+            warnings=['Set `output: "standalone"` in next.config for a much smaller image.'],
+        )
+
+    def context(self, project: Project, cfg: DockerConfig) -> Dict[str, Any]:
+        standalone = cfg.output_dir == STANDALONE_DIR
+        return {**super().context(project, cfg), "standalone": standalone, "public": project.is_dir("public")}
+
+    def writable_paths(self, cfg: DockerConfig) -> Optional[List[str]]:
+        # The image optimization and ISR cache.
+        return ["/tmp", "/app/.next/cache"]
+
+    def build_env(self, cfg: DockerConfig) -> Dict[str, str]:
+        return {"NEXT_TELEMETRY_DISABLED": "1"}
+
+    def env(self, cfg: DockerConfig) -> Dict[str, str]:
+        # The standalone server listens on HOSTNAME.
+        return {"HOSTNAME": "0.0.0.0", "NEXT_TELEMETRY_DISABLED": "1"}

quoll/languages/node/frameworks/nuxt/__init__.py

@@ -0,0 +1,10 @@
+"""Nuxt: type-check through nuxi (plain tsc misses the generated .nuxt types) and opt out of telemetry."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.nuxt.ci import NuxtCI
+from quoll.languages.node.frameworks.nuxt.detect import detect
+from quoll.languages.node.frameworks.nuxt.docker import NuxtImage
+
+framework = Framework(
+    name="nuxt", language="node", detect=detect, ci=NuxtCI(), lint_tools=("nuxt-typecheck",), docker=NuxtImage()
+)

quoll/languages/node/frameworks/nuxt/ci.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List
+
+from quoll.ci.steps import Item, step
+from quoll.languages.base import FrameworkCI
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+
+class NuxtCI(FrameworkCI):
+    def env(self, cfg: CIConfig) -> Dict[str, str]:
+        return {"NUXT_TELEMETRY_DISABLED": "1"}
+
+    def lint(self, cfg: CIConfig, tool: str) -> List[Item]:
+        return [step("Type check", run=cfg.language.ci.exec(cfg, "nuxi typecheck"))]

quoll/languages/node/frameworks/nuxt/detect.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from quoll.languages.base import SCRIPT_PREFIX, Detection
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    deps = dependencies(package_json(project))
+    if "nuxt" not in deps:
+        return False
+    had_tsc = "tsc" in det.lint_tools
+    det.lint_tools = [t for t in det.lint_tools if t != "tsc"]
+    has_typecheck_script = any(t.startswith(f"{SCRIPT_PREFIX}type") for t in det.lint_tools)
+    if (had_tsc or "vue-tsc" in deps) and not has_typecheck_script:
+        det.lint_tools.append("nuxt-typecheck")
+    return True

quoll/languages/node/frameworks/nuxt/docker.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+if TYPE_CHECKING:
+    from quoll.docker.config import DockerConfig
+
+
+class NuxtImage(NodeImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        # Nitro bundles the server and its dependencies into .output.
+        return DockerDefaults(
+            port=3000,
+            command="node .output/server/index.mjs",
+            build_command=det.build_command or "npm run build",
+            output_dir=".output",
+        )
+
+    def build_env(self, cfg: DockerConfig) -> Dict[str, str]:
+        return {"NUXT_TELEMETRY_DISABLED": "1"}

quoll/languages/node/frameworks/sveltekit/__init__.py

@@ -0,0 +1,15 @@
+"""SvelteKit: svelte-check after `svelte-kit sync` (plain tsc misses the generated .svelte-kit types)."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.sveltekit.ci import SvelteKitCI
+from quoll.languages.node.frameworks.sveltekit.detect import detect
+from quoll.languages.node.frameworks.sveltekit.docker import SvelteKitImage
+
+framework = Framework(
+    name="sveltekit",
+    language="node",
+    detect=detect,
+    ci=SvelteKitCI(),
+    lint_tools=("svelte-check",),
+    docker=SvelteKitImage(),
+)

quoll/languages/node/frameworks/sveltekit/ci.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from quoll.ci.steps import Item, step
+from quoll.languages.base import FrameworkCI
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+
+class SvelteKitCI(FrameworkCI):
+    def lint(self, cfg: CIConfig, tool: str) -> List[Item]:
+        exec_ = cfg.language.ci.exec
+        return [step("svelte-check", run=f"{exec_(cfg, 'svelte-kit sync')}\n{exec_(cfg, 'svelte-check')}")]

quoll/languages/node/frameworks/sveltekit/detect.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from quoll.languages.base import SCRIPT_PREFIX, Detection
+from quoll.languages.node.detect import dependencies, package_json, scripts_of
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    pkg = package_json(project)
+    if "@sveltejs/kit" not in dependencies(pkg):
+        return False
+    det.lint_tools = [t for t in det.lint_tools if t != "tsc"]
+    # The SvelteKit template ships a `check` script running svelte-kit sync + svelte-check.
+    if "check" in scripts_of(pkg):
+        det.lint_tools.append(f"{SCRIPT_PREFIX}check")
+    elif "svelte-check" in dependencies(pkg):
+        det.lint_tools.append("svelte-check")
+    return True

quoll/languages/node/frameworks/sveltekit/docker.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+
+class SvelteKitImage(NodeImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        deps = dependencies(package_json(project))
+        build = det.build_command or "npm run build"
+        if "@sveltejs/adapter-static" in deps:
+            return DockerDefaults(port=8080, build_command=build, output_dir="build", static=True)
+        warnings = []
+        if "@sveltejs/adapter-node" not in deps:
+            warnings.append("Use @sveltejs/adapter-node (or adapter-static) in svelte.config.js to run in a container.")
+        return DockerDefaults(port=3000, command="node build", build_command=build, warnings=warnings)

quoll/languages/node/starter.py

@@ -0,0 +1,42 @@
+"""A new Node.js API: Express 5 and TypeScript, tested with Vitest and Supertest, linted with ESLint.
+
+Copied from templates/express/, then `npm install` resolves the current version of each dependency (Express's
+major can be chosen: `express@4`). The Node.js version goes to .nvmrc, which the CI and the Dockerfile follow.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from quoll.languages.base import Starter
+from quoll.starters import from_template
+
+# Node.js version when none is asked for: the active LTS.
+NODE_DEFAULT = "24"
+
+DEPENDENCIES = ["express@{{version}}"]
+DEV_DEPENDENCIES = [
+    "typescript", "tsx", "@types/express@{{version}}",
+    "vitest", "@vitest/coverage-v8", "supertest", "@types/supertest",
+    "eslint", "@eslint/js", "typescript-eslint", "globals", "prettier",
+]
+
+starter = Starter(
+    name="express",
+    label="Express (TypeScript)",
+    role="back",
+    create=from_template(
+        Path(__file__).parent / "templates" / "express",
+        [
+            ["npm", "install", "--save", *DEPENDENCIES],
+            # Types of the Node.js the project runs on.
+            ["npm", "install", "--save-dev", *DEV_DEPENDENCIES, "@types/node@{{runtime}}"],
+            ["npx", "prettier", "--write", "."],
+        ],
+        runtime="node",
+        runtime_default=NODE_DEFAULT,
+        local_install=["npm", "ci"],
+        local_folder="node_modules",
+    ),
+    runtime="node",
+    runtime_default=NODE_DEFAULT,
+)

quoll/languages/node/templates/express/README.md

@@ -0,0 +1,11 @@
+# {{name}}
+
+Node.js API: Express 5 and TypeScript.
+
+```bash
+npm install
+npm run dev        # http://localhost:3000/health, reloads on change
+npm test           # Vitest
+npm run lint       # ESLint
+npm run build && npm start
+```

quoll/languages/node/templates/express/env.example

@@ -0,0 +1,2 @@
+# Copied to .env for local runs (npm run dev); never commit .env.
+PORT=3000

quoll/languages/node/templates/express/eslint.config.js

@@ -0,0 +1,15 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  { ignores: ["dist", "coverage"] },
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: { globals: globals.node },
+    rules: {
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    },
+  },
+);

quoll/languages/node/templates/express/gitignore

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+coverage/
+.env

quoll/languages/node/templates/express/nvmrc

@@ -0,0 +1 @@
+{{runtime}}

quoll/languages/node/templates/express/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">={{runtime}}"
+  },
+  "scripts": {
+    "dev": "tsx watch --env-file-if-exists=.env src/server.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "start": "node dist/server.js",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}

quoll/languages/node/templates/express/prettierignore

@@ -0,0 +1,6 @@
+# Written by quoll: their format is quoll's.
+compose.yaml
+.github/
+.gitlab-ci.yml
+.gitlab/
+chart/

quoll/languages/node/templates/express/src/app.ts

@@ -0,0 +1,27 @@
+import express, { type NextFunction, type Request, type Response } from "express";
+
+export function createApp() {
+  const app = express();
+  app.disable("x-powered-by");
+  app.use(express.json());
+
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok" });
+  });
+
+  app.get("/api/hello", (req, res) => {
+    const name = typeof req.query.name === "string" ? req.query.name : "world";
+    res.json({ message: `Hello, ${name}!` });
+  });
+
+  app.use((_req, res) => {
+    res.status(404).json({ error: "Not found" });
+  });
+
+  app.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
+    console.error(err);
+    res.status(500).json({ error: "Internal server error" });
+  });
+
+  return app;
+}

quoll/languages/node/templates/express/src/server.ts

@@ -0,0 +1,11 @@
+import { createApp } from "./app.js";
+
+const port = Number(process.env.PORT ?? 3000);
+const host = process.env.HOST ?? "0.0.0.0";
+
+const server = createApp().listen(port, host, () => {
+  console.log(`Listening on http://${host}:${port}`);
+});
+
+// Containers stop with SIGTERM: finish the requests in flight, then exit.
+process.on("SIGTERM", () => server.close(() => process.exit(0)));

quoll/languages/node/templates/express/test/app.test.ts

@@ -0,0 +1,29 @@
+import request from "supertest";
+import { describe, expect, it } from "vitest";
+
+import { createApp } from "../src/app.js";
+
+const app = createApp();
+
+describe("API", () => {
+  it("reports its health", async () => {
+    const res = await request(app).get("/health");
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ status: "ok" });
+  });
+
+  it("says hello", async () => {
+    const res = await request(app).get("/api/hello?name=quoll");
+    expect(res.body).toEqual({ message: "Hello, quoll!" });
+  });
+
+  it("says hello to the world by default", async () => {
+    const res = await request(app).get("/api/hello");
+    expect(res.body).toEqual({ message: "Hello, world!" });
+  });
+
+  it("answers 404 to unknown routes", async () => {
+    const res = await request(app).get("/nope");
+    expect(res.status).toBe(404);
+  });
+});

quoll/languages/node/templates/express/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "sourceMap": true
+  },
+  "include": ["src"]
+}

quoll/languages/node/templates/express/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": ["src", "test", "vitest.config.ts"]
+}

quoll/languages/node/templates/express/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: "v8",
+      include: ["src/**/*.ts"],
+      // The entry point only starts the server.
+      exclude: ["src/server.ts"],
+    },
+  },
+});