enlace-openapi 0.0.1-beta.2 → 0.0.1-beta.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Enlace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -186,18 +186,30 @@ Parameter names are auto-generated from the parent segment (e.g., `users` → `u
 
 ## Programmatic API
 
+### Next.js + Swagger UI Example
+
 ```typescript
+import SwaggerUI from "swagger-ui-react";
+import "swagger-ui-react/swagger-ui.css";
 import { parseSchema, generateOpenAPISpec } from "enlace-openapi";
 
-const { endpoints, schemas } = parseSchema("./types/APISchema.ts", "ApiSchema");
-
-const spec = generateOpenAPISpec(endpoints, schemas, {
-  title: "My API",
-  version: "1.0.0",
-  baseUrl: "https://api.example.com",
-});
+const spec = (() => {
+  const { endpoints, schemas } = parseSchema(
+    "./APISchema.ts",
+    "ApiSchema"
+  );
+  return generateOpenAPISpec(endpoints, schemas, {
+    title: "My API",
+    version: "1.0.0",
+    baseUrl: "https://api.example.com",
+  });
+})();
+
+const DocsPage = () => {
+  return <SwaggerUI spec={spec} />;
+};
 
-console.log(JSON.stringify(spec, null, 2));
+export default DocsPage;
 ```
 
 ## Viewing the OpenAPI Spec

package/dist/cli.js

@@ -299,16 +299,20 @@ function isEndpointStructure(type) {
   propNames.delete("data");
   propNames.delete("body");
   propNames.delete("error");
+  propNames.delete("query");
+  propNames.delete("formData");
   const remainingProps = [...propNames].filter(
     (name) => !name.startsWith("__@") && !name.includes("Brand")
   );
   return remainingProps.length === 0;
 }
-function parseEndpointType(type, path2, method, pathParams, ctx) {
+function parseEndpointType(type, pathStr, method, pathParams, ctx) {
   const { checker } = ctx;
   let dataType;
   let bodyType;
   let errorType;
+  let queryType;
+  let formDataType;
   const typesToCheck = type.isIntersection() ? type.types : [type];
   for (const t of typesToCheck) {
     const props = t.getProperties();
@@ -320,32 +324,93 @@ function parseEndpointType(type, path2, method, pathParams, ctx) {
         bodyType = checker.getTypeOfSymbol(prop);
       } else if (name === "error") {
         errorType = checker.getTypeOfSymbol(prop);
+      } else if (name === "query") {
+        queryType = checker.getTypeOfSymbol(prop);
+      } else if (name === "formData") {
+        formDataType = checker.getTypeOfSymbol(prop);
       }
     }
   }
   const endpoint = {
-    path: path2,
+    path: pathStr,
     method,
     responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
     pathParams
   };
-  if (bodyType && !(bodyType.flags & import_typescript2.default.TypeFlags.Never)) {
+  if (formDataType && !(formDataType.flags & import_typescript2.default.TypeFlags.Never)) {
+    endpoint.requestBodySchema = formDataTypeToSchema(formDataType, ctx);
+    endpoint.requestBodyContentType = "multipart/form-data";
+  } else if (bodyType && !(bodyType.flags & import_typescript2.default.TypeFlags.Never)) {
     endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+    endpoint.requestBodyContentType = "application/json";
+  }
+  if (queryType && !(queryType.flags & import_typescript2.default.TypeFlags.Never)) {
+    endpoint.queryParams = queryTypeToParams(queryType, ctx);
   }
   if (errorType && !(errorType.flags & import_typescript2.default.TypeFlags.Never) && !(errorType.flags & import_typescript2.default.TypeFlags.Unknown)) {
     endpoint.errorSchema = typeToSchema(errorType, ctx);
   }
   return endpoint;
 }
+function queryTypeToParams(queryType, ctx) {
+  const { checker } = ctx;
+  const params = [];
+  const props = queryType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & import_typescript2.default.SymbolFlags.Optional);
+    params.push({
+      name: propName,
+      in: "query",
+      required: !isOptional,
+      schema: typeToSchema(propType, ctx)
+    });
+  }
+  return params;
+}
+function formDataTypeToSchema(formDataType, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = formDataType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & import_typescript2.default.SymbolFlags.Optional);
+    const typeName = checker.typeToString(propType);
+    if (typeName.includes("File") || typeName.includes("Blob")) {
+      properties[propName] = { type: "string", format: "binary" };
+    } else if (propType.isUnion()) {
+      const hasFile = propType.types.some((t) => {
+        const name = checker.typeToString(t);
+        return name.includes("File") || name.includes("Blob");
+      });
+      if (hasFile) {
+        properties[propName] = { type: "string", format: "binary" };
+      } else {
+        properties[propName] = typeToSchema(propType, ctx);
+      }
+    } else {
+      properties[propName] = typeToSchema(propType, ctx);
+    }
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 
 // src/generator.ts
 function generateOpenAPISpec(endpoints, schemas, options = {}) {
-  const {
-    title = "API",
-    version = "1.0.0",
-    description,
-    baseUrl
-  } = options;
+  const { title = "API", version = "1.0.0", description, baseUrl } = options;
   const paths = {};
   for (const endpoint of endpoints) {
     if (!paths[endpoint.path]) {
@@ -399,11 +464,15 @@ function createOperation(endpoint) {
       }
     };
   }
+  if (endpoint.queryParams && endpoint.queryParams.length > 0) {
+    operation.parameters = endpoint.queryParams;
+  }
   if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    const contentType = endpoint.requestBodyContentType || "application/json";
     operation.requestBody = {
       required: true,
       content: {
-        "application/json": {
+        [contentType]: {
           schema: endpoint.requestBodySchema
         }
       }

package/dist/cli.mjs

@@ -276,16 +276,20 @@ function isEndpointStructure(type) {
   propNames.delete("data");
   propNames.delete("body");
   propNames.delete("error");
+  propNames.delete("query");
+  propNames.delete("formData");
   const remainingProps = [...propNames].filter(
     (name) => !name.startsWith("__@") && !name.includes("Brand")
   );
   return remainingProps.length === 0;
 }
-function parseEndpointType(type, path2, method, pathParams, ctx) {
+function parseEndpointType(type, pathStr, method, pathParams, ctx) {
   const { checker } = ctx;
   let dataType;
   let bodyType;
   let errorType;
+  let queryType;
+  let formDataType;
   const typesToCheck = type.isIntersection() ? type.types : [type];
   for (const t of typesToCheck) {
     const props = t.getProperties();
@@ -297,32 +301,93 @@ function parseEndpointType(type, path2, method, pathParams, ctx) {
         bodyType = checker.getTypeOfSymbol(prop);
       } else if (name === "error") {
         errorType = checker.getTypeOfSymbol(prop);
+      } else if (name === "query") {
+        queryType = checker.getTypeOfSymbol(prop);
+      } else if (name === "formData") {
+        formDataType = checker.getTypeOfSymbol(prop);
       }
     }
   }
   const endpoint = {
-    path: path2,
+    path: pathStr,
     method,
     responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
     pathParams
   };
-  if (bodyType && !(bodyType.flags & ts2.TypeFlags.Never)) {
+  if (formDataType && !(formDataType.flags & ts2.TypeFlags.Never)) {
+    endpoint.requestBodySchema = formDataTypeToSchema(formDataType, ctx);
+    endpoint.requestBodyContentType = "multipart/form-data";
+  } else if (bodyType && !(bodyType.flags & ts2.TypeFlags.Never)) {
     endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+    endpoint.requestBodyContentType = "application/json";
+  }
+  if (queryType && !(queryType.flags & ts2.TypeFlags.Never)) {
+    endpoint.queryParams = queryTypeToParams(queryType, ctx);
   }
   if (errorType && !(errorType.flags & ts2.TypeFlags.Never) && !(errorType.flags & ts2.TypeFlags.Unknown)) {
     endpoint.errorSchema = typeToSchema(errorType, ctx);
   }
   return endpoint;
 }
+function queryTypeToParams(queryType, ctx) {
+  const { checker } = ctx;
+  const params = [];
+  const props = queryType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & ts2.SymbolFlags.Optional);
+    params.push({
+      name: propName,
+      in: "query",
+      required: !isOptional,
+      schema: typeToSchema(propType, ctx)
+    });
+  }
+  return params;
+}
+function formDataTypeToSchema(formDataType, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = formDataType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & ts2.SymbolFlags.Optional);
+    const typeName = checker.typeToString(propType);
+    if (typeName.includes("File") || typeName.includes("Blob")) {
+      properties[propName] = { type: "string", format: "binary" };
+    } else if (propType.isUnion()) {
+      const hasFile = propType.types.some((t) => {
+        const name = checker.typeToString(t);
+        return name.includes("File") || name.includes("Blob");
+      });
+      if (hasFile) {
+        properties[propName] = { type: "string", format: "binary" };
+      } else {
+        properties[propName] = typeToSchema(propType, ctx);
+      }
+    } else {
+      properties[propName] = typeToSchema(propType, ctx);
+    }
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 
 // src/generator.ts
 function generateOpenAPISpec(endpoints, schemas, options = {}) {
-  const {
-    title = "API",
-    version = "1.0.0",
-    description,
-    baseUrl
-  } = options;
+  const { title = "API", version = "1.0.0", description, baseUrl } = options;
   const paths = {};
   for (const endpoint of endpoints) {
     if (!paths[endpoint.path]) {
@@ -376,11 +441,15 @@ function createOperation(endpoint) {
       }
     };
   }
+  if (endpoint.queryParams && endpoint.queryParams.length > 0) {
+    operation.parameters = endpoint.queryParams;
+  }
   if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    const contentType = endpoint.requestBodyContentType || "application/json";
     operation.requestBody = {
       required: true,
       content: {
-        "application/json": {
+        [contentType]: {
           schema: endpoint.requestBodySchema
         }
       }

package/dist/index.d.mts

@@ -14,20 +14,24 @@ type JSONSchema = {
     format?: string;
     description?: string;
 };
+type OpenAPIRequestBody = {
+    required?: boolean;
+    content: {
+        "application/json"?: {
+            schema: JSONSchema;
+        };
+        "multipart/form-data"?: {
+            schema: JSONSchema;
+        };
+    };
+};
 type OpenAPIOperation = {
     operationId?: string;
     summary?: string;
     description?: string;
     tags?: string[];
     parameters?: OpenAPIParameter[];
-    requestBody?: {
-        required?: boolean;
-        content: {
-            "application/json": {
-                schema: JSONSchema;
-            };
-        };
-    };
+    requestBody?: OpenAPIRequestBody;
     responses: Record<string, {
         description: string;
         content?: {
@@ -73,6 +77,8 @@ type ParsedEndpoint = {
     method: "get" | "post" | "put" | "patch" | "delete";
     responseSchema: JSONSchema;
     requestBodySchema?: JSONSchema;
+    requestBodyContentType?: "application/json" | "multipart/form-data";
+    queryParams?: OpenAPIParameter[];
     errorSchema?: JSONSchema;
     pathParams: string[];
 };
@@ -99,4 +105,4 @@ type GeneratorOptions = {
 };
 declare function generateOpenAPISpec(endpoints: ParsedEndpoint[], schemas: Map<string, JSONSchema>, options?: GeneratorOptions): OpenAPISpec;
 
-export { type CLIOptions, type JSONSchema, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPISpec, type ParsedEndpoint, generateOpenAPISpec, parseSchema };
+export { type CLIOptions, type JSONSchema, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPIRequestBody, type OpenAPISpec, type ParsedEndpoint, generateOpenAPISpec, parseSchema };

package/dist/index.d.ts

@@ -14,20 +14,24 @@ type JSONSchema = {
     format?: string;
     description?: string;
 };
+type OpenAPIRequestBody = {
+    required?: boolean;
+    content: {
+        "application/json"?: {
+            schema: JSONSchema;
+        };
+        "multipart/form-data"?: {
+            schema: JSONSchema;
+        };
+    };
+};
 type OpenAPIOperation = {
     operationId?: string;
     summary?: string;
     description?: string;
     tags?: string[];
     parameters?: OpenAPIParameter[];
-    requestBody?: {
-        required?: boolean;
-        content: {
-            "application/json": {
-                schema: JSONSchema;
-            };
-        };
-    };
+    requestBody?: OpenAPIRequestBody;
     responses: Record<string, {
         description: string;
         content?: {
@@ -73,6 +77,8 @@ type ParsedEndpoint = {
     method: "get" | "post" | "put" | "patch" | "delete";
     responseSchema: JSONSchema;
     requestBodySchema?: JSONSchema;
+    requestBodyContentType?: "application/json" | "multipart/form-data";
+    queryParams?: OpenAPIParameter[];
     errorSchema?: JSONSchema;
     pathParams: string[];
 };
@@ -99,4 +105,4 @@ type GeneratorOptions = {
 };
 declare function generateOpenAPISpec(endpoints: ParsedEndpoint[], schemas: Map<string, JSONSchema>, options?: GeneratorOptions): OpenAPISpec;
 
-export { type CLIOptions, type JSONSchema, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPISpec, type ParsedEndpoint, generateOpenAPISpec, parseSchema };
+export { type CLIOptions, type JSONSchema, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPIRequestBody, type OpenAPISpec, type ParsedEndpoint, generateOpenAPISpec, parseSchema };

package/dist/index.js

@@ -307,16 +307,20 @@ function isEndpointStructure(type) {
   propNames.delete("data");
   propNames.delete("body");
   propNames.delete("error");
+  propNames.delete("query");
+  propNames.delete("formData");
   const remainingProps = [...propNames].filter(
     (name) => !name.startsWith("__@") && !name.includes("Brand")
   );
   return remainingProps.length === 0;
 }
-function parseEndpointType(type, path2, method, pathParams, ctx) {
+function parseEndpointType(type, pathStr, method, pathParams, ctx) {
   const { checker } = ctx;
   let dataType;
   let bodyType;
   let errorType;
+  let queryType;
+  let formDataType;
   const typesToCheck = type.isIntersection() ? type.types : [type];
   for (const t of typesToCheck) {
     const props = t.getProperties();
@@ -328,32 +332,93 @@ function parseEndpointType(type, path2, method, pathParams, ctx) {
         bodyType = checker.getTypeOfSymbol(prop);
       } else if (name === "error") {
         errorType = checker.getTypeOfSymbol(prop);
+      } else if (name === "query") {
+        queryType = checker.getTypeOfSymbol(prop);
+      } else if (name === "formData") {
+        formDataType = checker.getTypeOfSymbol(prop);
       }
     }
   }
   const endpoint = {
-    path: path2,
+    path: pathStr,
     method,
     responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
     pathParams
   };
-  if (bodyType && !(bodyType.flags & import_typescript2.default.TypeFlags.Never)) {
+  if (formDataType && !(formDataType.flags & import_typescript2.default.TypeFlags.Never)) {
+    endpoint.requestBodySchema = formDataTypeToSchema(formDataType, ctx);
+    endpoint.requestBodyContentType = "multipart/form-data";
+  } else if (bodyType && !(bodyType.flags & import_typescript2.default.TypeFlags.Never)) {
     endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+    endpoint.requestBodyContentType = "application/json";
+  }
+  if (queryType && !(queryType.flags & import_typescript2.default.TypeFlags.Never)) {
+    endpoint.queryParams = queryTypeToParams(queryType, ctx);
   }
   if (errorType && !(errorType.flags & import_typescript2.default.TypeFlags.Never) && !(errorType.flags & import_typescript2.default.TypeFlags.Unknown)) {
     endpoint.errorSchema = typeToSchema(errorType, ctx);
   }
   return endpoint;
 }
+function queryTypeToParams(queryType, ctx) {
+  const { checker } = ctx;
+  const params = [];
+  const props = queryType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & import_typescript2.default.SymbolFlags.Optional);
+    params.push({
+      name: propName,
+      in: "query",
+      required: !isOptional,
+      schema: typeToSchema(propType, ctx)
+    });
+  }
+  return params;
+}
+function formDataTypeToSchema(formDataType, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = formDataType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & import_typescript2.default.SymbolFlags.Optional);
+    const typeName = checker.typeToString(propType);
+    if (typeName.includes("File") || typeName.includes("Blob")) {
+      properties[propName] = { type: "string", format: "binary" };
+    } else if (propType.isUnion()) {
+      const hasFile = propType.types.some((t) => {
+        const name = checker.typeToString(t);
+        return name.includes("File") || name.includes("Blob");
+      });
+      if (hasFile) {
+        properties[propName] = { type: "string", format: "binary" };
+      } else {
+        properties[propName] = typeToSchema(propType, ctx);
+      }
+    } else {
+      properties[propName] = typeToSchema(propType, ctx);
+    }
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 
 // src/generator.ts
 function generateOpenAPISpec(endpoints, schemas, options = {}) {
-  const {
-    title = "API",
-    version = "1.0.0",
-    description,
-    baseUrl
-  } = options;
+  const { title = "API", version = "1.0.0", description, baseUrl } = options;
   const paths = {};
   for (const endpoint of endpoints) {
     if (!paths[endpoint.path]) {
@@ -407,11 +472,15 @@ function createOperation(endpoint) {
       }
     };
   }
+  if (endpoint.queryParams && endpoint.queryParams.length > 0) {
+    operation.parameters = endpoint.queryParams;
+  }
   if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    const contentType = endpoint.requestBodyContentType || "application/json";
     operation.requestBody = {
       required: true,
       content: {
-        "application/json": {
+        [contentType]: {
           schema: endpoint.requestBodySchema
         }
       }

package/dist/index.mjs

@@ -270,16 +270,20 @@ function isEndpointStructure(type) {
   propNames.delete("data");
   propNames.delete("body");
   propNames.delete("error");
+  propNames.delete("query");
+  propNames.delete("formData");
   const remainingProps = [...propNames].filter(
     (name) => !name.startsWith("__@") && !name.includes("Brand")
   );
   return remainingProps.length === 0;
 }
-function parseEndpointType(type, path2, method, pathParams, ctx) {
+function parseEndpointType(type, pathStr, method, pathParams, ctx) {
   const { checker } = ctx;
   let dataType;
   let bodyType;
   let errorType;
+  let queryType;
+  let formDataType;
   const typesToCheck = type.isIntersection() ? type.types : [type];
   for (const t of typesToCheck) {
     const props = t.getProperties();
@@ -291,32 +295,93 @@ function parseEndpointType(type, path2, method, pathParams, ctx) {
         bodyType = checker.getTypeOfSymbol(prop);
       } else if (name === "error") {
         errorType = checker.getTypeOfSymbol(prop);
+      } else if (name === "query") {
+        queryType = checker.getTypeOfSymbol(prop);
+      } else if (name === "formData") {
+        formDataType = checker.getTypeOfSymbol(prop);
       }
     }
   }
   const endpoint = {
-    path: path2,
+    path: pathStr,
     method,
     responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
     pathParams
   };
-  if (bodyType && !(bodyType.flags & ts2.TypeFlags.Never)) {
+  if (formDataType && !(formDataType.flags & ts2.TypeFlags.Never)) {
+    endpoint.requestBodySchema = formDataTypeToSchema(formDataType, ctx);
+    endpoint.requestBodyContentType = "multipart/form-data";
+  } else if (bodyType && !(bodyType.flags & ts2.TypeFlags.Never)) {
     endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+    endpoint.requestBodyContentType = "application/json";
+  }
+  if (queryType && !(queryType.flags & ts2.TypeFlags.Never)) {
+    endpoint.queryParams = queryTypeToParams(queryType, ctx);
   }
   if (errorType && !(errorType.flags & ts2.TypeFlags.Never) && !(errorType.flags & ts2.TypeFlags.Unknown)) {
     endpoint.errorSchema = typeToSchema(errorType, ctx);
   }
   return endpoint;
 }
+function queryTypeToParams(queryType, ctx) {
+  const { checker } = ctx;
+  const params = [];
+  const props = queryType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & ts2.SymbolFlags.Optional);
+    params.push({
+      name: propName,
+      in: "query",
+      required: !isOptional,
+      schema: typeToSchema(propType, ctx)
+    });
+  }
+  return params;
+}
+function formDataTypeToSchema(formDataType, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = formDataType.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = !!(prop.flags & ts2.SymbolFlags.Optional);
+    const typeName = checker.typeToString(propType);
+    if (typeName.includes("File") || typeName.includes("Blob")) {
+      properties[propName] = { type: "string", format: "binary" };
+    } else if (propType.isUnion()) {
+      const hasFile = propType.types.some((t) => {
+        const name = checker.typeToString(t);
+        return name.includes("File") || name.includes("Blob");
+      });
+      if (hasFile) {
+        properties[propName] = { type: "string", format: "binary" };
+      } else {
+        properties[propName] = typeToSchema(propType, ctx);
+      }
+    } else {
+      properties[propName] = typeToSchema(propType, ctx);
+    }
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 
 // src/generator.ts
 function generateOpenAPISpec(endpoints, schemas, options = {}) {
-  const {
-    title = "API",
-    version = "1.0.0",
-    description,
-    baseUrl
-  } = options;
+  const { title = "API", version = "1.0.0", description, baseUrl } = options;
   const paths = {};
   for (const endpoint of endpoints) {
     if (!paths[endpoint.path]) {
@@ -370,11 +435,15 @@ function createOperation(endpoint) {
       }
     };
   }
+  if (endpoint.queryParams && endpoint.queryParams.length > 0) {
+    operation.parameters = endpoint.queryParams;
+  }
   if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    const contentType = endpoint.requestBodyContentType || "application/json";
     operation.requestBody = {
       required: true,
       content: {
-        "application/json": {
+        [contentType]: {
           schema: endpoint.requestBodySchema
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace-openapi",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.3",
   "license": "MIT",
   "bin": {
     "enlace-openapi": "./dist/cli.mjs"
@@ -15,18 +15,17 @@
       "require": "./dist/index.js"
     }
   },
-  "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --max-warnings 0",
-    "prepublishOnly": "npm run build && npm run typecheck && npm run lint"
-  },
   "dependencies": {
     "commander": "^12.1.0",
     "typescript": "^5.9.2"
   },
   "devDependencies": {
     "@types/node": "^22.19.2"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --max-warnings 0"
   }
-}
+}