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

package/README.md

@@ -0,0 +1,213 @@
+# enlace-openapi
+
+Generate OpenAPI 3.0 specifications from TypeScript API schema types.
+
+## Installation
+
+```bash
+pnpm add enlace-openapi
+```
+
+## Usage
+
+### CLI
+
+```bash
+enlace-openapi --schema ./types/APISchema.ts --output ./openapi.json
+```
+
+### Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-s, --schema <path>` | Path to TypeScript schema file | (required) |
+| `-t, --type <name>` | Schema type name to export | `ApiSchema` |
+| `-o, --output <path>` | Output file path | stdout |
+| `--title <title>` | API title | `API` |
+| `--version <version>` | API version | `1.0.0` |
+| `--base-url <url>` | Base URL for servers array | - |
+
+### Example
+
+```bash
+enlace-openapi \
+  --schema ./types/APISchema.ts \
+  --type ApiSchema \
+  --title "My API" \
+  --version "2.0.0" \
+  --base-url "https://api.example.com" \
+  --output ./openapi.json
+```
+
+## Schema Format
+
+Define your API schema using the `Endpoint` type from `enlace-core`:
+
+```typescript
+import { Endpoint } from "enlace-core";
+
+type User = {
+  id: string;
+  name: string;
+  email: string;
+};
+
+type CreateUserBody = {
+  name: string;
+  email: string;
+};
+
+type ValidationError = {
+  field: string;
+  message: string;
+};
+
+export type ApiSchema = {
+  users: {
+    $get: Endpoint<User[]>;
+    $post: Endpoint<User, CreateUserBody, ValidationError>;
+    _: {
+      $get: Endpoint<User>;
+      $put: Endpoint<User, Partial<CreateUserBody>>;
+      $delete: Endpoint<{ success: boolean }>;
+    };
+  };
+};
+```
+
+This generates:
+
+```json
+{
+  "openapi": "3.0.0",
+  "info": { "title": "My API", "version": "2.0.0" },
+  "servers": [{ "url": "https://api.example.com" }],
+  "paths": {
+    "/users": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "content": {
+              "application/json": {
+                "schema": { "type": "array", "items": { "$ref": "#/components/schemas/User" } }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": { "$ref": "#/components/schemas/CreateUserBody" }
+            }
+          }
+        },
+        "responses": {
+          "200": { "..." },
+          "400": {
+            "description": "Error response",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/ValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/users/{userId}": {
+      "parameters": [{ "name": "userId", "in": "path", "required": true, "schema": { "type": "string" } }],
+      "get": { "..." },
+      "put": { "..." },
+      "delete": { "..." }
+    }
+  },
+  "components": {
+    "schemas": {
+      "User": { "..." },
+      "CreateUserBody": { "..." },
+      "ValidationError": { "..." }
+    }
+  }
+}
+```
+
+## Endpoint Type
+
+The `Endpoint` type accepts three generic parameters:
+
+```typescript
+Endpoint<TData, TBody?, TError?>
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `TData` | Response data type (required) |
+| `TBody` | Request body type (optional) |
+| `TError` | Error response type (optional) |
+
+## Path Parameters
+
+Use `_` to define dynamic path segments:
+
+```typescript
+type ApiSchema = {
+  users: {
+    _: {
+      // /users/{userId}
+      posts: {
+        _: {
+          // /users/{userId}/posts/{postId}
+          $get: Endpoint<Post>;
+        };
+      };
+    };
+  };
+};
+```
+
+Parameter names are auto-generated from the parent segment (e.g., `users` → `userId`, `posts` → `postId`).
+
+## Supported Types
+
+- Primitives: `string`, `number`, `boolean`, `null`
+- Literals: `"active"`, `42`, `true`
+- Arrays: `User[]`, `Array<User>`
+- Objects: `{ name: string; age: number }`
+- Optional properties: `{ name?: string }`
+- Nullable: `string | null`
+- Unions: `"pending" | "active" | "inactive"`
+- Intersections: `BaseUser & { role: string }`
+- Date: converted to `{ type: "string", format: "date-time" }`
+- Named types: extracted to `#/components/schemas`
+
+## Programmatic API
+
+```typescript
+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",
+});
+
+console.log(JSON.stringify(spec, null, 2));
+```
+
+## Viewing the OpenAPI Spec
+
+Use [Swagger UI](https://swagger.io/tools/swagger-ui/) or [Swagger Editor](https://editor.swagger.io/) to visualize the generated spec.
+
+Quick local preview with Docker:
+
+```bash
+docker run -p 8080:8080 -e SWAGGER_JSON=/openapi.json -v $(pwd)/openapi.json:/openapi.json swaggerapi/swagger-ui
+```
+
+Then open http://localhost:8080

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_fs = __toESM(require("fs"));
+
+// src/parser.ts
+var import_typescript2 = __toESM(require("typescript"));
+var import_path = __toESM(require("path"));
+
+// src/type-to-schema.ts
+var import_typescript = __toESM(require("typescript"));
+function createSchemaContext(checker) {
+  return {
+    checker,
+    schemas: /* @__PURE__ */ new Map(),
+    visitedTypes: /* @__PURE__ */ new Set()
+  };
+}
+function typeToSchema(type, ctx) {
+  const { checker } = ctx;
+  if (type.flags & import_typescript.default.TypeFlags.String) {
+    return { type: "string" };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Number) {
+    return { type: "number" };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Boolean) {
+    return { type: "boolean" };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Null) {
+    return { type: "null" };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Undefined || type.flags & import_typescript.default.TypeFlags.Void) {
+    return {};
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Any || type.flags & import_typescript.default.TypeFlags.Unknown) {
+    return {};
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Never) {
+    return {};
+  }
+  if (type.isStringLiteral()) {
+    return { type: "string", const: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { type: "number", const: type.value };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.BooleanLiteral) {
+    const intrinsicName = type.intrinsicName;
+    return { type: "boolean", const: intrinsicName === "true" };
+  }
+  if (type.isUnion()) {
+    const nonNullTypes = type.types.filter(
+      (t) => !(t.flags & import_typescript.default.TypeFlags.Null) && !(t.flags & import_typescript.default.TypeFlags.Undefined)
+    );
+    const hasNull = type.types.some((t) => t.flags & import_typescript.default.TypeFlags.Null);
+    if (nonNullTypes.length === 1 && hasNull) {
+      const schema = typeToSchema(nonNullTypes[0], ctx);
+      return { ...schema, nullable: true };
+    }
+    if (nonNullTypes.every((t) => t.isStringLiteral())) {
+      return {
+        type: "string",
+        enum: nonNullTypes.map((t) => t.value)
+      };
+    }
+    if (nonNullTypes.every((t) => t.isNumberLiteral())) {
+      return {
+        type: "number",
+        enum: nonNullTypes.map((t) => t.value)
+      };
+    }
+    return {
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+    };
+  }
+  if (type.isIntersection()) {
+    return intersectionTypeToSchema(type, ctx);
+  }
+  if (checker.isArrayType(type)) {
+    const typeArgs = type.typeArguments;
+    if (typeArgs?.[0]) {
+      return {
+        type: "array",
+        items: typeToSchema(typeArgs[0], ctx)
+      };
+    }
+    return { type: "array" };
+  }
+  if (type.flags & import_typescript.default.TypeFlags.Object) {
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const typeName = symbol?.getName();
+    if (typeName === "Date") {
+      return { type: "string", format: "date-time" };
+    }
+    if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
+      if (ctx.visitedTypes.has(type)) {
+        return { $ref: `#/components/schemas/${typeName}` };
+      }
+      if (!ctx.schemas.has(typeName)) {
+        ctx.visitedTypes.add(type);
+        const schema = objectTypeToSchema(type, ctx);
+        ctx.schemas.set(typeName, schema);
+        ctx.visitedTypes.delete(type);
+      }
+      return { $ref: `#/components/schemas/${typeName}` };
+    }
+    return objectTypeToSchema(type, ctx);
+  }
+  return {};
+}
+function objectTypeToSchema(type, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = type.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
+    properties[propName] = typeToSchema(propType, ctx);
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+function intersectionTypeToSchema(type, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  for (const t of type.types) {
+    const props = t.getProperties();
+    for (const prop of props) {
+      const propName = prop.getName();
+      if (propName.startsWith("__")) continue;
+      const propType = checker.getTypeOfSymbol(prop);
+      const isOptional = prop.flags & import_typescript.default.SymbolFlags.Optional;
+      properties[propName] = typeToSchema(propType, ctx);
+      if (!isOptional && !required.includes(propName)) {
+        required.push(propName);
+      }
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+
+// src/parser.ts
+var HTTP_METHODS = ["$get", "$post", "$put", "$patch", "$delete"];
+function isHttpMethod(key) {
+  return HTTP_METHODS.includes(key);
+}
+function methodKeyToHttp(key) {
+  return key.slice(1);
+}
+function parseSchema(schemaFilePath, typeName) {
+  const absolutePath = import_path.default.resolve(schemaFilePath);
+  const schemaDir = import_path.default.dirname(absolutePath);
+  const configPath = import_typescript2.default.findConfigFile(schemaDir, import_typescript2.default.sys.fileExists, "tsconfig.json");
+  let compilerOptions = {
+    target: import_typescript2.default.ScriptTarget.ESNext,
+    module: import_typescript2.default.ModuleKind.NodeNext,
+    moduleResolution: import_typescript2.default.ModuleResolutionKind.NodeNext,
+    strict: true
+  };
+  if (configPath) {
+    const configFile = import_typescript2.default.readConfigFile(configPath, import_typescript2.default.sys.readFile);
+    if (!configFile.error) {
+      const parsed = import_typescript2.default.parseJsonConfigFileContent(
+        configFile.config,
+        import_typescript2.default.sys,
+        import_path.default.dirname(configPath)
+      );
+      compilerOptions = { ...compilerOptions, ...parsed.options };
+    }
+  }
+  const program2 = import_typescript2.default.createProgram([absolutePath], compilerOptions);
+  const checker = program2.getTypeChecker();
+  const sourceFile = program2.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  const schemaType = findExportedType(sourceFile, typeName, checker);
+  if (!schemaType) {
+    throw new Error(`Could not find exported type '${typeName}' in ${schemaFilePath}`);
+  }
+  const ctx = createSchemaContext(checker);
+  const endpoints = [];
+  walkSchemaType(schemaType, "", [], ctx, endpoints, checker);
+  return {
+    endpoints,
+    schemas: ctx.schemas
+  };
+}
+function findExportedType(sourceFile, typeName, checker) {
+  const symbol = checker.getSymbolAtLocation(sourceFile);
+  if (!symbol) return void 0;
+  const exports2 = checker.getExportsOfModule(symbol);
+  const typeSymbol = exports2.find((exp) => exp.getName() === typeName);
+  if (!typeSymbol) return void 0;
+  const declaredType = checker.getDeclaredTypeOfSymbol(typeSymbol);
+  return declaredType;
+}
+function walkSchemaType(type, currentPath, pathParams, ctx, endpoints, checker) {
+  const properties = type.getProperties();
+  for (const prop of properties) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    if (isHttpMethod(propName)) {
+      const endpoint = parseEndpoint(
+        propType,
+        currentPath || "/",
+        methodKeyToHttp(propName),
+        pathParams,
+        ctx
+      );
+      endpoints.push(endpoint);
+    } else if (propName === "_") {
+      const paramName = getParamNameFromPath(currentPath);
+      const newPath = `${currentPath}/{${paramName}}`;
+      walkSchemaType(propType, newPath, [...pathParams, paramName], ctx, endpoints, checker);
+    } else {
+      const newPath = `${currentPath}/${propName}`;
+      walkSchemaType(propType, newPath, pathParams, ctx, endpoints, checker);
+    }
+  }
+}
+function getParamNameFromPath(currentPath) {
+  const segments = currentPath.split("/").filter(Boolean);
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment) {
+    const singular = lastSegment.endsWith("s") ? lastSegment.slice(0, -1) : lastSegment;
+    return `${singular}Id`;
+  }
+  return "id";
+}
+function parseEndpoint(type, path2, method, pathParams, ctx) {
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      if (isEndpointStructure(t)) {
+        return parseEndpointType(type, path2, method, pathParams, ctx);
+      }
+    }
+  }
+  if (isEndpointStructure(type)) {
+    return parseEndpointType(type, path2, method, pathParams, ctx);
+  }
+  return {
+    path: path2,
+    method,
+    responseSchema: typeToSchema(type, ctx),
+    pathParams
+  };
+}
+function isEndpointStructure(type) {
+  const props = type.getProperties();
+  const propNames = new Set(props.map((p) => p.getName()));
+  if (!propNames.has("data")) {
+    return false;
+  }
+  propNames.delete("data");
+  propNames.delete("body");
+  propNames.delete("error");
+  const remainingProps = [...propNames].filter(
+    (name) => !name.startsWith("__@") && !name.includes("Brand")
+  );
+  return remainingProps.length === 0;
+}
+function parseEndpointType(type, path2, method, pathParams, ctx) {
+  const { checker } = ctx;
+  let dataType;
+  let bodyType;
+  let errorType;
+  const typesToCheck = type.isIntersection() ? type.types : [type];
+  for (const t of typesToCheck) {
+    const props = t.getProperties();
+    for (const prop of props) {
+      const name = prop.getName();
+      if (name === "data") {
+        dataType = checker.getTypeOfSymbol(prop);
+      } else if (name === "body") {
+        bodyType = checker.getTypeOfSymbol(prop);
+      } else if (name === "error") {
+        errorType = checker.getTypeOfSymbol(prop);
+      }
+    }
+  }
+  const endpoint = {
+    path: path2,
+    method,
+    responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
+    pathParams
+  };
+  if (bodyType && !(bodyType.flags & import_typescript2.default.TypeFlags.Never)) {
+    endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+  }
+  if (errorType && !(errorType.flags & import_typescript2.default.TypeFlags.Never) && !(errorType.flags & import_typescript2.default.TypeFlags.Unknown)) {
+    endpoint.errorSchema = typeToSchema(errorType, ctx);
+  }
+  return endpoint;
+}
+
+// src/generator.ts
+function generateOpenAPISpec(endpoints, schemas, options = {}) {
+  const {
+    title = "API",
+    version = "1.0.0",
+    description,
+    baseUrl
+  } = options;
+  const paths = {};
+  for (const endpoint of endpoints) {
+    if (!paths[endpoint.path]) {
+      paths[endpoint.path] = {};
+    }
+    const pathItem = paths[endpoint.path];
+    const operation = createOperation(endpoint);
+    pathItem[endpoint.method] = operation;
+    if (endpoint.pathParams.length > 0 && !pathItem.parameters) {
+      pathItem.parameters = endpoint.pathParams.map((param) => ({
+        name: param,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      }));
+    }
+  }
+  const spec = {
+    openapi: "3.0.0",
+    info: {
+      title,
+      version
+    },
+    paths
+  };
+  if (description) {
+    spec.info.description = description;
+  }
+  if (baseUrl) {
+    spec.servers = [{ url: baseUrl }];
+  }
+  if (schemas.size > 0) {
+    spec.components = {
+      schemas: Object.fromEntries(schemas)
+    };
+  }
+  return spec;
+}
+function createOperation(endpoint) {
+  const operation = {
+    responses: {
+      "200": {
+        description: "Successful response"
+      }
+    }
+  };
+  if (hasContent(endpoint.responseSchema)) {
+    operation.responses["200"].content = {
+      "application/json": {
+        schema: endpoint.responseSchema
+      }
+    };
+  }
+  if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    operation.requestBody = {
+      required: true,
+      content: {
+        "application/json": {
+          schema: endpoint.requestBodySchema
+        }
+      }
+    };
+  }
+  if (endpoint.errorSchema && hasContent(endpoint.errorSchema)) {
+    operation.responses["400"] = {
+      description: "Error response",
+      content: {
+        "application/json": {
+          schema: endpoint.errorSchema
+        }
+      }
+    };
+  }
+  return operation;
+}
+function hasContent(schema) {
+  return Object.keys(schema).length > 0;
+}
+
+// src/cli.ts
+import_commander.program.name("enlace-openapi").description("Generate OpenAPI spec from TypeScript API schema").requiredOption("-s, --schema <path>", "Path to TypeScript file containing the schema type").option("-t, --type <name>", "Name of the schema type to use", "ApiSchema").option("-o, --output <path>", "Output file path (default: stdout)").option("--title <title>", "API title for OpenAPI info").option("--version <version>", "API version for OpenAPI info", "1.0.0").option("--base-url <url>", "Base URL for servers array").action((options) => {
+  try {
+    const { endpoints, schemas } = parseSchema(options.schema, options.type);
+    const spec = generateOpenAPISpec(endpoints, schemas, {
+      title: options.title,
+      version: options.version,
+      baseUrl: options.baseUrl
+    });
+    const output = JSON.stringify(spec, null, 2);
+    if (options.output) {
+      import_fs.default.writeFileSync(options.output, output);
+      console.log(`OpenAPI spec written to ${options.output}`);
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+import_commander.program.parse();

package/dist/cli.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { program } from "commander";
+import fs from "fs";
+
+// src/parser.ts
+import ts2 from "typescript";
+import path from "path";
+
+// src/type-to-schema.ts
+import ts from "typescript";
+function createSchemaContext(checker) {
+  return {
+    checker,
+    schemas: /* @__PURE__ */ new Map(),
+    visitedTypes: /* @__PURE__ */ new Set()
+  };
+}
+function typeToSchema(type, ctx) {
+  const { checker } = ctx;
+  if (type.flags & ts.TypeFlags.String) {
+    return { type: "string" };
+  }
+  if (type.flags & ts.TypeFlags.Number) {
+    return { type: "number" };
+  }
+  if (type.flags & ts.TypeFlags.Boolean) {
+    return { type: "boolean" };
+  }
+  if (type.flags & ts.TypeFlags.Null) {
+    return { type: "null" };
+  }
+  if (type.flags & ts.TypeFlags.Undefined || type.flags & ts.TypeFlags.Void) {
+    return {};
+  }
+  if (type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown) {
+    return {};
+  }
+  if (type.flags & ts.TypeFlags.Never) {
+    return {};
+  }
+  if (type.isStringLiteral()) {
+    return { type: "string", const: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { type: "number", const: type.value };
+  }
+  if (type.flags & ts.TypeFlags.BooleanLiteral) {
+    const intrinsicName = type.intrinsicName;
+    return { type: "boolean", const: intrinsicName === "true" };
+  }
+  if (type.isUnion()) {
+    const nonNullTypes = type.types.filter(
+      (t) => !(t.flags & ts.TypeFlags.Null) && !(t.flags & ts.TypeFlags.Undefined)
+    );
+    const hasNull = type.types.some((t) => t.flags & ts.TypeFlags.Null);
+    if (nonNullTypes.length === 1 && hasNull) {
+      const schema = typeToSchema(nonNullTypes[0], ctx);
+      return { ...schema, nullable: true };
+    }
+    if (nonNullTypes.every((t) => t.isStringLiteral())) {
+      return {
+        type: "string",
+        enum: nonNullTypes.map((t) => t.value)
+      };
+    }
+    if (nonNullTypes.every((t) => t.isNumberLiteral())) {
+      return {
+        type: "number",
+        enum: nonNullTypes.map((t) => t.value)
+      };
+    }
+    return {
+      oneOf: nonNullTypes.map((t) => typeToSchema(t, ctx))
+    };
+  }
+  if (type.isIntersection()) {
+    return intersectionTypeToSchema(type, ctx);
+  }
+  if (checker.isArrayType(type)) {
+    const typeArgs = type.typeArguments;
+    if (typeArgs?.[0]) {
+      return {
+        type: "array",
+        items: typeToSchema(typeArgs[0], ctx)
+      };
+    }
+    return { type: "array" };
+  }
+  if (type.flags & ts.TypeFlags.Object) {
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const typeName = symbol?.getName();
+    if (typeName === "Date") {
+      return { type: "string", format: "date-time" };
+    }
+    if (typeName && typeName !== "__type" && typeName !== "Array" && !typeName.startsWith("__")) {
+      if (ctx.visitedTypes.has(type)) {
+        return { $ref: `#/components/schemas/${typeName}` };
+      }
+      if (!ctx.schemas.has(typeName)) {
+        ctx.visitedTypes.add(type);
+        const schema = objectTypeToSchema(type, ctx);
+        ctx.schemas.set(typeName, schema);
+        ctx.visitedTypes.delete(type);
+      }
+      return { $ref: `#/components/schemas/${typeName}` };
+    }
+    return objectTypeToSchema(type, ctx);
+  }
+  return {};
+}
+function objectTypeToSchema(type, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  const props = type.getProperties();
+  for (const prop of props) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    const isOptional = prop.flags & ts.SymbolFlags.Optional;
+    properties[propName] = typeToSchema(propType, ctx);
+    if (!isOptional) {
+      required.push(propName);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+function intersectionTypeToSchema(type, ctx) {
+  const { checker } = ctx;
+  const properties = {};
+  const required = [];
+  for (const t of type.types) {
+    const props = t.getProperties();
+    for (const prop of props) {
+      const propName = prop.getName();
+      if (propName.startsWith("__")) continue;
+      const propType = checker.getTypeOfSymbol(prop);
+      const isOptional = prop.flags & ts.SymbolFlags.Optional;
+      properties[propName] = typeToSchema(propType, ctx);
+      if (!isOptional && !required.includes(propName)) {
+        required.push(propName);
+      }
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+
+// src/parser.ts
+var HTTP_METHODS = ["$get", "$post", "$put", "$patch", "$delete"];
+function isHttpMethod(key) {
+  return HTTP_METHODS.includes(key);
+}
+function methodKeyToHttp(key) {
+  return key.slice(1);
+}
+function parseSchema(schemaFilePath, typeName) {
+  const absolutePath = path.resolve(schemaFilePath);
+  const schemaDir = path.dirname(absolutePath);
+  const configPath = ts2.findConfigFile(schemaDir, ts2.sys.fileExists, "tsconfig.json");
+  let compilerOptions = {
+    target: ts2.ScriptTarget.ESNext,
+    module: ts2.ModuleKind.NodeNext,
+    moduleResolution: ts2.ModuleResolutionKind.NodeNext,
+    strict: true
+  };
+  if (configPath) {
+    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    if (!configFile.error) {
+      const parsed = ts2.parseJsonConfigFileContent(
+        configFile.config,
+        ts2.sys,
+        path.dirname(configPath)
+      );
+      compilerOptions = { ...compilerOptions, ...parsed.options };
+    }
+  }
+  const program2 = ts2.createProgram([absolutePath], compilerOptions);
+  const checker = program2.getTypeChecker();
+  const sourceFile = program2.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  const schemaType = findExportedType(sourceFile, typeName, checker);
+  if (!schemaType) {
+    throw new Error(`Could not find exported type '${typeName}' in ${schemaFilePath}`);
+  }
+  const ctx = createSchemaContext(checker);
+  const endpoints = [];
+  walkSchemaType(schemaType, "", [], ctx, endpoints, checker);
+  return {
+    endpoints,
+    schemas: ctx.schemas
+  };
+}
+function findExportedType(sourceFile, typeName, checker) {
+  const symbol = checker.getSymbolAtLocation(sourceFile);
+  if (!symbol) return void 0;
+  const exports = checker.getExportsOfModule(symbol);
+  const typeSymbol = exports.find((exp) => exp.getName() === typeName);
+  if (!typeSymbol) return void 0;
+  const declaredType = checker.getDeclaredTypeOfSymbol(typeSymbol);
+  return declaredType;
+}
+function walkSchemaType(type, currentPath, pathParams, ctx, endpoints, checker) {
+  const properties = type.getProperties();
+  for (const prop of properties) {
+    const propName = prop.getName();
+    const propType = checker.getTypeOfSymbol(prop);
+    if (isHttpMethod(propName)) {
+      const endpoint = parseEndpoint(
+        propType,
+        currentPath || "/",
+        methodKeyToHttp(propName),
+        pathParams,
+        ctx
+      );
+      endpoints.push(endpoint);
+    } else if (propName === "_") {
+      const paramName = getParamNameFromPath(currentPath);
+      const newPath = `${currentPath}/{${paramName}}`;
+      walkSchemaType(propType, newPath, [...pathParams, paramName], ctx, endpoints, checker);
+    } else {
+      const newPath = `${currentPath}/${propName}`;
+      walkSchemaType(propType, newPath, pathParams, ctx, endpoints, checker);
+    }
+  }
+}
+function getParamNameFromPath(currentPath) {
+  const segments = currentPath.split("/").filter(Boolean);
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment) {
+    const singular = lastSegment.endsWith("s") ? lastSegment.slice(0, -1) : lastSegment;
+    return `${singular}Id`;
+  }
+  return "id";
+}
+function parseEndpoint(type, path2, method, pathParams, ctx) {
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      if (isEndpointStructure(t)) {
+        return parseEndpointType(type, path2, method, pathParams, ctx);
+      }
+    }
+  }
+  if (isEndpointStructure(type)) {
+    return parseEndpointType(type, path2, method, pathParams, ctx);
+  }
+  return {
+    path: path2,
+    method,
+    responseSchema: typeToSchema(type, ctx),
+    pathParams
+  };
+}
+function isEndpointStructure(type) {
+  const props = type.getProperties();
+  const propNames = new Set(props.map((p) => p.getName()));
+  if (!propNames.has("data")) {
+    return false;
+  }
+  propNames.delete("data");
+  propNames.delete("body");
+  propNames.delete("error");
+  const remainingProps = [...propNames].filter(
+    (name) => !name.startsWith("__@") && !name.includes("Brand")
+  );
+  return remainingProps.length === 0;
+}
+function parseEndpointType(type, path2, method, pathParams, ctx) {
+  const { checker } = ctx;
+  let dataType;
+  let bodyType;
+  let errorType;
+  const typesToCheck = type.isIntersection() ? type.types : [type];
+  for (const t of typesToCheck) {
+    const props = t.getProperties();
+    for (const prop of props) {
+      const name = prop.getName();
+      if (name === "data") {
+        dataType = checker.getTypeOfSymbol(prop);
+      } else if (name === "body") {
+        bodyType = checker.getTypeOfSymbol(prop);
+      } else if (name === "error") {
+        errorType = checker.getTypeOfSymbol(prop);
+      }
+    }
+  }
+  const endpoint = {
+    path: path2,
+    method,
+    responseSchema: dataType ? typeToSchema(dataType, ctx) : {},
+    pathParams
+  };
+  if (bodyType && !(bodyType.flags & ts2.TypeFlags.Never)) {
+    endpoint.requestBodySchema = typeToSchema(bodyType, ctx);
+  }
+  if (errorType && !(errorType.flags & ts2.TypeFlags.Never) && !(errorType.flags & ts2.TypeFlags.Unknown)) {
+    endpoint.errorSchema = typeToSchema(errorType, ctx);
+  }
+  return endpoint;
+}
+
+// src/generator.ts
+function generateOpenAPISpec(endpoints, schemas, options = {}) {
+  const {
+    title = "API",
+    version = "1.0.0",
+    description,
+    baseUrl
+  } = options;
+  const paths = {};
+  for (const endpoint of endpoints) {
+    if (!paths[endpoint.path]) {
+      paths[endpoint.path] = {};
+    }
+    const pathItem = paths[endpoint.path];
+    const operation = createOperation(endpoint);
+    pathItem[endpoint.method] = operation;
+    if (endpoint.pathParams.length > 0 && !pathItem.parameters) {
+      pathItem.parameters = endpoint.pathParams.map((param) => ({
+        name: param,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      }));
+    }
+  }
+  const spec = {
+    openapi: "3.0.0",
+    info: {
+      title,
+      version
+    },
+    paths
+  };
+  if (description) {
+    spec.info.description = description;
+  }
+  if (baseUrl) {
+    spec.servers = [{ url: baseUrl }];
+  }
+  if (schemas.size > 0) {
+    spec.components = {
+      schemas: Object.fromEntries(schemas)
+    };
+  }
+  return spec;
+}
+function createOperation(endpoint) {
+  const operation = {
+    responses: {
+      "200": {
+        description: "Successful response"
+      }
+    }
+  };
+  if (hasContent(endpoint.responseSchema)) {
+    operation.responses["200"].content = {
+      "application/json": {
+        schema: endpoint.responseSchema
+      }
+    };
+  }
+  if (endpoint.requestBodySchema && hasContent(endpoint.requestBodySchema)) {
+    operation.requestBody = {
+      required: true,
+      content: {
+        "application/json": {
+          schema: endpoint.requestBodySchema
+        }
+      }
+    };
+  }
+  if (endpoint.errorSchema && hasContent(endpoint.errorSchema)) {
+    operation.responses["400"] = {
+      description: "Error response",
+      content: {
+        "application/json": {
+          schema: endpoint.errorSchema
+        }
+      }
+    };
+  }
+  return operation;
+}
+function hasContent(schema) {
+  return Object.keys(schema).length > 0;
+}
+
+// src/cli.ts
+program.name("enlace-openapi").description("Generate OpenAPI spec from TypeScript API schema").requiredOption("-s, --schema <path>", "Path to TypeScript file containing the schema type").option("-t, --type <name>", "Name of the schema type to use", "ApiSchema").option("-o, --output <path>", "Output file path (default: stdout)").option("--title <title>", "API title for OpenAPI info").option("--version <version>", "API version for OpenAPI info", "1.0.0").option("--base-url <url>", "Base URL for servers array").action((options) => {
+  try {
+    const { endpoints, schemas } = parseSchema(options.schema, options.type);
+    const spec = generateOpenAPISpec(endpoints, schemas, {
+      title: options.title,
+      version: options.version,
+      baseUrl: options.baseUrl
+    });
+    const output = JSON.stringify(spec, null, 2);
+    if (options.output) {
+      fs.writeFileSync(options.output, output);
+      console.log(`OpenAPI spec written to ${options.output}`);
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/index.d.mts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 type JSONSchema = {
     type?: string;
     items?: JSONSchema;

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 type JSONSchema = {
     type?: string;
     items?: JSONSchema;

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -35,8 +34,6 @@ __export(src_exports, {
   parseSchema: () => parseSchema
 });
 module.exports = __toCommonJS(src_exports);
-var import_commander = require("commander");
-var import_fs = __toESM(require("fs"));
 
 // src/parser.ts
 var import_typescript2 = __toESM(require("typescript"));
@@ -223,9 +220,9 @@ function parseSchema(schemaFilePath, typeName) {
       compilerOptions = { ...compilerOptions, ...parsed.options };
     }
   }
-  const program2 = import_typescript2.default.createProgram([absolutePath], compilerOptions);
-  const checker = program2.getTypeChecker();
-  const sourceFile = program2.getSourceFile(absolutePath);
+  const program = import_typescript2.default.createProgram([absolutePath], compilerOptions);
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(absolutePath);
   if (!sourceFile) {
     throw new Error(`Could not find source file: ${absolutePath}`);
   }
@@ -435,29 +432,6 @@ function createOperation(endpoint) {
 function hasContent(schema) {
   return Object.keys(schema).length > 0;
 }
-
-// src/index.ts
-import_commander.program.name("enlace-openapi").description("Generate OpenAPI spec from TypeScript API schema").requiredOption("-s, --schema <path>", "Path to TypeScript file containing the schema type").option("-t, --type <name>", "Name of the schema type to use", "ApiSchema").option("-o, --output <path>", "Output file path (default: stdout)").option("--title <title>", "API title for OpenAPI info").option("--version <version>", "API version for OpenAPI info", "1.0.0").option("--base-url <url>", "Base URL for servers array").action((options) => {
-  try {
-    const { endpoints, schemas } = parseSchema(options.schema, options.type);
-    const spec = generateOpenAPISpec(endpoints, schemas, {
-      title: options.title,
-      version: options.version,
-      baseUrl: options.baseUrl
-    });
-    const output = JSON.stringify(spec, null, 2);
-    if (options.output) {
-      import_fs.default.writeFileSync(options.output, output);
-      console.log(`OpenAPI spec written to ${options.output}`);
-    } else {
-      console.log(output);
-    }
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-import_commander.program.parse();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateOpenAPISpec,

package/dist/index.mjs

@@ -1,9 +1,3 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { program } from "commander";
-import fs from "fs";
-
 // src/parser.ts
 import ts2 from "typescript";
 import path from "path";
@@ -189,9 +183,9 @@ function parseSchema(schemaFilePath, typeName) {
       compilerOptions = { ...compilerOptions, ...parsed.options };
     }
   }
-  const program2 = ts2.createProgram([absolutePath], compilerOptions);
-  const checker = program2.getTypeChecker();
-  const sourceFile = program2.getSourceFile(absolutePath);
+  const program = ts2.createProgram([absolutePath], compilerOptions);
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(absolutePath);
   if (!sourceFile) {
     throw new Error(`Could not find source file: ${absolutePath}`);
   }
@@ -401,29 +395,6 @@ function createOperation(endpoint) {
 function hasContent(schema) {
   return Object.keys(schema).length > 0;
 }
-
-// src/index.ts
-program.name("enlace-openapi").description("Generate OpenAPI spec from TypeScript API schema").requiredOption("-s, --schema <path>", "Path to TypeScript file containing the schema type").option("-t, --type <name>", "Name of the schema type to use", "ApiSchema").option("-o, --output <path>", "Output file path (default: stdout)").option("--title <title>", "API title for OpenAPI info").option("--version <version>", "API version for OpenAPI info", "1.0.0").option("--base-url <url>", "Base URL for servers array").action((options) => {
-  try {
-    const { endpoints, schemas } = parseSchema(options.schema, options.type);
-    const spec = generateOpenAPISpec(endpoints, schemas, {
-      title: options.title,
-      version: options.version,
-      baseUrl: options.baseUrl
-    });
-    const output = JSON.stringify(spec, null, 2);
-    if (options.output) {
-      fs.writeFileSync(options.output, output);
-      console.log(`OpenAPI spec written to ${options.output}`);
-    } else {
-      console.log(output);
-    }
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.parse();
 export {
   generateOpenAPISpec,
   parseSchema

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "enlace-openapi",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.2",
   "license": "MIT",
   "bin": {
-    "enlace-openapi": "./dist/index.mjs"
+    "enlace-openapi": "./dist/cli.mjs"
   },
   "files": [
     "dist"