@elysiajs/openapi 1.3.11 → 1.4.0-exp.0

package/dist/cjs/gen/index.js

@@ -36,9 +36,10 @@ var fromTypes = (targetFilePath, {
   instanceName,
   projectRoot = process.cwd(),
   overrideOutputPath,
-  debug = false
+  debug = false,
+  compilerOptions,
+  tmpRoot = (0, import_path.join)((0, import_os.tmpdir)(), ".ElysiaAutoOpenAPI")
 } = {}) => () => {
-  const tmpRoot = (0, import_path.join)((0, import_os.tmpdir)(), ".ElysiaAutoOpenAPI");
   try {
     if (!targetFilePath.endsWith(".ts") && !targetFilePath.endsWith(".tsx"))
       throw new Error("Only .ts files are supported");
@@ -57,25 +58,27 @@ var fromTypes = (targetFilePath, {
       (0, import_fs.mkdirSync)(tmpRoot, { recursive: true });
       const tsconfig = tsconfigPath.startsWith("/") ? tsconfigPath : (0, import_path.join)(projectRoot, tsconfigPath);
       let extendsRef = (0, import_fs.existsSync)(tsconfig) ? `"extends": "${(0, import_path.join)(projectRoot, "tsconfig.json")}",` : "";
+      let distDir = (0, import_path.join)(tmpRoot, "dist");
       if (typeof process !== "undefined" && process.platform === "win32") {
         extendsRef = extendsRef.replace(/\\/g, "/");
         src = src.replace(/\\/g, "/");
+        distDir = distDir.replace(/\\/g, "/");
       }
       (0, import_fs.writeFileSync)(
         (0, import_path.join)(tmpRoot, "tsconfig.json"),
         `{
 	${extendsRef}
-	"compilerOptions": {
-		"lib": ["ESNext"],
-		"module": "ESNext",
-		"noEmit": false,
-		"declaration": true,
-		"emitDeclarationOnly": true,
-		"moduleResolution": "bundler",
-		"skipLibCheck": true,
-		"skipDefaultLibCheck": true,
-		"outDir": "./dist"
-	},
+	"compilerOptions": ${compilerOptions ? JSON.stringify(compilerOptions) : `{
+	"lib": ["ESNext"],
+	"module": "ESNext",
+	"noEmit": false,
+	"declaration": true,
+	"emitDeclarationOnly": true,
+	"moduleResolution": "bundler",
+	"skipLibCheck": true,
+	"skipDefaultLibCheck": true,
+	"outDir": "${distDir}"
+}`},
 	"include": ["${src}"]
 }`
       );
@@ -117,6 +120,11 @@ var fromTypes = (targetFilePath, {
             );
             console.warn(tempFiles);
           }
+        } else {
+          console.log(
+            "reason: root folder doesn't exists",
+            (0, import_path.join)(tmpRoot, "dist")
+          );
         }
         return;
       }

package/dist/cjs/index.d.ts

@@ -19,16 +19,19 @@ export declare const openapi: <const Enabled extends boolean = true, const Path
     macro: {};
     macroFn: {};
     parser: {};
+    response: {};
 }, {}, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }>;
 export { toOpenAPISchema, withHeaders } from './openapi';
 export type { ElysiaOpenAPIConfig };

package/dist/cjs/index.js

@@ -295,6 +295,7 @@ var Hint = Symbol.for("TypeBox.Hint");
 var Kind = Symbol.for("TypeBox.Kind");
 
 // src/openapi.ts
