hono-openapi 0.4.8 → 0.5.0-rc.0

package/dist/index.js

@@ -0,0 +1,401 @@
+import { sValidator } from '@hono/standard-validator';
+import { toJsonSchema } from '@standard-community/standard-json';
+import { toOpenAPISchema } from '@standard-community/standard-openapi';
+
+const uniqueSymbol = Symbol("openapi");
+const ALLOWED_METHODS = [
+  "GET",
+  "PUT",
+  "POST",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+  "PATCH",
+  "TRACE"
+];
+const toOpenAPIPath = (path) => path.split("/").map((x) => {
+  let tmp = x;
+  if (tmp.startsWith(":")) {
+    const match = tmp.match(/^:([^{?]+)(?:{(.+)})?(\?)?$/);
+    if (match) {
+      const paramName = match[1];
+      tmp = `{${paramName}}`;
+    } else {
+      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 generateOperationIdCache = /* @__PURE__ */ new Map();
+const generateOperationId = (route) => {
+  const operationIdKey = `${route.method}:${route.path}`;
+  if (generateOperationIdCache.has(operationIdKey)) {
+    return generateOperationIdCache.get(operationIdKey);
+  }
+  let operationId = route.method;
+  if (route.path === "/") return `${operationId}Index`;
+  for (const segment of route.path.split("/")) {
+    if (segment.charCodeAt(0) === 123) {
+      operationId += `By${capitalize(segment.slice(1, -1))}`;
+    } else {
+      operationId += capitalize(segment);
+    }
+  }
+  generateOperationIdCache.set(operationIdKey, operationId);
+  return operationId;
+};
+const paramKey = (param) => "$ref" in param ? param.$ref : `${param.in} ${param.name}`;
+function mergeParameters(...params) {
+  const _params = params.flatMap((x) => x ?? []);
+  const merged = _params.reduce((acc, param) => {
+    acc.set(paramKey(param), param);
+    return acc;
+  }, /* @__PURE__ */ new Map());
+  return Array.from(merged.values());
+}
+function getProperty(obj, key, defaultValue) {
+  if (obj != null && key in obj) {
+    return obj[key];
+  }
+  return defaultValue;
+}
+const specsByPathContext = /* @__PURE__ */ new Map();
+function getPathContext(path) {
+  const keys = Array.from(specsByPathContext.keys());
+  const context = [];
+  for (const key of keys) {
+    if (path.match(key)) {
+      const data = specsByPathContext.get(key);
+      if (!data) continue;
+      context.push(data);
+    }
+  }
+  return context;
+}
+function mergeSpecs(...specs) {
+  return specs.reduce(
+    (prev, spec) => {
+      if (!spec) return prev;
+      return {
+        ...prev,
+        ...spec,
+        tags: Array.from(
+          /* @__PURE__ */ new Set([
+            ...getProperty(prev, "tags") ?? [],
+            ...getProperty(spec, "tags") ?? []
+          ])
+        ),
+        parameters: mergeParameters(
+          getProperty(prev, "parameters"),
+          getProperty(spec, "parameters")
+        ),
+        responses: {
+          ...getProperty(prev, "responses", {}),
+          ...getProperty(spec, "responses", {})
+        }
+      };
+    },
+    {}
+  );
+}
+function registerSchemaPath({
+  route,
+  specs,
+  paths
+}) {
+  const path = toOpenAPIPath(route.path);
+  const method = route.method.toLowerCase();
+  if (method === "all") {
+    if (!specs) return;
+    if (specsByPathContext.has(path)) {
+      const prev = specsByPathContext.get(path) ?? {};
+      specsByPathContext.set(path, mergeSpecs(prev, specs));
+    } else {
+      specsByPathContext.set(path, specs);
+    }
+  } else {
+    const pathContext = getPathContext(path);
+    paths[path] = {
+      ...paths[path] ? paths[path] : {},
+      [method]: {
+        operationId: generateOperationId(route),
+        ...mergeSpecs(...pathContext, paths[path]?.[method], specs)
+      }
+    };
+  }
+}
+function removeExcludedPaths(paths, ctx) {
+  const { exclude, excludeStaticFile } = ctx.options;
+  const newPaths = {};
+  const _exclude = Array.isArray(exclude) ? exclude : [exclude];
+  for (const [key, value] of Object.entries(paths)) {
+    const isPathExcluded = !_exclude.some((x) => {
+      if (typeof x === "string") return key === x;
+      return x.test(key);
+    });
+    const isStaticFileExcluded = excludeStaticFile ? !key.includes(".") || key.includes("{") : true;
+    if (isPathExcluded && !(key.includes("*") && !key.includes("{")) && isStaticFileExcluded && value != null) {
+      for (const method of Object.keys(value)) {
+        const schema = value[method];
+        if (key.includes("{")) {
+          if (!schema.parameters) schema.parameters = [];
+          const pathParameters = key.split("/").filter(
+            (x) => x.startsWith("{") && !schema.parameters.find(
+              (params) => params.in === "path" && params.name === x.slice(1, x.length - 1)
+            )
+          );
+          for (const param of pathParameters) {
+            const paramName = param.slice(1, param.length - 1);
+            const index = schema.parameters.findIndex(
+              (x) => x.in === "param" && x.name === paramName
+            );
+            if (index !== -1) schema.parameters[index].in = "path";
+            else {
+              schema.parameters.push({
+                schema: { type: "string" },
+                in: "path",
+                name: paramName,
+                required: true
+              });
+            }
+          }
+        }
+        if (!schema.responses) {
+          schema.responses = {
+            200: {}
+          };
+        }
+      }
+      newPaths[key] = value;
+    }
+  }
+  return newPaths;
+}
+
+const DEFAULT_OPTIONS = {
+  documentation: {},
+  excludeStaticFile: true,
+  exclude: [],
+  excludeMethods: ["OPTIONS"],
+  excludeTags: []
+};
+async function generateSpecs(hono, options = DEFAULT_OPTIONS, c) {
+  const ctx = {
+    components: {},
+    // @ts-expect-error
+    options: {
+      ...DEFAULT_OPTIONS,
+      ...options
+    }
+  };
+  const _documentation = ctx.options.documentation ?? {};
+  const schema = await generatePaths(hono, ctx);
+  for (const path in schema) {
+    for (const method in schema[path]) {
+      const isHidden = getHiddenValue({
+        valueOrFunc: schema[path][method]?.hide,
+        method,
+        path,
+        c
+      });
+      if (isHidden) {
+        delete schema[path][method];
+      }
+    }
+  }
+  return {
+    openapi: "3.1.0",
+    ..._documentation,
+    tags: _documentation.tags?.filter(
+      (tag) => !ctx.options.excludeTags?.includes(tag?.name)
+    ),
+    info: {
+      title: "Hono Documentation",
+      description: "Development documentation",
+      version: "0.0.0",
+      ..._documentation.info
+    },
+    paths: {
+      ...removeExcludedPaths(schema, ctx),
+      ..._documentation.paths
+    },
+    components: {
+      ..._documentation.components,
+      schemas: {
+        ...ctx.components.schemas,
+        ..._documentation.components?.schemas
+      }
+    }
+  };
+}
+async function generatePaths(hono, ctx) {
+  const paths = {};
+  for (const route of hono.routes) {
+    if (!(uniqueSymbol in route.handler)) {
+      if (ctx.options.includeEmptyPaths) {
+        registerSchemaPath({
+          route,
+          paths
+        });
+      }
+      continue;
+    }
+    const routeMethod = route.method;
+    if (routeMethod !== "ALL") {
+      if (ctx.options.excludeMethods?.includes(routeMethod)) {
+        continue;
+      }
+      if (!ALLOWED_METHODS.includes(routeMethod)) {
+        continue;
+      }
+    }
+    const middlewareHandler = route.handler[uniqueSymbol];
+    const defaultOptionsForThisMethod = ctx.options.defaultOptions?.[routeMethod];
+    const { schema: routeSpecs, components = {} } = await getSpec(
+      middlewareHandler,
+      defaultOptionsForThisMethod
+    );
+    ctx.components = {
+      ...ctx.components,
+      ...components,
+      schemas: {
+        ...ctx.components.schemas,
+        ...components.schemas
+      }
+    };
+    registerSchemaPath({
+      route,
+      specs: routeSpecs,
+      paths
+    });
+  }
+  return paths;
+}
+function getHiddenValue(options) {
+  const { valueOrFunc, c, method, path } = options;
+  if (valueOrFunc != null) {
+    if (typeof valueOrFunc === "boolean") {
+      return valueOrFunc;
+    } else if (typeof valueOrFunc === "function") {
+      if (c) {
+        return valueOrFunc(c);
+      } else {
+        console.warn(
+          `'c' is not defined, cannot evaluate hide function for ${method} ${path}`
+        );
+      }
+    }
+  }
+  return false;
+}
+async function getSpec(middlewareHandler, defaultOptions) {
+  if ("spec" in middlewareHandler) {
+    let components = {};
+    const tmp = {
+      ...defaultOptions,
+      ...middlewareHandler.spec,
+      responses: {
+        ...defaultOptions?.responses,
+        ...middlewareHandler.spec.responses
+      }
+    };
+    if (tmp.responses) {
+      for (const key of Object.keys(tmp.responses)) {
+        const response = tmp.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 && "toOpenAPISchema" in raw.schema) {
+            const result2 = await raw.schema.toOpenAPISchema(defaultOptions);
+            raw.schema = result2.schema;
+            if (result2.components) {
+              components = {
+                ...components,
+                ...result2.components
+              };
+            }
+          }
+        }
+      }
+    }
+    return { schema: tmp, components };
+  }
+  const result = await middlewareHandler.toOpenAPISchema();
+  const docs = {};
+  if (middlewareHandler.target === "form" || middlewareHandler.target === "json") {
+    const media = middlewareHandler.target === "json" ? "application/json" : "multipart/form-data";
+    if (!docs.requestBody || !("content" in docs.requestBody) || !docs.requestBody.content) {
+      docs.requestBody = {
+        content: {
+          [media]: {
+            schema: result.schema
+          }
+        }
+      };
+    } else {
+      docs.requestBody.content[media] = {
+        schema: result.schema
+      };
+    }
+  } else {
+    const parameters = [];
+    if ("$ref" in result.schema) {
+      parameters.push({
+        in: middlewareHandler.target,
+        // @ts-expect-error
+        name: result.schema.$ref,
+        // @ts-expect-error
+        schema: result.schema
+      });
+    } else {
+      for (const [key, value] of Object.entries(
+        result.schema.properties ?? {}
+      )) {
+        parameters.push({
+          in: middlewareHandler.target,
+          name: key,
+          // @ts-expect-error
+          schema: value,
+          required: result.schema.required?.includes(key)
+        });
+      }
+    }
+    docs.parameters = parameters;
+  }
+  return { schema: docs, components: result.components };
+}
+
+function resolver(schema) {
+  return {
+    vendor: schema["~standard"].vendor,
+    validate: schema["~standard"].validate,
+    toJSONSchema: (options) => toJsonSchema(schema, options),
+    toOpenAPISchema: (options) => toOpenAPISchema(schema, options)
+  };
+}
+function validator(target, schema, hook, options) {
+  const middleware = sValidator(target, schema, hook);
+  return Object.assign(middleware, {
+    [uniqueSymbol]: {
+      target,
+      ...resolver(schema),
+      options
+    }
+  });
+}
+function describeRoute(spec) {
+  const middleware = async (_c, next) => {
+    await next();
+  };
+  return Object.assign(middleware, {
+    [uniqueSymbol]: {
+      spec
+    }
+  });
+}
+
+export { ALLOWED_METHODS, describeRoute, generateSpecs, registerSchemaPath, removeExcludedPaths, resolver, uniqueSymbol, validator };

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "hono-openapi",
   "description": "OpenAPI schema generator for Hono",
-  "version": "0.4.8",
-  "types": "./index.d.ts",
-  "main": "./index.js",
+  "version": "0.5.0-rc.0",
   "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "license": "MIT",
   "keywords": [
     "hono",
@@ -27,47 +31,35 @@
   "bugs": {
     "url": "https://github.com/rhinobase/hono-openapi/issues"
   },
-  "dependencies": {
-    "json-schema-walker": "^2.0.0"
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    }
   },
   "peerDependencies": {
-    "@hono/arktype-validator": "^2.0.0",
-    "@hono/effect-validator": "^1.2.0",
-    "@hono/typebox-validator": "^0.2.0 || ^0.3.0",
-    "@hono/valibot-validator": "^0.5.1",
-    "@hono/zod-validator": "^0.4.1",
+    "@hono/standard-validator": "^0.1.2",
     "@sinclair/typebox": "^0.34.9",
-    "@valibot/to-json-schema": "^1.0.0-beta.3",
+    "@standard-community/standard-json": "^0.3.0-rc.1",
+    "@standard-community/standard-openapi": "^0.2.0-rc.1",
     "arktype": "^2.0.0",
-    "effect": "^3.11.3",
-    "hono": "^4.6.13",
+    "effect": "^3.16.12",
+    "hono": "^4.8.3",
     "openapi-types": "^12.1.3",
     "valibot": "^1.0.0-beta.9",
-    "zod": "^3.23.8",
-    "zod-openapi": "^4.0.0"
+    "zod": "^3.23.8"
   },
   "peerDependenciesMeta": {
-    "@hono/arktype-validator": {
-      "optional": true
-    },
-    "@hono/effect-validator": {
-      "optional": true
-    },
-    "@hono/typebox-validator": {
-      "optional": true
-    },
-    "@hono/valibot-validator": {
-      "optional": true
-    },
-    "@hono/zod-validator": {
+    "@hono/standard-validator": {
       "optional": true
     },
     "@sinclair/typebox": {
       "optional": true
     },
-    "@valibot/to-json-schema": {
-      "optional": true
-    },
     "arktype": {
       "optional": true
     },
@@ -82,76 +74,20 @@
     },
     "zod": {
       "optional": true
-    },
-    "zod-openapi": {
-      "optional": true
     }
   },
   "devDependencies": {
-    "@apidevtools/json-schema-ref-parser": "^12.0.1",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@types/json-schema": "^7.0.15"
+    "@biomejs/biome": "^2.0.6",
+    "@standard-schema/spec": "^1.0.0",
+    "@types/json-schema": "^7.0.15",
+    "@valibot/to-json-schema": "^1.3.0",
+    "pkgroll": "^2.13.1",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
   },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./index.d.cts",
-        "default": "./index.cjs"
-      }
-    },
-    "./zod": {
-      "import": {
-        "types": "./zod.d.ts",
-        "default": "./zod.js"
-      },
-      "require": {
-        "types": "./zod.d.cts",
-        "default": "./zod.cjs"
-      }
-    },
-    "./valibot": {
-      "import": {
-        "types": "./valibot.d.ts",
-        "default": "./valibot.js"
-      },
-      "require": {
-        "types": "./valibot.d.cts",
-        "default": "./valibot.cjs"
-      }
-    },
-    "./typebox": {
-      "import": {
-        "types": "./typebox.d.ts",
-        "default": "./typebox.js"
-      },
-      "require": {
-        "types": "./typebox.d.cts",
-        "default": "./typebox.cjs"
-      }
-    },
-    "./arktype": {
-      "import": {
-        "types": "./arktype.d.ts",
-        "default": "./arktype.js"
-      },
-      "require": {
-        "types": "./arktype.d.cts",
-        "default": "./arktype.cjs"
-      }
-    },
-    "./effect": {
-      "import": {
-        "types": "./effect.d.ts",
-        "default": "./effect.js"
-      },
-      "require": {
-        "types": "./effect.d.cts",
-        "default": "./effect.cjs"
-      }
-    }
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "format": "biome check --write .",
+    "test": "vitest"
   }
 }

