@honestjs/rpc-plugin 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // src/rpc.plugin.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs2 from "fs";
+import path3 from "path";
 import { Project } from "ts-morph";
 
 // src/constants/defaults.ts
@@ -8,7 +8,13 @@ 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([
@@ -70,22 +76,22 @@ import path2 from "path";
 // src/utils/path-utils.ts
 function buildFullPath(basePath, parameters) {
   if (!basePath || typeof basePath !== "string") return "/";
-  let path5 = 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);
-        path5 = path5.replace(`:${paramName}`, `\${${paramName}}`);
+        path4 = path4.replace(`:${paramName}`, `\${${paramName}}`);
       }
     }
   }
-  return path5;
+  return path4;
 }
 function buildFullApiPath(route) {
   const prefix = route.prefix || "";
   const version = route.version || "";
   const routePath = route.route || "";
-  const path5 = route.path || "";
+  const path4 = route.path || "";
   let fullPath = "";
   if (prefix && prefix !== "/") {
     fullPath += prefix.replace(/^\/+|\/+$/g, "");
@@ -96,9 +102,9 @@ function buildFullApiPath(route) {
   if (routePath && routePath !== "/") {
     fullPath += `/${routePath.replace(/^\/+|\/+$/g, "")}`;
   }
-  if (path5 && path5 !== "/") {
-    fullPath += `/${path5.replace(/^\/+|\/+$/g, "")}`;
-  } else if (path5 === "/") {
+  if (path4 && path4 !== "/") {
+    fullPath += `/${path4.replace(/^\/+|\/+$/g, "")}`;
+  } else if (path4 === "/") {
     fullPath += "/";
   }
   if (fullPath && !fullPath.startsWith("/")) fullPath = "/" + fullPath;
@@ -454,192 +460,6 @@ ${this.generateControllerMethods(controllerGroups)}
   }
 };
 
-// src/services/openapi-generator.service.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-var OpenApiGeneratorService = class {
-  constructor(outputDir) {
-    this.outputDir = outputDir;
-  }
-  async generateSpec(routes, schemas, options) {
-    await fs2.mkdir(this.outputDir, { recursive: true });
-    const schemaMap = this.buildSchemaMap(schemas);
-    const spec = this.buildSpec(routes, schemaMap, options);
-    const outputPath = path3.join(this.outputDir, options.outputFile);
-    await fs2.writeFile(outputPath, JSON.stringify(spec, null, 2), "utf-8");
-    return outputPath;
-  }
-  buildSpec(routes, schemaMap, options) {
-    const spec = {
-      openapi: "3.0.3",
-      info: {
-        title: options.title,
-        version: options.version,
-        description: options.description
-      },
-      paths: {},
-      components: { schemas: schemaMap }
-    };
-    if (options.servers.length > 0) {
-      spec.servers = options.servers.map((s) => ({ ...s }));
-    }
-    for (const route of routes) {
-      const apiPath = this.toOpenApiPath(buildFullApiPath(route));
-      const method = safeToString(route.method).toLowerCase();
-      if (!spec.paths[apiPath]) {
-        spec.paths[apiPath] = {};
-      }
-      spec.paths[apiPath][method] = this.buildOperation(route, schemaMap);
-    }
-    return spec;
-  }
-  buildOperation(route, schemaMap) {
-    const controllerName = safeToString(route.controller).replace(/Controller$/, "");
-    const handlerName = safeToString(route.handler);
-    const parameters = route.parameters || [];
-    const operation = {
-      operationId: handlerName,
-      tags: [controllerName],
-      responses: this.buildResponses(route.returns, schemaMap)
-    };
-    const openApiParams = this.buildParameters(parameters);
-    if (openApiParams.length > 0) {
-      operation.parameters = openApiParams;
-    }
-    const requestBody = this.buildRequestBody(parameters, schemaMap);
-    if (requestBody) {
-      operation.requestBody = requestBody;
-    }
-    return operation;
-  }
-  buildParameters(parameters) {
-    const result = [];
-    for (const param of parameters) {
-      if (param.decoratorType === "param") {
-        result.push({
-          name: param.data ?? param.name,
-          in: "path",
-          required: true,
-          schema: this.tsTypeToJsonSchema(param.type)
-        });
-      } else if (param.decoratorType === "query") {
-        if (param.data) {
-          result.push({
-            name: param.data,
-            in: "query",
-            required: param.required === true,
-            schema: this.tsTypeToJsonSchema(param.type)
-          });
-        } else {
-          result.push({
-            name: param.name,
-            in: "query",
-            required: param.required === true,
-            schema: this.tsTypeToJsonSchema(param.type)
-          });
-        }
-      }
-    }
-    return result;
-  }
-  buildRequestBody(parameters, schemaMap) {
-    const bodyParams = parameters.filter((p) => p.decoratorType === "body");
-    if (bodyParams.length === 0) return null;
-    const bodyParam = bodyParams[0];
-    const typeName = this.extractBaseTypeName(bodyParam.type);
-    let schema;
-    if (typeName && schemaMap[typeName]) {
-      schema = { $ref: `#/components/schemas/${typeName}` };
-    } else {
-      schema = { type: "object" };
-    }
-    return {
-      required: true,
-      content: {
-        "application/json": { schema }
-      }
-    };
-  }
-  buildResponses(returns, schemaMap) {
-    const responseSchema = this.resolveResponseSchema(returns, schemaMap);
-    if (!responseSchema) {
-      return { "200": { description: "Successful response" } };
-    }
-    return {
-      "200": {
-        description: "Successful response",
-        content: {
-          "application/json": { schema: responseSchema }
-        }
-      }
-    };
-  }
-  resolveResponseSchema(returns, schemaMap) {
-    if (!returns) return null;
-    let innerType = returns;
-    const promiseMatch = returns.match(/^Promise<(.+)>$/);
-    if (promiseMatch) {
-      innerType = promiseMatch[1];
-    }
-    const isArray = innerType.endsWith("[]");
-    const baseType = isArray ? innerType.slice(0, -2) : innerType;
-    if (["string", "number", "boolean"].includes(baseType)) {
-      const primitiveSchema = this.tsTypeToJsonSchema(baseType);
-      return isArray ? { type: "array", items: primitiveSchema } : primitiveSchema;
-    }
-    if (["void", "any", "unknown"].includes(baseType)) return null;
-    if (schemaMap[baseType]) {
-      const ref = { $ref: `#/components/schemas/${baseType}` };
-      return isArray ? { type: "array", items: ref } : ref;
-    }
-    return null;
-  }
-  buildSchemaMap(schemas) {
-    const result = {};
-    for (const schemaInfo of schemas) {
-      const definition = schemaInfo.schema?.definitions?.[schemaInfo.type];
-      if (definition) {
-        result[schemaInfo.type] = definition;
-      }
-    }
-    return result;
-  }
-  /**
-   * Converts Express-style `:param` path to OpenAPI `{param}` syntax
-   */
-  toOpenApiPath(expressPath) {
-    return expressPath.replace(/:(\w+)/g, "{$1}");
-  }
-  tsTypeToJsonSchema(tsType) {
-    switch (tsType) {
-      case "number":
-        return { type: "number" };
-      case "boolean":
-        return { type: "boolean" };
-      case "string":
-      default:
-        return { type: "string" };
-    }
-  }
-  /**
-   * Extracts the base type name from a TS type string, stripping
-   * wrappers like `Partial<...>`, `...[]`, `Promise<...>`.
-   */
-  extractBaseTypeName(tsType) {
-    if (!tsType) return null;
-    let type = tsType;
-    const promiseMatch = type.match(/^Promise<(.+)>$/);
-    if (promiseMatch) type = promiseMatch[1];
-    type = type.replace(/\[\]$/, "");
-    const genericMatch = type.match(/^\w+<(\w+)>$/);
-    if (genericMatch) type = genericMatch[1];
-    if (["string", "number", "boolean", "any", "void", "unknown", "object"].includes(type)) {
-      return null;
-    }
-    return type;
-  }
-};
-
 // src/services/route-analyzer.service.ts
 import { RouteRegistry } from "honestjs";
 var RouteAnalyzerService = class {
@@ -934,41 +754,31 @@ var RPCPlugin = class {
   tsConfigPath;
   outputDir;
   generateOnInit;
+  contextNamespace;
+  contextArtifactKey;
   // Services
   routeAnalyzer;
   schemaGenerator;
   clientGenerator;
-  openApiGenerator;
-  openApiOptions;
   // 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 ?? path4.resolve(process.cwd(), DEFAULT_OPTIONS.tsConfigPath);
-    this.outputDir = options.outputDir ?? path4.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.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.openApiOptions = this.resolveOpenApiOptions(options.openapi);
-    this.openApiGenerator = this.openApiOptions ? new OpenApiGeneratorService(this.outputDir) : null;
     this.validateConfiguration();
   }
-  resolveOpenApiOptions(input) {
-    if (!input) return null;
-    const opts = input === true ? {} : input;
-    return {
-      title: opts.title ?? "API",
-      version: opts.version ?? "1.0.0",
-      description: opts.description ?? "",
-      servers: opts.servers ?? [],
-      outputFile: opts.outputFile ?? "openapi.json"
-    };
-  }
   /**
    * Validates the plugin configuration
    */
@@ -980,13 +790,19 @@ var RPCPlugin = class {
     if (!this.tsConfigPath?.trim()) {
       errors.push("TypeScript config path cannot be empty");
     } else {
-      if (!fs3.existsSync(this.tsConfigPath)) {
+      if (!fs2.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(", ")}`);
     }
@@ -998,8 +814,10 @@ 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);
     }
   };
   /**
@@ -1008,9 +826,6 @@ var RPCPlugin = class {
   async analyzeEverything(force = false) {
     try {
       this.log("Starting comprehensive RPC analysis...");
-      this.analyzedRoutes = [];
-      this.analyzedSchemas = [];
-      this.generatedInfo = null;
       this.dispose();
       this.project = new Project({ tsConfigFilePath: this.tsConfigPath });
       this.project.addSourceFilesAtPaths([this.controllerPattern]);
@@ -1019,23 +834,22 @@ var RPCPlugin = class {
         const currentHash = computeHash(filePaths);
         const stored = readChecksum(this.outputDir);
         if (stored && stored.hash === currentHash && this.outputFilesExist()) {
-          this.log("Source files unchanged \u2014 skipping regeneration");
-          this.dispose();
-          return;
+          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.project);
       this.analyzedSchemas = await this.schemaGenerator.generateSchemas(this.project);
       this.generatedInfo = await this.clientGenerator.generateClient(this.analyzedRoutes, this.analyzedSchemas);
-      if (this.openApiGenerator && this.openApiOptions) {
-        const specPath = await this.openApiGenerator.generateSpec(
-          this.analyzedRoutes,
-          this.analyzedSchemas,
-          this.openApiOptions
-        );
-        this.log(`OpenAPI spec generated: ${specPath}`);
-      }
       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`
       );
@@ -1051,6 +865,9 @@ var RPCPlugin = class {
    */
   async analyze(force = true) {
     await this.analyzeEverything(force);
+    if (this.app) {
+      this.publishArtifact(this.app);
+    }
   }
   /**
    * Get the analyzed routes
@@ -1074,11 +891,42 @@ var RPCPlugin = class {
    * Checks whether expected output files exist on disk
    */
   outputFilesExist() {
-    if (!fs3.existsSync(path4.join(this.outputDir, "client.ts"))) return false;
-    if (this.openApiOptions) {
-      return fs3.existsSync(path4.join(this.outputDir, this.openApiOptions.outputFile));
+    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;
     }
-    return true;
+  }
+  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
@@ -1112,7 +960,6 @@ export {
   DEFAULT_OPTIONS,
   GENERIC_TYPES,
   LOG_PREFIX,
-  OpenApiGeneratorService,
   RPCPlugin,
   RouteAnalyzerService,
   SchemaGeneratorService,