nitro 3.0.1-alpha.2 → 3.0.260415-beta

package/dist/docs/3.examples/5.database.md

@@ -0,0 +1,157 @@
+# Database
+
+> Built-in database support with SQL template literals.
+
+<code-tree>
+
+```ts [nitro.config.ts]
+import { defineConfig } from "nitro";
+
+export default defineConfig({
+  experimental: {
+    database: true,
+    tasks: true,
+  },
+  database: {
+    default: { connector: "sqlite" },
+  },
+});
+```
+
+```json [package.json]
+{
+  "type": "module",
+  "scripts": {
+    "dev": "nitro dev",
+    "build": "nitro build"
+  },
+  "devDependencies": {
+    "nitro": "latest"
+  }
+}
+```
+
+```ts [server.ts]
+import { defineHandler } from "nitro";
+import { useDatabase } from "nitro/database";
+
+export default defineHandler(async () => {
+  const db = useDatabase();
+
+  // Create users table
+  await db.sql`DROP TABLE IF EXISTS users`;
+  await db.sql`CREATE TABLE IF NOT EXISTS users ("id" TEXT PRIMARY KEY, "firstName" TEXT, "lastName" TEXT, "email" TEXT)`;
+
+  // Add a new user
+  const userId = String(Math.round(Math.random() * 10_000));
+  await db.sql`INSERT INTO users VALUES (${userId}, 'John', 'Doe', '')`;
+
+  // Query for users
+  const { rows } = await db.sql`SELECT * FROM users WHERE id = ${userId}`;
+
+  return {
+    rows,
+  };
+});
+```
+
+```json [tsconfig.json]
+{
+  "extends": "nitro/tsconfig"
+}
+```
+
+```ts [vite.config.ts]
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({ plugins: [nitro()] });
+```
+
+```ts [tasks/db/migrate.ts]
+import { defineTask } from "nitro/task";
+import { useDatabase } from "nitro/database";
+
+export default defineTask({
+  meta: {
+    description: "Run database migrations",
+  },
+  async run() {
+    const db = useDatabase();
+
+    console.log("Running database migrations...");
+
+    // Create users table
+    await db.sql`DROP TABLE IF EXISTS users`;
+    await db.sql`CREATE TABLE IF NOT EXISTS users ("id" TEXT PRIMARY KEY, "firstName" TEXT, "lastName" TEXT, "email" TEXT)`;
+
+    return {
+      result: "Database migrations complete!",
+    };
+  },
+});
+```
+</code-tree>
+
+Nitro provides a built-in database layer that uses SQL template literals for safe, parameterized queries. This example creates a users table, inserts a record, and queries it back.
+
+## Querying the Database
+
+```ts [server.ts]
+import { defineHandler } from "nitro";
+import { useDatabase } from "nitro/database";
+
+export default defineHandler(async () => {
+  const db = useDatabase();
+
+  // Create users table
+  await db.sql`DROP TABLE IF EXISTS users`;
+  await db.sql`CREATE TABLE IF NOT EXISTS users ("id" TEXT PRIMARY KEY, "firstName" TEXT, "lastName" TEXT, "email" TEXT)`;
+
+  // Add a new user
+  const userId = String(Math.round(Math.random() * 10_000));
+  await db.sql`INSERT INTO users VALUES (${userId}, 'John', 'Doe', '')`;
+
+  // Query for users
+  const { rows } = await db.sql`SELECT * FROM users WHERE id = ${userId}`;
+
+  return {
+    rows,
+  };
+});
+```
+
+Retrieve the database instance using `useDatabase()`. The database can be queried using `db.sql`, and variables like `${userId}` are automatically escaped to prevent SQL injection.
+
+## Running Migrations with Tasks
+
+Nitro tasks let you run operations outside of request handlers. For database migrations, create a task file in `tasks/` and run it via the CLI. This keeps schema changes separate from your application code.
+
+```ts [tasks/db/migrate.ts]
+import { defineTask } from "nitro/task";
+import { useDatabase } from "nitro/database";
+
+export default defineTask({
+  meta: {
+    description: "Run database migrations",
+  },
+  async run() {
+    const db = useDatabase();
+
+    console.log("Running database migrations...");
+
+    // Create users table
+    await db.sql`DROP TABLE IF EXISTS users`;
+    await db.sql`CREATE TABLE IF NOT EXISTS users ("id" TEXT PRIMARY KEY, "firstName" TEXT, "lastName" TEXT, "email" TEXT)`;
+
+    return {
+      result: "Database migrations complete!",
+    };
+  },
+});
+```
+
+## Learn More
+
+- [Database](/docs/database)
+- [Tasks](/docs/tasks)

