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

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

@@ -135,13 +135,11 @@ This generates:
 }
 ```
 
-## Endpoint Type
+## Endpoint Types
 
-The `Endpoint` type accepts three generic parameters:
+### `Endpoint<TData, TBody?, TError?>`
 
-```typescript
-Endpoint<TData, TBody?, TError?>
-```
+For endpoints with JSON body:
 
 | Parameter | Description |
 |-----------|-------------|
@@ -149,6 +147,112 @@ Endpoint<TData, TBody?, TError?>
 | `TBody` | Request body type (optional) |
 | `TError` | Error response type (optional) |
 
+### `EndpointWithQuery<TData, TQuery, TError?>`
+
+For endpoints with typed query parameters:
+
+```typescript
+import { EndpointWithQuery } from "enlace-core";
+
+type ApiSchema = {
+  users: {
+    $get: EndpointWithQuery<User[], { page: number; limit: number; search?: string }>;
+  };
+};
+```
+
+Generated OpenAPI:
+
+```json
+{
+  "/users": {
+    "get": {
+      "parameters": [
+        { "name": "page", "in": "query", "required": true, "schema": { "type": "number" } },
+        { "name": "limit", "in": "query", "required": true, "schema": { "type": "number" } },
+        { "name": "search", "in": "query", "required": false, "schema": { "type": "string" } }
+      ],
+      "responses": { "200": { "..." } }
+    }
+  }
+}
+```
+
+### `EndpointWithFormData<TData, TFormData, TError?>`
+
+For file upload endpoints (multipart/form-data):
+
+```typescript
+import { EndpointWithFormData } from "enlace-core";
+
+type ApiSchema = {
+  uploads: {
+    $post: EndpointWithFormData<Upload, { file: Blob | File; name: string }>;
+  };
+};
+```
+
+Generated OpenAPI:
+
+```json
+{
+  "/uploads": {
+    "post": {
+      "requestBody": {
+        "required": true,
+        "content": {
+          "multipart/form-data": {
+            "schema": {
+              "type": "object",
+              "properties": {
+                "file": { "type": "string", "format": "binary" },
+                "name": { "type": "string" }
+              },
+              "required": ["file", "name"]
+            }
+          }
+        }
+      },
+      "responses": { "200": { "..." } }
+    }
+  }
+}
+```
+
+### `EndpointFull<T>`
+
+Object-style for complex endpoints with multiple options:
+
+```typescript
+import { EndpointFull } from "enlace-core";
+
+type ApiSchema = {
+  products: {
+    $post: EndpointFull<{
+      data: Product;
+      body: CreateProduct;
+      query: { categoryId: string };
+      error: ValidationError;
+    }>;
+  };
+  files: {
+    $post: EndpointFull<{
+      data: FileUpload;
+      formData: { file: File; description: string };
+      query: { folder: string };
+    }>;
+  };
+};
+```
+
+| Property | Description | OpenAPI Mapping |
+|----------|-------------|-----------------|
+| `data` | Response data type | `responses.200.content` |
+| `body` | JSON request body | `requestBody` with `application/json` |
+| `query` | Query parameters | `parameters` with `in: "query"` |
+| `formData` | FormData fields | `requestBody` with `multipart/form-data` |
+| `error` | Error response type | `responses.400.content` |
+
 ## Path Parameters
 
 Use `_` to define dynamic path segments:
@@ -186,18 +290,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

@@ -33,14 +33,19 @@ var import_path = __toESM(require("path"));
 
 // src/type-to-schema.ts
 var import_typescript = __toESM(require("typescript"));
+var MAX_DEPTH = 50;
 function createSchemaContext(checker) {
   return {
     checker,
     schemas: /* @__PURE__ */ new Map(),
-    visitedTypes: /* @__PURE__ */ new Set()
+    visitedTypes: /* @__PURE__ */ new Set(),
+    depth: 0
   };
 }
 function typeToSchema(type, ctx) {
+  if (ctx.depth > MAX_DEPTH) {
+    return {};
+  }
   const { checker } = ctx;
   if (type.flags & import_typescript.default.TypeFlags.String) {
     return { type: "string" };
@@ -118,18 +123,18 @@ function typeToSchema(type, ctx) {
       return { type: "string", format: "date-time" };
     }
     if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
-      if (ctx.visitedTypes.has(type)) {
+      if (ctx.visitedTypes.has(typeName)) {
         return { $ref: `#/components/schemas/${typeName}` };
       }
       if (!ctx.schemas.has(typeName)) {
-        ctx.visitedTypes.add(type);
-        const schema = objectTypeToSchema(type, ctx);
+        ctx.visitedTypes.add(typeName);
+        const schema = objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
         ctx.schemas.set(typeName, schema);
-        ctx.visitedTypes.delete(type);
+        ctx.visitedTypes.delete(typeName);
       }
       return { $ref: `#/components/schemas/${typeName}` };
     }
