@elysiajs/openapi 1.4.8 → 1.4.10

package/dist/openapi.d.ts

@@ -1,6 +1,6 @@
 import { type AnyElysia, type TSchema, type InputSchema } from 'elysia';
 import type { OpenAPIV3 } from 'openapi-types';
-import { type TProperties } from '@sinclair/typebox';
+import { TAnySchema, type TProperties } from '@sinclair/typebox';
 import type { AdditionalReferences, ElysiaOpenAPIConfig, MapJsonSchema } from './types';
 export declare const capitalize: (word: string) => string;
 /**
@@ -11,6 +11,7 @@ export declare const capitalize: (word: string) => string;
 export declare const getPossiblePath: (path: string) => string[];
 export declare const getLoosePath: (path: string) => string;
 export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?: MapJsonSchema) => OpenAPIV3.SchemaObject | undefined;
+export declare const enumToOpenApi: <T extends TAnySchema | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined>(_schema: T) => T;
 /**
  * Converts Elysia routes to OpenAPI 3.0.3 paths schema
  * @param routes Array of Elysia route objects

package/dist/openapi.mjs

@@ -76,62 +76,98 @@ var unwrapReference = (schema, definitions) => {
   if (!ref) return schema;
   const name = ref.slice(ref.lastIndexOf("/") + 1);
   if (ref && definitions[name]) schema = definitions[name];
-  return schema;
+  return enumToOpenApi(schema);
 };
 var unwrapSchema = (schema, mapJsonSchema) => {
   if (!schema) return;
   if (typeof schema === "string") schema = toRef(schema);
-  if (Kind in schema) return schema;
+  if (Kind in schema) return enumToOpenApi(schema);
   if (Kind in schema || !schema?.["~standard"]) return;
   const vendor = schema["~standard"].vendor;
-  if (mapJsonSchema?.[vendor] && typeof mapJsonSchema[vendor] === "function")
-    return mapJsonSchema[vendor](schema);
-  switch (vendor) {
-    case "zod":
-      if (warned.zod4 || warned.zod3) break;
-      console.warn(
-        "[@elysiajs/openapi] Zod doesn't provide JSON Schema method on the schema"
-      );
-      if ("_zod" in schema) {
-        warned.zod4 = true;
+  try {
+    if (mapJsonSchema?.[vendor] && typeof mapJsonSchema[vendor] === "function")
+      return enumToOpenApi(mapJsonSchema[vendor](schema));
+    switch (vendor) {
+      case "zod":
+        if (warned.zod4 || warned.zod3) break;
         console.warn(
-          "For Zod v4, please provide z.toJSONSchema as follows:\n"
+          "[@elysiajs/openapi] Zod doesn't provide JSON Schema method on the schema"
         );
-        console.warn(warnings.zod4);
-      } else {
-        warned.zod3 = true;
+        if ("_zod" in schema) {
+          warned.zod4 = true;
+          console.warn(
+            "For Zod v4, please provide z.toJSONSchema as follows:\n"
+          );
+          console.warn(warnings.zod4);
+        } else {
+          warned.zod3 = true;
+          console.warn(
+            "For Zod v3, please install zod-to-json-schema package and use it like this:\n"
+          );
+          console.warn(warnings.zod3);
+        }
+        break;
+      case "valibot":
+        if (warned.valibot) break;
+        warned.valibot = true;
         console.warn(
-          "For Zod v3, please install zod-to-json-schema package and use it like this:\n"
+          "[@elysiajs/openapi] Valibot require a separate package for JSON Schema conversion"
         );
-        console.warn(warnings.zod3);
-      }
-      break;
-    case "valibot":
-      if (warned.valibot) break;
-      warned.valibot = true;
-      console.warn(
-        "[@elysiajs/openapi] Valibot require a separate package for JSON Schema conversion"
-      );
-      console.warn(
-        "Please install @valibot/to-json-schema package and use it like this:\n"
-      );
-      console.warn(warnings.valibot);
-      break;
-    case "effect":
-      if (warned.effect) break;
-      warned.effect = true;
-      console.warn(
-        "[@elysiajs/openapi] Effect Schema doesn't provide JSON Schema method on the schema"
-      );
-      console.warn(
-        "please provide JSONSchema from 'effect' package as follows:\n"
-      );
-      console.warn(warnings.effect);
-      break;
+        console.warn(
+          "Please install @valibot/to-json-schema package and use it like this:\n"
+        );
+        console.warn(warnings.valibot);
+        break;
+      case "effect":
+        if (warned.effect) break;
+        warned.effect = true;
+        console.warn(
+          "[@elysiajs/openapi] Effect Schema doesn't provide JSON Schema method on the schema"
+        );
+        console.warn(
+          "please provide JSONSchema from 'effect' package as follows:\n"
+        );
+        console.warn(warnings.effect);
+        break;
+    }
+    if (vendor === "arktype")
+      return enumToOpenApi(schema?.toJsonSchema?.());
+    return enumToOpenApi(
+      // @ts-ignore
+      schema.toJSONSchema?.() ?? schema?.toJsonSchema?.()
+    );
+  } catch (error) {
+    console.warn(error);
+  }
+};
+var enumToOpenApi = (_schema) => {
+  if (!_schema || typeof _schema !== "object") return _schema;
+  if (Kind in _schema) {
+    const schema2 = _schema;
+    if (schema2[Kind] === "Union" && schema2.anyOf && Array.isArray(schema2.anyOf) && schema2.anyOf.length > 0 && schema2.anyOf.every(
+      (item) => item && typeof item === "object" && item.const !== void 0
+    ))
+      return {
+        type: "string",
+        enum: schema2.anyOf.map((item) => item.const)
+      };
+  }
+  const schema = _schema;
+  if (schema.type === "object" && schema.properties) {
+    const properties = {};
+    for (const [key, value] of Object.entries(schema.properties))
+      properties[key] = enumToOpenApi(value);
+    return {
+      ...schema,
+      properties
+    };
   }
-  if (vendor === "arktype")
-    return schema?.toJsonSchema?.();
-  return schema.toJSONSchema?.() ?? schema?.toJsonSchema?.();
+  if (schema.type === "array" && schema.items)
+    return {
+      ...schema,
+      items: enumToOpenApi(schema.items)
+    };
+  return schema;
 };
 function toOpenAPISchema(app, exclude, references, vendors) {
   let {
@@ -204,16 +240,24 @@ function toOpenAPISchema(app, exclude, references, vendors) {
         definitions
       );
       if (params && params.type === "object" && params.properties)
-        for (const [paramName, paramSchema] of Object.entries(
-          params.properties
-        ))
+        for (const [name, schema] of Object.entries(params.properties))
           parameters.push({
-            name: paramName,
+            name,
             in: "path",
             required: true,
             // Path parameters are always required
-            schema: paramSchema
+            schema
           });
+    } else {
+      for (const match of route.path.matchAll(/:([^/]+)/g)) {
+        const name = match[1].replace("?", "");
+        parameters.push({
+          name,
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        });
+      }
     }
     if (hooks.query) {
       const query = unwrapReference(
@@ -222,32 +266,28 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       );
       if (query && query.type === "object" && query.properties) {
         const required = query.required || [];
-        for (const [queryName, querySchema] of Object.entries(
-          query.properties
-        ))
+        for (const [name, schema] of Object.entries(query.properties))
           parameters.push({
-            name: queryName,
+            name,
             in: "query",
-            required: required.includes(queryName),
-            schema: querySchema
+            required: required.includes(name),
+            schema
           });
       }
     }
     if (hooks.headers) {
       const headers = unwrapReference(
-        unwrapSchema(hooks.query, vendors),
+        unwrapSchema(hooks.headers, vendors),
         definitions
       );
       if (headers && headers.type === "object" && headers.properties) {
         const required = headers.required || [];
-        for (const [headerName, headerSchema] of Object.entries(
-          headers.properties
-        ))
+        for (const [name, schema] of Object.entries(headers.properties))
           parameters.push({
-            name: headerName,
+            name,
             in: "header",
-            required: required.includes(headerName),
-            schema: headerSchema
+            required: required.includes(name),
+            schema
           });
       }
     }
@@ -258,14 +298,12 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       );
       if (cookie && cookie.type === "object" && cookie.properties) {
         const required = cookie.required || [];
-        for (const [cookieName, cookieSchema] of Object.entries(
-          cookie.properties
-        ))
+        for (const [name, schema] of Object.entries(cookie.properties))
           parameters.push({
-            name: cookieName,
+            name,
             in: "cookie",
-            required: required.includes(cookieName),
-            schema: cookieSchema
+            required: required.includes(name),
+            schema
           });
       }
     }
@@ -313,6 +351,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
         } else {
           operation.requestBody = {
             description,
+            required: true,
             content: type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
               "text/plain": {
                 schema: body
@@ -327,8 +366,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
               "multipart/form-data": {
                 schema: body
               }
-            },
-            required: true
+            }
           };
         }
       }
@@ -340,7 +378,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
         for (let [status, schema] of Object.entries(hooks.response)) {
           const response = unwrapSchema(schema, vendors);
           if (!response) continue;
-          const { type, description, $ref, ...options } = unwrapReference(response, definitions);
+          const { type, description, $ref, ..._options } = unwrapReference(response, definitions);
           operation.responses[status] = {
             description: description ?? `Response for status ${status}`,
             content: type === "void" || type === "null" || type === "undefined" ? { type, description } : type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
@@ -379,7 +417,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       }
     }
     for (let path of getPossiblePath(route.path)) {
-      const operationId = toOperationId(route.method, path);
+      const operationId = hooks.detail?.operationId ?? toOperationId(route.method, path);
       path = path.replace(/:([^/]+)/g, "{$1}");
       if (!paths[path]) paths[path] = {};
       const current = paths[path];
@@ -424,6 +462,7 @@ var withHeaders = (schema, headers) => Object.assign(schema, {
 });
 export {
   capitalize,
+  enumToOpenApi,
   getLoosePath,
   getPossiblePath,
   toOpenAPISchema,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@elysiajs/openapi",
-    "version": "1.4.8",
+    "version": "1.4.10",
     "description": "Plugin for Elysia to auto-generate API documentation",
     "author": {
         "name": "saltyAom",