@honestjs/rpc-plugin 1.0.0

package/dist/index.js

@@ -0,0 +1,981 @@
+"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 index_exports = {};
+__export(index_exports, {
+  BUILTIN_TYPES: () => BUILTIN_TYPES,
+  BUILTIN_UTILITY_TYPES: () => BUILTIN_UTILITY_TYPES,
+  ClientGeneratorService: () => ClientGeneratorService,
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  GENERIC_TYPES: () => GENERIC_TYPES,
+  LOG_PREFIX: () => LOG_PREFIX,
+  RPCPlugin: () => RPCPlugin,
+  RouteAnalyzerService: () => RouteAnalyzerService,
+  SchemaGeneratorService: () => SchemaGeneratorService,
+  buildFullApiPath: () => buildFullApiPath,
+  buildFullPath: () => buildFullPath,
+  camelCase: () => camelCase,
+  extractNamedType: () => extractNamedType,
+  generateTypeImports: () => generateTypeImports,
+  generateTypeScriptInterface: () => generateTypeScriptInterface,
+  mapJsonSchemaTypeToTypeScript: () => mapJsonSchemaTypeToTypeScript,
+  safeToString: () => safeToString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/rpc.plugin.ts
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
+// src/constants/defaults.ts
+var DEFAULT_OPTIONS = {
+  controllerPattern: "src/modules/*/*.controller.ts",
+  tsConfigPath: "tsconfig.json",
+  outputDir: "./generated/rpc",
+  generateOnInit: true
+};
+var LOG_PREFIX = "[ RPCPlugin ]";
+var BUILTIN_UTILITY_TYPES = /* @__PURE__ */ new Set([
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Record",
+  "Exclude",
+  "Extract",
+  "ReturnType",
+  "InstanceType"
+]);
+var BUILTIN_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "any", "void", "unknown"]);
+var GENERIC_TYPES = /* @__PURE__ */ new Set(["Array", "Promise", "Partial"]);
+
+// src/services/client-generator.service.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+
+// src/utils/path-utils.ts
+function buildFullPath(basePath, parameters) {
+  if (!basePath || typeof basePath !== "string") return "/";
+  let path3 = basePath;
+  if (parameters && Array.isArray(parameters)) {
+    for (const param of parameters) {
+      if (param.data && typeof param.data === "string" && param.data.startsWith(":")) {
+        const paramName = param.data.slice(1);
+        path3 = path3.replace(`:${paramName}`, `\${${paramName}}`);
+      }
+    }
+  }
+  return path3;
+}
+function buildFullApiPath(route) {
+  const prefix = route.prefix || "";
+  const version = route.version || "";
+  const routePath = route.route || "";
+  const path3 = route.path || "";
+  let fullPath = "";
+  if (prefix && prefix !== "/") {
+    fullPath += prefix.replace(/^\/+|\/+$/g, "");
+  }
+  if (version && version !== "/") {
+    fullPath += `/${version.replace(/^\/+|\/+$/g, "")}`;
+  }
+  if (routePath && routePath !== "/") {
+    fullPath += `/${routePath.replace(/^\/+|\/+$/g, "")}`;
+  }
+  if (path3 && path3 !== "/") {
+    fullPath += `/${path3.replace(/^\/+|\/+$/g, "")}`;
+  } else if (path3 === "/") {
+    fullPath += "/";
+  }
+  return fullPath || "/";
+}
+
+// src/utils/string-utils.ts
+function safeToString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "symbol") return value.description || "Symbol";
+  return String(value);
+}
+function camelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+// src/services/client-generator.service.ts
+var ClientGeneratorService = class {
+  constructor(outputDir) {
+    this.outputDir = outputDir;
+  }
+  /**
+   * Generates the TypeScript RPC client
+   */
+  async generateClient(routes, schemas) {
+    await import_promises.default.mkdir(this.outputDir, { recursive: true });
+    await this.generateClientFile(routes, schemas);
+    const generatedInfo = {
+      clientFile: import_path.default.join(this.outputDir, "client.ts"),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return generatedInfo;
+  }
+  /**
+   * Generates the main client file with types included
+   */
+  async generateClientFile(routes, schemas) {
+    const clientContent = this.generateClientContent(routes, schemas);
+    const clientPath = import_path.default.join(this.outputDir, "client.ts");
+    await import_promises.default.writeFile(clientPath, clientContent, "utf-8");
+  }
+  /**
+   * Generates the client TypeScript content with types included
+   */
+  generateClientContent(routes, schemas) {
+    const controllerGroups = this.groupRoutesByController(routes);
+    return `// ============================================================================
+// TYPES SECTION
+// ============================================================================
+
+/**
+ * API Response wrapper
+ */
+export interface ApiResponse<T = any> {
+	data: T
+	message?: string
+	success: boolean
+}
+
+/**
+ * API Error class
+ */
+export class ApiError extends Error {
+	constructor(
+		public statusCode: number,
+		message: string
+	) {
+		super(message)
+		this.name = 'ApiError'
+	}
+}
+
+/**
+ * Clean separation of concerns for request options
+ */
+export type RequestOptions<
+	TParams = undefined,
+	TQuery = undefined,
+	TBody = undefined,
+	THeaders = undefined
+> = (TParams extends undefined ? object : { params: TParams }) &
+	(TQuery extends undefined ? object : { query: TQuery }) &
+	(TBody extends undefined ? object : { body: TBody }) &
+	(THeaders extends undefined ? object : { headers: THeaders })
+
+// Generated DTOs and types from integrated Schema Generation
+${this.generateSchemaTypes(schemas)}
+
+// ============================================================================
+// CLIENT SECTION
+// ============================================================================
+
+/**
+ * Generated RPC Client
+ * 
+ * This class provides a type-safe HTTP client for interacting with your API endpoints.
+ * It's automatically generated by the RPCPlugin based on your controller definitions.
+ * 
+ * @example
+ * \`\`\`typescript
+ * const apiClient = new ApiClient('http://localhost:3000')
+ * 
+ * // Make a request to get users
+ * const response = await apiClient.users.getUsers()
+ * 
+ * // Make a request with parameters
+ * const user = await apiClient.users.getUser({ params: { id: '123' } })
+ * 
+ * // Make a request with body data
+ * const newUser = await apiClient.users.createUser({ 
+ *   body: { name: 'John', email: 'john@example.com' } 
+ * })
+ * \`\`\`
+ * 
+ * @generated This class is auto-generated by RPCPlugin
+ */
+export class ApiClient {
+	private baseUrl: string
+	private defaultHeaders: Record<string, string>
+
+	constructor(baseUrl: string, defaultHeaders: Record<string, string> = {}) {
+		this.baseUrl = baseUrl.replace(/\\/$/, '')
+		this.defaultHeaders = {
+			'Content-Type': 'application/json',
+			...defaultHeaders
+		}
+	}
+
+	/**
+	 * Set default headers for all requests
+	 */
+	setDefaultHeaders(headers: Record<string, string>): this {
+		this.defaultHeaders = { ...this.defaultHeaders, ...headers }
+		return this
+	}
+
+	/**
+	 * Set default authorization header
+	 */
+	setDefaultAuth(token: string): this {
+		this.defaultHeaders.Authorization = \`Bearer \${token}\`
+		return this
+	}
+
+	/**
+	 * Make an HTTP request with flexible options
+	 */
+	private async request<T>(
+		method: string,
+		path: string,
+		options: RequestOptions<any, any, any, any> = {}
+	): Promise<ApiResponse<T>> {
+		const { params, query, body, headers = {} } = options as any
+		
+		// Build the final URL with path parameters
+		let finalPath = path
+		if (params) {
+			Object.entries(params).forEach(([key, value]) => {
+				finalPath = finalPath.replace(\`:\${key}\`, String(value))
+			})
+		}
+
+		const url = new URL(finalPath, this.baseUrl)
+		
+		// Add query parameters
+		if (query) {
+			Object.entries(query).forEach(([key, value]) => {
+				if (value !== undefined && value !== null) {
+					url.searchParams.append(key, String(value))
+				}
+			})
+		}
+
+		// Merge default headers with request-specific headers
+		const finalHeaders = { ...this.defaultHeaders, ...headers }
+
+		const requestOptions: RequestInit = {
+			method,
+			headers: finalHeaders,
+		}
+
+		if (body && method !== 'GET') {
+			requestOptions.body = JSON.stringify(body)
+		}
+
+		try {
+			const response = await fetch(url.toString(), requestOptions)
+			const responseData = await response.json()
+
+			if (!response.ok) {
+				throw new ApiError(response.status, responseData.message || 'Request failed')
+			}
+
+			return responseData
+		} catch (error) {
+			if (error instanceof ApiError) {
+				throw error
+			}
+			throw new ApiError(0, error instanceof Error ? error.message : 'Network error')
+		}
+	}
+
+${this.generateControllerMethods(controllerGroups)}
+}
+`;
+  }
+  /**
+   * Generates controller methods for the client
+   */
+  generateControllerMethods(controllerGroups) {
+    let methods = "";
+    for (const [controllerName, routes] of controllerGroups) {
+      const className = controllerName.replace(/Controller$/, "");
+      methods += `
+	// ${className} Controller
+`;
+      methods += `	get ${camelCase(className)}() {
+`;
+      methods += `		return {
+`;
+      for (const route of routes) {
+        const methodName = camelCase(safeToString(route.handler));
+        const httpMethod = safeToString(route.method).toLowerCase();
+        const { pathParams, queryParams, bodyParams } = this.analyzeRouteParameters(route);
+        const hasRequiredParams = pathParams.length > 0 || queryParams.some((p) => p.required) || bodyParams.length > 0 && httpMethod !== "get";
+        methods += `			${methodName}: async (options${hasRequiredParams ? "" : "?"}: RequestOptions<`;
+        if (pathParams.length > 0) {
+          const pathParamTypes = pathParams.map((p) => {
+            const paramName = p.name;
+            const paramType = p.type || "any";
+            return `${paramName}: ${paramType}`;
+          });
+          methods += `{ ${pathParamTypes.join(", ")} }`;
+        } else {
+          methods += "undefined";
+        }
+        methods += ", ";
+        if (queryParams.length > 0) {
+          const queryParamTypes = queryParams.map((p) => {
+            const paramName = p.name;
+            const paramType = p.type || "any";
+            return `${paramName}: ${paramType}`;
+          });
+          methods += `{ ${queryParamTypes.join(", ")} }`;
+        } else {
+          methods += "undefined";
+        }
+        methods += ", ";
+        if (bodyParams.length > 0) {
+          const bodyParamTypes = bodyParams.map((p) => {
+            const paramType = p.type || "any";
+            return paramType;
+          });
+          methods += bodyParamTypes[0] || "any";
+        } else {
+          methods += "undefined";
+        }
+        methods += ", ";
+        methods += "undefined";
+        const returnType = this.extractReturnType(route.returns);
+        methods += `>): Promise<ApiResponse<${returnType}>> => {
+`;
+        let requestPath = buildFullApiPath(route);
+        if (pathParams.length > 0) {
+          for (const pathParam of pathParams) {
+            const paramName = pathParam.name;
+            const placeholder = `:${String(pathParam.data)}`;
+            requestPath = requestPath.replace(placeholder, `:${paramName}`);
+          }
+        }
+        methods += `				return this.request<${returnType}>('${httpMethod.toUpperCase()}', \`${requestPath}\`, options)
+`;
+        methods += `			},
+`;
+      }
+      methods += `		}
+`;
+      methods += `	}
+`;
+    }
+    return methods;
+  }
+  /**
+   * Extracts the proper return type from route analysis
+   */
+  extractReturnType(returns) {
+    if (!returns) return "any";
+    const promiseMatch = returns.match(/Promise<(.+)>/);
+    if (promiseMatch) {
+      return promiseMatch[1];
+    }
+    return returns;
+  }
+  /**
+   * Generates schema types from integrated schema generation
+   */
+  generateSchemaTypes(schemas) {
+    if (schemas.length === 0) {
+      return "// No schemas available from integrated Schema Generation\n";
+    }
+    let content = "// Schema types from integrated Schema Generation\n";
+    for (const schemaInfo of schemas) {
+      if (schemaInfo.typescriptType) {
+        content += `${schemaInfo.typescriptType}
+
+`;
+      }
+    }
+    return content;
+  }
+  /**
+   * Groups routes by controller for better organization
+   */
+  groupRoutesByController(routes) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const controller = safeToString(route.controller);
+      if (!groups.has(controller)) {
+        groups.set(controller, []);
+      }
+      groups.get(controller).push(route);
+    }
+    return groups;
+  }
+  /**
+   * Analyzes route parameters to determine their types and usage
+   */
+  analyzeRouteParameters(route) {
+    const parameters = route.parameters || [];
+    const method = String(route.method || "").toLowerCase();
+    const isInPath = (p) => {
+      const pathSegment = p.data;
+      return !!pathSegment && typeof pathSegment === "string" && route.path.includes(`:${pathSegment}`);
+    };
+    const pathParams = parameters.filter((p) => isInPath(p)).map((p) => ({ ...p, required: true }));
+    const rawBody = parameters.filter((p) => !isInPath(p) && method !== "get");
+    const bodyParams = rawBody.map((p) => ({
+      ...p,
+      required: true
+    }));
+    const queryParams = parameters.filter((p) => !isInPath(p) && method === "get").map((p) => ({
+      ...p,
+      required: p.required === true
+      // default false if not provided
+    }));
+    return { pathParams, queryParams, bodyParams };
+  }
+};
+
+// src/services/route-analyzer.service.ts
+var import_honestjs = require("honestjs");
+var import_ts_morph = require("ts-morph");
+var RouteAnalyzerService = class {
+  constructor(controllerPattern, tsConfigPath) {
+    this.controllerPattern = controllerPattern;
+    this.tsConfigPath = tsConfigPath;
+  }
+  // Track projects for cleanup
+  projects = [];
+  /**
+   * Analyzes controller methods to extract type information
+   */
+  async analyzeControllerMethods() {
+    const routes = import_honestjs.RouteRegistry.getRoutes();
+    if (!routes?.length) {
+      return [];
+    }
+    const project = this.createProject();
+    const controllers = this.findControllerClasses(project);
+    if (controllers.size === 0) {
+      return [];
+    }
+    return this.processRoutes(routes, controllers);
+  }
+  /**
+   * Creates a new ts-morph project
+   */
+  createProject() {
+    const project = new import_ts_morph.Project({
+      tsConfigFilePath: this.tsConfigPath
+    });
+    project.addSourceFilesAtPaths([this.controllerPattern]);
+    this.projects.push(project);
+    return project;
+  }
+  /**
+   * Cleanup resources to prevent memory leaks
+   */
+  dispose() {
+    this.projects.forEach((project) => {
+      project.getSourceFiles().forEach((file) => project.removeSourceFile(file));
+    });
+    this.projects = [];
+  }
+  /**
+   * Finds controller classes in the project
+   */
+  findControllerClasses(project) {
+    const controllers = /* @__PURE__ */ new Map();
+    const files = project.getSourceFiles();
+    for (const sourceFile of files) {
+      const classes = sourceFile.getClasses();
+      for (const classDeclaration of classes) {
+        const className = classDeclaration.getName();
+        if (className?.endsWith("Controller")) {
+          controllers.set(className, classDeclaration);
+        }
+      }
+    }
+    return controllers;
+  }
+  /**
+   * Processes all routes and extracts type information
+   */
+  processRoutes(routes, controllers) {
+    const analyzedRoutes = [];
+    const errors = [];
+    for (const route of routes) {
+      try {
+        const extendedRoute = this.createExtendedRoute(route, controllers);
+        analyzedRoutes.push(extendedRoute);
+      } catch (routeError) {
+        const error = routeError instanceof Error ? routeError : new Error(String(routeError));
+        errors.push(error);
+        console.error(
+          `Error processing route ${safeToString(route.controller)}.${safeToString(route.handler)}:`,
+          routeError
+        );
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Failed to process ${errors.length} routes: ${errors.map((e) => e.message).join(", ")}`);
+    }
+    return analyzedRoutes;
+  }
+  /**
+   * Creates an extended route with type information
+   */
+  createExtendedRoute(route, controllers) {
+    const controllerName = safeToString(route.controller);
+    const handlerName = safeToString(route.handler);
+    const controllerClass = controllers.get(controllerName);
+    let returns;
+    let parameters;
+    if (controllerClass) {
+      const handlerMethod = controllerClass.getMethods().find((method) => method.getName() === handlerName);
+      if (handlerMethod) {
+        returns = this.getReturnType(handlerMethod);
+        parameters = this.getParametersWithTypes(handlerMethod, route.parameters || []);
+      }
+    }
+    return {
+      controller: controllerName,
+      handler: handlerName,
+      method: safeToString(route.method).toUpperCase(),
+      prefix: route.prefix,
+      version: route.version,
+      route: route.route,
+      path: route.path,
+      fullPath: buildFullPath(route.path, route.parameters),
+      parameters,
+      returns
+    };
+  }
+  /**
+   * Gets the return type of a method
+   */
+  getReturnType(method) {
+    const type = method.getReturnType();
+    const typeText = type.getText(method);
+    const aliasSymbol = type.getAliasSymbol();
+    if (aliasSymbol) {
+      return aliasSymbol.getName();
+    }
+    return typeText.replace(/import\(".*?"\)\./g, "");
+  }
+  /**
+   * Gets parameters with their types
+   */
+  getParametersWithTypes(method, parameters) {
+    const result = [];
+    const declaredParams = method.getParameters();
+    const sortedParams = [...parameters].sort((a, b) => a.index - b.index);
+    for (const param of sortedParams) {
+      const index = param.index;
+      if (index < declaredParams.length) {
+        const declaredParam = declaredParams[index];
+        const paramName = declaredParam.getName();
+        const paramType = declaredParam.getType().getText().replace(/import\(".*?"\)\./g, "");
+        result.push({
+          index,
+          name: paramName,
+          type: paramType,
+          required: true,
+          data: param.data,
+          factory: param.factory,
+          metatype: param.metatype
+        });
+      } else {
+        result.push({
+          index,
+          name: `param${index}`,
+          type: param.metatype?.name || "unknown",
+          required: true,
+          data: param.data,
+          factory: param.factory,
+          metatype: param.metatype
+        });
+      }
+    }
+    return result;
+  }
+};
+
+// src/services/schema-generator.service.ts
+var import_ts_json_schema_generator = require("ts-json-schema-generator");
+var import_ts_morph2 = require("ts-morph");
+
+// src/utils/schema-utils.ts
+function mapJsonSchemaTypeToTypeScript(schema) {
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      if (schema.enum && Array.isArray(schema.enum)) {
+        return `'${schema.enum.join("' | '")}'`;
+      }
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array": {
+      const itemType = mapJsonSchemaTypeToTypeScript(schema.items || {});
+      return `${itemType}[]`;
+    }
+    case "object":
+      return "Record<string, any>";
+    default:
+      return "any";
+  }
+}
+function generateTypeScriptInterface(typeName, schema) {
+  try {
+    const typeDefinition = schema.definitions?.[typeName];
+    if (!typeDefinition) {
+      return `export interface ${typeName} {
+	// No schema definition found
+}`;
+    }
+    const properties = typeDefinition.properties || {};
+    const required = typeDefinition.required || [];
+    let interfaceCode = `export interface ${typeName} {
+`;
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(propName);
+      const type = mapJsonSchemaTypeToTypeScript(propSchema);
+      const optional = isRequired ? "" : "?";
+      interfaceCode += `	${propName}${optional}: ${type}
+`;
+    }
+    interfaceCode += "}";
+    return interfaceCode;
+  } catch (error) {
+    console.error(`Failed to generate TypeScript interface for ${typeName}:`, error);
+    return `export interface ${typeName} {
+	// Failed to generate interface
+}`;
+  }
+}
+
+// src/utils/type-utils.ts
+function extractNamedType(type) {
+  const symbol = type.getAliasSymbol() || type.getSymbol();
+  if (!symbol) return null;
+  const name = symbol.getName();
+  if (GENERIC_TYPES.has(name)) {
+    const inner = type.getAliasTypeArguments()?.[0] || type.getTypeArguments()?.[0];
+    return inner ? extractNamedType(inner) : null;
+  }
+  if (BUILTIN_TYPES.has(name)) return null;
+  return name;
+}
+function generateTypeImports(routes) {
+  const types = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.parameters) {
+      for (const param of route.parameters) {
+        if (param.type && !["string", "number", "boolean"].includes(param.type)) {
+          const typeMatch = param.type.match(/(\w+)(?:<.*>)?/);
+          if (typeMatch) {
+            const typeName = typeMatch[1];
+            if (!BUILTIN_UTILITY_TYPES.has(typeName)) {
+              types.add(typeName);
+            }
+          }
+        }
+      }
+    }
+    if (route.returns) {
+      const returnType = route.returns.replace(/Promise<(.+)>/, "$1");
+      const baseType = returnType.replace(/\[\]$/, "");
+      if (!["string", "number", "boolean", "any", "void", "unknown"].includes(baseType)) {
+        types.add(baseType);
+      }
+    }
+  }
+  return Array.from(types).join(", ");
+}
+
+// src/services/schema-generator.service.ts
+var SchemaGeneratorService = class {
+  constructor(controllerPattern, tsConfigPath) {
+    this.controllerPattern = controllerPattern;
+    this.tsConfigPath = tsConfigPath;
+  }
+  // Track projects for cleanup
+  projects = [];
+  /**
+   * Generates JSON schemas from types used in controllers
+   */
+  async generateSchemas() {
+    const project = this.createProject();
+    const sourceFiles = project.getSourceFiles(this.controllerPattern);
+    const collectedTypes = this.collectTypesFromControllers(sourceFiles);
+    return this.processTypes(collectedTypes);
+  }
+  /**
+   * Creates a new ts-morph project
+   */
+  createProject() {
+    const project = new import_ts_morph2.Project({
+      tsConfigFilePath: this.tsConfigPath
+    });
+    this.projects.push(project);
+    return project;
+  }
+  /**
+   * Cleanup resources to prevent memory leaks
+   */
+  dispose() {
+    this.projects.forEach((project) => {
+      project.getSourceFiles().forEach((file) => project.removeSourceFile(file));
+    });
+    this.projects = [];
+  }
+  /**
+   * Collects types from controller files
+   */
+  collectTypesFromControllers(sourceFiles) {
+    const collectedTypes = /* @__PURE__ */ new Set();
+    for (const file of sourceFiles) {
+      for (const cls of file.getClasses()) {
+        for (const method of cls.getMethods()) {
+          this.collectTypesFromMethod(method, collectedTypes);
+        }
+      }
+    }
+    return collectedTypes;
+  }
+  /**
+   * Collects types from a single method
+   */
+  collectTypesFromMethod(method, collectedTypes) {
+    for (const param of method.getParameters()) {
+      const type2 = extractNamedType(param.getType());
+      if (type2) collectedTypes.add(type2);
+    }
+    const returnType = method.getReturnType();
+    const innerType = returnType.getTypeArguments()[0] ?? returnType;
+    const type = extractNamedType(innerType);
+    if (type) collectedTypes.add(type);
+  }
+  /**
+   * Processes collected types to generate schemas
+   */
+  async processTypes(collectedTypes) {
+    const schemas = [];
+    for (const typeName of collectedTypes) {
+      try {
+        const schema = await this.generateSchemaForType(typeName);
+        const typescriptType = generateTypeScriptInterface(typeName, schema);
+        schemas.push({
+          type: typeName,
+          schema,
+          typescriptType
+        });
+      } catch (err) {
+        console.error(`Failed to generate schema for ${typeName}:`, err);
+      }
+    }
+    return schemas;
+  }
+  /**
+   * Generates schema for a specific type
+   */
+  async generateSchemaForType(typeName) {
+    try {
+      const generator = (0, import_ts_json_schema_generator.createGenerator)({
+        path: this.controllerPattern,
+        tsconfig: this.tsConfigPath,
+        type: typeName,
+        skipTypeCheck: false
+        // Enable type checking for better error detection
+      });
+      return generator.createSchema(typeName);
+    } catch (error) {
+      console.error(`Failed to generate schema for type ${typeName}:`, error);
+      return {
+        type: "object",
+        properties: {},
+        required: []
+      };
+    }
+  }
+};
+
+// src/rpc.plugin.ts
+var RPCPlugin = class {
+  controllerPattern;
+  tsConfigPath;
+  outputDir;
+  generateOnInit;
+  // Services
+  routeAnalyzer;
+  schemaGenerator;
+  clientGenerator;
+  // Internal state
+  analyzedRoutes = [];
+  analyzedSchemas = [];
+  generatedInfo = null;
+  constructor(options = {}) {
+    this.controllerPattern = options.controllerPattern ?? DEFAULT_OPTIONS.controllerPattern;
+    this.tsConfigPath = options.tsConfigPath ?? import_path2.default.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
+    this.outputDir = options.outputDir ?? import_path2.default.resolve(process.cwd(), DEFAULT_OPTIONS.outputDir);
+    this.generateOnInit = options.generateOnInit ?? DEFAULT_OPTIONS.generateOnInit;
+    this.routeAnalyzer = new RouteAnalyzerService(this.controllerPattern, this.tsConfigPath);
+    this.schemaGenerator = new SchemaGeneratorService(this.controllerPattern, this.tsConfigPath);
+    this.clientGenerator = new ClientGeneratorService(this.outputDir);
+    this.validateConfiguration();
+  }
+  /**
+   * Validates the plugin configuration
+   */
+  validateConfiguration() {
+    const errors = [];
+    if (!this.controllerPattern?.trim()) {
+      errors.push("Controller pattern cannot be empty");
+    }
+    if (!this.tsConfigPath?.trim()) {
+      errors.push("TypeScript config path cannot be empty");
+    } else {
+      if (!import_fs.default.existsSync(this.tsConfigPath)) {
+        errors.push(`TypeScript config file not found at: ${this.tsConfigPath}`);
+      }
+    }
+    if (!this.outputDir?.trim()) {
+      errors.push("Output directory cannot be empty");
+    }
+    if (errors.length > 0) {
+      throw new Error(`Configuration validation failed: ${errors.join(", ")}`);
+    }
+    this.log(
+      `Configuration validated: controllerPattern=${this.controllerPattern}, tsConfigPath=${this.tsConfigPath}, outputDir=${this.outputDir}`
+    );
+  }
+  /**
+   * Called after all modules are registered
+   */
+  afterModulesRegistered = async (app, hono) => {
+    if (this.generateOnInit) {
+      await this.analyzeEverything();
+    }
+  };
+  /**
+   * Main analysis method that coordinates all three components
+   */
+  async analyzeEverything() {
+    try {
+      this.log("Starting comprehensive RPC analysis...");
+      this.analyzedRoutes.push(...await this.routeAnalyzer.analyzeControllerMethods());
+      this.analyzedSchemas.push(...await this.schemaGenerator.generateSchemas());
+      this.generatedInfo = await this.clientGenerator.generateClient(this.analyzedRoutes, this.analyzedSchemas);
+      this.log(
+        `\u2705 RPC analysis complete: ${this.analyzedRoutes.length} routes, ${this.analyzedSchemas.length} schemas`
+      );
+    } catch (error) {
+      this.logError("Error during RPC analysis:", error);
+      this.dispose();
+      throw error;
+    }
+  }
+  /**
+   * Manually trigger analysis (useful for testing or re-generation)
+   */
+  async analyze() {
+    await this.analyzeEverything();
+  }
+  /**
+   * Get the analyzed routes
+   */
+  getRoutes() {
+    return this.analyzedRoutes;
+  }
+  /**
+   * Get the analyzed schemas
+   */
+  getSchemas() {
+    return this.analyzedSchemas;
+  }
+  /**
+   * Get the generation info
+   */
+  getGenerationInfo() {
+    return this.generatedInfo;
+  }
+  /**
+   * Cleanup resources to prevent memory leaks
+   */
+  dispose() {
+    this.routeAnalyzer.dispose();
+    this.schemaGenerator.dispose();
+    this.log("Resources cleaned up");
+  }
+  /**
+   * Plugin lifecycle cleanup
+   */
+  onDestroy() {
+    this.dispose();
+  }
+  // ============================================================================
+  // LOGGING UTILITIES
+  // ============================================================================
+  /**
+   * Logs a message with the plugin prefix
+   */
+  log(message) {
+    console.log(`${LOG_PREFIX} ${message}`);
+  }
+  /**
+   * Logs an error with the plugin prefix
+   */
+  logError(message, error) {
+    console.error(`${LOG_PREFIX} ${message}`, error || "");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILTIN_TYPES,
+  BUILTIN_UTILITY_TYPES,
+  ClientGeneratorService,
+  DEFAULT_OPTIONS,
+  GENERIC_TYPES,
+  LOG_PREFIX,
+  RPCPlugin,
+  RouteAnalyzerService,
+  SchemaGeneratorService,
+  buildFullApiPath,
+  buildFullPath,
+  camelCase,
+  extractNamedType,
+  generateTypeImports,
+  generateTypeScriptInterface,
+  mapJsonSchemaTypeToTypeScript,
+  safeToString
+});
+//# sourceMappingURL=index.js.map