@honestjs/rpc-plugin 1.2.0 → 1.4.0

package/dist/index.js

@@ -42,24 +42,33 @@ __export(index_exports, {
   buildFullApiPath: () => buildFullApiPath,
   buildFullPath: () => buildFullPath,
   camelCase: () => camelCase,
+  computeHash: () => computeHash,
   extractNamedType: () => extractNamedType,
-  generateTypeImports: () => generateTypeImports,
   generateTypeScriptInterface: () => generateTypeScriptInterface,
   mapJsonSchemaTypeToTypeScript: () => mapJsonSchemaTypeToTypeScript,
-  safeToString: () => safeToString
+  readChecksum: () => readChecksum,
+  safeToString: () => safeToString,
+  writeChecksum: () => writeChecksum
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/rpc.plugin.ts
-var import_fs = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_ts_morph = require("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([
@@ -77,29 +86,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/services/client-generator.service.ts
-var import_promises = __toESM(require("fs/promises"));
+// src/utils/hash-utils.ts
+var import_crypto = require("crypto");
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
 var import_path = __toESM(require("path"));
+var CHECKSUM_FILENAME = ".rpc-checksum";
+function computeHash(filePaths) {
+  const sorted = [...filePaths].sort();
+  const hasher = (0, import_crypto.createHash)("sha256");
+  hasher.update(`files:${sorted.length}
+`);
+  for (const filePath of sorted) {
+    hasher.update((0, import_fs.readFileSync)(filePath, "utf-8"));
+    hasher.update("\0");
+  }
+  return hasher.digest("hex");
+}
+function readChecksum(outputDir) {
+  const checksumPath = import_path.default.join(outputDir, CHECKSUM_FILENAME);
+  if (!(0, import_fs.existsSync)(checksumPath)) return null;
+  try {
+    const raw = (0, import_fs.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 (0, import_promises.mkdir)(outputDir, { recursive: true });
+  const checksumPath = import_path.default.join(outputDir, CHECKSUM_FILENAME);
+  await (0, import_promises.writeFile)(checksumPath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+// src/services/client-generator.service.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("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, "");
@@ -110,11 +156,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 || "/";
 }
 
@@ -137,10 +184,10 @@ var ClientGeneratorService = class {
    * Generates the TypeScript RPC client
    */
   async generateClient(routes, schemas) {
-    await import_promises.default.mkdir(this.outputDir, { recursive: true });
+    await import_promises2.default.mkdir(this.outputDir, { recursive: true });
     await this.generateClientFile(routes, schemas);
     const generatedInfo = {
-      clientFile: import_path.default.join(this.outputDir, "client.ts"),
+      clientFile: import_path2.default.join(this.outputDir, "client.ts"),
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     return generatedInfo;
@@ -150,8 +197,8 @@ var ClientGeneratorService = class {
    */
   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");
+    const clientPath = import_path2.default.join(this.outputDir, "client.ts");
+    await import_promises2.default.writeFile(clientPath, clientContent, "utf-8");
   }
   /**
    * Generates the client TypeScript content with types included
@@ -310,6 +357,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) {
@@ -452,71 +507,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
 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() {
+  async analyzeControllerMethods(project) {
     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
    */
@@ -539,23 +553,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;
   }
   /**
@@ -608,6 +616,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();
@@ -615,6 +624,7 @@ var RouteAnalyzerService = class {
         result.push({
           index,
           name: paramName,
+          decoratorType,
           type: paramType,
           required: true,
           data: param.data,
@@ -625,6 +635,7 @@ var RouteAnalyzerService = class {
         result.push({
           index,
           name: `param${index}`,
+          decoratorType,
           type: param.metatype?.name || "unknown",
           required: true,
           data: param.data,
@@ -639,7 +650,6 @@ var RouteAnalyzerService = class {
 
 // 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) {
@@ -706,32 +716,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 {
@@ -739,37 +723,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 import_ts_morph2.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 = [];
-  }
   /**
    * Collects types from controller files
    */
@@ -847,20 +808,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 ?? import_path2.default.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
-    this.outputDir = options.outputDir ?? import_path2.default.resolve(process.cwd(), DEFAULT_OPTIONS.outputDir);
+    this.tsConfigPath = options.tsConfigPath ?? import_path3.default.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
+    this.outputDir = options.outputDir ?? import_path3.default.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();
@@ -876,13 +844,19 @@ var RPCPlugin = class {
     if (!this.tsConfigPath?.trim()) {
       errors.push("TypeScript config path cannot be empty");
     } else {
-      if (!import_fs.default.existsSync(this.tsConfigPath)) {
+      if (!import_fs2.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 (!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(", ")}`);
     }
@@ -894,22 +868,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 import_ts_morph.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`
       );
@@ -920,10 +914,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
@@ -943,13 +941,55 @@ var RPCPlugin = class {
   getGenerationInfo() {
     return this.generatedInfo;
   }
+  /**
+   * Checks whether expected output files exist on disk
+   */
+  outputFilesExist() {
+    return import_fs2.default.existsSync(import_path3.default.join(this.outputDir, "client.ts")) && import_fs2.default.existsSync(import_path3.default.join(this.outputDir, "rpc-artifact.json"));
+  }
+  getArtifactPath() {
+    return import_path3.default.join(this.outputDir, "rpc-artifact.json");
+  }
+  writeArtifactToDisk() {
+    const artifact = {
+      routes: this.analyzedRoutes,
+      schemas: this.analyzedSchemas
+    };
+    import_fs2.default.mkdirSync(this.outputDir, { recursive: true });
+    import_fs2.default.writeFileSync(this.getArtifactPath(), JSON.stringify(artifact));
+  }
+  loadArtifactFromDisk() {
+    try {
+      const raw = import_fs2.default.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
@@ -981,10 +1021,12 @@ var RPCPlugin = class {
   buildFullApiPath,
   buildFullPath,
   camelCase,
+  computeHash,
   extractNamedType,
-  generateTypeImports,
   generateTypeScriptInterface,
   mapJsonSchemaTypeToTypeScript,
-  safeToString
+  readChecksum,
+  safeToString,
+  writeChecksum
 });
 //# sourceMappingURL=index.js.map