package/arktype.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("@hono/arktype-validator"),r=require("./toOpenAPISchema.cjs"),a=require("./utils.cjs");function t(e){return{builder:async()=>({schema:await r.convert(e.in.toJsonSchema())}),validator:r=>{e.assert(r)}}}require("json-schema-walker"),exports.resolver=t,exports.validator=function(r,o,s){const i=e.arktypeValidator(r,o,s);return Object.assign(i,{[a.uniqueSymbol]:{resolver:async e=>a.generateValidatorDocs(r,await t(o).builder(e))}})};

package/arktype.d.cts

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

package/arktype.d.ts

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

package/arktype.js

@@ -1 +0,0 @@
-import{arktypeValidator as a}from"@hono/arktype-validator";import{c as r}from"./toOpenAPISchema.js";import{u as o,g as t}from"./utils.js";import"json-schema-walker";function s(a){return{builder:async()=>({schema:await r(a.in.toJsonSchema())}),validator:r=>{a.assert(r)}}}function e(r,e,i){const n=a(r,e,i);return Object.assign(n,{[o]:{resolver:async a=>t(r,await s(e).builder(a))}})}export{s as resolver,e as validator};

package/effect.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("@hono/effect-validator"),r=require("effect"),a=require("./toOpenAPISchema.cjs"),t=require("./utils.cjs");function i(e){return{builder:async()=>({schema:await a.convert(r.JSONSchema.make(e))}),validator:async a=>{await r.Schema.decodeUnknownPromise(e)(a)}}}require("json-schema-walker"),exports.resolver=i,exports.validator=function(r,a){const o=e.effectValidator(r,a);return Object.assign(o,{[t.uniqueSymbol]:{resolver:async e=>t.generateValidatorDocs(r,await i(a).builder(e))}})};

