openapi-domainify 0.1.0

package/dist/cli.js

@@ -0,0 +1,886 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/config.ts
+import { existsSync } from "fs";
+import { pathToFileURL } from "url";
+import { resolve } from "path";
+var CONFIG_FILES = [
+  "domainify.config.ts",
+  "domainify.config.js",
+  "domainify.config.mjs"
+];
+async function loadConfig(configPath) {
+  let resolvedPath;
+  if (configPath) {
+    resolvedPath = resolve(configPath);
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+  } else {
+    for (const file of CONFIG_FILES) {
+      const fullPath = resolve(process.cwd(), file);
+      if (existsSync(fullPath)) {
+        resolvedPath = fullPath;
+        break;
+      }
+    }
+  }
+  if (!resolvedPath) {
+    throw new Error(
+      `No config file found. Create one of: ${CONFIG_FILES.join(", ")}
+Or run: npx openapi-domainify init`
+    );
+  }
+  const configModule = await import(pathToFileURL(resolvedPath).href);
+  const config = configModule.default;
+  if (!config.input) {
+    throw new Error("Config missing required field: input");
+  }
+  if (!config.output) {
+    throw new Error("Config missing required field: output");
+  }
+  if (!config.domains || config.domains.length === 0) {
+    throw new Error("Config missing required field: domains (must have at least one)");
+  }
+  return resolveConfig(config);
+}
+function resolveConfig(config) {
+  return {
+    ...config,
+    fallback: config.fallback ?? { name: "api", prefix: "/", className: "Api" },
+    httpClientImport: config.httpClientImport ?? "../../http",
+    overridesDir: config.overridesDir ?? "./overrides",
+    generateIndex: config.generateIndex ?? true
+  };
+}
+
+// src/generator.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2, rmSync, readFileSync } from "fs";
+import { join, dirname, resolve as resolve2 } from "path";
+import { execSync } from "child_process";
+import * as ts from "typescript";
+async function loadSpec(config) {
+  const { input } = config;
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    console.log("Fetching OpenAPI spec...");
+    console.log(`   Source: ${input}`);
+    const response = await fetch(input);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const text = await response.text();
+    console.log(`   Fetched successfully`);
+    return text;
+  }
+  const filePath = resolve2(input);
+  if (!existsSync2(filePath)) {
+    throw new Error(`OpenAPI spec not found: ${filePath}`);
+  }
+  console.log("Loading OpenAPI spec...");
+  console.log(`   Source: ${filePath}`);
+  return readFileSync(filePath, "utf-8");
+}
+function parseSpec(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(
+      "Failed to parse OpenAPI spec. Currently only JSON format is supported.\nIf you have a YAML spec, convert it to JSON first."
+    );
+  }
+}
+function generateOpenapiTypes(specPath, outputPath) {
+  console.log("\nGenerating TypeScript types from OpenAPI spec...");
+  try {
+    execSync(`npx openapi-typescript "${specPath}" -o "${outputPath}"`, {
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    console.log(`   Generated base types`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to generate types: ${message}`);
+  }
+}
+function createProgram2(openapiTsPath) {
+  if (!existsSync2(openapiTsPath)) {
+    throw new Error(`Generated types not found: ${openapiTsPath}`);
+  }
+  const program = ts.createProgram([openapiTsPath], {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    strict: true
+  });
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(openapiTsPath);
+  if (!sourceFile) {
+    throw new Error(`Could not load ${openapiTsPath}`);
+  }
+  let pathsSymbol;
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isInterfaceDeclaration(node) && node.name.text === "paths") {
+      pathsSymbol = checker.getSymbolAtLocation(node.name);
+    }
+  });
+  if (!pathsSymbol) {
+    throw new Error('Could not find "paths" interface in generated types');
+  }
+  const pathsType = checker.getDeclaredTypeOfSymbol(pathsSymbol);
+  return { checker, sourceFile, pathsType };
+}
+function extractEndpoints(checker, sourceFile, pathsType) {
+  const endpoints = [];
+  const methods = ["get", "post", "put", "patch", "delete"];
+  for (const pathProp of pathsType.getProperties()) {
+    const path = pathProp.name;
+    const pathType = checker.getTypeOfSymbolAtLocation(pathProp, sourceFile);
+    for (const method of methods) {
+      const methodProp = pathType.getProperty(method);
+      if (!methodProp) continue;
+      const methodType = checker.getTypeOfSymbolAtLocation(methodProp, sourceFile);
+      const typeString = checker.typeToString(methodType);
+      if (typeString === "undefined" || typeString === "never") continue;
+      const operationType = checker.getApparentType(methodType);
+      const pathParams = (path.match(/\{([^}]+)\}/g) || []).map((p) => p.slice(1, -1));
+      const queryParams = [];
+      const parametersProp = operationType.getProperty("parameters");
+      if (parametersProp) {
+        const paramsType = checker.getApparentType(
+          checker.getTypeOfSymbolAtLocation(parametersProp, sourceFile)
+        );
+        const queryProp = paramsType.getProperty("query");
+        if (queryProp) {
+          const queryType = checker.getTypeOfSymbolAtLocation(queryProp, sourceFile);
+          for (const prop of queryType.getProperties()) {
+            queryParams.push(prop.name);
+          }
+        }
+      }
+      const requestBodyProp = operationType.getProperty("requestBody");
+      let hasBody = false;
+      if (requestBodyProp) {
+        const bodyType = checker.getTypeOfSymbolAtLocation(requestBodyProp, sourceFile);
+        hasBody = !(bodyType.flags & (ts.TypeFlags.Never | ts.TypeFlags.Undefined));
+      }
+      endpoints.push({
+        path,
+        method,
+        pathParams,
+        queryParams,
+        hasBody
+      });
+    }
+  }
+  return endpoints;
+}
+function createTypeExtractor(checker, sourceFile, pathsType) {
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  function formatType(type) {
+    const typeNode = checker.typeToTypeNode(
+      type,
+      sourceFile,
+      ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.MultilineObjectLiterals
+    );
+    if (!typeNode) {
+      return checker.typeToString(type, sourceFile, ts.TypeFormatFlags.NoTruncation);
+    }
+    return printer.printNode(ts.EmitHint.Unspecified, typeNode, sourceFile);
+  }
+  function getNestedType(type, ...propertyPath) {
+    let currentType = type;
+    for (const prop of propertyPath) {
+      currentType = checker.getApparentType(currentType);
+      const property = currentType.getProperty(prop);
+      if (!property) return void 0;
+      currentType = checker.getTypeOfSymbolAtLocation(property, sourceFile);
+    }
+    return checker.getApparentType(currentType);
+  }
+  function getMethodType(path, method) {
+    const pathProp = pathsType.getProperty(path);
+    if (!pathProp) return void 0;
+    const pathType = checker.getTypeOfSymbolAtLocation(pathProp, sourceFile);
+    const methodProp = pathType.getProperty(method);
+    if (!methodProp) return void 0;
+    return checker.getApparentType(checker.getTypeOfSymbolAtLocation(methodProp, sourceFile));
+  }
+  function isUnknownType(typeStr) {
+    return typeStr === "unknown" || typeStr === "never" || typeStr === "undefined";
+  }
+  return {
+    getResponseType(path, method) {
+      const methodType = getMethodType(path, method);
+      if (!methodType) return null;
+      const responseType = getNestedType(methodType, "responses", "200", "content", "application/json");
+      if (!responseType) return null;
+      const formatted = formatType(responseType);
+      return isUnknownType(formatted) ? null : formatted;
+    },
+    getRequestType(path, method) {
+      const methodType = getMethodType(path, method);
+      if (!methodType) return null;
+      const requestBodyProp = methodType.getProperty("requestBody");
+      if (!requestBodyProp) return null;
+      let requestBodyType = checker.getTypeOfSymbolAtLocation(requestBodyProp, sourceFile);
+      if (requestBodyType.isUnion()) {
+        const nonUndefinedTypes = requestBodyType.types.filter(
+          (t) => !(t.flags & ts.TypeFlags.Undefined)
+        );
+        if (nonUndefinedTypes.length === 1) {
+          requestBodyType = nonUndefinedTypes[0];
+        }
+      }
+      requestBodyType = checker.getApparentType(requestBodyType);
+      const requestType = getNestedType(requestBodyType, "content", "application/json");
+      if (!requestType) return null;
+      const formatted = formatType(requestType);
+      return isUnknownType(formatted) ? null : formatted;
+    },
+    getQueryType(path, method) {
+      const methodType = getMethodType(path, method);
+      if (!methodType) return null;
+      const queryType = getNestedType(methodType, "parameters", "query");
+      if (!queryType) return null;
+      const formatted = formatType(queryType);
+      return isUnknownType(formatted) ? null : formatted;
+    }
+  };
+}
+function getAllDomains(config) {
+  return [...config.domains, config.fallback];
+}
+function getDomain(path, config) {
+  const strippedPath = config.stripPrefix ? path.replace(config.stripPrefix, "") : path;
+  for (const domain of config.domains) {
+    if (strippedPath.startsWith(domain.prefix)) {
+      return domain.name;
+    }
+  }
+  return config.fallback.name;
+}
+function getDomainConfig(name, config) {
+  const found = getAllDomains(config).find((d) => d.name === name);
+  if (!found) {
+    throw new Error(`Unknown domain: ${name}`);
+  }
+  return found;
+}
+function pascalCase(str) {
+  return str.replace(/[-_\/]([a-z])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase()).replace(/[{}]/g, "");
+}
+function camelCase(str) {
+  return str.replace(/[-_\/]([a-z])/g, (_, c) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase()).replace(/[{}]/g, "");
+}
+function singularize(word) {
+  if (word.endsWith("ies")) return word.slice(0, -3) + "y";
+  if (/(x|ch|sh|ss|z)es$/i.test(word)) return word.slice(0, -2);
+  if (word.endsWith("s") && !word.endsWith("ss")) return word.slice(0, -1);
+  return word;
+}
+function getMethodName(endpoint, domain, config) {
+  const domainConfig = getDomainConfig(domain, config);
+  let relativePath = endpoint.path;
+  if (config.stripPrefix) {
+    relativePath = relativePath.replace(config.stripPrefix, "");
+  }
+  relativePath = relativePath.replace(domainConfig.prefix, "").replace(/^\//, "");
+  const allSegments = relativePath.split("/").filter(Boolean);
+  const endsWithParam = allSegments.length > 0 && allSegments[allSegments.length - 1].startsWith("{");
+  const segments = allSegments.filter((seg) => !seg.startsWith("{"));
+  if (segments.length === 0) {
+    return endpoint.method;
+  }
+  const resource = segments[0];
+  const subPath = segments.slice(1);
+  const resourceName = endsWithParam ? singularize(pascalCase(resource)) : pascalCase(resource);
+  const subPathPart = subPath.map(pascalCase).join("");
+  const fullPath = resourceName + subPathPart;
+  switch (endpoint.method) {
+    case "get":
+      if (endsWithParam || subPath.length > 0) {
+        return `get${fullPath}`;
+      }
+      return camelCase(fullPath);
+    case "post":
+      return `create${singularize(fullPath)}`;
+    case "put":
+      return `update${singularize(fullPath)}`;
+    case "patch":
+      return `patch${singularize(fullPath)}`;
+    case "delete":
+      return `delete${singularize(fullPath)}`;
+    default:
+      return `${endpoint.method}${fullPath}`;
+  }
+}
+function getTypeName(path, method, kind, config) {
+  let cleanPath = path;
+  if (config.stripPrefix) {
+    cleanPath = cleanPath.replace(config.stripPrefix, "");
+  }
+  cleanPath = cleanPath.replace(/^\//, "").replace(/\{[^}]+\}/g, "ById").split("/").map(pascalCase).join("");
+  const methodPrefix = method.charAt(0).toUpperCase() + method.slice(1);
+  return `${methodPrefix}${cleanPath}${kind}`;
+}
+function groupByDomain(endpoints, config) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const domain of getAllDomains(config)) {
+    groups.set(domain.name, []);
+  }
+  for (const endpoint of endpoints) {
+    const domain = getDomain(endpoint.path, config);
+    const domainEndpoints = groups.get(domain);
+    if (domainEndpoints) {
+      domainEndpoints.push(endpoint);
+    }
+  }
+  return groups;
+}
+function generateTypes(domain, endpoints, extractor, config) {
+  const lines = [];
+  const domainConfig = getDomainConfig(domain, config);
+  const allTypes = [];
+  const requestTypes = [];
+  for (const endpoint of endpoints) {
+    if (endpoint.hasBody) {
+      const typeBody = extractor.getRequestType(endpoint.path, endpoint.method);
+      if (typeBody) {
+        const typeName = getTypeName(endpoint.path, endpoint.method, "Request", config);
+        requestTypes.push(`export type ${typeName} = ${typeBody}`);
+      }
+    }
+  }
+  allTypes.push(...requestTypes);
+  const queryTypes = [];
+  for (const endpoint of endpoints) {
+    if (endpoint.queryParams.length > 0) {
+      const typeBody = extractor.getQueryType(endpoint.path, endpoint.method);
+      if (typeBody) {
+        const typeName = getTypeName(endpoint.path, endpoint.method, "Query", config);
+        queryTypes.push(`export type ${typeName} = ${typeBody}`);
+      }
+    }
+  }
+  allTypes.push(...queryTypes);
+  const responseTypes = [];
+  for (const endpoint of endpoints) {
+    const typeBody = extractor.getResponseType(endpoint.path, endpoint.method);
+    if (typeBody) {
+      const typeName = getTypeName(endpoint.path, endpoint.method, "Response", config);
+      responseTypes.push(`export type ${typeName} = ${typeBody}`);
+    }
+  }
+  allTypes.push(...responseTypes);
+  const usesComponents = allTypes.some((t) => t.includes("components["));
+  lines.push(`/**`);
+  lines.push(` * ${domainConfig.className} Domain Types`);
+  lines.push(` * Auto-generated - DO NOT EDIT`);
+  lines.push(` */`);
+  if (usesComponents) {
+    lines.push(`import type { components } from '../openapi'`);
+  }
+  lines.push(``);
+  lines.push(`// \u2500\u2500\u2500 Common Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  lines.push(``);
+  lines.push(`export interface PaginatedResponse<T> {`);
+  lines.push(`  data: T[]`);
+  lines.push(`  current_page: number`);
+  lines.push(`  last_page: number`);
+  lines.push(`  per_page: number`);
+  lines.push(`  total: number`);
+  lines.push(`  from: number | null`);
+  lines.push(`  to: number | null`);
+  lines.push(`}`);
+  lines.push(``);
+  if (requestTypes.length > 0) {
+    lines.push(`// \u2500\u2500\u2500 Request Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    lines.push(``);
+    lines.push(...requestTypes);
+    lines.push(``);
+  }
+  if (queryTypes.length > 0) {
+    lines.push(`// \u2500\u2500\u2500 Query Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    lines.push(``);
+    lines.push(...queryTypes);
+    lines.push(``);
+  }
+  if (responseTypes.length > 0) {
+    lines.push(`// \u2500\u2500\u2500 Response Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    lines.push(``);
+    lines.push(...responseTypes);
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+function generateService(domain, endpoints, extractor, config) {
+  const lines = [];
+  const domainConfig = getDomainConfig(domain, config);
+  const className = `${domainConfig.className}Service`;
+  lines.push(`/**`);
+  lines.push(` * ${domainConfig.className} Domain Service`);
+  lines.push(` * Auto-generated - DO NOT EDIT`);
+  lines.push(` */`);
+  lines.push(`import type { HttpClient } from '${config.httpClientImport}'`);
+  lines.push(`import type * as T from './types'`);
+  lines.push(``);
+  lines.push(`export class ${className} {`);
+  lines.push(`  constructor(private http: HttpClient) {}`);
+  const usedNames = /* @__PURE__ */ new Map();
+  const resourceGroups = /* @__PURE__ */ new Map();
+  for (const endpoint of endpoints) {
+    let relativePath = endpoint.path;
+    if (config.stripPrefix) {
+      relativePath = relativePath.replace(config.stripPrefix, "");
+    }
+    relativePath = relativePath.replace(domainConfig.prefix, "").replace(/^\//, "");
+    const resource = relativePath.split("/")[0]?.replace(/\{[^}]+\}/, "") || "root";
+    if (!resourceGroups.has(resource)) resourceGroups.set(resource, []);
+    resourceGroups.get(resource).push(endpoint);
+  }
+  for (const [resource, resourceEndpoints] of resourceGroups) {
+    lines.push(``);
+    lines.push(`  // \u2500\u2500\u2500 ${pascalCase(resource) || "Root"} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    for (const endpoint of resourceEndpoints) {
+      let methodName = getMethodName(endpoint, domain, config);
+      const count = usedNames.get(methodName) || 0;
+      if (count > 0) {
+        methodName = `${methodName}${count + 1}`;
+      }
+      usedNames.set(methodName, count + 1);
+      const params = [];
+      for (const param of endpoint.pathParams) {
+        const paramName = camelCase(param.replace(/_id$/, "Id"));
+        params.push(`${paramName}: string | number`);
+      }
+      if (endpoint.queryParams.length > 0) {
+        const queryType = extractor.getQueryType(endpoint.path, endpoint.method);
+        if (queryType) {
+          const queryTypeName = getTypeName(endpoint.path, endpoint.method, "Query", config);
+          params.push(`params?: T.${queryTypeName}`);
+        } else {
+          params.push(`params?: Record<string, unknown>`);
+        }
+      }
+      if (endpoint.hasBody && endpoint.method !== "get") {
+        const requestType = extractor.getRequestType(endpoint.path, endpoint.method);
+        if (requestType) {
+          const bodyTypeName = getTypeName(endpoint.path, endpoint.method, "Request", config);
+          params.push(`data: T.${bodyTypeName}`);
+        } else {
+          params.push(`data: unknown`);
+        }
+      }
+      const responseType = extractor.getResponseType(endpoint.path, endpoint.method);
+      let returnType;
+      if (responseType) {
+        const responseTypeName = getTypeName(endpoint.path, endpoint.method, "Response", config);
+        returnType = `T.${responseTypeName}`;
+      } else {
+        returnType = "unknown";
+      }
+      let urlPath = endpoint.path;
+      if (config.stripPrefix) {
+        urlPath = urlPath.replace(config.stripPrefix, "");
+      }
+      for (const param of endpoint.pathParams) {
+        const paramName = camelCase(param.replace(/_id$/, "Id"));
+        urlPath = urlPath.replace(`{${param}}`, `\${${paramName}}`);
+      }
+      const pathLiteral = urlPath.includes("$") ? "`" + urlPath + "`" : `'${urlPath}'`;
+      lines.push(`  ${methodName}(${params.join(", ")}): Promise<${returnType}> {`);
+      const hasParams = endpoint.queryParams.length > 0;
+      switch (endpoint.method) {
+        case "get":
+          lines.push(hasParams ? `    return this.http.get(${pathLiteral}, { params })` : `    return this.http.get(${pathLiteral})`);
+          break;
+        case "post":
+          lines.push(endpoint.hasBody ? `    return this.http.post(${pathLiteral}, data)` : `    return this.http.post(${pathLiteral})`);
+          break;
+        case "put":
+          lines.push(endpoint.hasBody ? `    return this.http.put(${pathLiteral}, data)` : `    return this.http.put(${pathLiteral})`);
+          break;
+        case "patch":
+          lines.push(endpoint.hasBody ? `    return this.http.patch(${pathLiteral}, data)` : `    return this.http.patch(${pathLiteral})`);
+          break;
+        case "delete":
+          lines.push(hasParams ? `    return this.http.delete(${pathLiteral}, { params })` : `    return this.http.delete(${pathLiteral})`);
+          break;
+      }
+      lines.push(`  }`);
+    }
+  }
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateOverrideTemplate(domain, config) {
+  const domainConfig = getDomainConfig(domain, config);
+  const className = `${domainConfig.className}Service`;
+  return `/**
+ * ${domainConfig.className} Service Overrides
+ *
+ * Extend or override methods from the generated ${className}.
+ * This file is NOT overwritten by the generator - safe to edit.
+ *
+ * To enable: update index.ts to import from here instead of generated.
+ */
+import { ${className} as Generated${className} } from '../../generated/${domain}/service'
+import type { HttpClient } from '../../http'
+
+export class ${className} extends Generated${className} {
+  constructor(http: HttpClient) {
+    super(http)
+  }
+
+  // Example: Override a method that has issues in the OpenAPI spec
+  // async someMethod(): Promise<SomeType> {
+  //   // Custom implementation or fix
+  //   return super.someMethod()
+  // }
+
+  // Example: Add a method not in the OpenAPI spec
+  // async customMethod(): Promise<void> {
+  //   // Custom logic
+  // }
+}
+`;
+}
+function generateHttpTemplate(config) {
+  return `/**
+ * HTTP Client Interface
+ *
+ * Implement this interface with your preferred HTTP library.
+ * This file is NOT overwritten by the generator - safe to edit.
+ */
+
+export interface HttpClient {
+  get<T>(url: string, options?: { params?: Record<string, unknown> }): Promise<T>
+  post<T>(url: string, body?: Record<string, unknown>): Promise<T>
+  put<T>(url: string, body?: Record<string, unknown>): Promise<T>
+  patch<T>(url: string, body?: Record<string, unknown>): Promise<T>
+  delete<T>(url: string, options?: { params?: Record<string, unknown> }): Promise<T>
+}
+
+// \u2500\u2500\u2500 Example Implementation (using fetch) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+export interface HttpClientOptions {
+  baseUrl: string
+  getToken?: () => string | null | Promise<string | null>
+  onError?: (error: ApiError) => void
+}
+
+export interface ApiError {
+  status: number
+  statusText: string
+  message: string
+  data?: unknown
+}
+
+export class FetchHttpClient implements HttpClient {
+  constructor(private options: HttpClientOptions) {}
+
+  private async request<T>(
+    method: string,
+    url: string,
+    body?: unknown,
+    params?: Record<string, unknown>
+  ): Promise<T> {
+    const query = params
+      ? '?' + new URLSearchParams(
+          Object.entries(params)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => [k, String(v)])
+        ).toString()
+      : ''
+
+    const token = await this.options.getToken?.()
+
+    const response = await fetch(this.options.baseUrl + url + query, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(token && { Authorization: \`Bearer \${token}\` }),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    })
+
+    if (!response.ok) {
+      const error: ApiError = {
+        status: response.status,
+        statusText: response.statusText,
+        message: response.statusText,
+      }
+      try {
+        error.data = await response.json()
+        error.message = (error.data as { message?: string })?.message || error.statusText
+      } catch {}
+      this.options.onError?.(error)
+      throw error
+    }
+
+    return response.json()
+  }
+
+  get<T>(url: string, opts?: { params?: Record<string, unknown> }) {
+    return this.request<T>('GET', url, undefined, opts?.params)
+  }
+  post<T>(url: string, body?: Record<string, unknown>) {
+    return this.request<T>('POST', url, body)
+  }
+  put<T>(url: string, body?: Record<string, unknown>) {
+    return this.request<T>('PUT', url, body)
+  }
+  patch<T>(url: string, body?: Record<string, unknown>) {
+    return this.request<T>('PATCH', url, body)
+  }
+  delete<T>(url: string, opts?: { params?: Record<string, unknown> }) {
+    return this.request<T>('DELETE', url, undefined, opts?.params)
+  }
+}
+`;
+}
+function generateIndexFile(activeDomains, config, overridesDir) {
+  const lines = [];
+  lines.push(`/**`);
+  lines.push(` * API Client`);
+  lines.push(` *`);
+  lines.push(` * Auto-generated index that wires domain services together.`);
+  lines.push(` * This file IS overwritten by the generator.`);
+  lines.push(` *`);
+  lines.push(` * To use overrides: uncomment the override import and comment out the generated import.`);
+  lines.push(` */`);
+  lines.push(`import type { HttpClient } from './http'`);
+  lines.push(``);
+  for (const domain of activeDomains) {
+    const domainConfig = getDomainConfig(domain, config);
+    const className = `${domainConfig.className}Service`;
+    const overridePath = join(overridesDir, domain, "service.ts");
+    const hasOverride = existsSync2(overridePath);
+    if (hasOverride) {
+      const content = readFileSync(overridePath, "utf-8");
+      const isCustomized = !content.includes("// Example: Override a method") || content.split("async ").length > 2;
+      if (isCustomized) {
+        lines.push(`import { ${className} } from './overrides/${domain}/service'`);
+      } else {
+        lines.push(`// import { ${className} } from './overrides/${domain}/service'`);
+        lines.push(`import { ${className} } from './generated/${domain}/service'`);
+      }
+    } else {
+      lines.push(`import { ${className} } from './generated/${domain}/service'`);
+    }
+  }
+  lines.push(``);
+  lines.push(`// \u2500\u2500\u2500 API Client \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  lines.push(``);
+  lines.push(`export class ApiClient {`);
+  lines.push(`  constructor(private http: HttpClient) {`);
+  for (const domain of activeDomains) {
+    const domainConfig = getDomainConfig(domain, config);
+    lines.push(`    this.${domain} = new ${domainConfig.className}Service(http)`);
+  }
+  lines.push(`  }`);
+  lines.push(``);
+  for (const domain of activeDomains) {
+    const domainConfig = getDomainConfig(domain, config);
+    lines.push(`  readonly ${domain}: ${domainConfig.className}Service`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`export function createApiClient(http: HttpClient): ApiClient {`);
+  lines.push(`  return new ApiClient(http)`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`// \u2500\u2500\u2500 Re-exports \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  lines.push(``);
+  for (const domain of activeDomains) {
+    const domainConfig = getDomainConfig(domain, config);
+    lines.push(`export * as ${domainConfig.className}Types from './generated/${domain}/types'`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+function writeFileSafe(path, content, overwrite = true) {
+  if (!overwrite && existsSync2(path)) {
+    return false;
+  }
+  writeFileSync(path, content);
+  return true;
+}
+async function generate(config) {
+  console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551                     openapi-domainify                            \u2551");
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+  const specContent = await loadSpec(config);
+  const spec = parseSpec(specContent);
+  const outputDir = resolve2(config.output);
+  const generatedDir = join(outputDir, "generated");
+  const overridesDir = resolve2(outputDir, config.overridesDir);
+  if (!existsSync2(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  if (!existsSync2(generatedDir)) {
+    mkdirSync(generatedDir, { recursive: true });
+  }
+  const specPath = config.specOutput ? resolve2(config.specOutput) : join(generatedDir, "openapi.json");
+  const specDir = dirname(specPath);
+  if (!existsSync2(specDir)) {
+    mkdirSync(specDir, { recursive: true });
+  }
+  writeFileSync(specPath, JSON.stringify(spec, null, 2));
+  const openapiTsPath = join(generatedDir, "openapi.ts");
+  generateOpenapiTypes(specPath, openapiTsPath);
+  console.log("\n\u{1F4CA} Generating domain services...");
+  const { checker, sourceFile, pathsType } = createProgram2(openapiTsPath);
+  console.log("   Extracting endpoints...");
+  const endpoints = extractEndpoints(checker, sourceFile, pathsType);
+  console.log(`   Found ${endpoints.length} endpoints`);
+  const extractor = createTypeExtractor(checker, sourceFile, pathsType);
+  const domains = groupByDomain(endpoints, config);
+  const activeDomains = [];
+  for (const [domain, domainEndpoints] of domains) {
+    if (domainEndpoints.length === 0) continue;
+    activeDomains.push(domain);
+    const domainDir = join(generatedDir, domain);
+    if (existsSync2(domainDir)) {
+      rmSync(domainDir, { recursive: true });
+    }
+    mkdirSync(domainDir, { recursive: true });
+    console.log(`
+\u{1F4C1} generated/${domain}/ (${domainEndpoints.length} endpoints)`);
+    const typesContent = generateTypes(domain, domainEndpoints, extractor, config);
+    writeFileSync(join(domainDir, "types.ts"), typesContent);
+    console.log(`   \u2728 types.ts`);
+    const serviceContent = generateService(domain, domainEndpoints, extractor, config);
+    writeFileSync(join(domainDir, "service.ts"), serviceContent);
+    console.log(`   \u2728 service.ts`);
+  }
+  console.log("\n\u{1F3D7}\uFE0F  Scaffolding...");
+  if (!existsSync2(overridesDir)) {
+    mkdirSync(overridesDir, { recursive: true });
+  }
+  for (const domain of activeDomains) {
+    const overrideDomainDir = join(overridesDir, domain);
+    if (!existsSync2(overrideDomainDir)) {
+      mkdirSync(overrideDomainDir, { recursive: true });
+    }
+    const overrideServicePath = join(overrideDomainDir, "service.ts");
+    if (writeFileSafe(overrideServicePath, generateOverrideTemplate(domain, config), false)) {
+      console.log(`   \u{1F4DD} overrides/${domain}/service.ts (new)`);
+    }
+  }
+  const httpPath = join(outputDir, "http.ts");
+  if (writeFileSafe(httpPath, generateHttpTemplate(config), false)) {
+    console.log(`   \u{1F4DD} http.ts (new)`);
+  }
+  if (config.generateIndex) {
+    const indexContent = generateIndexFile(activeDomains, config, overridesDir);
+    writeFileSync(join(outputDir, "index.ts"), indexContent);
+    console.log(`   \u2728 index.ts`);
+  }
+  console.log("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551                    \u2705 Generation Complete!                       \u2551");
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  console.log(`
+Output: ${outputDir}`);
+  console.log(`
+Structure:`);
+  console.log(`  ${outputDir}/`);
+  console.log(`  \u251C\u2500\u2500 index.ts          # API client (regenerated)`);
+  console.log(`  \u251C\u2500\u2500 http.ts           # HTTP client template (safe to edit)`);
+  console.log(`  \u251C\u2500\u2500 generated/        # Auto-generated (DO NOT EDIT)`);
+  for (const domain of activeDomains) {
+    console.log(`  \u2502   \u2514\u2500\u2500 ${domain}/`);
+  }
+  console.log(`  \u2514\u2500\u2500 overrides/        # Your customizations (safe to edit)`);
+  for (const domain of activeDomains) {
+    console.log(`      \u2514\u2500\u2500 ${domain}/`);
+  }
+}
+
+// src/cli.ts
+var INIT_CONFIG = `import { defineConfig } from 'openapi-domainify'
+
+export default defineConfig({
+  // OpenAPI spec source (URL or local file path)
+  input: 'https://api.example.com/openapi.json',
+  
+  // Where to write generated code
+  // Creates: output/generated/, output/overrides/, output/index.ts, output/http.ts
+  output: './src/api',
+
+  // Domain splitting rules (order matters - first match wins)
+  domains: [
+    { name: 'auth', prefix: '/auth/', className: 'Auth' },
+    { name: 'users', prefix: '/users/', className: 'Users' },
+  ],
+
+  // Catch-all for unmatched paths
+  fallback: { name: 'api', prefix: '/', className: 'Api' },
+})
+`;
+var HELP = `
+openapi-domainify - Split OpenAPI specs into domain-based TypeScript services
+
+USAGE
+  npx openapi-domainify <command> [options]
+
+COMMANDS
+  init              Create a domainify.config.ts file
+  generate          Generate domain services from OpenAPI spec
+  help              Show this help message
+
+OPTIONS
+  -c, --config      Path to config file (default: domainify.config.ts)
+
+EXAMPLES
+  npx openapi-domainify init
+  npx openapi-domainify generate
+  npx openapi-domainify generate --config ./custom.config.ts
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (command === "init") {
+    const configPath = resolve3("domainify.config.ts");
+    if (existsSync3(configPath)) {
+      console.error("\u274C domainify.config.ts already exists");
+      process.exit(1);
+    }
+    writeFileSync2(configPath, INIT_CONFIG);
+    console.log("\u2705 Created domainify.config.ts");
+    console.log("\nNext steps:");
+    console.log("  1. Edit domainify.config.ts with your OpenAPI spec URL");
+    console.log("  2. Run: npx openapi-domainify generate");
+    process.exit(0);
+  }
+  if (command === "generate") {
+    let configPath;
+    const configIdx = args.findIndex((a) => a === "-c" || a === "--config");
+    if (configIdx !== -1 && args[configIdx + 1]) {
+      configPath = args[configIdx + 1];
+    }
+    try {
+      const config = await loadConfig(configPath);
+      await generate(config);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`
+\u274C ${message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  console.error(`Unknown command: ${command}`);
+  console.log(HELP);
+  process.exit(1);
+}
+main();
+//# sourceMappingURL=cli.js.map