@honestjs/rpc-plugin 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,337 @@
+import { RouteInfo, ParameterMetadata, IPlugin, Application } from 'honestjs';
+import { Hono } from 'hono';
+import { Type } from 'ts-morph';
+
+/**
+ * Parameter metadata with enhanced type information
+ */
+interface ParameterMetadataWithType extends ParameterMetadata {
+    readonly type: string;
+    readonly required: boolean;
+    readonly name: string;
+}
+/**
+ * Extended route information with comprehensive type data
+ */
+interface ExtendedRouteInfo extends Omit<RouteInfo, 'parameters' | 'method'> {
+    readonly returns?: string;
+    readonly parameters?: readonly ParameterMetadataWithType[];
+    readonly method: string;
+    readonly fullPath: string;
+}
+/**
+ * Controller groups for organization
+ */
+type ControllerGroups = Map<string, readonly ExtendedRouteInfo[]>;
+/**
+ * Route parameter information for client generation
+ * Extends ParameterMetadataWithType for consistency
+ */
+interface RouteParameter extends ParameterMetadataWithType {
+}
+
+/**
+ * Schema with comprehensive type information
+ */
+interface SchemaInfo {
+    readonly type: string;
+    readonly schema: Record<string, any>;
+    readonly typescriptType?: string;
+}
+/**
+ * Generated client file information
+ */
+interface GeneratedClientInfo {
+    readonly clientFile: string;
+    readonly generatedAt: string;
+}
+
+/**
+ * Clean separation of concerns for request options
+ */
+type RequestOptions<TParams = never, TQuery = never, TBody = never, THeaders = never> = (TParams extends never ? {
+    params?: never;
+} : {
+    params: TParams;
+}) & (TQuery extends never ? {
+    query?: never;
+} : {
+    query?: TQuery;
+}) & (TBody extends never ? {
+    body?: never;
+} : {
+    body: TBody;
+}) & (THeaders extends never ? {
+    headers?: never;
+} : {
+    headers: THeaders;
+});
+/**
+ * API Response wrapper
+ */
+interface ApiResponse<T = any> {
+    data: T;
+    message?: string;
+    success: boolean;
+}
+/**
+ * API Error class
+ */
+declare class ApiError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+
+/**
+ * Configuration options for the RPCPlugin
+ */
+interface RPCPluginOptions {
+    readonly controllerPattern?: string;
+    readonly tsConfigPath?: string;
+    readonly outputDir?: string;
+    readonly generateOnInit?: boolean;
+}
+/**
+ * Comprehensive RPC plugin that combines route analysis, schema generation, and client generation
+ */
+declare class RPCPlugin implements IPlugin {
+    private readonly controllerPattern;
+    private readonly tsConfigPath;
+    private readonly outputDir;
+    private readonly generateOnInit;
+    private readonly routeAnalyzer;
+    private readonly schemaGenerator;
+    private readonly clientGenerator;
+    private readonly analyzedRoutes;
+    private readonly analyzedSchemas;
+    private generatedInfo;
+    constructor(options?: RPCPluginOptions);
+    /**
+     * Validates the plugin configuration
+     */
+    private validateConfiguration;
+    /**
+     * Called after all modules are registered
+     */
+    afterModulesRegistered: (app: Application, hono: Hono) => Promise<void>;
+    /**
+     * Main analysis method that coordinates all three components
+     */
+    private analyzeEverything;
+    /**
+     * Manually trigger analysis (useful for testing or re-generation)
+     */
+    analyze(): Promise<void>;
+    /**
+     * Get the analyzed routes
+     */
+    getRoutes(): readonly ExtendedRouteInfo[];
+    /**
+     * Get the analyzed schemas
+     */
+    getSchemas(): readonly SchemaInfo[];
+    /**
+     * Get the generation info
+     */
+    getGenerationInfo(): GeneratedClientInfo | null;
+    /**
+     * Cleanup resources to prevent memory leaks
+     */
+    dispose(): void;
+    /**
+     * Plugin lifecycle cleanup
+     */
+    onDestroy(): void;
+    /**
+     * Logs a message with the plugin prefix
+     */
+    private log;
+    /**
+     * Logs an error with the plugin prefix
+     */
+    private logError;
+}
+
+/**
+ * Service for generating TypeScript RPC clients
+ */
+declare class ClientGeneratorService {
+    private readonly outputDir;
+    constructor(outputDir: string);
+    /**
+     * Generates the TypeScript RPC client
+     */
+    generateClient(routes: readonly ExtendedRouteInfo[], schemas: readonly SchemaInfo[]): Promise<GeneratedClientInfo>;
+    /**
+     * Generates the main client file with types included
+     */
+    private generateClientFile;
+    /**
+     * Generates the client TypeScript content with types included
+     */
+    private generateClientContent;
+    /**
+     * Generates controller methods for the client
+     */
+    private generateControllerMethods;
+    /**
+     * Extracts the proper return type from route analysis
+     */
+    private extractReturnType;
+    /**
+     * Generates schema types from integrated schema generation
+     */
+    private generateSchemaTypes;
+    /**
+     * Groups routes by controller for better organization
+     */
+    private groupRoutesByController;
+    /**
+     * Analyzes route parameters to determine their types and usage
+     */
+    private analyzeRouteParameters;
+}
+
+/**
+ * Service for analyzing controller methods and extracting type information
+ */
+declare class RouteAnalyzerService {
+    private readonly controllerPattern;
+    private readonly tsConfigPath;
+    constructor(controllerPattern: string, tsConfigPath: string);
+    private projects;
+    /**
+     * Analyzes controller methods to extract type information
+     */
+    analyzeControllerMethods(): Promise<ExtendedRouteInfo[]>;
+    /**
+     * Creates a new ts-morph project
+     */
+    private createProject;
+    /**
+     * Cleanup resources to prevent memory leaks
+     */
+    dispose(): void;
+    /**
+     * Finds controller classes in the project
+     */
+    private findControllerClasses;
+    /**
+     * Processes all routes and extracts type information
+     */
+    private processRoutes;
+    /**
+     * Creates an extended route with type information
+     */
+    private createExtendedRoute;
+    /**
+     * Gets the return type of a method
+     */
+    private getReturnType;
+    /**
+     * Gets parameters with their types
+     */
+    private getParametersWithTypes;
+}
+
+/**
+ * Service for generating JSON schemas from TypeScript types used in controllers
+ */
+declare class SchemaGeneratorService {
+    private readonly controllerPattern;
+    private readonly tsConfigPath;
+    constructor(controllerPattern: string, tsConfigPath: string);
+    private projects;
+    /**
+     * Generates JSON schemas from types used in controllers
+     */
+    generateSchemas(): Promise<SchemaInfo[]>;
+    /**
+     * Creates a new ts-morph project
+     */
+    private createProject;
+    /**
+     * Cleanup resources to prevent memory leaks
+     */
+    dispose(): void;
+    /**
+     * Collects types from controller files
+     */
+    private collectTypesFromControllers;
+    /**
+     * Collects types from a single method
+     */
+    private collectTypesFromMethod;
+    /**
+     * Processes collected types to generate schemas
+     */
+    private processTypes;
+    /**
+     * Generates schema for a specific type
+     */
+    private generateSchemaForType;
+}
+
+/**
+ * Builds the full path with parameter placeholders
+ */
+declare function buildFullPath(basePath: string, parameters: readonly ParameterMetadata[]): string;
+/**
+ * Builds the full API path using route information
+ */
+declare function buildFullApiPath(route: ExtendedRouteInfo): string;
+
+/**
+ * Maps JSON schema types to TypeScript types
+ */
+declare function mapJsonSchemaTypeToTypeScript(schema: Record<string, any>): string;
+/**
+ * Generates TypeScript interface from JSON schema
+ */
+declare function generateTypeScriptInterface(typeName: string, schema: Record<string, any>): string;
+
+/**
+ * Safely converts a value to string, handling symbols and other types
+ */
+declare function safeToString(value: unknown): string;
+/**
+ * Converts a string to camelCase
+ */
+declare function camelCase(str: string): string;
+
+/**
+ * Extracts a named type from a TypeScript type
+ */
+declare function extractNamedType(type: Type): string | null;
+/**
+ * Generates type imports for the client
+ */
+declare function generateTypeImports(routes: readonly any[]): string;
+
+/**
+ * Default configuration options for the RPCPlugin
+ */
+declare const DEFAULT_OPTIONS: {
+    readonly controllerPattern: "src/modules/*/*.controller.ts";
+    readonly tsConfigPath: "tsconfig.json";
+    readonly outputDir: "./generated/rpc";
+    readonly generateOnInit: true;
+};
+/**
+ * Log prefix for the RPC plugin
+ */
+declare const LOG_PREFIX = "[ RPCPlugin ]";
+/**
+ * Built-in TypeScript types that should not be imported
+ */
+declare const BUILTIN_UTILITY_TYPES: Set<string>;
+/**
+ * Built-in TypeScript types that should be skipped
+ */
+declare const BUILTIN_TYPES: Set<string>;
+/**
+ * Generic type names that should be unwrapped
+ */
+declare const GENERIC_TYPES: Set<string>;
+
+export { ApiError, type ApiResponse, BUILTIN_TYPES, BUILTIN_UTILITY_TYPES, ClientGeneratorService, type ControllerGroups, DEFAULT_OPTIONS, type ExtendedRouteInfo, GENERIC_TYPES, type GeneratedClientInfo, LOG_PREFIX, type ParameterMetadataWithType, RPCPlugin, type RPCPluginOptions, type RequestOptions, RouteAnalyzerService, type RouteParameter, SchemaGeneratorService, type SchemaInfo, buildFullApiPath, buildFullPath, camelCase, extractNamedType, generateTypeImports, generateTypeScriptInterface, mapJsonSchemaTypeToTypeScript, safeToString };