hono-openapi 0.5.0-rc.2 → 0.5.0-rc.4

package/dist/index.cjs

@@ -31,12 +31,7 @@ const toOpenAPIPath = (path) => path.split("/").map((x) => {
   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("/")) {
@@ -46,61 +41,61 @@ const generateOperationId = (route) => {
       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) => {
+  const merged = params.flatMap((x) => x ?? []).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;
+  for (const [key, data] of specsByPathContext) {
+    if (data && path.match(key)) {
       context.push(data);
     }
   }
   return context;
 }
-function mergeSpecs(...specs) {
+function mergeSpecs(route, ...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", {})
+      if (!spec || !prev) return prev;
+      for (const [key, value] of Object.entries(spec)) {
+        if (value == null) continue;
+        if (key in prev && (typeof value === "object" || typeof value === "function" && key === "operationId")) {
+          if (Array.isArray(value)) {
+            const values = [...prev[key] ?? [], ...value];
+            if (key === "tags") {
+              prev[key] = Array.from(new Set(values));
+            } else {
+              prev[key] = values;
+            }
+          } else if (typeof value === "function") {
+            prev[key] = value(route);
+          } else {
+            if (key === "parameters") {
+              prev[key] = mergeParameters(prev[key], value);
+            } else {
+              prev[key] = {
+                ...prev[key],
+                ...value
+              };
+            }
+          }
+        } else {
+          prev[key] = value;
         }
-      };
+      }
+      return prev;
     },
-    {}
+    {
+      operationId: generateOperationId(route)
+    }
   );
 }
 function registerSchemaPath({
@@ -114,19 +109,23 @@ function registerSchemaPath({
     if (!specs) return;
     if (specsByPathContext.has(path)) {
       const prev = specsByPathContext.get(path) ?? {};
-      specsByPathContext.set(path, mergeSpecs(prev, specs));
+      specsByPathContext.set(path, mergeSpecs(route, 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)
-      }
-    };
+    if (!(path in paths)) {
+      paths[path] = {};
+    }
+    if (paths[path]) {
+      paths[path][method] = mergeSpecs(
+        route,
+        ...pathContext,
+        paths[path]?.[method],
+        specs
+      );
+    }
   }
 }
 function removeExcludedPaths(paths, ctx) {
@@ -152,10 +151,21 @@ function removeExcludedPaths(paths, ctx) {
           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
+              (x) => {
+                if ("$ref" in x) {
+                  const pos = x.$ref.split("/").pop();
+                  if (pos) {
+                    const param2 = ctx.components.parameters?.[pos];
+                    if (param2 && !("$ref" in param2)) {
+                      return param2.in === "path" && param2.name === paramName;
+                    }
+                  }
+                  return false;
+                }
+                return x.in === "path" && x.name === paramName;
+              }
             );
-            if (index !== -1) schema.parameters[index].in = "path";
-            else {
+            if (index === -1) {
               schema.parameters.push({
                 schema: { type: "string" },
                 in: "path",
@@ -202,20 +212,24 @@ async function generateSpecs(hono, options = DEFAULT_OPTIONS, c) {
     }
   };
   const _documentation = ctx.options.documentation ?? {};
-  const schema = await generatePaths(hono, ctx);
-  for (const path in schema) {
-    for (const method in schema[path]) {
+  const paths = await generatePaths(hono, ctx);
+  for (const path in paths) {
+    for (const method in paths[path]) {
       const isHidden = getHiddenValue({
-        valueOrFunc: schema[path][method]?.hide,
+        valueOrFunc: paths[path][method]?.hide,
         method,
         path,
         c
       });
       if (isHidden) {
-        delete schema[path][method];
+        paths[path][method] = void 0;
       }
     }
   }
+  const components = mergeComponentsObjects(
+    _documentation.components,
+    ctx.components
+  );
   return {
     openapi: "3.1.0",
     ..._documentation,
@@ -229,22 +243,17 @@ async function generateSpecs(hono, options = DEFAULT_OPTIONS, c) {
       ..._documentation.info
     },
     paths: {
-      ...removeExcludedPaths(schema, ctx),
+      ...removeExcludedPaths(paths, ctx),
       ..._documentation.paths
     },
-    components: {
-      ..._documentation.components,
-      schemas: {
-        ...ctx.components.schemas,
-        ..._documentation.components?.schemas
-      }
-    }
+    components
   };
 }
 async function generatePaths(hono, ctx) {
   const paths = {};
   for (const route of hono.routes) {
-    if (!(uniqueSymbol in route.handler)) {
+    const middlewareHandler = route.handler[uniqueSymbol];
+    if (!middlewareHandler) {
       if (ctx.options.includeEmptyPaths) {
         registerSchemaPath({
           route,
@@ -262,20 +271,12 @@ async function generatePaths(hono, ctx) {
         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
-      }
-    };
+    ctx.components = mergeComponentsObjects(ctx.components, components);
     registerSchemaPath({
       route,
       specs: routeSpecs,
@@ -289,14 +290,9 @@ function getHiddenValue(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}`
-        );
-      }
+    }
+    if (typeof valueOrFunc === "function") {
+      return valueOrFunc({ c, method, path });
     }
   }
   return false;
@@ -320,7 +316,7 @@ async function getSpec(middlewareHandler, defaultOptions) {
           const raw = response.content?.[contentKey];
           if (!raw) continue;
           if (raw.schema && "toOpenAPISchema" in raw.schema) {
-            const result2 = await raw.schema.toOpenAPISchema(defaultOptions);
+            const result2 = await raw.schema.toOpenAPISchema();
             raw.schema = result2.schema;
             if (result2.components) {
               components = {
@@ -337,7 +333,7 @@ async function getSpec(middlewareHandler, defaultOptions) {
   const result = await middlewareHandler.toOpenAPISchema();
   const docs = {};
   if (middlewareHandler.target === "form" || middlewareHandler.target === "json") {
-    const media = middlewareHandler.target === "json" ? "application/json" : "multipart/form-data";
+    const media = middlewareHandler.options?.media ?? middlewareHandler.target === "json" ? "application/json" : "multipart/form-data";
     if (!docs.requestBody || !("content" in docs.requestBody) || !docs.requestBody.content) {
       docs.requestBody = {
         content: {
@@ -352,39 +348,78 @@ async function getSpec(middlewareHandler, defaultOptions) {
       };
     }
   } else {
-    const parameters = [];
+    let 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 ?? {}
-      )) {
+      const ref = result.schema.$ref;
+      const pos = ref.split("/").pop();
+      if (pos && result.components?.schemas?.[pos]) {
+        const schema = result.components.schemas[pos];
+        const newParameters = generateParameters(
+          middlewareHandler.target,
+          schema
+        )[0];
+        if (!result.components.parameters) {
+          result.components.parameters = {};
+        }
+        result.components.parameters[pos] = newParameters;
+        delete result.components.schemas[pos];
         parameters.push({
-          in: middlewareHandler.target,
-          name: key,
-          // @ts-expect-error
-          schema: value,
-          required: result.schema.required?.includes(key)
+          $ref: `#/components/parameters/${pos}`
         });
       }
+    } else {
+      parameters = generateParameters(middlewareHandler.target, result.schema);
     }
     docs.parameters = parameters;
   }
   return { schema: docs, components: result.components };
 }
+function generateParameters(target, schema) {
+  const parameters = [];
+  for (const [key, value] of Object.entries(schema.properties ?? {})) {
+    const def = {
+      in: target === "param" ? "path" : target,
+      name: key,
+      // @ts-expect-error
+      schema: value,
+      required: schema.required?.includes(key)
+    };
+    if (def.schema && "description" in def.schema && def.schema.description) {
+      def.description = def.schema.description;
+      def.schema.description = void 0;
+    }
+    parameters.push(def);
+  }
+  return parameters;
+}
+function mergeComponentsObjects(...components) {
+  return components.reduce(
+    (prev, component, index) => {
+      if (!component || index === 0) return prev;
+      if (prev.schemas && Object.keys(prev.schemas).length > 0 || component.schemas && Object.keys(component.schemas).length > 0) {
+        prev.schemas = {
+          ...prev.schemas,
+          ...component.schemas
+        };
+      }
+      if (prev.parameters && Object.keys(prev.parameters).length > 0 || component.parameters && Object.keys(component.parameters).length > 0) {
+        prev.parameters = {
+          ...prev.parameters,
+          ...component.parameters
+        };
+      }
+      return prev;
+    },
+    components[0] ?? {}
+  );
+}
 
-function resolver(schema) {
+function resolver(schema, options) {
   return {
     vendor: schema["~standard"].vendor,
     validate: schema["~standard"].validate,
-    toJSONSchema: (options) => standardJson.toJsonSchema(schema, options),
-    toOpenAPISchema: (options) => standardOpenapi.toOpenAPISchema(schema, options)
+    toJSONSchema: () => standardJson.toJsonSchema(schema, options),
+    toOpenAPISchema: () => standardOpenapi.toOpenAPISchema(schema, options)
   };
 }
 function validator(target, schema, hook, options) {
@@ -392,7 +427,7 @@ function validator(target, schema, hook, options) {
   return Object.assign(middleware, {
     [uniqueSymbol]: {
       target,
-      ...resolver(schema),
+      ...resolver(schema, options),
       options
     }
   });
@@ -407,16 +442,17 @@ function describeRoute(spec) {
     }
   });
 }
-function describeResponse(handler, responses) {
+function describeResponse(handler, responses, options) {
   const _responses = Object.entries(responses).reduce(
     (acc, [statusCode, response]) => {
       if (response.content) {
         const content = Object.entries(response.content).reduce(
           (contentAcc, [mediaType, media]) => {
             if (media.vSchema) {
+              const { vSchema, ...rest } = media;
               contentAcc[mediaType] = {
-                ...media,
-                schema: resolver(media.vSchema)
+                ...rest,
+                schema: resolver(vSchema, options)
               };
             } else {
               contentAcc[mediaType] = media;