package/effect.d.cts

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

package/effect.d.ts

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

package/effect.js

@@ -1 +0,0 @@
-import{effectValidator as o}from"@hono/effect-validator";import{JSONSchema as a,Schema as r}from"effect";import{c as e}from"./toOpenAPISchema.js";import{u as t,g as i}from"./utils.js";import"json-schema-walker";function n(o){return{builder:async()=>({schema:await e(a.make(o))}),validator:async a=>{await r.decodeUnknownPromise(o)(a)}}}function s(a,r){const e=o(a,r);return Object.assign(e,{[t]:{resolver:async o=>i(a,await n(r).builder(o))}})}export{n as resolver,s as validator};

package/index.cjs

@@ -1 +0,0 @@
-"use strict";var e=require("./utils.cjs"),t=require("hono/http-exception");const n=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"],s=e=>e.charAt(0).toUpperCase()+e.slice(1),o=new Map,a=(e,t)=>{const n=`${e}:${t}`;if(o.has(n))return o.get(n);let a=e;if("/"===t)return`${a}Index`;for(const e of t.split("/"))123===e.charCodeAt(0)?a+=`By${s(e.slice(1,-1))}`:a+=s(e);return o.set(n,a),a},r=new Map;function c(e,t,n){return e&&t in e?e[t]??n:n}function i(...e){return e.reduce(((e,t)=>{if(!t)return e;let n;return("tags"in e&&e.tags||"tags"in t&&t.tags)&&(n=Array.from(new Set([...c(e,"tags",[]),...c(t,"tags",[])]))),{...e,...t,tags:n,responses:{...c(e,"responses",{}),...c(t,"responses",{})},parameters:l(e.parameters,t.parameters)}}),{})}function p({path:e,method:t,data:n,schema:s}){e=(e=>e.split("/").map((e=>{let t=e;if(t.startsWith(":")){const e=t.match(/^:([^{?]+)(?:{(.+)})?(\?)?$/);e?t=`{${e[1]}}`:(t=t.slice(1,t.length),t.endsWith("?")&&(t=t.slice(0,-1)),t=`{${t}}`)}return t})).join("/"))(e);const o=t.toLowerCase();if("all"===o){if(!n)return;if(r.has(e)){const t=r.get(e)??{};r.set(e,{...t,...n,parameters:l(t.parameters,n.parameters)})}else r.set(e,n)}else{const t=function(e){const t=Array.from(r.keys());let n={};for(const s of t)e.match(s)&&(n=i(n,r.get(s)??{}));return n}(e);s[e]={...s[e]?s[e]:{},[o]:{responses:{},operationId:a(o,e),...i(t,s[e]?.[o],n)}}}}const u=e=>"$ref"in e?e.$ref:`${e.in} ${e.name}`;function l(...e){const t=e.flatMap((e=>e??[])).reduce(((e,t)=>(e.set(u(t),t),e)),new Map);return Array.from(t.values())}function m(e,{excludeStaticFile:t=!0,exclude:n=[]}){const s={},o=Array.isArray(n)?n:[n];for(const[n,a]of Object.entries(e))if(!o.some((e=>"string"==typeof e?n===e:e.test(n)))&&(!n.includes("*")||n.includes("{"))&&(!t||(!n.includes(".")||n.includes("{")))){for(const e of Object.keys(a)){const t=a[e];if(n.includes("{")){t.parameters||(t.parameters=[]);const e=n.split("/").filter((e=>e.startsWith("{")&&!t.parameters.find((t=>"path"===t.in&&t.name===e.slice(1,e.length-1)))));for(const n of e){const e=n.slice(1,n.length-1),s=t.parameters.findIndex((t=>"param"===t.in&&t.name===e));-1!==s?t.parameters[s].in="path":t.parameters.push({schema:{type:"string"},in:"path",name:e,required:!0})}}t.responses||(t.responses={200:{}})}s[n]=a}return s}const f={documentation:{},excludeStaticFile:!0,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]},d={version:"3.1.0",components:{}};async function h(t,s=f,o=d,a){const r={...f,...s},c={...d,...o},i=r.documentation??{},u=await async function(t,s,o){const a={};for(const r of t.routes){if(!(e.uniqueSymbol in r.handler)){s.includeEmptyPaths&&p({method:r.method,path:r.path,schema:a});continue}if(s.excludeMethods.includes(r.method))continue;if(!1===n.includes(r.method)&&"ALL"!==r.method)continue;const{resolver:t,metadata:c={}}=r.handler[e.uniqueSymbol],i=s.defaultOptions?.[r.method],{docs:u,components:l}=await t({...o,...c},i);o.components={...o.components,...l??{}},p({method:r.method,path:r.path,data:u,schema:a})}return a}(t,r,c);for(const e in u)for(const t in u[e]){const n=u[e][t]?.hide;if(n){let s=!1;"boolean"==typeof n?s=n:"function"==typeof n&&(a?s=n(a):console.warn(`'c' is not defined, cannot evaluate hide function for ${t} ${e}`)),s&&delete u[e][t]}}return{openapi:c.version,...{...i,tags:i.tags?.filter((e=>!r.excludeTags?.includes(e?.name))),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...i.info},paths:{...m(u,r),...i.paths},components:{...i.components,schemas:{...c.components,...i.components?.schemas}}}}}async function g(e,t,n={}){let s={};const o={...n,...t,responses:{...n?.responses,...t.responses}};if(o.responses)for(const t of Object.keys(o.responses)){const n=o.responses[t];if(n&&"content"in n)for(const t of Object.keys(n.content??{})){const o=n.content?.[t];if(o&&(o.schema&&"builder"in o.schema)){const t=await o.schema.builder(e);o.schema=t.schema,t.components&&(s={...s,...t.components})}}}return{docs:o,components:s}}exports.generateValidatorDocs=e.generateValidatorDocs,exports.uniqueSymbol=e.uniqueSymbol,exports.describeRoute=function(n){const{validateResponse:s,...o}=n;return Object.assign((async(e,o)=>{if(await o(),s&&n.responses){const o=e.res.status,a=e.res.headers.get("content-type");if(o&&a){const r=n.responses[o];if(r&&"content"in r&&r.content){const n=a.split(";")[0],o=r.content[n];if(o?.schema&&"validator"in o.schema)try{let t;const s=e.res.clone();if("application/json"===n?t=await s.json():"text/plain"===n&&(t=await s.text()),!t)throw new Error("No data to validate!");await o.schema.validator(t)}catch(e){let n={status:500,message:"Response validation failed!"};throw"object"==typeof s&&(n={...n,...s}),new t.HTTPException(n.status,{message:n.message,cause:e})}}}}}),{[e.uniqueSymbol]:{resolver:(e,t)=>g(e,o,t)}})},exports.generateRouteSpecs=g,exports.generateSpecs=h,exports.openAPISpecs=function(e,t){const n={version:"3.1.0",components:{}};let s;return async o=>(s||(s=await h(e,t,n,o)),o.json(s))};

package/index.d.cts

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

package/index.d.ts

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

package/index.js

@@ -1 +0,0 @@
-import{u as e}from"./utils.js";export{g as generateValidatorDocs}from"./utils.js";import{HTTPException as t}from"hono/http-exception";const n=["GET","PUT","POST","DELETE","OPTIONS","HEAD","PATCH","TRACE"],s=e=>e.charAt(0).toUpperCase()+e.slice(1),o=new Map,a=(e,t)=>{const n=`${e}:${t}`;if(o.has(n))return o.get(n);let a=e;if("/"===t)return`${a}Index`;for(const e of t.split("/"))123===e.charCodeAt(0)?a+=`By${s(e.slice(1,-1))}`:a+=s(e);return o.set(n,a),a},r=new Map;function c(e,t,n){return e&&t in e?e[t]??n:n}function i(...e){return e.reduce(((e,t)=>{if(!t)return e;let n;return("tags"in e&&e.tags||"tags"in t&&t.tags)&&(n=Array.from(new Set([...c(e,"tags",[]),...c(t,"tags",[])]))),{...e,...t,tags:n,responses:{...c(e,"responses",{}),...c(t,"responses",{})},parameters:m(e.parameters,t.parameters)}}),{})}function p({path:e,method:t,data:n,schema:s}){e=(e=>e.split("/").map((e=>{let t=e;if(t.startsWith(":")){const e=t.match(/^:([^{?]+)(?:{(.+)})?(\?)?$/);e?t=`{${e[1]}}`:(t=t.slice(1,t.length),t.endsWith("?")&&(t=t.slice(0,-1)),t=`{${t}}`)}return t})).join("/"))(e);const o=t.toLowerCase();if("all"===o){if(!n)return;if(r.has(e)){const t=r.get(e)??{};r.set(e,{...t,...n,parameters:m(t.parameters,n.parameters)})}else r.set(e,n)}else{const t=function(e){const t=Array.from(r.keys());let n={};for(const s of t)e.match(s)&&(n=i(n,r.get(s)??{}));return n}(e);s[e]={...s[e]?s[e]:{},[o]:{responses:{},operationId:a(o,e),...i(t,s[e]?.[o],n)}}}}const f=e=>"$ref"in e?e.$ref:`${e.in} ${e.name}`;function m(...e){const t=e.flatMap((e=>e??[])).reduce(((e,t)=>(e.set(f(t),t),e)),new Map);return Array.from(t.values())}function l(e,{excludeStaticFile:t=!0,exclude:n=[]}){const s={},o=Array.isArray(n)?n:[n];for(const[n,a]of Object.entries(e))if(!o.some((e=>"string"==typeof e?n===e:e.test(n)))&&(!n.includes("*")||n.includes("{"))&&(!t||(!n.includes(".")||n.includes("{")))){for(const e of Object.keys(a)){const t=a[e];if(n.includes("{")){t.parameters||(t.parameters=[]);const e=n.split("/").filter((e=>e.startsWith("{")&&!t.parameters.find((t=>"path"===t.in&&t.name===e.slice(1,e.length-1)))));for(const n of e){const e=n.slice(1,n.length-1),s=t.parameters.findIndex((t=>"param"===t.in&&t.name===e));-1!==s?t.parameters[s].in="path":t.parameters.push({schema:{type:"string"},in:"path",name:e,required:!0})}}t.responses||(t.responses={200:{}})}s[n]=a}return s}const u={documentation:{},excludeStaticFile:!0,exclude:[],excludeMethods:["OPTIONS"],excludeTags:[]},d={version:"3.1.0",components:{}};function h(e,t){const n={version:"3.1.0",components:{}};let s;return async o=>(s||(s=await y(e,t,n,o)),o.json(s))}async function y(t,s=u,o=d,a){const r={...u,...s},c={...d,...o},i=r.documentation??{},f=await async function(t,s,o){const a={};for(const r of t.routes){if(!(e in r.handler)){s.includeEmptyPaths&&p({method:r.method,path:r.path,schema:a});continue}if(s.excludeMethods.includes(r.method))continue;if(!1===n.includes(r.method)&&"ALL"!==r.method)continue;const{resolver:t,metadata:c={}}=r.handler[e],i=s.defaultOptions?.[r.method],{docs:f,components:m}=await t({...o,...c},i);o.components={...o.components,...m??{}},p({method:r.method,path:r.path,data:f,schema:a})}return a}(t,r,c);for(const e in f)for(const t in f[e]){const n=f[e][t]?.hide;if(n){let s=!1;"boolean"==typeof n?s=n:"function"==typeof n&&(a?s=n(a):console.warn(`'c' is not defined, cannot evaluate hide function for ${t} ${e}`)),s&&delete f[e][t]}}return{openapi:c.version,...{...i,tags:i.tags?.filter((e=>!r.excludeTags?.includes(e?.name))),info:{title:"Hono Documentation",description:"Development documentation",version:"0.0.0",...i.info},paths:{...l(f,r),...i.paths},components:{...i.components,schemas:{...c.components,...i.components?.schemas}}}}}function w(n){const{validateResponse:s,...o}=n;return Object.assign((async(e,o)=>{if(await o(),s&&n.responses){const o=e.res.status,a=e.res.headers.get("content-type");if(o&&a){const r=n.responses[o];if(r&&"content"in r&&r.content){const n=a.split(";")[0],o=r.content[n];if(o?.schema&&"validator"in o.schema)try{let t;const s=e.res.clone();if("application/json"===n?t=await s.json():"text/plain"===n&&(t=await s.text()),!t)throw new Error("No data to validate!");await o.schema.validator(t)}catch(e){let n={status:500,message:"Response validation failed!"};throw"object"==typeof s&&(n={...n,...s}),new t(n.status,{message:n.message,cause:e})}}}}}),{[e]:{resolver:(e,t)=>x(e,o,t)}})}async function x(e,t,n={}){let s={};const o={...n,...t,responses:{...n?.responses,...t.responses}};if(o.responses)for(const t of Object.keys(o.responses)){const n=o.responses[t];if(n&&"content"in n)for(const t of Object.keys(n.content??{})){const o=n.content?.[t];if(o&&(o.schema&&"builder"in o.schema)){const t=await o.schema.builder(e);o.schema=t.schema,t.components&&(s={...s,...t.components})}}}return{docs:o,components:s}}export{w as describeRoute,x as generateRouteSpecs,y as generateSpecs,h as openAPISpecs,e as uniqueSymbol};

package/src/arktype.d.ts

@@ -1,36 +0,0 @@
-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.js";
-/**
- * Generate a resolver for an Arktype schema
- * @param schema Arktype schema
- * @returns Resolver result
- */
-export declare function resolver<T extends Type>(schema: T): ResolverResult;
-/**
- * Create a validator middleware
- * @param target Target for validation
- * @param schema Arktype schema
- * @param hook Hook for validation
- * @returns Middleware handler
- */
-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>;