hono-openapi 0.1.5 → 0.2.1

package/README.md

@@ -9,8 +9,9 @@ This can automatically generate the OpenAPI specification for the Hono API using
 Supported Validation Libraries:
 
 - [x] [Zod](https://zod.dev/)
-- [ ] [TypeBox](https://github.com/sinclairzx81/typebox)
-- [ ] [Valibot](https://valibot.dev/)
+- [x] [Valibot](https://valibot.dev/)
+- [x] [ArkType](https://arktype.io/)
+- [x] [TypeBox](https://github.com/sinclairzx81/typebox)
 
 > [!Note]
 > This package is still in development and your feedback is highly appreciated. If you have any suggestions or issues, please let us know by creating an issue on GitHub.
@@ -21,8 +22,28 @@ Supported Validation Libraries:
 
 You can install the package using favorite package manager.
 
+#### For Zod
+
+```bash
+pnpm add hono-openapi @hono/zod-validator zod zod-openapi
+```
+
+#### For Valibot
+
 ```bash
-pnpm add hono-openapi
+pnpm add hono-openapi @hono/valibot-validator valibot @valibot/to-json-schema
+```
+
+#### For ArkType
+
+```bash
+pnpm add hono-openapi @hono/arktype-validator arktype
+```
+
+#### For TypeBox
+
+```bash
+pnpm add hono-openapi @hono/typebox-validator @sinclair/typebox"
 ```
 
 ### Basic Usage
@@ -170,6 +191,43 @@ app.get(
 );
 ```
 
+#### Conditionaly Hiding Routes
+
+You can conditionally hide routes from the OpenAPI specification by using the `hide` property in the `describeRoute` function.
+
+```ts
+app.get(
+  "/",
+  describeRoute({
+    // ...
+    hide: process.env.NODE_ENV === "production",
+  }),
+  (c) => {
+    return c.text("Private Route");
+  }
+);
+```
+
+#### Validating Responses
+
+> [!Warning]
+> Experimental
+
+You can validate the responses using the `validateResponse` property in the `describeRoute` function. This will validate the response against the schema and return an error if the response is invalid.
+
+```ts
+app.get(
+  "/",
+  describeRoute({
+    // ...
+    validateResponse: process.env.NODE_ENV === "development",
+  }),
+  (c) => {
+    return c.text("Private Route");
+  }
+);
+```
+
 ## Contributing
 
 We would love to have more contributors involved!

package/arktype.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/arktype";

package/arktype.cjs.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var arktypeValidator = require('@hono/arktype-validator');
+var index = require('./index.cjs2.js');
+var utils = require('./utils.cjs.js');
+require('json-schema-walker');
+
+function resolver(schema){return {builder:async options=>({schema:await index.convert(schema.toJsonSchema())}),validator:value=>{schema(value);}}}function validator(target,schema,hook){const middleware=arktypeValidator.arktypeValidator(target,schema,hook);return Object.assign(middleware,{[utils.uniqueSymbol]:{resolver:async config=>utils.generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+exports.resolver = resolver;
+exports.validator = validator;

package/arktype.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/arktype";

package/arktype.esm.js

@@ -0,0 +1,8 @@
+import { arktypeValidator } from '@hono/arktype-validator';
+import { c as convert } from './index.esm2.js';
+import { u as uniqueSymbol, g as generateValidatorDocs } from './utils.esm.js';
+import 'json-schema-walker';
+
+function resolver(schema){return {builder:async options=>({schema:await convert(schema.toJsonSchema())}),validator:value=>{schema(value);}}}function validator(target,schema,hook){const middleware=arktypeValidator(target,schema,hook);return Object.assign(middleware,{[uniqueSymbol]:{resolver:async config=>generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+export { resolver, validator };

package/index.cjs.js

@@ -1 +1,13 @@
-"use strict";var e=require("./constants.cjs.js");const t=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"],n=e=>e.charAt(0).toUpperCase()+e.slice(1),s=(e,t)=>{let s=e;if("/"===t)return`${s}Index`;for(const e of t.split("/"))123===e.charCodeAt(0)?s+=`By${n(e.slice(1,-1))}`:s+=n(e);return s};function o({path:e,method:t,data:n,schema:o}){e=(e=>e.split("/").map((e=>{let t=e;return t.startsWith(":")&&(t=t.slice(1,t.length),t.endsWith("?")&&(t=t.slice(0,-1)),t=`{${t}}`),t})).join("/"))(e);const c=t.toLowerCase();o[e]={...o[e]?o[e]:{},[c]:{responses:{},...o[e]?.[c]??{},operationId:s(c,e),...n}}}function c(e,{excludeStaticFile:t=!0,exclude:n=[]}){const s={};for(const[o,c]of Object.entries(e))if(!(n.some((e=>"string"==typeof e?o===e:e.test(o)))||o.includes("*")||t&&o.includes("."))){for(const e of Object.keys(c)){const t=c[e];o.includes("{")&&(t.parameters||(t.parameters=[]),t.parameters=[...o.split("/").filter((e=>e.startsWith("{")&&!t.parameters.find((t=>"path"===t.in&&t.name===e.slice(1,e.length-1))))).map((e=>({schema:{type:"string"},in:"path",name:e.slice(1,e.length-1),required:!0}))),...t.parameters]),t.responses||(t.responses={200:{}})}s[o]=c}return s}exports.describeRoute=function(t){return Object.assign((async(e,t)=>{await t()}),{[e.uniqueSymbol]:{resolver:e=>{const n={...t};let s={};if(n.responses)for(const t of Object.keys(n.responses)){const o=n.responses[t];if(!o||"content"in o)for(const t of Object.keys(o.content??{})){const n=o.content?.[t];if(n&&(n.schema&&"builder"in n.schema)){const t=n.schema.builder(e);n.schema=t.schema,t.components&&(s={...s,...t.components})}}}return{docs:n,components:s}}}})},exports.openAPISpecs=function(n,{documentation:s={},excludeStaticFile:i=!0,exclude:r=[],excludeMethods:a=["OPTIONS"],excludeTags:l=[]}={documentation:{},excludeStaticFile:!0,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]}){const d={version:"3.0.3",components:{}},m={};for(const s of n.routes){if(!(e.uniqueSymbol in s.handler))continue;if(a.includes(s.method))continue;if(!1===t.includes(s.method)&&"ALL"!==s.method)continue;const{resolver:n,metadata:c={}}=s.handler[e.uniqueSymbol],{docs:i,components:r}=n({...d,...c});if(d.components={...d.components,...r??{}},"ALL"===s.method)for(const e of t)o({path:s.path,data:i,method:e,schema:m});else o({method:s.method,path:s.path,data:i,schema:m})}for(const e in m)for(const t in m[e])m[e][t].hide&&delete m[e][t];const p={openapi:d.version,...{...s,tags:s.tags?.filter((e=>!l?.includes(e?.name))),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...s.info},paths:{...c(m,{excludeStaticFile:i,exclude:Array.isArray(r)?r:[r]}),...s.paths},components:{...s.components,schemas:{...d.components,...s.components?.schemas}}}};return e=>e.json(p)};
+'use strict';
+
+var httpException = require('hono/http-exception');
+var utils = require('./utils.cjs.js');
+
+function describeRoute(specs){const middleware=async(c,next)=>{await next();if(specs.validateResponse&&specs.responses){const status=c.res.status;const contentType=c.res.headers.get("content-type");if(status&&contentType){const response=specs.responses[status];if(response&&"content"in response&&response.content){const content=response.content[contentType];if(content?.schema&&"validator"in content.schema){try{await content.schema.validator(c.res.body);}catch(error){throw new httpException.HTTPException(400,{message:"Response validation failed!"})}}}}}};return Object.assign(middleware,{[utils.uniqueSymbol]:{resolver:async config=>{const docs={...specs};let components={};if(docs.responses){for(const key of Object.keys(docs.responses)){const response=docs.responses[key];if(response&&!("content"in response))continue;for(const contentKey of Object.keys(response.content??{})){const raw=response.content?.[contentKey];if(!raw)continue;if(raw.schema&&"builder"in raw.schema){const result=await raw.schema.builder(config);raw.schema=result.schema;if(result.components){components={...components,...result.components};}}}}}return {docs,components}}}})}
+
+const ALLOWED_METHODS=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"];const toOpenAPIPath=path=>path.split("/").map(x=>{let tmp=x;if(tmp.startsWith(":")){tmp=tmp.slice(1,tmp.length);if(tmp.endsWith("?"))tmp=tmp.slice(0,-1);tmp=`{${tmp}}`;}return tmp}).join("/");const capitalize=word=>word.charAt(0).toUpperCase()+word.slice(1);const generateOperationId=(method,paths)=>{let operationId=method;if(paths==="/")return `${operationId}Index`;for(const path of paths.split("/")){if(path.charCodeAt(0)===123){operationId+=`By${capitalize(path.slice(1,-1))}`;}else {operationId+=capitalize(path);}}return operationId};function registerSchemaPath({path,method:_method,data,schema}){path=toOpenAPIPath(path);const method=_method.toLowerCase();schema[path]={...schema[path]?schema[path]:{},[method]:{responses:{},...schema[path]?.[method]??{},operationId:generateOperationId(method,path),...data}};}function filterPaths(paths,{excludeStaticFile=true,exclude=[]}){const newPaths={};for(const[key,value]of Object.entries(paths)){if(!exclude.some(x=>{if(typeof x==="string")return key===x;return x.test(key)})&&!key.includes("*")&&(excludeStaticFile?!key.includes("."):true)){for(const method of Object.keys(value)){const schema=value[method];if(key.includes("{")){if(!schema.parameters)schema.parameters=[];schema.parameters=[...key.split("/").filter(x=>x.startsWith("{")&&!schema.parameters.find(params=>params.in==="path"&&params.name===x.slice(1,x.length-1))).map(x=>({schema:{type:"string"},in:"path",name:x.slice(1,x.length-1),required:true})),...schema.parameters];}if(!schema.responses)schema.responses={200:{}};}newPaths[key]=value;}}return newPaths}
+
+function openAPISpecs(hono,{documentation={},excludeStaticFile=true,exclude=[],excludeMethods=["OPTIONS"],excludeTags=[]}={documentation:{},excludeStaticFile:true,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]}){const config={version:"3.1.0",components:{}};const schema={};let specs=null;return async c=>{if(specs)return c.json(specs);for(const route of hono.routes){if(!(utils.uniqueSymbol in route.handler))continue;if(excludeMethods.includes(route.method))continue;if(ALLOWED_METHODS.includes(route.method)===false&&route.method!=="ALL")continue;const{resolver,metadata={}}=route.handler[utils.uniqueSymbol];const{docs,components}=await resolver({...config,...metadata});config.components={...config.components,...components??{}};if(route.method==="ALL"){for(const method of ALLOWED_METHODS){registerSchemaPath({path:route.path,data:docs,method,schema});}}else {registerSchemaPath({method:route.method,path:route.path,data:docs,schema});}}for(const path in schema){for(const method in schema[path]){const valueOrFunc=schema[path][method]?.hide;if(valueOrFunc&&(typeof valueOrFunc==="boolean"?valueOrFunc:valueOrFunc(c))){delete schema[path][method];}}}specs={openapi:config.version,...{...documentation,tags:documentation.tags?.filter(tag=>!excludeTags?.includes(tag?.name)),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...documentation.info},paths:{...filterPaths(schema,{excludeStaticFile,exclude:Array.isArray(exclude)?exclude:[exclude]}),...documentation.paths},components:{...documentation.components,schemas:{...config.components,...documentation.components?.schemas}}}};return c.json(specs)}}
+
+exports.describeRoute = describeRoute;
+exports.openAPISpecs = openAPISpecs;

package/index.cjs2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var jsonSchemaWalker = require('json-schema-walker');
+
+const allowedKeywords=["$ref","definitions","title","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","enum","type","not","allOf","oneOf","anyOf","items","properties","additionalProperties","description","format","default","nullable","discriminator","readOnly","writeOnly","example","externalDocs","deprecated","xml"];
+
+let InvalidTypeError=class InvalidTypeError extends Error{constructor(message){super(message);this.name="InvalidTypeError";this.message=message;}};const oasExtensionPrefix="x-";const handleDefinition=async(def,schema)=>{if(typeof def!=="object"){return def}const type=def.type;if(type){const walker=new jsonSchemaWalker.Walker;await walker.loadSchema({definitions:schema["definitions"]||[],...def,$schema:schema["$schema"]},{dereference:true,cloneSchema:true,dereferenceOptions:{dereference:{circular:"ignore"}}});await walker.walk(convertSchema,walker.vocabularies.DRAFT_07);if("definitions"in walker.rootSchema){walker.rootSchema.definitions=undefined;}return walker.rootSchema}if(Array.isArray(def)){const typeArr=def;const hasNull=typeArr.includes("null");if(hasNull){const actualTypes=typeArr.filter(l=>l!=="null");return {type:actualTypes.length===1?actualTypes[0]:actualTypes,nullable:true}}}return def};const convert=async(schema,options)=>{const walker=new jsonSchemaWalker.Walker;await walker.loadSchema(schema,options);await walker.walk(convertSchema,walker.vocabularies.DRAFT_07);const rootSchema=walker.rootSchema;if(rootSchema?.definitions){for(const defName in rootSchema.definitions){const def=rootSchema.definitions[defName];rootSchema.definitions[defName]=await handleDefinition(def,schema);}}return rootSchema};function stripIllegalKeywords(schema){if(typeof schema!=="object"){return schema}schema["$schema"]=undefined;schema["$id"]=undefined;if("id"in schema){schema["id"]=undefined;}return schema}function convertSchema(schema){if(!schema){return schema}schema=stripIllegalKeywords(schema);schema=convertTypes(schema);schema=rewriteConst(schema);schema=convertDependencies(schema);schema=convertNullable(schema);schema=rewriteIfThenElse(schema);schema=rewriteExclusiveMinMax(schema);schema=convertExamples(schema);if(typeof schema["patternProperties"]==="object"){schema=convertPatternProperties(schema);}if(schema.type==="array"&&typeof schema.items==="undefined"){schema.items={};}schema=convertIllegalKeywordsAsExtensions(schema);return schema}const validTypes=new Set(["null","boolean","object","array","number","string","integer"]);function validateType(type){if(typeof type==="object"&&!Array.isArray(type)){if(type.$ref){return}if(type.properties){return}}const types=Array.isArray(type)?type:[type];for(const type of types){if(type&&!validTypes.has(type))throw new InvalidTypeError(`Type "${type}" is not a valid type`)}}function convertDependencies(schema){const deps=schema.dependencies;if(typeof deps!=="object"){return schema}schema.dependencies=undefined;if(!Array.isArray(schema.allOf)){schema.allOf=[];}for(const key in deps){const foo={oneOf:[{not:{required:[key]}},{required:[key,deps[key]].flat()}]};schema.allOf.push(foo);}return schema}function convertNullable(schema){for(const key of ["oneOf","anyOf"]){const schemas=schema[key];if(!schemas)continue;if(!Array.isArray(schemas)){return schema}const hasNullable=schemas.some(item=>item.type==="null");if(!hasNullable){return schema}const filtered=schemas.filter(l=>l.type!=="null");for(const schemaEntry of filtered){schemaEntry.nullable=true;}schema[key]=filtered;}return schema}function convertTypes(schema){if(typeof schema!=="object"){return schema}if(schema.type===undefined){return schema}validateType(schema.type);if(Array.isArray(schema.type)){if(schema.type.includes("null")){schema.nullable=true;}const typesWithoutNull=schema.type.filter(type=>type!=="null");if(typesWithoutNull.length===0){schema.type=undefined;}else if(typesWithoutNull.length===1){schema.type=typesWithoutNull[0];}else {schema.type=undefined;schema.anyOf=typesWithoutNull.map(type=>({type}));}}else if(schema.type==="null"){schema.type=undefined;schema.nullable=true;}return schema}function convertPatternProperties(schema){schema["x-patternProperties"]=schema.patternProperties;schema.patternProperties=undefined;schema.additionalProperties??=true;return schema}function convertIllegalKeywordsAsExtensions(schema){const keys=Object.keys(schema);for(const keyword of keys){if(!keyword.startsWith(oasExtensionPrefix)&&!allowedKeywords.includes(keyword)){const key=`${oasExtensionPrefix}${keyword}`;schema[key]=schema[keyword];schema[keyword]=undefined;}}return schema}function convertExamples(schema){if(schema["examples"]&&Array.isArray(schema["examples"])){schema["example"]=schema["examples"][0];schema["examples"]=undefined;}return schema}function rewriteConst(schema){if(Object.hasOwnProperty.call(schema,"const")){schema.enum=[schema.const];schema.const=undefined;}return schema}function rewriteIfThenElse(schema){if(typeof schema!=="object"){return schema}if("if"in schema&&schema.if&&schema.then){schema.oneOf=[{allOf:[schema.if,schema.then].filter(Boolean)},{allOf:[{not:schema.if},schema.else].filter(Boolean)}];schema.if=undefined;schema.then=undefined;schema.else=undefined;}return schema}function rewriteExclusiveMinMax(schema){if(typeof schema.exclusiveMaximum==="number"){schema.maximum=schema.exclusiveMaximum;schema.exclusiveMaximum=true;}if(typeof schema.exclusiveMinimum==="number"){schema.minimum=schema.exclusiveMinimum;schema.exclusiveMinimum=true;}return schema}
+
+exports.convert = convert;

package/index.esm.js

@@ -1 +1,10 @@
-import{u as e}from"./constants.esm.js";function t(t){return Object.assign((async(e,t)=>{await t()}),{[e]:{resolver:e=>{const n={...t};let s={};if(n.responses)for(const t of Object.keys(n.responses)){const o=n.responses[t];if(!o||"content"in o)for(const t of Object.keys(o.content??{})){const n=o.content?.[t];if(n&&(n.schema&&"builder"in n.schema)){const t=n.schema.builder(e);n.schema=t.schema,t.components&&(s={...s,...t.components})}}}return{docs:n,components:s}}}})}const n=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"],s=e=>e.charAt(0).toUpperCase()+e.slice(1),o=(e,t)=>{let n=e;if("/"===t)return`${n}Index`;for(const e of t.split("/"))123===e.charCodeAt(0)?n+=`By${s(e.slice(1,-1))}`:n+=s(e);return n};function c({path:e,method:t,data:n,schema:s}){e=(e=>e.split("/").map((e=>{let t=e;return t.startsWith(":")&&(t=t.slice(1,t.length),t.endsWith("?")&&(t=t.slice(0,-1)),t=`{${t}}`),t})).join("/"))(e);const c=t.toLowerCase();s[e]={...s[e]?s[e]:{},[c]:{responses:{},...s[e]?.[c]??{},operationId:o(c,e),...n}}}function i(e,{excludeStaticFile:t=!0,exclude:n=[]}){const s={};for(const[o,c]of Object.entries(e))if(!(n.some((e=>"string"==typeof e?o===e:e.test(o)))||o.includes("*")||t&&o.includes("."))){for(const e of Object.keys(c)){const t=c[e];o.includes("{")&&(t.parameters||(t.parameters=[]),t.parameters=[...o.split("/").filter((e=>e.startsWith("{")&&!t.parameters.find((t=>"path"===t.in&&t.name===e.slice(1,e.length-1))))).map((e=>({schema:{type:"string"},in:"path",name:e.slice(1,e.length-1),required:!0}))),...t.parameters]),t.responses||(t.responses={200:{}})}s[o]=c}return s}function a(t,{documentation:s={},excludeStaticFile:o=!0,exclude:a=[],excludeMethods:r=["OPTIONS"],excludeTags:d=[]}={documentation:{},excludeStaticFile:!0,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]}){const m={version:"3.0.3",components:{}},l={};for(const s of t.routes){if(!(e in s.handler))continue;if(r.includes(s.method))continue;if(!1===n.includes(s.method)&&"ALL"!==s.method)continue;const{resolver:t,metadata:o={}}=s.handler[e],{docs:i,components:a}=t({...m,...o});if(m.components={...m.components,...a??{}},"ALL"===s.method)for(const e of n)c({path:s.path,data:i,method:e,schema:l});else c({method:s.method,path:s.path,data:i,schema:l})}for(const e in l)for(const t in l[e])l[e][t].hide&&delete l[e][t];const p={openapi:m.version,...{...s,tags:s.tags?.filter((e=>!d?.includes(e?.name))),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...s.info},paths:{...i(l,{excludeStaticFile:o,exclude:Array.isArray(a)?a:[a]}),...s.paths},components:{...s.components,schemas:{...m.components,...s.components?.schemas}}}};return e=>e.json(p)}export{t as describeRoute,a as openAPISpecs};
+import { HTTPException } from 'hono/http-exception';
+import { u as uniqueSymbol } from './utils.esm.js';
+
+function describeRoute(specs){const middleware=async(c,next)=>{await next();if(specs.validateResponse&&specs.responses){const status=c.res.status;const contentType=c.res.headers.get("content-type");if(status&&contentType){const response=specs.responses[status];if(response&&"content"in response&&response.content){const content=response.content[contentType];if(content?.schema&&"validator"in content.schema){try{await content.schema.validator(c.res.body);}catch(error){throw new HTTPException(400,{message:"Response validation failed!"})}}}}}};return Object.assign(middleware,{[uniqueSymbol]:{resolver:async config=>{const docs={...specs};let components={};if(docs.responses){for(const key of Object.keys(docs.responses)){const response=docs.responses[key];if(response&&!("content"in response))continue;for(const contentKey of Object.keys(response.content??{})){const raw=response.content?.[contentKey];if(!raw)continue;if(raw.schema&&"builder"in raw.schema){const result=await raw.schema.builder(config);raw.schema=result.schema;if(result.components){components={...components,...result.components};}}}}}return {docs,components}}}})}
+
+const ALLOWED_METHODS=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"];const toOpenAPIPath=path=>path.split("/").map(x=>{let tmp=x;if(tmp.startsWith(":")){tmp=tmp.slice(1,tmp.length);if(tmp.endsWith("?"))tmp=tmp.slice(0,-1);tmp=`{${tmp}}`;}return tmp}).join("/");const capitalize=word=>word.charAt(0).toUpperCase()+word.slice(1);const generateOperationId=(method,paths)=>{let operationId=method;if(paths==="/")return `${operationId}Index`;for(const path of paths.split("/")){if(path.charCodeAt(0)===123){operationId+=`By${capitalize(path.slice(1,-1))}`;}else {operationId+=capitalize(path);}}return operationId};function registerSchemaPath({path,method:_method,data,schema}){path=toOpenAPIPath(path);const method=_method.toLowerCase();schema[path]={...schema[path]?schema[path]:{},[method]:{responses:{},...schema[path]?.[method]??{},operationId:generateOperationId(method,path),...data}};}function filterPaths(paths,{excludeStaticFile=true,exclude=[]}){const newPaths={};for(const[key,value]of Object.entries(paths)){if(!exclude.some(x=>{if(typeof x==="string")return key===x;return x.test(key)})&&!key.includes("*")&&(excludeStaticFile?!key.includes("."):true)){for(const method of Object.keys(value)){const schema=value[method];if(key.includes("{")){if(!schema.parameters)schema.parameters=[];schema.parameters=[...key.split("/").filter(x=>x.startsWith("{")&&!schema.parameters.find(params=>params.in==="path"&&params.name===x.slice(1,x.length-1))).map(x=>({schema:{type:"string"},in:"path",name:x.slice(1,x.length-1),required:true})),...schema.parameters];}if(!schema.responses)schema.responses={200:{}};}newPaths[key]=value;}}return newPaths}
+
+function openAPISpecs(hono,{documentation={},excludeStaticFile=true,exclude=[],excludeMethods=["OPTIONS"],excludeTags=[]}={documentation:{},excludeStaticFile:true,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]}){const config={version:"3.1.0",components:{}};const schema={};let specs=null;return async c=>{if(specs)return c.json(specs);for(const route of hono.routes){if(!(uniqueSymbol in route.handler))continue;if(excludeMethods.includes(route.method))continue;if(ALLOWED_METHODS.includes(route.method)===false&&route.method!=="ALL")continue;const{resolver,metadata={}}=route.handler[uniqueSymbol];const{docs,components}=await resolver({...config,...metadata});config.components={...config.components,...components??{}};if(route.method==="ALL"){for(const method of ALLOWED_METHODS){registerSchemaPath({path:route.path,data:docs,method,schema});}}else {registerSchemaPath({method:route.method,path:route.path,data:docs,schema});}}for(const path in schema){for(const method in schema[path]){const valueOrFunc=schema[path][method]?.hide;if(valueOrFunc&&(typeof valueOrFunc==="boolean"?valueOrFunc:valueOrFunc(c))){delete schema[path][method];}}}specs={openapi:config.version,...{...documentation,tags:documentation.tags?.filter(tag=>!excludeTags?.includes(tag?.name)),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...documentation.info},paths:{...filterPaths(schema,{excludeStaticFile,exclude:Array.isArray(exclude)?exclude:[exclude]}),...documentation.paths},components:{...documentation.components,schemas:{...config.components,...documentation.components?.schemas}}}};return c.json(specs)}}
+
+export { describeRoute, openAPISpecs };

package/index.esm2.js

@@ -0,0 +1,7 @@
+import { Walker } from 'json-schema-walker';
+
+const allowedKeywords=["$ref","definitions","title","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","enum","type","not","allOf","oneOf","anyOf","items","properties","additionalProperties","description","format","default","nullable","discriminator","readOnly","writeOnly","example","externalDocs","deprecated","xml"];
+
+let InvalidTypeError=class InvalidTypeError extends Error{constructor(message){super(message);this.name="InvalidTypeError";this.message=message;}};const oasExtensionPrefix="x-";const handleDefinition=async(def,schema)=>{if(typeof def!=="object"){return def}const type=def.type;if(type){const walker=new Walker;await walker.loadSchema({definitions:schema["definitions"]||[],...def,$schema:schema["$schema"]},{dereference:true,cloneSchema:true,dereferenceOptions:{dereference:{circular:"ignore"}}});await walker.walk(convertSchema,walker.vocabularies.DRAFT_07);if("definitions"in walker.rootSchema){walker.rootSchema.definitions=undefined;}return walker.rootSchema}if(Array.isArray(def)){const typeArr=def;const hasNull=typeArr.includes("null");if(hasNull){const actualTypes=typeArr.filter(l=>l!=="null");return {type:actualTypes.length===1?actualTypes[0]:actualTypes,nullable:true}}}return def};const convert=async(schema,options)=>{const walker=new Walker;await walker.loadSchema(schema,options);await walker.walk(convertSchema,walker.vocabularies.DRAFT_07);const rootSchema=walker.rootSchema;if(rootSchema?.definitions){for(const defName in rootSchema.definitions){const def=rootSchema.definitions[defName];rootSchema.definitions[defName]=await handleDefinition(def,schema);}}return rootSchema};function stripIllegalKeywords(schema){if(typeof schema!=="object"){return schema}schema["$schema"]=undefined;schema["$id"]=undefined;if("id"in schema){schema["id"]=undefined;}return schema}function convertSchema(schema){if(!schema){return schema}schema=stripIllegalKeywords(schema);schema=convertTypes(schema);schema=rewriteConst(schema);schema=convertDependencies(schema);schema=convertNullable(schema);schema=rewriteIfThenElse(schema);schema=rewriteExclusiveMinMax(schema);schema=convertExamples(schema);if(typeof schema["patternProperties"]==="object"){schema=convertPatternProperties(schema);}if(schema.type==="array"&&typeof schema.items==="undefined"){schema.items={};}schema=convertIllegalKeywordsAsExtensions(schema);return schema}const validTypes=new Set(["null","boolean","object","array","number","string","integer"]);function validateType(type){if(typeof type==="object"&&!Array.isArray(type)){if(type.$ref){return}if(type.properties){return}}const types=Array.isArray(type)?type:[type];for(const type of types){if(type&&!validTypes.has(type))throw new InvalidTypeError(`Type "${type}" is not a valid type`)}}function convertDependencies(schema){const deps=schema.dependencies;if(typeof deps!=="object"){return schema}schema.dependencies=undefined;if(!Array.isArray(schema.allOf)){schema.allOf=[];}for(const key in deps){const foo={oneOf:[{not:{required:[key]}},{required:[key,deps[key]].flat()}]};schema.allOf.push(foo);}return schema}function convertNullable(schema){for(const key of ["oneOf","anyOf"]){const schemas=schema[key];if(!schemas)continue;if(!Array.isArray(schemas)){return schema}const hasNullable=schemas.some(item=>item.type==="null");if(!hasNullable){return schema}const filtered=schemas.filter(l=>l.type!=="null");for(const schemaEntry of filtered){schemaEntry.nullable=true;}schema[key]=filtered;}return schema}function convertTypes(schema){if(typeof schema!=="object"){return schema}if(schema.type===undefined){return schema}validateType(schema.type);if(Array.isArray(schema.type)){if(schema.type.includes("null")){schema.nullable=true;}const typesWithoutNull=schema.type.filter(type=>type!=="null");if(typesWithoutNull.length===0){schema.type=undefined;}else if(typesWithoutNull.length===1){schema.type=typesWithoutNull[0];}else {schema.type=undefined;schema.anyOf=typesWithoutNull.map(type=>({type}));}}else if(schema.type==="null"){schema.type=undefined;schema.nullable=true;}return schema}function convertPatternProperties(schema){schema["x-patternProperties"]=schema.patternProperties;schema.patternProperties=undefined;schema.additionalProperties??=true;return schema}function convertIllegalKeywordsAsExtensions(schema){const keys=Object.keys(schema);for(const keyword of keys){if(!keyword.startsWith(oasExtensionPrefix)&&!allowedKeywords.includes(keyword)){const key=`${oasExtensionPrefix}${keyword}`;schema[key]=schema[keyword];schema[keyword]=undefined;}}return schema}function convertExamples(schema){if(schema["examples"]&&Array.isArray(schema["examples"])){schema["example"]=schema["examples"][0];schema["examples"]=undefined;}return schema}function rewriteConst(schema){if(Object.hasOwnProperty.call(schema,"const")){schema.enum=[schema.const];schema.const=undefined;}return schema}function rewriteIfThenElse(schema){if(typeof schema!=="object"){return schema}if("if"in schema&&schema.if&&schema.then){schema.oneOf=[{allOf:[schema.if,schema.then].filter(Boolean)},{allOf:[{not:schema.if},schema.else].filter(Boolean)}];schema.if=undefined;schema.then=undefined;schema.else=undefined;}return schema}function rewriteExclusiveMinMax(schema){if(typeof schema.exclusiveMaximum==="number"){schema.maximum=schema.exclusiveMaximum;schema.exclusiveMaximum=true;}if(typeof schema.exclusiveMinimum==="number"){schema.minimum=schema.exclusiveMinimum;schema.exclusiveMinimum=true;}return schema}
+
+export { convert as c };

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "hono-openapi",
   "description": "OpenAPI schema generator for Hono",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "license": "MIT",
   "keywords": [
     "hono",
-    "openapi"
+    "openapi",
+    "zod",
+    "valibot",
+    "typebox",
+    "arktype"
   ],
   "homepage": "https://github.com/rhinobase/hono-openapi",
   "publishConfig": {
@@ -14,31 +18,83 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rhinobase/hono-openapi.git",
-    "directory": "packages/ui"
+    "directory": "packages/core"
   },
   "bugs": {
     "url": "https://github.com/rhinobase/hono-openapi/issues"
   },
-  "peerDependencies": {
-    "hono": "^4.6.4",
+  "dependencies": {
+    "json-schema-walker": "^2.0.0"
+  },
+  "optionalDependencies": {
+    "@hono/arktype-validator": "^2.0.0",
+    "@hono/typebox-validator": "^0.2.6",
+    "@hono/valibot-validator": "^0.5.1",
     "@hono/zod-validator": "^0.4.1",
+    "@sinclair/typebox": "^0.34.9",
+    "@valibot/to-json-schema": "^1.0.0-beta.3",
+    "arktype": "2.0.0-rc.25",
+    "hono": "^4.6.4",
+    "openapi-types": "^12.1.3",
+    "valibot": "^1.0.0-beta.9",
     "zod": "^3.23.8",
-    "zod-openapi": "^3.1.1",
-    "openapi-types": "^12.1.3"
+    "zod-openapi": "^4.0.0"
   },
   "devDependencies": {
-    "@rollup/plugin-terser": "^0.4.4"
+    "@rollup/plugin-terser": "^0.4.4",
+    "@apidevtools/json-schema-ref-parser": "^11.7.2",
+    "@types/json-schema": "^7.0.15"
   },
   "exports": {
     ".": {
-      "import": "./index.esm.js",
-      "require": "./index.cjs.js",
-      "types": "./index.cjs.d.ts"
+      "import": {
+        "default": "./index.esm.js",
+        "types": "./index.esm.d.ts"
+      },
+      "require": {
+        "default": "./index.cjs.js",
+        "types": "./index.cjs.d.ts"
+      }
     },
     "./zod": {
-      "import": "./zod.esm.js",
-      "require": "./zod.cjs.js",
-      "types": "./zod.cjs.d.ts"
+      "import": {
+        "default": "./zod.esm.js",
+        "types": "./zod.esm.d.ts"
+      },
+      "require": {
+        "default": "./zod.cjs.js",
+        "types": "./zod.cjs.d.ts"
+      }
+    },
+    "./valibot": {
+      "import": {
+        "default": "./valibot.esm.js",
+        "types": "./valibot.esm.d.ts"
+      },
+      "require": {
+        "default": "./valibot.cjs.js",
+        "types": "./valibot.cjs.d.ts"
+      }
+    },
+    "./typebox": {
+      "import": {
+        "default": "./typebox.esm.js",
+        "types": "./typebox.esm.d.ts"
+      },
+      "require": {
+        "default": "./typebox.cjs.js",
+        "types": "./typebox.cjs.d.ts"
+      }
+    },
+    "./arktype": {
+      "import": {
+        "default": "./arktype.esm.js",
+        "types": "./arktype.esm.d.ts"
+      },
+      "require": {
+        "default": "./arktype.cjs.js",
+        "types": "./arktype.cjs.d.ts"
+      }
     }
   },
   "module": "./index.esm.js",

package/src/arktype.d.ts

@@ -0,0 +1,24 @@
+import { type Hook } from "@hono/arktype-validator";
+import type { Type } from "arktype";
+import type { Env, MiddlewareHandler, ValidationTargets } from "hono";
+import type { HasUndefined, ResolverResult } from "./types";
+export declare function resolver<T extends Type>(schema: T): ResolverResult;
+export declare function validator<T extends Type, Target extends keyof ValidationTargets, E extends Env, P extends string, I = T["inferIn"], O = T["infer"], V extends {
+    in: HasUndefined<I> extends true ? {
+        [K in Target]?: I;
+    } : {
+        [K in Target]: I;
+    };
+    out: {
+        [K in Target]: O;
+    };
+} = {
+    in: HasUndefined<I> extends true ? {
+        [K in Target]?: I;
+    } : {
+        [K in Target]: I;
+    };
+    out: {
+        [K in Target]: O;
+    };
+}>(target: Target, schema: T, hook?: Hook<T["infer"], E, P>): MiddlewareHandler<E, P, V>;

package/src/helper.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from "openapi-types";
+import type { OpenAPIRoute } from "./types";
+export declare const ALLOWED_METHODS: readonly ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
+export declare const toOpenAPIPath: (path: string) => string;
+export declare const capitalize: (word: string) => string;
+export declare const generateOperationId: (method: string, paths: string) => string;
+export declare function registerSchemaPath({ path, method: _method, data, schema, }: OpenAPIRoute & {
+    schema: Partial<OpenAPIV3.PathsObject>;
+}): void;
+export declare function filterPaths(paths: OpenAPIV3.PathsObject, { excludeStaticFile, exclude, }: {
+    excludeStaticFile: boolean;
+    exclude: (string | RegExp)[];
+}): OpenAPIV3.PathsObject<{}, {}>;

package/src/index.d.ts

@@ -1,2 +1,3 @@
 export { describeRoute } from "./route";
 export { openAPISpecs } from "./openapi";
+export type * from "./types";

package/src/openapi.d.ts

@@ -1,3 +1,4 @@
-import type { Context, Env, Hono, Input } from "hono";
+import type { Context, Env, Hono, Input, Schema } from "hono";
+import type { BlankSchema } from "hono/types";
 import type { OpenApiSpecsOptions } from "./types";
-export declare function openAPISpecs<E extends Env = Env, P extends string = string, I extends Input = Input>(hono: Hono, { documentation, excludeStaticFile, exclude, excludeMethods, excludeTags, }?: OpenApiSpecsOptions): (c: Context<E, P, I>) => any;
+export declare function openAPISpecs<E extends Env = Env, P extends string = string, I extends Input = Input, S extends Schema = BlankSchema>(hono: Hono<E, S, P>, { documentation, excludeStaticFile, exclude, excludeMethods, excludeTags, }?: OpenApiSpecsOptions): (c: Context<E, P, I>) => Promise<any>;

package/src/route.d.ts

@@ -1,33 +1,3 @@
 import type { Env, Input, MiddlewareHandler } from "hono/types";
-import type { DescribeRouteOptions, OpenAPIRouteHandlerConfig } from "./types";
-import { uniqueSymbol } from "./constants";
-export declare function describeRoute<E extends Env = Env, P extends string = string, I extends Input = Input>(specs: DescribeRouteOptions): MiddlewareHandler<E, P, I> & {
-    [uniqueSymbol]: {
-        resolver: (config: OpenAPIRouteHandlerConfig) => {
-            docs: {
-                tags?: string[] | undefined;
-                summary?: string | undefined;
-                description?: string | undefined;
-                externalDocs?: import("openapi-types").OpenAPIV3.ExternalDocumentationObject | undefined;
-                operationId?: string | undefined;
-                callbacks?: {
-                    [callback: string]: import("openapi-types").OpenAPIV3.ReferenceObject | import("openapi-types").OpenAPIV3.CallbackObject;
-                } | undefined;
-                deprecated?: boolean | undefined;
-                security?: import("openapi-types").OpenAPIV3.SecurityRequirementObject[] | undefined;
-                servers?: import("openapi-types").OpenAPIV3.ServerObject[] | undefined;
-                hide?: boolean;
-                responses?: {
-                    [key: string]: import("openapi-types").OpenAPIV3.ResponseObject & {
-                        content?: {
-                            [key: string]: Omit<import("openapi-types").OpenAPIV3.MediaTypeObject, "schema"> & {
-                                schema?: import("openapi-types").OpenAPIV3.ReferenceObject | import("openapi-types").OpenAPIV3.SchemaObject | import("./types").ResolverResult;
-                            };
-                        };
-                    };
-                };
-            };
-            components: {};
-        };
-    };
-};
+import type { DescribeRouteOptions } from "./types";
+export declare function describeRoute<E extends Env = Env, P extends string = string, I extends Input = Input>(specs: DescribeRouteOptions<E, P, I>): MiddlewareHandler<E, P, I>;

package/src/toOpenAPISchema/const.d.ts

@@ -0,0 +1 @@
+export declare const allowedKeywords: string[];

package/src/toOpenAPISchema/index.d.ts

@@ -0,0 +1,5 @@
+import type { JSONSchema4 } from "json-schema";
+import type { Options } from "./types";
+import type { OpenAPIV3 } from "openapi-types";
+declare const convert: <T extends object = JSONSchema4>(schema: T, options?: Options) => Promise<OpenAPIV3.Document>;
+export default convert;

package/src/toOpenAPISchema/types.d.ts

@@ -0,0 +1,18 @@
+import type { JSONSchema, ParserOptions } from "@apidevtools/json-schema-ref-parser";
+export type addPrefixToObject = {
+    [K in keyof JSONSchema as `x-${K}`]: JSONSchema[K];
+};
+export interface Options {
+    cloneSchema?: boolean;
+    dereference?: boolean;
+    convertUnreferencedDefinitions?: boolean;
+    dereferenceOptions?: ParserOptions | undefined;
+}
+type ExtendedJSONSchema = addPrefixToObject & JSONSchema;
+export type SchemaType = ExtendedJSONSchema & {
+    example?: JSONSchema["examples"][number];
+    "x-patternProperties"?: JSONSchema["patternProperties"];
+    nullable?: boolean;
+};
+export type SchemaTypeKeys = keyof SchemaType;
+export {};

package/src/typebox.d.ts

@@ -0,0 +1,13 @@
+import { type Hook } from "@hono/typebox-validator";
+import type { Static, TSchema } from "@sinclair/typebox";
+import type { Env, MiddlewareHandler, ValidationTargets } from "hono";
+import type { ResolverResult } from "./types";
+export declare function resolver<T extends TSchema>(schema: T): ResolverResult;
+export declare function validator<T extends TSchema, Target extends keyof ValidationTargets, E extends Env, P extends string, V extends {
+    in: {
+        [K in Target]: Static<T>;
+    };
+    out: {
+        [K in Target]: Static<T>;
+    };
+}>(target: Target, schema: T, hook?: Hook<Static<T>, E, P>): MiddlewareHandler<E, P, V>;

package/src/types.d.ts

@@ -1,5 +1,9 @@
+import type { Context, Env, Input } from "hono";
+import type { BlankInput } from "hono/types";
 import type { OpenAPIV3 } from "openapi-types";
-import type { ALLOWED_METHODS } from "./utils";
+import type { ALLOWED_METHODS } from "./helper";
+export type HasUndefined<T> = undefined extends T ? true : false;
+export type PromiseOr<T> = T | Promise<T>;
 export type OpenAPIRouteHandlerConfig = {
     version: "3.0.0" | "3.0.1" | "3.0.2" | "3.0.3" | "3.1.0";
     components: OpenAPIV3.ComponentsObject["schemas"];
@@ -7,35 +11,40 @@ export type OpenAPIRouteHandlerConfig = {
     [key: string]: unknown;
 };
 export type ResolverResult = {
-    builder: (options?: OpenAPIRouteHandlerConfig) => {
+    builder: (options?: OpenAPIRouteHandlerConfig) => PromiseOr<{
         schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
         components?: OpenAPIV3.ComponentsObject["schemas"];
-    };
-    validator: (values: unknown) => void | Promise<void>;
+    }>;
+    validator: (values: unknown) => PromiseOr<void>;
 };
 export type HandlerResponse = {
-    resolver: (config: OpenAPIRouteHandlerConfig) => {
+    resolver: (config: OpenAPIRouteHandlerConfig) => PromiseOr<{
         docs: OpenAPIV3.OperationObject;
         components?: OpenAPIV3.ComponentsObject["schemas"];
-    };
+    }>;
     metadata?: Record<string, unknown>;
 };
-export type DescribeRouteOptions = Omit<OpenAPIV3.OperationObject, "responses" | "requestBody" | "parameters"> & {
+export type DescribeRouteOptions<E extends Env = Env, P extends string = string, I extends Input = BlankInput> = Omit<OpenAPIV3.OperationObject, "responses" | "requestBody" | "parameters"> & {
     /**
      * Pass `true` to hide route from OpenAPI/swagger document
      */
-    hide?: boolean;
+    hide?: boolean | ((c: Context<E, P, I>) => boolean);
+    /**
+     * Validate response of the route
+     * @experimental
+     */
+    validateResponse?: boolean;
     /**
      * Responses of the request
      */
     responses?: {
-        [key: string]: OpenAPIV3.ResponseObject & {
+        [key: string]: (OpenAPIV3.ResponseObject & {
             content?: {
                 [key: string]: Omit<OpenAPIV3.MediaTypeObject, "schema"> & {
                     schema?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | ResolverResult;
                 };
             };
-        };
+        }) | OpenAPIV3.ReferenceObject;
     };
 };
 export interface OpenAPIRoute {

package/src/utils.d.ts

@@ -1,13 +1,25 @@
+import type { ValidationTargets } from "hono";
 import type { OpenAPIV3 } from "openapi-types";
-import type { OpenAPIRoute } from "./types";
-export declare const ALLOWED_METHODS: readonly ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
-export declare const toOpenAPIPath: (path: string) => string;
-export declare const capitalize: (word: string) => string;
-export declare const generateOperationId: (method: string, paths: string) => string;
-export declare function registerSchemaPath({ path, method: _method, data, schema, }: OpenAPIRoute & {
-    schema: Partial<OpenAPIV3.PathsObject>;
-}): void;
-export declare function filterPaths(paths: OpenAPIV3.PathsObject, { excludeStaticFile, exclude, }: {
-    excludeStaticFile: boolean;
-    exclude: (string | RegExp)[];
-}): OpenAPIV3.PathsObject<{}, {}>;
+import type { ResolverResult } from "./types";
+export declare const uniqueSymbol: unique symbol;
+export declare function generateValidatorDocs<Target extends keyof ValidationTargets>(target: Target, _result: ReturnType<ResolverResult["builder"]>): Promise<{
+    docs: Pick<{
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: OpenAPIV3.ExternalDocumentationObject;
+        operationId?: string;
+        parameters?: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[];
+        requestBody?: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject;
+        responses: OpenAPIV3.ResponsesObject;
+        callbacks?: {
+            [callback: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.CallbackObject;
+        };
+        deprecated?: boolean;
+        security?: OpenAPIV3.SecurityRequirementObject[];
+        servers?: OpenAPIV3.ServerObject[];
+    }, "parameters" | "requestBody">;
+    components: {
+        [key: string]: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+    } | undefined;
+}>;

package/src/valibot.d.ts

@@ -0,0 +1,23 @@
+import { type Hook } from "@hono/valibot-validator";
+import type { Env, Input as HonoInput, MiddlewareHandler, ValidationTargets } from "hono";
+import { type BaseIssue, type BaseSchema, type GenericSchema, type GenericSchemaAsync, type InferInput, type InferOutput } from "valibot";
+import type { HasUndefined, ResolverResult } from "./types";
+export declare function resolver<T extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: T): ResolverResult;
+export declare function validator<T extends GenericSchema | GenericSchemaAsync, Target extends keyof ValidationTargets, E extends Env, P extends string, In = InferInput<T>, Out = InferOutput<T>, I extends HonoInput = {
+    in: HasUndefined<In> extends true ? {
+        [K in Target]?: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
+            [K2 in keyof In]?: ValidationTargets[K][K2];
+        } : {
+            [K2 in keyof In]: ValidationTargets[K][K2];
+        };
+    } : {
+        [K in Target]: K extends "json" ? In : HasUndefined<keyof ValidationTargets[K]> extends true ? {
+            [K2 in keyof In]?: ValidationTargets[K][K2];
+        } : {
+            [K2 in keyof In]: ValidationTargets[K][K2];
+        };
+    };
+    out: {
+        [K in Target]: Out;
+    };
+}, V extends I = I>(target: Target, schema: T, hook?: Hook<T, E, P>): MiddlewareHandler<E, P, V>;

package/src/zod.d.ts

@@ -1,9 +1,8 @@
-import type { z, ZodSchema } from "zod";
 import { type Hook } from "@hono/zod-validator";
-import type { ResolverResult } from "./types";
 import type { Env, Input, MiddlewareHandler, ValidationTargets } from "hono";
+import type { ZodSchema, z } from "zod";
+import type { HasUndefined, ResolverResult } from "./types";
 export declare function resolver<T extends ZodSchema>(schema: T): ResolverResult;
-type HasUndefined<T> = undefined extends T ? true : false;
 export declare function validator<T extends ZodSchema, Target extends keyof ValidationTargets, E extends Env, P extends string, In = z.input<T>, Out = z.output<T>, I extends Input = {
     in: HasUndefined<In> extends true ? {
         [K in Target]?: In extends ValidationTargets[K] ? In : {
@@ -18,4 +17,3 @@ export declare function validator<T extends ZodSchema, Target extends keyof Vali
         [K in Target]: Out;
     };
 }, V extends I = I>(target: Target, schema: T, hook?: Hook<z.infer<T>, E, P, Target>): MiddlewareHandler<E, P, V>;
-export {};

package/typebox.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/typebox";

package/typebox.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var typeboxValidator = require('@hono/typebox-validator');
+var index = require('./index.cjs2.js');
+var value = require('@sinclair/typebox/value');
+var utils = require('./utils.cjs.js');
+require('json-schema-walker');
+
+function resolver(schema){return {builder:async options=>({schema:await index.convert(schema)}),validator:value$1=>{value.Value.Parse(schema,value$1);}}}function validator(target,schema,hook){const middleware=typeboxValidator.tbValidator(target,schema,hook);return Object.assign(middleware,{[utils.uniqueSymbol]:{resolver:async config=>utils.generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+exports.resolver = resolver;
+exports.validator = validator;

package/typebox.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/typebox";

package/typebox.esm.js

@@ -0,0 +1,9 @@
+import { tbValidator } from '@hono/typebox-validator';
+import { c as convert } from './index.esm2.js';
+import { Value } from '@sinclair/typebox/value';
+import { u as uniqueSymbol, g as generateValidatorDocs } from './utils.esm.js';
+import 'json-schema-walker';
+
+function resolver(schema){return {builder:async options=>({schema:await convert(schema)}),validator:value=>{Value.Parse(schema,value);}}}function validator(target,schema,hook){const middleware=tbValidator(target,schema,hook);return Object.assign(middleware,{[uniqueSymbol]:{resolver:async config=>generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+export { resolver, validator };

package/utils.cjs.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const uniqueSymbol=Symbol("openapi");async function generateValidatorDocs(target,_result){const result=await _result;const docs={};if(target==="form"||target==="json"){docs.requestBody={content:{[target==="json"?"application/json":"application/x-www-form-urlencoded"]:{schema:result.schema}}};}else {const parameters=[];if("$ref"in result.schema){parameters.push({in:target,name:result.schema.$ref,schema:result.schema});}else {for(const[key,value]of Object.entries(result.schema.properties??{})){parameters.push({in:target,name:key,schema:value,required:result.schema.required?.includes(key)});}}docs.parameters=parameters;}return {docs,components:result.components}}
+
+exports.generateValidatorDocs = generateValidatorDocs;
+exports.uniqueSymbol = uniqueSymbol;

package/utils.esm.js

@@ -0,0 +1,3 @@
+const uniqueSymbol=Symbol("openapi");async function generateValidatorDocs(target,_result){const result=await _result;const docs={};if(target==="form"||target==="json"){docs.requestBody={content:{[target==="json"?"application/json":"application/x-www-form-urlencoded"]:{schema:result.schema}}};}else {const parameters=[];if("$ref"in result.schema){parameters.push({in:target,name:result.schema.$ref,schema:result.schema});}else {for(const[key,value]of Object.entries(result.schema.properties??{})){parameters.push({in:target,name:key,schema:value,required:result.schema.required?.includes(key)});}}docs.parameters=parameters;}return {docs,components:result.components}}
+
+export { generateValidatorDocs as g, uniqueSymbol as u };

package/valibot.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/valibot";

package/valibot.cjs.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var valibotValidator = require('@hono/valibot-validator');
+var index = require('./index.cjs2.js');
+var toJsonSchema = require('@valibot/to-json-schema');
+var valibot = require('valibot');
+var utils = require('./utils.cjs.js');
+require('json-schema-walker');
+
+function resolver(schema){return {builder:async options=>({schema:await index.convert(toJsonSchema.toJsonSchema(schema))}),validator:async value=>{await valibot.parseAsync(schema,value);}}}function validator(target,schema,hook){const middleware=valibotValidator.vValidator(target,schema,hook);return Object.assign(middleware,{[utils.uniqueSymbol]:{resolver:async config=>utils.generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+exports.resolver = resolver;
+exports.validator = validator;

package/valibot.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/valibot";

package/valibot.esm.js

@@ -0,0 +1,10 @@
+import { vValidator } from '@hono/valibot-validator';
+import { c as convert } from './index.esm2.js';
+import { toJsonSchema } from '@valibot/to-json-schema';
+import { parseAsync } from 'valibot';
+import { u as uniqueSymbol, g as generateValidatorDocs } from './utils.esm.js';
+import 'json-schema-walker';
+
+function resolver(schema){return {builder:async options=>({schema:await convert(toJsonSchema(schema))}),validator:async value=>{await parseAsync(schema,value);}}}function validator(target,schema,hook){const middleware=vValidator(target,schema,hook);return Object.assign(middleware,{[uniqueSymbol]:{resolver:async config=>generateValidatorDocs(target,await resolver(schema).builder(config))}})}
+
+export { resolver, validator };

package/zod.cjs.js

@@ -1 +1,10 @@
-"use strict";var e=require("@hono/zod-validator"),o=require("zod-openapi"),s=require("./constants.cjs.js");function n(e){return{builder:s=>o.createSchema(e,s?{openapi:s.version,components:s.components,schemaType:s.schemaType}:void 0),validator:e.parse}}exports.resolver=n,exports.validator=function(o,r,a){const t=e.zValidator(o,r,a);return Object.assign(t,{[s.uniqueSymbol]:{resolver:e=>{const s=n(r).builder(e),a={};if("form"===o||"json"===o)a.requestBody={content:{["json"===o?"application/json":"application/x-www-form-urlencoded"]:{schema:s.schema}}};else{const e=[];if("$ref"in s.schema)e.push({in:o,name:s.schema.$ref,schema:s.schema});else for(const[n,r]of Object.entries(s.schema.properties??{}))e.push({in:o,name:n,schema:r});a.parameters=e}return{docs:a,components:s.components}},metadata:{schemaType:"input"}}})};
+'use strict';
+
+var zodValidator = require('@hono/zod-validator');
+var zodOpenapi = require('zod-openapi');
+var utils = require('./utils.cjs.js');
+
+function resolver(schema){return {builder:options=>{const{version,...rest}=options??{};return zodOpenapi.createSchema(schema,options?{openapi:version,...rest}:undefined)},validator:schema.parse}}function validator(target,schema,hook){const middleware=zodValidator.zValidator(target,schema,hook);return Object.assign(middleware,{[utils.uniqueSymbol]:{resolver:async config=>utils.generateValidatorDocs(target,await resolver(schema).builder(config)),metadata:{schemaType:"input"}}})}
+
+exports.resolver = resolver;
+exports.validator = validator;

package/zod.esm.js

@@ -1 +1,7 @@
-import{zValidator as e}from"@hono/zod-validator";import{createSchema as o}from"zod-openapi";import{u as n}from"./constants.esm.js";function s(e){return{builder:n=>o(e,n?{openapi:n.version,components:n.components,schemaType:n.schemaType}:void 0),validator:e.parse}}function t(o,t,r){const a=e(o,t,r);return Object.assign(a,{[n]:{resolver:e=>{const n=s(t).builder(e),r={};if("form"===o||"json"===o)r.requestBody={content:{["json"===o?"application/json":"application/x-www-form-urlencoded"]:{schema:n.schema}}};else{const e=[];if("$ref"in n.schema)e.push({in:o,name:n.schema.$ref,schema:n.schema});else for(const[s,t]of Object.entries(n.schema.properties??{}))e.push({in:o,name:s,schema:t});r.parameters=e}return{docs:r,components:n.components}},metadata:{schemaType:"input"}}})}export{s as resolver,t as validator};
+import { zValidator } from '@hono/zod-validator';
+import { createSchema } from 'zod-openapi';
+import { u as uniqueSymbol, g as generateValidatorDocs } from './utils.esm.js';
+
+function resolver(schema){return {builder:options=>{const{version,...rest}=options??{};return createSchema(schema,options?{openapi:version,...rest}:undefined)},validator:schema.parse}}function validator(target,schema,hook){const middleware=zValidator(target,schema,hook);return Object.assign(middleware,{[uniqueSymbol]:{resolver:async config=>generateValidatorDocs(target,await resolver(schema).builder(config)),metadata:{schemaType:"input"}}})}
+
+export { resolver, validator };

package/constants.cjs.js

@@ -1 +0,0 @@
-"use strict";const o=Symbol("openapi");exports.uniqueSymbol=o;

package/constants.esm.js

@@ -1 +0,0 @@
-const o=Symbol("openapi");export{o as u};

package/src/constants.d.ts

@@ -1 +0,0 @@
-export declare const uniqueSymbol: unique symbol;