package/dist/docs/3.examples/6.elysia.md

@@ -0,0 +1,70 @@
+# Elysia
+
+> Integrate Elysia with Nitro using the server entry.
+
+<code-tree>
+
+```ts [nitro.config.ts]
+import { defineConfig } from "nitro";
+
+export default defineConfig({});
+```
+
+```json [package.json]
+{
+  "type": "module",
+  "scripts": {
+    "build": "nitro build",
+    "dev": "nitro dev"
+  },
+  "devDependencies": {
+    "elysia": "^1.4.28",
+    "nitro": "latest"
+  }
+}
+```
+
+```ts [server.ts]
+import { Elysia } from "elysia";
+
+const app = new Elysia();
+
+app.get("/", () => "Hello, Elysia with Nitro!");
+
+export default app.compile();
+```
+
+```json [tsconfig.json]
+{
+  "extends": "nitro/tsconfig"
+}
+```
+
+```ts [vite.config.ts]
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({ plugins: [nitro()] });
+```
+</code-tree>
+
+## Server Entry
+
+```ts [server.ts]
+import { Elysia } from "elysia";
+
+const app = new Elysia();
+
+app.get("/", () => "Hello, Elysia with Nitro!");
+
+export default app.compile();
+```
+
+Nitro auto-detects `server.ts` in your project root and uses it as the server entry. The Elysia app handles all incoming requests, giving you full control over routing and middleware.
+
+Call `app.compile()` before exporting to optimize the router for production.
+
+## Learn More
+
+- [Server Entry](/docs/server-entry)
+- [Elysia Documentation](https://elysiajs.com/)

package/dist/docs/3.examples/7.express.md

@@ -0,0 +1,78 @@
+# Express
+
+> Integrate Express with Nitro using the server entry.
+
+<code-tree>
+
+```ts [nitro.config.ts]
+import { defineConfig } from "nitro";
+
+export default defineConfig({});
+```
+
+```json [package.json]
+{
+  "type": "module",
+  "scripts": {
+    "build": "nitro build",
+    "dev": "nitro dev"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "express": "^5.2.1",
+    "nitro": "latest"
+  }
+}
+```
+
+```ts [server.node.ts]
+import Express from "express";
+
+const app = Express();
+
+app.use("/", (_req, res) => {
+  res.send("Hello from Express with Nitro!");
+});
+
+export default app;
+```
+
+```json [tsconfig.json]
+{
+  "extends": "nitro/tsconfig"
+}
+```
+
+```ts [vite.config.ts]
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({ plugins: [nitro()] });
+```
+</code-tree>
+
+## Server Entry
+
+```ts [server.node.ts]
+import Express from "express";
+
+const app = Express();
+
+app.use("/", (_req, res) => {
+  res.send("Hello from Express with Nitro!");
+});
+
+export default app;
+```
+
+Nitro auto-detects `server.node.ts` in your project root and uses it as the server entry. The Express app handles all incoming requests, giving you full control over routing and middleware.
+
+<note>
+
+The `.node.ts` suffix indicates this entry is Node.js specific and won't work in other runtimes like Cloudflare Workers or Deno.
+</note>
+
+## Learn More
+
+- [Server Entry](/docs/server-entry)
+- [Express Documentation](https://expressjs.com/)

package/dist/docs/3.examples/8.fastify.md

@@ -0,0 +1,79 @@
+# Fastify
+
+> Integrate Fastify with Nitro using the server entry.
+
+<code-tree>
+
+```ts [nitro.config.ts]
+import { defineConfig } from "nitro";
+
+export default defineConfig({});
+```
+
+```json [package.json]
+{
+  "type": "module",
+  "scripts": {
+    "build": "nitro build",
+    "dev": "nitro dev"
+  },
+  "devDependencies": {
+    "fastify": "^5.8.4",
+    "nitro": "latest"
+  }
+}
+```
+
+```ts [server.node.ts]
+import Fastify from "fastify";
+
+const app = Fastify();
+
+app.get("/", () => "Hello, Fastify with Nitro!");
+
+await app.ready();
+
+export default app.routing;
+```
+
+```json [tsconfig.json]
+{
+  "extends": "nitro/tsconfig"
+}
+```
+
+```ts [vite.config.ts]
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({ plugins: [nitro()] });
+```
+</code-tree>
+
+## Server Entry
+
+```ts [server.node.ts]
+import Fastify from "fastify";
+
+const app = Fastify();
+
+app.get("/", () => "Hello, Fastify with Nitro!");
+
+await app.ready();
+
+export default app.routing;
+```
+
+Nitro auto-detects `server.node.ts` in your project root and uses it as the server entry.
+
+Call `await app.ready()` to initialize all registered plugins before exporting. Export `app.routing` (not `app`) to provide Nitro with the request handler function.
+
+<note>
+
+The `.node.ts` suffix indicates this entry is Node.js specific and won't work in other runtimes like Cloudflare Workers or Deno.
+</note>
+
+## Learn More
+
+- [Server Entry](/docs/server-entry)
+- [Fastify Documentation](https://fastify.dev/)

package/dist/docs/3.examples/9.hello-world.md

@@ -0,0 +1,68 @@
+# Hello World
+
+> Minimal Nitro server using the web standard fetch handler.
+
+<code-tree>
+
+```ts [nitro.config.ts]
+import { defineConfig } from "nitro";
+
+export default defineConfig({});
+```
+
+```json [package.json]
+{
+  "type": "module",
+  "scripts": {
+    "build": "nitro build",
+    "dev": "nitro dev",
+    "preview": "node .output/server/index.mjs"
+  },
+  "devDependencies": {
+    "nitro": "latest"
+  }
+}
+```
+
+```ts [server.ts]
+export default {
+  fetch(req: Request) {
+    return new Response("Nitro Works!");
+  },
+};
+```
+
+```json [tsconfig.json]
+{
+  "extends": "nitro/tsconfig"
+}
+```
+
+```ts [vite.config.ts]
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({ plugins: [nitro()] });
+```
+</code-tree>
+
+The simplest Nitro server. Export an object with a `fetch` method that receives a standard `Request` and returns a `Response`. No frameworks, no abstractions, just the web platform.
+
+## Server Entry
+
+```ts [server.ts]
+export default {
+  fetch(req: Request) {
+    return new Response("Nitro Works!");
+  },
+};
+```
+
+The `fetch` method follows the same signature as Service Workers and Cloudflare Workers. This pattern works across all deployment targets because it uses web standards.
+
+Add the Nitro plugin to Vite and it handles the rest: dev server, hot reloading, and production builds.
+
+## Learn More
+
+- [Server Entry](/docs/server-entry)
+- [Configuration](/docs/configuration)

package/dist/docs/README.md

@@ -0,0 +1,86 @@
+# Nitro Documentation
+
+- [Docs](./0.docs/0.index/index.md)
+  - [Introduction](./0.docs/0.index/index.md)
+  - [Quick Start](./0.docs/1.quick-start.md)
+  - [Renderer](./0.docs/2.renderer.md)
+  - [Routing](./0.docs/3.routing.md)
+  - [Server Entry](./0.docs/4.server-entry.md)
+  - [Cache](./0.docs/5.cache.md)
+  - [KV Storage](./0.docs/6.storage.md)
+  - [Assets](./0.docs/7.assets.md)
+  - [Configuration](./0.docs/8.configuration.md)
+  - [Database](./0.docs/9.database.md)
+  - [Lifecycle](./0.docs/10.lifecycle.md)
+  - [OpenAPI](./0.docs/11.openapi.md)
+  - [Plugins](./0.docs/12.plugins.md)
+  - [Tasks](./0.docs/13.tasks.md)
+  - [WebSocket](./0.docs/14.websocket.md)
+  - [Migration Guide](./0.docs/15.migration.md)
+  - [Nightly Channel](./0.docs/16.nightly.md)
+- [Deploy](./1.deploy/0.index/index.md)
+  - [Deploy](./1.deploy/0.index/index.md)
+    - [Node.js](./1.deploy/1.runtimes/0.node.md)
+    - [Bun](./1.deploy/1.runtimes/1.bun.md)
+    - [Deno](./1.deploy/1.runtimes/2.deno.md)
+    - [Alwaysdata](./1.deploy/2.providers/0.alwaysdata.md)
+    - [AWS Lambda](./1.deploy/2.providers/1.aws.md)
+    - [AWS Amplify](./1.deploy/2.providers/2.aws-amplify.md)
+    - [Azure](./1.deploy/2.providers/3.azure.md)
+    - [Cleavr](./1.deploy/2.providers/4.cleavr.md)
+    - [Cloudflare](./1.deploy/2.providers/5.cloudflare.md)
+    - [Deno Deploy](./1.deploy/2.providers/6.deno-deploy.md)
+    - [DigitalOcean](./1.deploy/2.providers/7.digitalocean.md)
+    - [EdgeOne Pages](./1.deploy/2.providers/8.edgeone.md)
+    - [Firebase](./1.deploy/2.providers/9.firebase.md)
+    - [Flightcontrol](./1.deploy/2.providers/10.flightcontrol.md)
+    - [Genezio](./1.deploy/2.providers/11.genezio.md)
+    - [GitHub Pages](./1.deploy/2.providers/12.github-pages.md)
+    - [GitLab Pages](./1.deploy/2.providers/13.gitlab-pages.md)
+    - [Heroku](./1.deploy/2.providers/14.heroku.md)
+    - [IIS](./1.deploy/2.providers/15.iis.md)
+    - [Koyeb](./1.deploy/2.providers/16.koyeb.md)
+    - [Netlify](./1.deploy/2.providers/17.netlify.md)
+    - [Platform.sh](./1.deploy/2.providers/18.platform-sh.md)
+    - [Render.com](./1.deploy/2.providers/19.render.md)
+    - [StormKit](./1.deploy/2.providers/20.stormkit.md)
+    - [Vercel](./1.deploy/2.providers/21.vercel.md)
+    - [Zeabur](./1.deploy/2.providers/22.zeabur.md)
+    - [Zephyr Cloud](./1.deploy/2.providers/23.zephyr.md)
+    - [Zerops](./1.deploy/2.providers/24.zerops.md)
+- [Config](./2.config/0.index/index.md)
+  - [Config](./2.config/0.index/index.md)
+- [Examples](./3.examples/0.index/index.md)
+  - [Examples](./3.examples/0.index/index.md)
+  - [API Routes](./3.examples/1.api-routes.md)
+  - [Auto Imports](./3.examples/2.auto-imports.md)
+  - [Cached Handler](./3.examples/3.cached-handler.md)
+  - [Custom Error Handler](./3.examples/4.custom-error-handler.md)
+  - [Database](./3.examples/5.database.md)
+  - [Elysia](./3.examples/6.elysia.md)
+  - [Express](./3.examples/7.express.md)
+  - [Fastify](./3.examples/8.fastify.md)
+  - [Hello World](./3.examples/9.hello-world.md)
+  - [Hono](./3.examples/10.hono.md)
+  - [Import Alias](./3.examples/11.import-alias.md)
+  - [Middleware](./3.examples/12.middleware.md)
+  - [Mono JSX](./3.examples/13.mono-jsx.md)
+  - [Nano JSX](./3.examples/14.nano-jsx.md)
+  - [Plugins](./3.examples/15.plugins.md)
+  - [Custom Renderer](./3.examples/16.renderer.md)
+  - [Runtime Config](./3.examples/17.runtime-config.md)
+  - [Server Fetch](./3.examples/18.server-fetch.md)
+  - [Shiki](./3.examples/19.shiki.md)
+  - [Virtual Routes](./3.examples/20.virtual-routes.md)
+  - [Vite Nitro Plugin](./3.examples/21.vite-nitro-plugin.md)
+  - [Vite RSC](./3.examples/22.vite-rsc.md)
+  - [Vite SSR HTML](./3.examples/23.vite-ssr-html.md)
+  - [SSR with Preact](./3.examples/24.vite-ssr-preact.md)
+  - [SSR with React](./3.examples/25.vite-ssr-react.md)
+  - [SSR with SolidJS](./3.examples/26.vite-ssr-solid.md)
+  - [SSR with TanStack Router](./3.examples/27.vite-ssr-tsr-react.md)
+  - [SSR with TanStack Start](./3.examples/28.vite-ssr-tss-react.md)
+  - [SSR with Vue Router](./3.examples/29.vite-ssr-vue-router.md)
+  - [Vite + tRPC](./3.examples/30.vite-trpc.md)
+  - [WebSocket](./3.examples/31.websocket.md)
+- [Index](./index.md)

package/dist/docs/index.md

@@ -0,0 +1,121 @@
+<u-page-hero>
+
+<code-group>
+
+<prose-pre>
+
+```ts
+import { defineConfig } from 'vite'
+import { nitro } from 'nitro/vite'
+
+export default defineConfig({
+  plugins: [nitro()],
+  nitro: {
+    serverDir: "./server"
+  }
+})
+```
+</prose-pre>
+
+<prose-pre>
+
+```ts
+import { defineConfig } from 'nitro'
+
+export default defineConfig({
+  preset: "node",
+  serverDir: "./server",
+  routeRules: {
+    "/api/**": { cache: true }
+  }
+})
+```
+</prose-pre>
+</code-group>
+
+<hero-background></hero-background>
+
+Build /Servers
+
+Nitro extends your Vite application with a production-ready server, compatible with any runtime. Add server routes to your application and deploy many hosting platform with a zero-config experience.
+
+<app-hero-links></app-hero-links>
+</u-page-hero>
+
+<hero-features>
+
+</hero-features>
+
+<performance-showcase>
+
+</performance-showcase>
+
+<landing-features>
+
+<feature-card>
+
+File-system routing
+
+Create server routes in the routes/ folder and they are automatically registered. Or bring your own framework — H3, Hono, Elysia, Express — via a server.ts entry.
+</feature-card>
+
+<feature-card>
+
+Deploy everywhere
+
+The same codebase deploys to Node.js, Cloudflare Workers, Deno, Bun, AWS Lambda, Vercel, Netlify, and more — zero config, no vendor lock-in.
+</feature-card>
+
+<feature-card>
+
+Universal storage
+
+Built-in key-value storage abstraction powered by unstorage. Works with filesystem, Redis, Cloudflare KV, and more — same API everywhere.
+</feature-card>
+
+<feature-card>
+
+Built-in caching
+
+Cache route handlers and arbitrary functions with a simple API. Supports multiple storage backends and stale-while-revalidate patterns.
+</feature-card>
+
+<feature-card>
+
+Web standard server
+
+Go full Web standard and pick the library of your choice. Use H3, Hono, Elysia, Express, or the raw fetch API — Nitro handles the rest.
+</feature-card>
+
+<feature-card>
+
+Universal renderer
+
+Use any frontend framework as your renderer. Nitro provides the server layer while your framework handles the UI.
+</feature-card>
+
+<feature-card>
+
+Server plugins
+
+Extend Nitro's runtime behavior with plugins. Hook into lifecycle events, register custom logic, and auto-load from the plugins/ directory.
+</feature-card>
+
+<feature-card>
+
+Built-in database
+
+Lightweight SQL database layer powered by db0. Pre-configured with SQLite out of the box, with support for PostgreSQL, MySQL, and Cloudflare D1.
+</feature-card>
+
+<feature-card>
+
+Static & server assets
+
+Serve public assets directly to clients or bundle server assets for programmatic access. Works seamlessly across all deployment targets.
+</feature-card>
+</landing-features>
+
+<page-sponsors>
+
+</page-sponsors>

package/dist/node_modules/@poppinss/dumper/build/formatters/html/main.js

@@ -630,6 +630,14 @@ function createStyleSheet() {
   padding: 10px 15px;
   margin: 0;
 }
+.dumper-dump pre code, .dumper-dump pre code span {
+  display: inline;
+  margin: 0;
+  padding: 0;
+}
+.dumper-toggle {
+  padding: 0 !important;
+}
 .dumper-dump pre samp {
   position: relative;
 }

package/dist/node_modules/@poppinss/dumper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poppinss/dumper",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "Pretty print JavaScript data types in the terminal and the browser",
   "main": "build/index.js",
   "type": "module",