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

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:

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" };
@@ -79,7 +84,7 @@ function typeToSchema(type, ctx) {
     );
     const hasNull = type.types.some((t) => t.flags & import_typescript.default.TypeFlags.Null);
     if (nonNullTypes.length === 1 && hasNull) {
-      const schema = typeToSchema(nonNullTypes[0], ctx);
+      const schema = typeToSchema(nonNullTypes[0], { ...ctx, depth: ctx.depth + 1 });
       return { ...schema, nullable: true };
     }
     if (nonNullTypes.every((t) => t.isStringLiteral())) {
@@ -94,19 +99,20 @@ function typeToSchema(type, ctx) {
         enum: nonNullTypes.map((t) => t.value)
       };
     }
+    const nextCtx = { ...ctx, depth: ctx.depth + 1 };
     return {
-      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, nextCtx))
     };
   }
   if (type.isIntersection()) {
-    return intersectionTypeToSchema(type, ctx);
+    return intersectionTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   if (checker.isArrayType(type)) {
     const typeArgs = type.typeArguments;
     if (typeArgs?.[0]) {
       return {
         type: "array",
-        items: typeToSchema(typeArgs[0], ctx)
+        items: typeToSchema(typeArgs[0], { ...ctx, depth: ctx.depth + 1 })
       };
     }
     return { type: "array" };
@@ -118,18 +124,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 +148,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 +173,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);
       }

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" };
@@ -56,7 +61,7 @@ function typeToSchema(type, ctx) {
     );
     const hasNull = type.types.some((t) => t.flags & ts.TypeFlags.Null);
     if (nonNullTypes.length === 1 && hasNull) {
-      const schema = typeToSchema(nonNullTypes[0], ctx);
+      const schema = typeToSchema(nonNullTypes[0], { ...ctx, depth: ctx.depth + 1 });
       return { ...schema, nullable: true };
     }
     if (nonNullTypes.every((t) => t.isStringLiteral())) {
@@ -71,19 +76,20 @@ function typeToSchema(type, ctx) {
         enum: nonNullTypes.map((t) => t.value)
       };
     }
+    const nextCtx = { ...ctx, depth: ctx.depth + 1 };
     return {
-      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, nextCtx))
     };
   }
   if (type.isIntersection()) {
-    return intersectionTypeToSchema(type, ctx);
+    return intersectionTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   if (checker.isArrayType(type)) {
     const typeArgs = type.typeArguments;
     if (typeArgs?.[0]) {
       return {
         type: "array",
-        items: typeToSchema(typeArgs[0], ctx)
+        items: typeToSchema(typeArgs[0], { ...ctx, depth: ctx.depth + 1 })
       };
     }
     return { type: "array" };
@@ -95,18 +101,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 +125,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 +150,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);
       }

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" };
@@ -87,7 +92,7 @@ function typeToSchema(type, ctx) {
     );
     const hasNull = type.types.some((t) => t.flags & import_typescript.default.TypeFlags.Null);
     if (nonNullTypes.length === 1 && hasNull) {
-      const schema = typeToSchema(nonNullTypes[0], ctx);
+      const schema = typeToSchema(nonNullTypes[0], { ...ctx, depth: ctx.depth + 1 });
       return { ...schema, nullable: true };
     }
     if (nonNullTypes.every((t) => t.isStringLiteral())) {
@@ -102,19 +107,20 @@ function typeToSchema(type, ctx) {
         enum: nonNullTypes.map((t) => t.value)
       };
     }
+    const nextCtx = { ...ctx, depth: ctx.depth + 1 };
     return {
-      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, nextCtx))
     };
   }
   if (type.isIntersection()) {
-    return intersectionTypeToSchema(type, ctx);
+    return intersectionTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   if (checker.isArrayType(type)) {
     const typeArgs = type.typeArguments;
     if (typeArgs?.[0]) {
       return {
         type: "array",
-        items: typeToSchema(typeArgs[0], ctx)
+        items: typeToSchema(typeArgs[0], { ...ctx, depth: ctx.depth + 1 })
       };
     }
     return { type: "array" };
@@ -126,18 +132,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 +156,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 +181,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);
       }

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" };
@@ -50,7 +55,7 @@ function typeToSchema(type, ctx) {
     );
     const hasNull = type.types.some((t) => t.flags & ts.TypeFlags.Null);
     if (nonNullTypes.length === 1 && hasNull) {
-      const schema = typeToSchema(nonNullTypes[0], ctx);
+      const schema = typeToSchema(nonNullTypes[0], { ...ctx, depth: ctx.depth + 1 });
       return { ...schema, nullable: true };
     }
     if (nonNullTypes.every((t) => t.isStringLiteral())) {
@@ -65,19 +70,20 @@ function typeToSchema(type, ctx) {
         enum: nonNullTypes.map((t) => t.value)
       };
     }
+    const nextCtx = { ...ctx, depth: ctx.depth + 1 };
     return {
-      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, nextCtx))
     };
   }
   if (type.isIntersection()) {
-    return intersectionTypeToSchema(type, ctx);
+    return intersectionTypeToSchema(type, { ...ctx, depth: ctx.depth + 1 });
   }
   if (checker.isArrayType(type)) {
     const typeArgs = type.typeArguments;
     if (typeArgs?.[0]) {
       return {
         type: "array",
-        items: typeToSchema(typeArgs[0], ctx)
+        items: typeToSchema(typeArgs[0], { ...ctx, depth: ctx.depth + 1 })
       };
     }
     return { type: "array" };
@@ -89,18 +95,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 +119,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 +144,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);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace-openapi",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.5",
   "license": "MIT",
   "bin": {
     "enlace-openapi": "./dist/cli.mjs"