+var import_xsschema = require("xsschema");
 var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
 var toRef = (name) => import_elysia.t.Ref(`#/components/schemas/${name}`);
 var toOperationId = (method, paths) => {
@@ -323,7 +324,14 @@ var getLoosePath = (path) => {
     return path.slice(0, path.length - 1);
   return path + "/";
 };
-function toOpenAPISchema(app, exclude, references) {
+var unwrapSchema = (schema) => {
+  if (!schema) return;
+  if (typeof schema === "string") schema = toRef(schema);
+  if (Kind in schema) return schema;
+  if (Kind in schema === false && schema["~standard"])
+    return (0, import_xsschema.toJsonSchema)(schema);
+};
+async function toOpenAPISchema(app, exclude, references) {
   const {
     methods: excludeMethods = ["OPTIONS"],
     staticFile: excludeStaticFile = true,
@@ -376,11 +384,11 @@ function toOpenAPISchema(app, exclude, references) {
     };
     const parameters = [];
     if (hooks.params) {
-      if (typeof hooks.params === "string")
-        hooks.params = toRef(hooks.params);
-      if (hooks.params.type === "object" && hooks.params.properties) {
+      let params = unwrapSchema(hooks.params);
+      if (params) params = await params;
+      if (params && params.type === "object" && params.properties)
         for (const [paramName, paramSchema] of Object.entries(
-          hooks.params.properties
+          params.properties
         ))
           parameters.push({
             name: paramName,
@@ -389,15 +397,14 @@ function toOpenAPISchema(app, exclude, references) {
             // Path parameters are always required
             schema: paramSchema
           });
-      }
     }
     if (hooks.query) {
-      if (typeof hooks.query === "string")
-        hooks.query = toRef(hooks.query);
-      if (hooks.query.type === "object" && hooks.query.properties) {
-        const required = hooks.query.required || [];
+      let query = unwrapSchema(hooks.query);
+      if (query) query = await query;
+      if (query && query.type === "object" && query.properties) {
+        const required = query.required || [];
         for (const [queryName, querySchema] of Object.entries(
-          hooks.query.properties
+          query.properties
         ))
           parameters.push({
             name: queryName,
@@ -408,12 +415,12 @@ function toOpenAPISchema(app, exclude, references) {
       }
     }
     if (hooks.headers) {
-      if (typeof hooks.headers === "string")
-        hooks.headers = toRef(hooks.headers);
-      if (hooks.headers.type === "object" && hooks.headers.properties) {
-        const required = hooks.headers.required || [];
+      let headers = unwrapSchema(hooks.query);
+      if (headers) headers = await headers;
+      if (headers && headers.type === "object" && headers.properties) {
+        const required = headers.required || [];
         for (const [headerName, headerSchema] of Object.entries(
-          hooks.headers.properties
+          headers.properties
         ))
           parameters.push({
             name: headerName,
@@ -424,12 +431,12 @@ function toOpenAPISchema(app, exclude, references) {
       }
     }
     if (hooks.cookie) {
-      if (typeof hooks.cookie === "string")
-        hooks.cookie = toRef(hooks.cookie);
-      if (hooks.cookie.type === "object" && hooks.cookie.properties) {
-        const required = hooks.cookie.required || [];
+      let cookie = unwrapSchema(hooks.cookie);
+      if (cookie) cookie = await cookie;
+      if (cookie && cookie.type === "object" && cookie.properties) {
+        const required = cookie.required || [];
         for (const [cookieName, cookieSchema] of Object.entries(
-          hooks.cookie.properties
+          cookie.properties
         ))
           parameters.push({
             name: cookieName,
@@ -441,80 +448,107 @@ function toOpenAPISchema(app, exclude, references) {
     }
     if (parameters.length > 0) operation.parameters = parameters;
     if (hooks.body && method !== "get" && method !== "head") {
-      if (typeof hooks.body === "string") hooks.body = toRef(hooks.body);
-      if (hooks.parse) {
-        const content = {};
-        const parsers = hooks.parse;
-        for (const parser of parsers) {
-          if (typeof parser.fn === "function") continue;
-          switch (parser.fn) {
-            case "text":
-            case "text/plain":
-              content["text/plain"] = { schema: hooks.body };
-              continue;
-            case "urlencoded":
-            case "application/x-www-form-urlencoded":
-              content["application/x-www-form-urlencoded"] = {
-                schema: hooks.body
-              };
-              continue;
-            case "json":
-            case "application/json":
-              content["application/json"] = { schema: hooks.body };
-              continue;
-            case "formdata":
-            case "multipart/form-data":
-              content["multipart/form-data"] = {
-                schema: hooks.body
-              };
-              continue;
+      let body = unwrapSchema(hooks.body);
+      if (body) body = await body;
+      if (body) {
+        const { type: _type, description, ...options } = body;
+        const type = _type;
+        if (hooks.parse) {
+          const content = {};
+          const parsers = hooks.parse;
+          for (const parser of parsers) {
+            if (typeof parser.fn === "function") continue;
+            switch (parser.fn) {
+              case "text":
+              case "text/plain":
+                content["text/plain"] = { schema: body };
+                continue;
+              case "urlencoded":
+              case "application/x-www-form-urlencoded":
+                content["application/x-www-form-urlencoded"] = {
+                  schema: body
+                };
+                continue;
+              case "json":
+              case "application/json":
+                content["application/json"] = { schema: body };
+                continue;
+              case "formdata":
+              case "multipart/form-data":
+                content["multipart/form-data"] = {
+                  schema: body
+                };
+                continue;
+            }
           }
-        }
-        operation.requestBody = { content, required: true };
-      } else {
-        operation.requestBody = {
-          content: {
-            "application/json": {
-              schema: hooks.body
-            },
-            "application/x-www-form-urlencoded": {
-              schema: hooks.body
+          operation.requestBody = {
+            description,
+            content,
+            required: true
+          };
+        } else {
+          operation.requestBody = {
+            description,
+            content: type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
+              "text/plain": body
+            } : {
+              "application/json": {
+                schema: body
+              },
+              "application/x-www-form-urlencoded": {
+                schema: body
+              },
+              "multipart/form-data": {
+                schema: body
+              }
             },
-            "multipart/form-data": {
-              schema: hooks.body
-            }
-          },
-          required: true
-        };
+            required: true
+          };
+        }
       }
     }
     if (hooks.response) {
       operation.responses = {};
       if (typeof hooks.response === "object" && !hooks.response.type && !hooks.response.$ref) {
         for (let [status, schema] of Object.entries(hooks.response)) {
-          if (typeof schema === "string") schema = toRef(schema);
-          const { type, examples, $ref, ...options } = schema;
+          let response = unwrapSchema(schema);
+          if (response) response = await response;
+          if (!response) continue;
+          const { type: _type, description, ...options } = response;
+          const type = _type;
           operation.responses[status] = {
-            description: `Response for status ${status}`,
+            description: description ?? `Response for status ${status}`,
             ...options,
-            content: type === "void" || type === "null" || type === "undefined" ? schema : {
+            content: type === "void" || type === "null" || type === "undefined" ? response : type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
+              "text/plain": {
+                schema: response
+              }
+            } : {
               "application/json": {
-                schema
+                schema: response
               }
             }
           };
         }
       } else {
-        if (typeof hooks.response === "string")
-          hooks.response = toRef(hooks.response);
-        operation.responses["200"] = {
-          description: "Successful response",
-          content: {
-            "application/json": {
-              schema: hooks.response
+        let response = unwrapSchema(hooks.response);
+        if (response) response = await response;
+        if (response) {
+          const { type: _type, description, ...options } = response;
+          const type = _type;
+          operation.responses["200"] = {
+            description: description ?? `Response for status 200`,
+            content: type === "void" || type === "null" || type === "undefined" ? response : type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
+              "text/plain": {
+                schema: response
+              }
+            } : {
+              "application/json": {
+                schema: response
+              }
             }
-          }
-        };
+          };
+        }
       }
     }
     for (let path of getPossiblePath(route.path)) {
@@ -545,7 +579,14 @@ function toOpenAPISchema(app, exclude, references) {
         };
     }
   }
-  const schemas = app.getGlobalDefinitions?.().type;
+  const _schemas = app.getGlobalDefinitions?.().type;
+  const schemas = /* @__PURE__ */ Object.create(null);
+  if (_schemas)
+    for (const [name, schema] of Object.entries(_schemas)) {
+      let jsonSchema = unwrapSchema(schema);
+      if (jsonSchema instanceof Promise) jsonSchema = await jsonSchema;
+      if (jsonSchema) schemas[name] = jsonSchema;
+    }
   return {
     components: {
       schemas
@@ -611,13 +652,13 @@ var openapi = ({
     );
   }).get(
     specPath,
-    function openAPISchema() {
+    async function openAPISchema() {
       if (totalRoutes === app.routes.length) return cachedSchema;
       totalRoutes = app.routes.length;
       const {
         paths,
         components: { schemas }
-      } = toOpenAPISchema(app, exclude, references);
+      } = await toOpenAPISchema(app, exclude, references);
       return cachedSchema = {
         openapi: "3.0.3",
         ...documentation,

package/dist/cjs/openapi.d.ts

@@ -1,4 +1,4 @@
-import { type AnyElysia, type TSchema } from 'elysia';
+import { type AnyElysia, type TSchema, type InputSchema } from 'elysia';
 import type { OpenAPIV3 } from 'openapi-types';
 import { type TProperties } from '@sinclair/typebox';
 import type { AdditionalReferences, ElysiaOpenAPIConfig } from './types';
@@ -10,17 +10,20 @@ export declare const capitalize: (word: string) => string;
  */
 export declare const getPossiblePath: (path: string) => string[];
 export declare const getLoosePath: (path: string) => string;
+type MaybePromise<T> = T | Promise<T>;
+export declare const unwrapSchema: (schema: InputSchema["body"]) => MaybePromise<OpenAPIV3.SchemaObject | undefined>;
 /**
  * Converts Elysia routes to OpenAPI 3.0.3 paths schema
  * @param routes Array of Elysia route objects
  * @returns OpenAPI paths object
  */
-export declare function toOpenAPISchema(app: AnyElysia, exclude?: ElysiaOpenAPIConfig['exclude'], references?: AdditionalReferences): {
+export declare function toOpenAPISchema(app: AnyElysia, exclude?: ElysiaOpenAPIConfig['exclude'], references?: AdditionalReferences): Promise<{
     components: {
-        schemas: Record<string, TSchema>;
+        schemas: any;
     };
     paths: OpenAPIV3.PathsObject<{}, {}>;
-};
+}>;
 export declare const withHeaders: (schema: TSchema, headers: TProperties) => TSchema & {
     headers: TProperties;
 };
+export {};