nitro-openapi-schemas 2.0.0 → 3.0.0

package/README.md

@@ -1,7 +1,7 @@
 # nitro-openapi-schemas
 
-[![CI](https://github.com/oumarbarry/nitro-openapi-schemas/actions/workflows/ci.yml/badge.svg?branch=nitro-v2)](https://github.com/oumarbarry/nitro-openapi-schemas/actions/workflows/ci.yml)
-[![npm version](https://img.shields.io/npm/v/nitro-openapi-schemas/nitro-v2?color=yellow)](https://npmjs.com/package/nitro-openapi-schemas/v/nitro-v2)
+[![CI](https://github.com/oumarbarry/nitro-openapi-schemas/actions/workflows/ci.yml/badge.svg)](https://github.com/oumarbarry/nitro-openapi-schemas/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/nitro-openapi-schemas?color=yellow)](https://npmjs.com/package/nitro-openapi-schemas)
 [![license](https://img.shields.io/npm/l/nitro-openapi-schemas?color=yellow)](https://github.com/oumarbarry/nitro-openapi-schemas/blob/main/LICENSE)
 
 Schema-driven OpenAPI for [Nitro](https://nitro.build). The Zod, Valibot or
@@ -17,9 +17,8 @@ Zod / Valibot / ArkType schema
   → openapi.json             written after `nitro build`, ready for SDK codegen
 ```
 
-- This is the Nitro v2 and Nuxt 4 line: `nitropack` 2.x and h3 1.x, published
-  as 2.x under the `nitro-v2` dist-tag from the branch of the same name. Nitro v3 users
-  want the [`main` branch](https://github.com/oumarbarry/nitro-openapi-schemas/tree/main) and the `latest` tag.
+- Nitro v3 and h3 v2, published as 3.x under the `latest` tag. Nitro v2 and
+  Nuxt 4 have their own line, see [below](#nitro-v2-and-nuxt-4).
 - Zod 4.2+, ArkType 2.1.28+, and Valibot through `@valibot/to-json-schema`
   1.5+, via [Standard JSON Schema](https://github.com/standard-schema/standard-schema/pull/134).
   Bring the one you use; none is installed for you.
@@ -29,7 +28,7 @@ Zod / Valibot / ArkType schema
 ## Install
 
 ```sh
-bun add nitro-openapi-schemas@nitro-v2   # or npm, pnpm
+bun add nitro-openapi-schemas   # or npm, pnpm
 ```
 
 ## Usage
@@ -38,10 +37,10 @@ Register the module and, optionally, the `info` block of the spec:
 
 ```ts
 // nitro.config.ts
-import { defineNitroConfig } from "nitropack/config";
+import { defineConfig } from "nitro";
 import openAPISchemas from "nitro-openapi-schemas";
 
-export default defineNitroConfig({
+export default defineConfig({
   modules: [openAPISchemas],
   openAPISchemas: {
     info: { title: "Payments API", version: "1.0.0" },
@@ -51,28 +50,14 @@ export default defineNitroConfig({
 });
 ```
 
-```ts
-// nuxt.config.ts (Nuxt 4): same options, nested under `nitro`
-import openAPISchemas from "nitro-openapi-schemas";
-
-export default defineNuxtConfig({
-  nitro: {
-    modules: [openAPISchemas],
-    openAPISchemas: { info: { title: "Payments API", version: "1.0.0" } },
-  },
-});
-```
-
-Then write routes with `defineValidatedHandler` from `nitro-openapi-schemas/h3`.
-It validates `query`, `headers` and `body` through each schema's own
-`~standard.validate` (400 with the issues in `data` on failure, body skipped
-for GET and HEAD) and documents them. `meta.openAPI` is merged into the
-operation, and a `schema` on a response is converted too:
+Then write routes with `defineValidatedHandler` from `nitro/h3`. The `body`,
+`query` and `headers` schemas are validated by h3 and documented by this
+module. `meta.openAPI` is merged into the operation, and a `schema` on a
+response is converted too:
 
 ```ts
-// routes/api/payments/index.post.ts (Nuxt: server/api/payments/index.post.ts)
-import { readBody } from "h3";
-import { defineValidatedHandler } from "nitro-openapi-schemas/h3";
+// routes/api/payments/index.post.ts
+import { defineValidatedHandler } from "nitro/h3";
 import { createPaymentSchema, paymentSchema } from "../../shared/schema.ts";
 
 export default defineValidatedHandler({
@@ -85,17 +70,15 @@ export default defineValidatedHandler({
     },
   },
   handler: async (event) => {
-    const body = await readBody(event); // already validated
+    const body = await event.req.json(); // already validated
     // ...
   },
 });
 ```
 
-`readBody` returns the parsed body as it was sent, not the schema's output, so
-defaults and coercions declared in the schema are not applied to it. Start the
-server and open `/_scalar`, or fetch `/_openapi.json`. Path parameters are
-documented from the route pattern, so `defineValidatedHandler` with only `meta`
-is enough for a route without validation.
+Start the server and open `/_scalar`, or fetch `/_openapi.json`. Path
+parameters are documented from the route pattern, so a plain `defineHandler`
+with `meta` is enough for a route without validation.
 
 ### Naming components
 
@@ -125,25 +108,25 @@ bun run openapi   # nitro build, boot the output, write openapi.json
 bun run sdk       # openapi-typescript openapi.json -o sdk.d.ts
 ```
 
-## Nitro v3
+## Nitro v2 and Nuxt 4
 
-The `latest` dist-tag targets Nitro v3 and h3 v2, where `defineValidatedHandler`
-comes from `nitro/h3` itself. Install with `bun add nitro-openapi-schemas` and
-read the [`main` branch](https://github.com/oumarbarry/nitro-openapi-schemas) README.
+The `v2` dist-tag targets `nitropack` 2.x and h3 1.x, which is what Nuxt 4
+ships. h3 1.x has no `defineValidatedHandler`, so that line provides one at
+`nitro-openapi-schemas/h3`. Install with `bun add nitro-openapi-schemas@v2`
+and read the [`nitro-v2` branch](https://github.com/oumarbarry/nitro-openapi-schemas/tree/nitro-v2) README.
 
 ## How it works
 
 The module emits a virtual module that imports every scanned route handler
-directly, bypassing Nitro's lazy wrappers. `defineValidatedHandler` from
-`nitro-openapi-schemas/h3` assigns the `validate` schemas and `meta` onto the
-handler function, the same contract h3 v2 provides natively, so the spec route
-can read those live objects, convert each schema through `~standard.jsonSchema`
-(or wrap it with `@valibot/to-json-schema` when the library does not expose
-that yet), hoist named schemas and Zod's nested `$defs` into
-`components/schemas`, and cache the document after the first request.
+directly, bypassing Nitro's lazy wrappers, because h3's `defineValidatedHandler`
+and `defineHandler` assign the definition, `validate` schemas and `meta`
+included, onto the handler function. The spec route reads those live objects,
+converts each schema through `~standard.jsonSchema` (or wraps it with
+`@valibot/to-json-schema` when the library does not expose that yet), hoists
+named schemas and Zod's nested `$defs` into `components/schemas`, and caches
+the document after the first request.
 
 The trade-off: routes imported by the spec route are no longer lazy-loaded.
-Nuxt's catch-all renderer (`/**`) is left out of the import for that reason.
 
 ## Limitations
 
@@ -170,11 +153,10 @@ works as a standalone module.
 
 ```sh
 bun install && bun install --force   # the second install links the built dist/ into the examples
-bun run dev            # example app at http://localhost:3000/_scalar
-bun run check          # oxlint + oxfmt
-bun run build          # obuild, writes dist/
-bun run openapi        # end-to-end: build examples/nitro and write its openapi.json
-bun run openapi:nuxt4  # same for examples/nuxt4
+bun run dev       # example app at http://localhost:3000/_scalar
+bun run check     # oxlint + oxfmt
+bun run build     # obuild, writes dist/
+bun run openapi   # end-to-end: build the example and write its openapi.json
 ```
 
 See [CONTRIBUTING.md](CONTRIBUTING.md).

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { NitroModule } from "nitropack/types";
+import { NitroModule } from "nitro/types";
 interface NitroOpenAPISchemasOptions {
   /** Route serving the generated spec. Default: `/_openapi.json` */
   route?: string;
@@ -11,7 +11,7 @@ interface NitroOpenAPISchemasOptions {
     description?: string;
   };
 }
-declare module "nitropack/types" {
+declare module "nitro/types" {
   interface NitroConfig {
     openAPISchemas?: NitroOpenAPISchemasOptions;
   }
@@ -20,13 +20,10 @@ declare module "nitropack/types" {
   }
 }
 /**
- * Nitro v2 / Nuxt 4 line.
- *
  * Emits a virtual module that imports every scanned route handler *directly*
  * (bypassing lazy wrappers), so the spec route can read the live `validate`
- * schemas and `meta` attached to the handler function at runtime. h3 v1 has
- * no defineValidatedHandler, so this package ships its own shim (see ./h3.ts)
- * that attaches them.
+ * schemas and `meta` that h3's defineValidatedHandler/defineHandler attach to
+ * the handler function at runtime.
  */
 declare const nitroOpenAPISchemas: NitroModule;
 export { NitroOpenAPISchemasOptions, nitroOpenAPISchemas as default };

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
-import { runtimeDir } from "nitropack/runtime/meta";
+import { runtimeDir } from "nitro/meta";
 const nitroOpenAPISchemas = {
 	name: "nitro-openapi-schemas",
 	setup(nitro) {
 		const options = nitro.options.openAPISchemas || {};
 		const specRoute = options.route || "/_openapi.json";
 		nitro.options.virtual["#nitro-openapi-schemas"] = () => {
-			const entries = [...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => h.route && !h.middleware && h.route !== specRoute && !h.route.startsWith("/_") && !h.route.includes("**") && typeof h.handler === "string");
+			const entries = Object.values(nitro.routing.routes.routes).flatMap((r) => r.data).filter((h) => h.route && h.route !== specRoute && !h.route.startsWith("/_") && typeof h.handler === "string");
 			const files = [...new Set(entries.map((h) => h.handler))];
 			return [
 				...files.map((file, i) => `import h${i} from ${JSON.stringify(file)};`),

package/dist/runtime/route.mjs

@@ -1,11 +1,11 @@
-import { defineEventHandler, getRequestURL } from "h3";
+import { defineHandler } from "h3";
 // @ts-expect-error virtual module provided by ../index.ts
 import { routes, config } from "#nitro-openapi-schemas";
 import { toOpenAPIDocument } from "./generator.mjs";
 let cached;
-export default defineEventHandler((event) => {
+export default defineHandler((event) => {
 	
-	const origin = getRequestURL(event).origin;
+	const origin = new URL(event.req.url).origin;
 	return cached ??= toOpenAPIDocument(routes, {
 		info: config.info,
 		servers: [{ url: origin }]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-openapi-schemas",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Schema-driven OpenAPI for Nitro: the Zod, Valibot or ArkType schema that validates a route also documents it",
   "keywords": [
     "api",
@@ -35,10 +35,6 @@
     ".": {
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
-    },
-    "./h3": {
-      "types": "./dist/h3.d.mts",
-      "default": "./dist/h3.mjs"
     }
   },
   "publishConfig": {
@@ -47,7 +43,6 @@
   "scripts": {
     "dev": "bun run --cwd examples/nitro dev",
     "openapi": "bun run --cwd examples/nitro openapi",
-    "openapi:nuxt4": "bun run --cwd examples/nuxt4 openapi",
     "sdk": "bun run --cwd examples/nitro sdk",
     "build": "obuild",
     "prepare": "obuild",
@@ -69,8 +64,8 @@
   "peerDependencies": {
     "@valibot/to-json-schema": "^1.5.0",
     "arktype": "^2.1.28",
-    "h3": "^1.15.0",
-    "nitropack": "^2.12.0",
+    "h3": "^2.0.1-rc.22",
+    "nitro": "^3.0.260610-beta",
     "zod": "^4.2.0"
   },
   "peerDependenciesMeta": {

package/dist/h3.d.mts

@@ -1,36 +0,0 @@
-import { EventHandler, EventHandlerObject, EventHandlerRequest, EventHandlerResponse } from "h3";
-interface StandardSchema {
-  "~standard": {
-    vendor: string;
-    version: number;
-    validate: (value: unknown) => {
-      value: unknown;
-      issues?: undefined;
-    } | {
-      issues: readonly unknown[];
-    } | Promise<{
-      value: unknown;
-      issues?: undefined;
-    } | {
-      issues: readonly unknown[];
-    }>;
-  };
-}
-interface ValidateSchemas {
-  body?: StandardSchema;
-  query?: StandardSchema;
-  headers?: StandardSchema;
-}
-interface HandlerMeta {
-  openAPI?: Record<string, any>;
-  [key: string]: unknown;
-}
-type ValidatedHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response = EventHandlerResponse> = EventHandler<Request, Response> & {
-  validate?: ValidateSchemas;
-  meta?: HandlerMeta;
-};
-declare function defineValidatedHandler<Request extends EventHandlerRequest = EventHandlerRequest, Response = EventHandlerResponse>(def: EventHandlerObject<Request, Response> & {
-  validate?: ValidateSchemas;
-  meta?: HandlerMeta;
-}): ValidatedHandler<Request, Response>;
-export { HandlerMeta, ValidateSchemas, ValidatedHandler, defineValidatedHandler };

package/dist/h3.mjs

@@ -1,27 +0,0 @@
-import { createError, defineEventHandler, getQuery, getRequestHeaders, readBody } from "h3";
-function defineValidatedHandler(def) {
-	const { validate, meta } = def;
-	const handler = defineEventHandler({
-		...def,
-		handler: async (event) => {
-			if (validate?.query) await validatePart(validate.query, getQuery(event), "query");
-			if (validate?.headers) await validatePart(validate.headers, getRequestHeaders(event), "headers");
-			if (validate?.body && event.method !== "GET" && event.method !== "HEAD") await validatePart(validate.body, await readBody(event), "body");
-			return def.handler(event);
-		}
-	});
-	return Object.assign(handler, {
-		validate,
-		meta
-	});
-}
-async function validatePart(schema, value, part) {
-	const result = await schema["~standard"].validate(value);
-	if (result.issues) throw createError({
-		status: 400,
-		statusMessage: "Validation Error",
-		message: `Invalid ${part}`,
-		data: result.issues
-	});
-}
-export { defineValidatedHandler };