@elysiajs/openapi 1.3.11 → 1.4.0-exp.0

package/dist/cjs/openapi.js

@@ -24,6 +24,7 @@ __export(openapi_exports, {
   getLoosePath: () => getLoosePath,
   getPossiblePath: () => getPossiblePath,
   toOpenAPISchema: () => toOpenAPISchema,
+  unwrapSchema: () => unwrapSchema,
   withHeaders: () => withHeaders
 });
 module.exports = __toCommonJS(openapi_exports);
@@ -37,6 +38,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) => {
@@ -65,7 +67,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,
@@ -118,11 +127,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,
@@ -131,15 +140,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,
@@ -150,12 +158,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,
@@ -166,12 +174,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,
@@ -183,80 +191,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)) {
@@ -287,7 +322,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
@@ -304,5 +346,6 @@ var withHeaders = (schema, headers) => Object.assign(schema, {
   getLoosePath,
   getPossiblePath,
   toOpenAPISchema,
+  unwrapSchema,
   withHeaders
 });

package/dist/gen/index.d.ts

@@ -31,6 +31,21 @@ interface OpenAPIGeneratorOptions {
      * @default false
      */
     debug?: boolean;
+    /**
+     * compilerOptions
+     *
+     * Override tsconfig.json compilerOptions
+     */
+    compilerOptions?: Record<string, any>;
+    /**
+     * Temporary root
+     *
+     * a folder where temporary files are stored
+     * @default os.tmpdir()/.ElysiaAutoOpenAPI
+     *
+     * ! be careful that the folder will be removed after the process ends
+     */
+    tmpRoot?: string;
 }
 /**
  * Auto generate OpenAPI schema from Elysia instance
@@ -45,5 +60,5 @@ export declare const fromTypes: (
  *
  * The path must export an Elysia instance
  */
-targetFilePath: string, { tsconfigPath, instanceName, projectRoot, overrideOutputPath, debug }?: OpenAPIGeneratorOptions) => () => AdditionalReference | undefined;
+targetFilePath: string, { tsconfigPath, instanceName, projectRoot, overrideOutputPath, debug, compilerOptions, tmpRoot }?: OpenAPIGeneratorOptions) => () => AdditionalReference | undefined;
 export {};

package/dist/gen/index.mjs

@@ -19,9 +19,10 @@ var fromTypes = (targetFilePath, {
   instanceName,
   projectRoot = process.cwd(),
   overrideOutputPath,
-  debug = false
+  debug = false,
+  compilerOptions,
+  tmpRoot = join(tmpdir(), ".ElysiaAutoOpenAPI")
 } = {}) => () => {
-  const tmpRoot = join(tmpdir(), ".ElysiaAutoOpenAPI");
   try {
     if (!targetFilePath.endsWith(".ts") && !targetFilePath.endsWith(".tsx"))
       throw new Error("Only .ts files are supported");
@@ -40,25 +41,27 @@ var fromTypes = (targetFilePath, {
       mkdirSync(tmpRoot, { recursive: true });
       const tsconfig = tsconfigPath.startsWith("/") ? tsconfigPath : join(projectRoot, tsconfigPath);
       let extendsRef = existsSync(tsconfig) ? `"extends": "${join(projectRoot, "tsconfig.json")}",` : "";
+      let distDir = join(tmpRoot, "dist");
       if (typeof process !== "undefined" && process.platform === "win32") {
         extendsRef = extendsRef.replace(/\\/g, "/");
         src = src.replace(/\\/g, "/");
+        distDir = distDir.replace(/\\/g, "/");
       }
       writeFileSync(
         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}"]
 }`
       );
@@ -100,6 +103,11 @@ var fromTypes = (targetFilePath, {
             );
             console.warn(tempFiles);
           }
+        } else {
+          console.log(
+            "reason: root folder doesn't exists",
+            join(tmpRoot, "dist")
+          );
         }
         return;
       }

package/dist/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 };