-    return objectTypeToSchema(type, ctx);
+    return objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   return {};
 }
@@ -142,7 +147,7 @@ function objectTypeToSchema(type, ctx) {
     const propName = prop.getName();
     const propType = checker.getTypeOfSymbol(prop);
     const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
-    properties[propName] = typeToSchema(propType, ctx);
+    properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
     if (!isOptional) {
       required.push(propName);
     }
@@ -167,7 +172,7 @@ function intersectionTypeToSchema(type, ctx) {
       if (propName.startsWith("__")) continue;
       const propType = checker.getTypeOfSymbol(prop);
       const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
-      properties[propName] = typeToSchema(propType, ctx);
+      properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
       if (!isOptional && !required.includes(propName)) {
         required.push(propName);
       }
@@ -299,16 +304,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 +329,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 +469,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

@@ -10,14 +10,19 @@ import path from "path";
 
 // src/type-to-schema.ts
 import ts from "typescript";
+var MAX_DEPTH = 50;
 function createSchemaContext(checker) {
   return {
     checker,
     schemas: /* @__PURE__ */ new Map(),
-    visitedTypes: /* @__PURE__ */ new Set()
+    visitedTypes: /* @__PURE__ */ new Set(),
+    depth: 0
   };
 }
 function typeToSchema(type, ctx) {
+  if (ctx.depth > MAX_DEPTH) {
+    return {};
+  }
   const { checker } = ctx;
   if (type.flags & ts.TypeFlags.String) {
     return { type: "string" };
@@ -95,18 +100,18 @@ function typeToSchema(type, ctx) {
       return { type: "string", format: "date-time" };
     }
     if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
-      if (ctx.visitedTypes.has(type)) {
+      if (ctx.visitedTypes.has(typeName)) {
         return { $ref: `#/components/schemas/${typeName}` };
       }
       if (!ctx.schemas.has(typeName)) {
-        ctx.visitedTypes.add(type);
-        const schema = objectTypeToSchema(type, ctx);
+        ctx.visitedTypes.add(typeName);
+        const schema = objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
         ctx.schemas.set(typeName, schema);
-        ctx.visitedTypes.delete(type);
+        ctx.visitedTypes.delete(typeName);
       }
       return { $ref: `#/components/schemas/${typeName}` };
     }
-    return objectTypeToSchema(type, ctx);
+    return objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   return {};
 }
@@ -119,7 +124,7 @@ function objectTypeToSchema(type, ctx) {
     const propName = prop.getName();
     const propType = checker.getTypeOfSymbol(prop);
     const isOptional = prop.flags & ts.SymbolFlags.Optional;
-    properties[propName] = typeToSchema(propType, ctx);
+    properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
     if (!isOptional) {
       required.push(propName);
     }
@@ -144,7 +149,7 @@ function intersectionTypeToSchema(type, ctx) {
       if (propName.startsWith("__")) continue;
       const propType = checker.getTypeOfSymbol(prop);
       const isOptional = prop.flags & ts.SymbolFlags.Optional;
-      properties[propName] = typeToSchema(propType, ctx);
+      properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
       if (!isOptional && !required.includes(propName)) {
         required.push(propName);
       }
@@ -276,16 +281,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 +306,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 +446,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

@@ -41,14 +41,19 @@ var import_path = __toESM(require("path"));
 
 // src/type-to-schema.ts
 var import_typescript = __toESM(require("typescript"));
+var MAX_DEPTH = 50;
 function createSchemaContext(checker) {
   return {
     checker,
     schemas: /* @__PURE__ */ new Map(),
-    visitedTypes: /* @__PURE__ */ new Set()
+    visitedTypes: /* @__PURE__ */ new Set(),
+    depth: 0
   };
 }
 function typeToSchema(type, ctx) {
+  if (ctx.depth > MAX_DEPTH) {
+    return {};
+  }
   const { checker } = ctx;
   if (type.flags & import_typescript.default.TypeFlags.String) {
     return { type: "string" };
@@ -126,18 +131,18 @@ function typeToSchema(type, ctx) {
       return { type: "string", format: "date-time" };
     }
     if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
-      if (ctx.visitedTypes.has(type)) {
+      if (ctx.visitedTypes.has(typeName)) {
         return { $ref: `#/components/schemas/${typeName}` };
       }
       if (!ctx.schemas.has(typeName)) {
-        ctx.visitedTypes.add(type);
-        const schema = objectTypeToSchema(type, ctx);
+        ctx.visitedTypes.add(typeName);
+        const schema = objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
         ctx.schemas.set(typeName, schema);
-        ctx.visitedTypes.delete(type);
+        ctx.visitedTypes.delete(typeName);
       }
       return { $ref: `#/components/schemas/${typeName}` };
     }
-    return objectTypeToSchema(type, ctx);
+    return objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   return {};
 }
@@ -150,7 +155,7 @@ function objectTypeToSchema(type, ctx) {
     const propName = prop.getName();
     const propType = checker.getTypeOfSymbol(prop);
     const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
-    properties[propName] = typeToSchema(propType, ctx);
+    properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
     if (!isOptional) {
       required.push(propName);
     }
@@ -175,7 +180,7 @@ function intersectionTypeToSchema(type, ctx) {
       if (propName.startsWith("__")) continue;
       const propType = checker.getTypeOfSymbol(prop);
       const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
-      properties[propName] = typeToSchema(propType, ctx);
+      properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
       if (!isOptional && !required.includes(propName)) {
         required.push(propName);
       }
@@ -307,16 +312,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 +337,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 +477,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

@@ -4,14 +4,19 @@ import path from "path";
 
 // src/type-to-schema.ts
 import ts from "typescript";
+var MAX_DEPTH = 50;
 function createSchemaContext(checker) {
   return {
     checker,
     schemas: /* @__PURE__ */ new Map(),
-    visitedTypes: /* @__PURE__ */ new Set()
+    visitedTypes: /* @__PURE__ */ new Set(),
+    depth: 0
   };
 }
 function typeToSchema(type, ctx) {
+  if (ctx.depth > MAX_DEPTH) {
+    return {};
+  }
   const { checker } = ctx;
   if (type.flags & ts.TypeFlags.String) {
     return { type: "string" };
@@ -89,18 +94,18 @@ function typeToSchema(type, ctx) {
       return { type: "string", format: "date-time" };
     }
     if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
-      if (ctx.visitedTypes.has(type)) {
+      if (ctx.visitedTypes.has(typeName)) {
         return { $ref: `#/components/schemas/${typeName}` };
       }
       if (!ctx.schemas.has(typeName)) {
-        ctx.visitedTypes.add(type);
-        const schema = objectTypeToSchema(type, ctx);
+        ctx.visitedTypes.add(typeName);
+        const schema = objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
         ctx.schemas.set(typeName, schema);
-        ctx.visitedTypes.delete(type);
+        ctx.visitedTypes.delete(typeName);
       }
       return { $ref: `#/components/schemas/${typeName}` };
     }
-    return objectTypeToSchema(type, ctx);
+    return objectTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   return {};
 }
@@ -113,7 +118,7 @@ function objectTypeToSchema(type, ctx) {
     const propName = prop.getName();
     const propType = checker.getTypeOfSymbol(prop);
     const isOptional = prop.flags & ts.SymbolFlags.Optional;
-    properties[propName] = typeToSchema(propType, ctx);
+    properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
     if (!isOptional) {
       required.push(propName);
     }
@@ -138,7 +143,7 @@ function intersectionTypeToSchema(type, ctx) {
       if (propName.startsWith("__")) continue;
       const propType = checker.getTypeOfSymbol(prop);
       const isOptional = prop.flags & ts.SymbolFlags.Optional;
-      properties[propName] = typeToSchema(propType, ctx);
+      properties[propName] = typeToSchema(propType, { ...ctx, depth: ctx.depth + 1 });
       if (!isOptional && !required.includes(propName)) {
         required.push(propName);
       }
@@ -270,16 +275,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 +300,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 +440,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.4",
   "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"
   }
-}
+}