enlace-openapi 0.0.1-beta.1

package/dist/index.d.mts

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+type JSONSchema = {
+    type?: string;
+    items?: JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    $ref?: string;
+    oneOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    allOf?: JSONSchema[];
+    enum?: (string | number | boolean | null)[];
+    const?: unknown;
+    additionalProperties?: boolean | JSONSchema;
+    nullable?: boolean;
+    format?: string;
+    description?: string;
+};
+type OpenAPIOperation = {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: {
+        required?: boolean;
+        content: {
+            "application/json": {
+                schema: JSONSchema;
+            };
+        };
+    };
+    responses: Record<string, {
+        description: string;
+        content?: {
+            "application/json": {
+                schema: JSONSchema;
+            };
+        };
+    }>;
+};
+type OpenAPIParameter = {
+    name: string;
+    in: "path" | "query" | "header" | "cookie";
+    required?: boolean;
+    schema: JSONSchema;
+    description?: string;
+};
+type OpenAPIPathItem = {
+    get?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    parameters?: OpenAPIParameter[];
+};
+type OpenAPISpec = {
+    openapi: "3.0.0";
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, OpenAPIPathItem>;
+    components?: {
+        schemas?: Record<string, JSONSchema>;
+    };
+};
+type ParsedEndpoint = {
+    path: string;
+    method: "get" | "post" | "put" | "patch" | "delete";
+    responseSchema: JSONSchema;
+    requestBodySchema?: JSONSchema;
+    errorSchema?: JSONSchema;
+    pathParams: string[];
+};
+type CLIOptions = {
+    schema: string;
+    type: string;
+    output?: string;
+    title?: string;
+    version?: string;
+    baseUrl?: string;
+};
+
+type ParseResult = {
+    endpoints: ParsedEndpoint[];
+    schemas: Map<string, JSONSchema>;
+};
+declare function parseSchema(schemaFilePath: string, typeName: string): ParseResult;
+
+type GeneratorOptions = {
+    title?: string;
+    version?: string;
+    description?: string;
+    baseUrl?: string;
+};
+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 };

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+type JSONSchema = {
+    type?: string;
+    items?: JSONSchema;
+    properties?: Record<string, JSONSchema>;
+    required?: string[];
+    $ref?: string;
+    oneOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    allOf?: JSONSchema[];
+    enum?: (string | number | boolean | null)[];
+    const?: unknown;
+    additionalProperties?: boolean | JSONSchema;
+    nullable?: boolean;
+    format?: string;
+    description?: string;
+};
+type OpenAPIOperation = {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: {
+        required?: boolean;
+        content: {
+            "application/json": {
+                schema: JSONSchema;
+            };
+        };
+    };
+    responses: Record<string, {
+        description: string;
+        content?: {
+            "application/json": {
+                schema: JSONSchema;
+            };
+        };
+    }>;
+};
+type OpenAPIParameter = {
+    name: string;
+    in: "path" | "query" | "header" | "cookie";
+    required?: boolean;
+    schema: JSONSchema;
+    description?: string;
+};
+type OpenAPIPathItem = {
+    get?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    parameters?: OpenAPIParameter[];
+};
+type OpenAPISpec = {
+    openapi: "3.0.0";
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, OpenAPIPathItem>;
+    components?: {
+        schemas?: Record<string, JSONSchema>;
+    };
+};
+type ParsedEndpoint = {
+    path: string;
+    method: "get" | "post" | "put" | "patch" | "delete";
+    responseSchema: JSONSchema;
+    requestBodySchema?: JSONSchema;
+    errorSchema?: JSONSchema;
+    pathParams: string[];
+};
+type CLIOptions = {
+    schema: string;
+    type: string;
+    output?: string;
+    title?: string;
+    version?: string;
+    baseUrl?: string;
+};
+
+type ParseResult = {
+    endpoints: ParsedEndpoint[];
+    schemas: Map<string, JSONSchema>;
+};
+declare function parseSchema(schemaFilePath: string, typeName: string): ParseResult;
+
+type GeneratorOptions = {
+    title?: string;
+    version?: string;
+    description?: string;
+    baseUrl?: string;
+};
+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 };

package/dist/index.js

@@ -0,0 +1,465 @@
+#!/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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  generateOpenAPISpec: () => generateOpenAPISpec,
+  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"));
+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/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,
+  parseSchema
+});

package/dist/index.mjs

@@ -0,0 +1,430 @@
+#!/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";
+
+// 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/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

@@ -0,0 +1,32 @@
+{
+  "name": "enlace-openapi",
+  "version": "0.0.1-beta.1",
+  "license": "MIT",
+  "bin": {
+    "enlace-openapi": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "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"
+  }
+}