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

package/dist/cli.js

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