@honestjs/rpc-plugin 1.2.0 → 1.4.0

package/dist/index.mjs

@@ -1,13 +1,20 @@
 // src/rpc.plugin.ts
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
+import { Project } from "ts-morph";
 
 // src/constants/defaults.ts
 var DEFAULT_OPTIONS = {
   controllerPattern: "src/modules/*/*.controller.ts",
   tsConfigPath: "tsconfig.json",
   outputDir: "./generated/rpc",
-  generateOnInit: true
+  generateOnInit: true,
+  context: {
+    namespace: "rpc",
+    keys: {
+      artifact: "artifact"
+    }
+  }
 };
 var LOG_PREFIX = "[ RPCPlugin ]";
 var BUILTIN_UTILITY_TYPES = /* @__PURE__ */ new Set([
@@ -25,29 +32,66 @@ var BUILTIN_UTILITY_TYPES = /* @__PURE__ */ new Set([
 var BUILTIN_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "any", "void", "unknown"]);
 var GENERIC_TYPES = /* @__PURE__ */ new Set(["Array", "Promise", "Partial"]);
 
+// src/utils/hash-utils.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+var CHECKSUM_FILENAME = ".rpc-checksum";
+function computeHash(filePaths) {
+  const sorted = [...filePaths].sort();
+  const hasher = createHash("sha256");
+  hasher.update(`files:${sorted.length}
+`);
+  for (const filePath of sorted) {
+    hasher.update(readFileSync(filePath, "utf-8"));
+    hasher.update("\0");
+  }
+  return hasher.digest("hex");
+}
+function readChecksum(outputDir) {
+  const checksumPath = path.join(outputDir, CHECKSUM_FILENAME);
+  if (!existsSync(checksumPath)) return null;
+  try {
+    const raw = readFileSync(checksumPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data.hash !== "string" || !Array.isArray(data.files)) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function writeChecksum(outputDir, data) {
+  await mkdir(outputDir, { recursive: true });
+  const checksumPath = path.join(outputDir, CHECKSUM_FILENAME);
+  await writeFile(checksumPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
 // src/services/client-generator.service.ts
 import fs from "fs/promises";
-import path from "path";
+import path2 from "path";
 
 // src/utils/path-utils.ts
 function buildFullPath(basePath, parameters) {
   if (!basePath || typeof basePath !== "string") return "/";
-  let path3 = basePath;
+  let path4 = 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}}`);
+        path4 = path4.replace(`:${paramName}`, `\${${paramName}}`);
       }
     }
   }
-  return path3;
+  return path4;
 }
 function buildFullApiPath(route) {
   const prefix = route.prefix || "";
   const version = route.version || "";
   const routePath = route.route || "";
-  const path3 = route.path || "";
+  const path4 = route.path || "";
   let fullPath = "";
   if (prefix && prefix !== "/") {
     fullPath += prefix.replace(/^\/+|\/+$/g, "");
@@ -58,11 +102,12 @@ function buildFullApiPath(route) {
   if (routePath && routePath !== "/") {
     fullPath += `/${routePath.replace(/^\/+|\/+$/g, "")}`;
   }
-  if (path3 && path3 !== "/") {
-    fullPath += `/${path3.replace(/^\/+|\/+$/g, "")}`;
-  } else if (path3 === "/") {
+  if (path4 && path4 !== "/") {
+    fullPath += `/${path4.replace(/^\/+|\/+$/g, "")}`;
+  } else if (path4 === "/") {
     fullPath += "/";
   }
+  if (fullPath && !fullPath.startsWith("/")) fullPath = "/" + fullPath;
   return fullPath || "/";
 }
 
@@ -88,7 +133,7 @@ var ClientGeneratorService = class {
     await fs.mkdir(this.outputDir, { recursive: true });
     await this.generateClientFile(routes, schemas);
     const generatedInfo = {
-      clientFile: path.join(this.outputDir, "client.ts"),
+      clientFile: path2.join(this.outputDir, "client.ts"),
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     return generatedInfo;
@@ -98,7 +143,7 @@ var ClientGeneratorService = class {
    */
   async generateClientFile(routes, schemas) {
     const clientContent = this.generateClientContent(routes, schemas);
-    const clientPath = path.join(this.outputDir, "client.ts");
+    const clientPath = path2.join(this.outputDir, "client.ts");
     await fs.writeFile(clientPath, clientContent, "utf-8");
   }
   /**
@@ -258,6 +303,14 @@ export class ApiClient {
 
 		try {
 			const response = await this.fetchFn(url.toString(), requestOptions)
+
+			if (response.status === 204 || response.headers.get('content-length') === '0') {
+				if (!response.ok) {
+					throw new ApiError(response.status, 'Request failed')
+				}
+				return undefined as T
+			}
+
 			const responseData = await response.json()
 
 			if (!response.ok) {
@@ -400,71 +453,30 @@ ${this.generateControllerMethods(controllerGroups)}
    */
   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
-    }));
+    const pathParams = parameters.filter((p) => p.decoratorType === "param").map((p) => ({ ...p, required: true }));
+    const bodyParams = parameters.filter((p) => p.decoratorType === "body").map((p) => ({ ...p, required: true }));
+    const queryParams = parameters.filter((p) => p.decoratorType === "query").map((p) => ({ ...p, required: p.required === true }));
     return { pathParams, queryParams, bodyParams };
   }
 };
 
 // src/services/route-analyzer.service.ts
 import { RouteRegistry } from "honestjs";
-import { Project } from "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() {
+  async analyzeControllerMethods(project) {
     const routes = 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 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
    */
@@ -487,23 +499,17 @@ var RouteAnalyzerService = class {
    */
   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)}:`,
+        console.warn(
+          `${LOG_PREFIX} Skipping 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;
   }
   /**
@@ -556,6 +562,7 @@ var RouteAnalyzerService = class {
     const sortedParams = [...parameters].sort((a, b) => a.index - b.index);
     for (const param of sortedParams) {
       const index = param.index;
+      const decoratorType = param.name;
       if (index < declaredParams.length) {
         const declaredParam = declaredParams[index];
         const paramName = declaredParam.getName();
@@ -563,6 +570,7 @@ var RouteAnalyzerService = class {
         result.push({
           index,
           name: paramName,
+          decoratorType,
           type: paramType,
           required: true,
           data: param.data,
@@ -573,6 +581,7 @@ var RouteAnalyzerService = class {
         result.push({
           index,
           name: `param${index}`,
+          decoratorType,
           type: param.metatype?.name || "unknown",
           required: true,
           data: param.data,
@@ -587,7 +596,6 @@ var RouteAnalyzerService = class {
 
 // src/services/schema-generator.service.ts
 import { createGenerator } from "ts-json-schema-generator";
-import { Project as Project2 } from "ts-morph";
 
 // src/utils/schema-utils.ts
 function mapJsonSchemaTypeToTypeScript(schema) {
@@ -654,32 +662,6 @@ function extractNamedType(type) {
   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 {
@@ -687,37 +669,14 @@ var SchemaGeneratorService = class {
     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();
+  async generateSchemas(project) {
     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 Project2({
-      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 = [];
-  }
   /**
    * Collects types from controller files
    */
@@ -795,20 +754,27 @@ var RPCPlugin = class {
   tsConfigPath;
   outputDir;
   generateOnInit;
+  contextNamespace;
+  contextArtifactKey;
   // Services
   routeAnalyzer;
   schemaGenerator;
   clientGenerator;
+  // Shared ts-morph project
+  project = null;
   // Internal state
   analyzedRoutes = [];
   analyzedSchemas = [];
   generatedInfo = null;
+  app = null;
   constructor(options = {}) {
     this.controllerPattern = options.controllerPattern ?? DEFAULT_OPTIONS.controllerPattern;
-    this.tsConfigPath = options.tsConfigPath ?? path2.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
-    this.outputDir = options.outputDir ?? path2.resolve(process.cwd(), DEFAULT_OPTIONS.outputDir);
+    this.tsConfigPath = options.tsConfigPath ?? path3.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
+    this.outputDir = options.outputDir ?? path3.resolve(process.cwd(), DEFAULT_OPTIONS.outputDir);
     this.generateOnInit = options.generateOnInit ?? DEFAULT_OPTIONS.generateOnInit;
-    this.routeAnalyzer = new RouteAnalyzerService(this.controllerPattern, this.tsConfigPath);
+    this.contextNamespace = options.context?.namespace ?? DEFAULT_OPTIONS.context.namespace;
+    this.contextArtifactKey = options.context?.keys?.artifact ?? DEFAULT_OPTIONS.context.keys.artifact;
+    this.routeAnalyzer = new RouteAnalyzerService();
     this.schemaGenerator = new SchemaGeneratorService(this.controllerPattern, this.tsConfigPath);
     this.clientGenerator = new ClientGeneratorService(this.outputDir);
     this.validateConfiguration();
@@ -831,6 +797,12 @@ var RPCPlugin = class {
     if (!this.outputDir?.trim()) {
       errors.push("Output directory cannot be empty");
     }
+    if (!this.contextNamespace?.trim()) {
+      errors.push("Context namespace cannot be empty");
+    }
+    if (!this.contextArtifactKey?.trim()) {
+      errors.push("Context artifact key cannot be empty");
+    }
     if (errors.length > 0) {
       throw new Error(`Configuration validation failed: ${errors.join(", ")}`);
     }
@@ -842,22 +814,42 @@ var RPCPlugin = class {
    * Called after all modules are registered
    */
   afterModulesRegistered = async (app, hono) => {
+    this.app = app;
     if (this.generateOnInit) {
       await this.analyzeEverything();
+      this.publishArtifact(app);
     }
   };
   /**
    * Main analysis method that coordinates all three components
    */
-  async analyzeEverything() {
+  async analyzeEverything(force = false) {
     try {
       this.log("Starting comprehensive RPC analysis...");
+      this.dispose();
+      this.project = new Project({ tsConfigFilePath: this.tsConfigPath });
+      this.project.addSourceFilesAtPaths([this.controllerPattern]);
+      const filePaths = this.project.getSourceFiles().map((f) => f.getFilePath());
+      if (!force) {
+        const currentHash = computeHash(filePaths);
+        const stored = readChecksum(this.outputDir);
+        if (stored && stored.hash === currentHash && this.outputFilesExist()) {
+          if (this.loadArtifactFromDisk()) {
+            this.log("Source files unchanged \u2014 skipping regeneration");
+            this.dispose();
+            return;
+          }
+          this.log("Source files unchanged but cached artifact missing/invalid \u2014 regenerating");
+        }
+      }
       this.analyzedRoutes = [];
       this.analyzedSchemas = [];
       this.generatedInfo = null;
-      this.analyzedRoutes = await this.routeAnalyzer.analyzeControllerMethods();
-      this.analyzedSchemas = await this.schemaGenerator.generateSchemas();
+      this.analyzedRoutes = await this.routeAnalyzer.analyzeControllerMethods(this.project);
+      this.analyzedSchemas = await this.schemaGenerator.generateSchemas(this.project);
       this.generatedInfo = await this.clientGenerator.generateClient(this.analyzedRoutes, this.analyzedSchemas);
+      await writeChecksum(this.outputDir, { hash: computeHash(filePaths), files: filePaths });
+      this.writeArtifactToDisk();
       this.log(
         `\u2705 RPC analysis complete: ${this.analyzedRoutes.length} routes, ${this.analyzedSchemas.length} schemas`
       );
@@ -868,10 +860,14 @@ var RPCPlugin = class {
     }
   }
   /**
-   * Manually trigger analysis (useful for testing or re-generation)
+   * Manually trigger analysis (useful for testing or re-generation).
+   * Defaults to force=true to bypass cache; pass false to use caching.
    */
-  async analyze() {
-    await this.analyzeEverything();
+  async analyze(force = true) {
+    await this.analyzeEverything(force);
+    if (this.app) {
+      this.publishArtifact(this.app);
+    }
   }
   /**
    * Get the analyzed routes
@@ -891,13 +887,55 @@ var RPCPlugin = class {
   getGenerationInfo() {
     return this.generatedInfo;
   }
+  /**
+   * Checks whether expected output files exist on disk
+   */
+  outputFilesExist() {
+    return fs2.existsSync(path3.join(this.outputDir, "client.ts")) && fs2.existsSync(path3.join(this.outputDir, "rpc-artifact.json"));
+  }
+  getArtifactPath() {
+    return path3.join(this.outputDir, "rpc-artifact.json");
+  }
+  writeArtifactToDisk() {
+    const artifact = {
+      routes: this.analyzedRoutes,
+      schemas: this.analyzedSchemas
+    };
+    fs2.mkdirSync(this.outputDir, { recursive: true });
+    fs2.writeFileSync(this.getArtifactPath(), JSON.stringify(artifact));
+  }
+  loadArtifactFromDisk() {
+    try {
+      const raw = fs2.readFileSync(this.getArtifactPath(), "utf8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed.routes) || !Array.isArray(parsed.schemas)) {
+        return false;
+      }
+      this.analyzedRoutes = parsed.routes;
+      this.analyzedSchemas = parsed.schemas;
+      this.generatedInfo = null;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  publishArtifact(app) {
+    app.getContext().set(this.getArtifactContextKey(), {
+      routes: this.analyzedRoutes,
+      schemas: this.analyzedSchemas
+    });
+  }
+  getArtifactContextKey() {
+    return `${this.contextNamespace}.${this.contextArtifactKey}`;
+  }
   /**
    * Cleanup resources to prevent memory leaks
    */
   dispose() {
-    this.routeAnalyzer.dispose();
-    this.schemaGenerator.dispose();
-    this.log("Resources cleaned up");
+    if (this.project) {
+      this.project.getSourceFiles().forEach((file) => this.project.removeSourceFile(file));
+      this.project = null;
+    }
   }
   // ============================================================================
   // LOGGING UTILITIES
@@ -928,10 +966,12 @@ export {
   buildFullApiPath,
   buildFullPath,
   camelCase,
+  computeHash,
   extractNamedType,
-  generateTypeImports,
   generateTypeScriptInterface,
   mapJsonSchemaTypeToTypeScript,
-  safeToString
+  readChecksum,
+  safeToString,
+  writeChecksum
 };
 //# sourceMappingURL=index.mjs.map