@angelitosystems/nest-devtools 1.0.14 → 1.0.15

package/dist/index.cjs

@@ -621,12 +621,29 @@ var PerformanceInstrumentation = class {
 };
 
 // src/instrumentation/app-explorer.ts
+var import_module = require("module");
+var import_meta = {};
+var safeRequire = (() => {
+  try {
+    return (0, import_module.createRequire)(import_meta.url);
+  } catch {
+    return null;
+  }
+})();
+var PATH_METADATA = "path";
+var METHOD_METADATA = "method";
+var GUARDS_METADATA = "__guards__";
+var INTERCEPTORS_METADATA = "__interceptors__";
+var PIPES_METADATA = "__pipes__";
+var EXCEPTION_FILTERS_METADATA = "__exceptionFilters__";
+var ROUTE_ARGS_METADATA = "__routeArguments__";
+var BODY_PARAM_TYPE = 3;
+var HTTP_METHOD_NAMES = ["GET", "POST", "PUT", "DELETE", "PATCH", "ALL", "OPTIONS", "HEAD"];
 var AppExplorer = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
   ctx;
-  /** Walk the container and emit app.snapshot. Returns a no-op cleanup. */
   attach(app) {
     try {
       const snapshot = this.buildSnapshot(app);
@@ -638,12 +655,13 @@ var AppExplorer = class {
   }
   buildSnapshot(app) {
     const internal = app.container;
+    const globals = this.extractGlobals(app);
     const modules = [];
     const modulesMap = internal?.getModules?.();
     if (modulesMap) {
       for (const [id, node] of modulesMap) {
         const moduleName = node.metatype?.name ?? String(id);
-        const members = this.extractMembers(node);
+        const members = this.extractMembers(node, globals);
         modules.push({
           name: moduleName,
           imports: [],
@@ -658,23 +676,55 @@ var AppExplorer = class {
       projectName: this.ctx.projectInfo.projectName,
       modules,
       nestjsVersion: this.ctx.projectInfo.nestjsVersion,
-      capturedAt: Date.now()
+      capturedAt: Date.now(),
+      globals
     };
   }
-  extractMembers(node) {
+  /** Global prefix, versioning, and APP_GUARD/APP_INTERCEPTOR/APP_FILTER/APP_PIPE providers (from AppModule's `providers` array). */
+  extractGlobals(app) {
+    const result = { prefix: null, versioning: null, guards: [], interceptors: [], filters: [], pipes: [] };
+    try {
+      const config = app.config;
+      result.prefix = typeof config?.getGlobalPrefix === "function" ? config.getGlobalPrefix() || null : null;
+      const versioning = typeof config?.getVersioning === "function" ? config.getVersioning() : null;
+      if (versioning) result.versioning = { type: String(versioning.type), defaultVersion: versioning.defaultVersion };
+      const internal = app.container;
+      const modulesMap = internal?.getModules?.();
+      if (modulesMap) {
+        for (const node of modulesMap.values()) {
+          const providersMap = node.providers;
+          if (!(providersMap instanceof Map)) continue;
+          for (const wrapper of providersMap.values()) {
+            const w = wrapper;
+            const name = w?.metatype?.name ?? w?.name;
+            if (!name || typeof name !== "string") continue;
+            const instance = w?.instance;
+            if (!instance) continue;
+            if (typeof instance.canActivate === "function" && name.endsWith("Guard")) pushUnique(result.guards, name);
+            else if (typeof instance.intercept === "function" && name.endsWith("Interceptor")) pushUnique(result.interceptors, name);
+            else if (typeof instance.catch === "function" && name.endsWith("Filter")) pushUnique(result.filters, name);
+            else if (typeof instance.transform === "function" && name.endsWith("Pipe")) pushUnique(result.pipes, name);
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  extractMembers(node, globals) {
     const controllers = [];
     const providers = [];
     const controllersMap = node.controllers;
     if (controllersMap instanceof Map) {
       for (const [id, wrapper] of controllersMap) {
-        const member = this.memberFromWrapper(id, wrapper, "controller");
+        const member = this.memberFromWrapper(id, wrapper, globals, "controller");
         if (member) controllers.push(member);
       }
     }
     const providersMap = node.providers;
     if (providersMap instanceof Map) {
       for (const [id, wrapper] of providersMap) {
-        const member = this.memberFromWrapper(id, wrapper);
+        const member = this.memberFromWrapper(id, wrapper, globals);
         if (!member) continue;
         if (wrapper && wrapper.subtype === "httpController") {
           controllers.push(member);
@@ -685,73 +735,144 @@ var AppExplorer = class {
     }
     return { controllers, providers };
   }
-  memberFromWrapper(id, wrapper, forcedType) {
+  memberFromWrapper(id, wrapper, globals, forcedType) {
     const w = wrapper;
     const name = w?.metatype?.name ?? (typeof id === "string" ? id.replace(/^[A-Z_0-9]+:/, "") : "unknown");
     const type = forcedType ?? classify(name, w?.instance);
-    const routes = type === "controller" ? extractControllerRoutes(w?.metatype) : void 0;
-    return { name, type, routes };
+    if (type !== "controller" || !w?.metatype) {
+      return { name, type };
+    }
+    const { basePath, routes } = this.extractRoutes(w.metatype, globals);
+    return {
+      name,
+      type,
+      basePath,
+      routeDetails: routes,
+      routes: routes.map((r) => `${r.method} ${r.path}`)
+      // legacy field, kept for old dashboards
+    };
   }
-};
-function classify(name, instance) {
-  if (name.endsWith("Gateway")) return "gateway";
-  if (name.endsWith("Guard")) return "guard";
-  if (name.endsWith("Interceptor")) return "interceptor";
-  if (name.endsWith("Pipe")) return "pipe";
-  if (name.endsWith("Filter")) return "filter";
-  if (instance && typeof instance.canActivate === "function") return "guard";
-  if (instance && typeof instance.intercept === "function") return "interceptor";
-  if (instance && typeof instance.transform === "function") return "pipe";
-  if (instance && typeof instance.catch === "function") return "filter";
-  return "provider";
-}
-function extractControllerRoutes(metatype) {
-  if (!metatype) return [];
-  try {
-    const proto = metatype.prototype;
-    if (!proto) return [];
-    const props = Object.getOwnPropertyNames(proto).filter((name) => name !== "constructor");
+  /** Extract every HTTP route of a controller class, with method/path/guards/interceptors/pipes/filters/dto. */
+  extractRoutes(controller, globals) {
     const routes = [];
-    for (const key of props) {
-      const desc = Object.getOwnPropertyDescriptor(proto, key);
-      if (!desc?.value) continue;
-      const value = desc.value;
-      const routesForMethod = gatherHttpRoutes(value);
-      for (const r of routesForMethod) {
-        if (typeof r === "string" && r.length > 0) routes.push(r);
+    let basePath = "";
+    try {
+      const R = Reflect;
+      basePath = normalizeSegment(R.getMetadata?.(PATH_METADATA, controller) ?? "");
+      const classGuards = readMetaNames(R, GUARDS_METADATA, controller);
+      const classInterceptors = readMetaNames(R, INTERCEPTORS_METADATA, controller);
+      const classPipes = readMetaNames(R, PIPES_METADATA, controller);
+      const classFilters = readMetaNames(R, EXCEPTION_FILTERS_METADATA, controller);
+      const proto = controller.prototype;
+      if (!proto) return { basePath, routes };
+      const version = globals.versioning?.defaultVersion;
+      const versionSegment = globals.versioning?.type === "URI" && version && version !== "-1" ? `v${Array.isArray(version) ? version[0] : version}` : "";
+      for (const key of Object.getOwnPropertyNames(proto)) {
+        if (key === "constructor") continue;
+        const handler = proto[key];
+        if (typeof handler !== "function") continue;
+        const httpMethod = R.getMetadata?.(METHOD_METADATA, handler);
+        if (httpMethod === void 0) continue;
+        const methodPath = normalizeSegment(R.getMetadata?.(PATH_METADATA, handler) ?? "");
+        const fullPath = ["/", globals.prefix, versionSegment, basePath, methodPath].filter((segment) => segment && segment !== "/").join("/").replace(/\/+/g, "/");
+        const methodGuards = readMetaNames(R, GUARDS_METADATA, handler);
+        const methodInterceptors = readMetaNames(R, INTERCEPTORS_METADATA, handler);
+        const methodPipes = readMetaNames(R, PIPES_METADATA, handler);
+        const methodFilters = readMetaNames(R, EXCEPTION_FILTERS_METADATA, handler);
+        routes.push({
+          method: HTTP_METHOD_NAMES[httpMethod] ?? "GET",
+          path: fullPath.startsWith("/") ? fullPath : `/${fullPath}`,
+          handlerName: key,
+          guards: dedupe([...classGuards, ...methodGuards]),
+          interceptors: dedupe([...classInterceptors, ...methodInterceptors]),
+          pipes: dedupe([...classPipes, ...methodPipes]),
+          filters: dedupe([...classFilters, ...methodFilters]),
+          dto: this.extractBodyDto(R, controller, proto, key)
+        });
       }
+    } catch {
     }
-    return routes;
-  } catch {
-    return [];
+    return { basePath, routes };
   }
-}
-function gatherHttpRoutes(value) {
-  try {
-    const decorators = Reflect.getMetadata?.("design:http:method", {}, void 0, void 0) ?? [];
-    const out = [];
-    if (decorators.length > 0) {
-      for (const d of decorators) {
-        if (d && typeof d === "object" && d.method && d.path) {
-          out.push(`${String(d.method).toUpperCase()} ${String(d.path)}`);
+  /** Best-effort: find the @Body() parameter's class and describe its fields via class-validator, if present. */
+  extractBodyDto(R, controller, proto, methodName) {
+    try {
+      const paramTypes = R.getMetadata?.("design:paramtypes", proto, methodName) ?? [];
+      const routeArgs = R.getMetadata?.(ROUTE_ARGS_METADATA, controller, methodName) ?? {};
+      let bodyIndex = -1;
+      for (const key of Object.keys(routeArgs)) {
+        const [paramType] = key.split(":");
+        if (Number(paramType) === BODY_PARAM_TYPE) {
+          bodyIndex = routeArgs[key]?.index ?? -1;
+          break;
         }
       }
+      if (bodyIndex === -1) return null;
+      const dtoClass = paramTypes[bodyIndex];
+      if (!dtoClass || !dtoClass.name || ["Object", "String", "Number", "Boolean", "Array"].includes(dtoClass.name)) {
+        return null;
+      }
+      return { name: dtoClass.name, fields: this.describeDtoFields(dtoClass) };
+    } catch {
+      return null;
     }
-    if (typeof value === "function") {
-      const fn = value;
-      const path = fn.PATH ?? void 0;
-      const method = fn.METHOD ?? void 0;
-      if (typeof path === "string" && typeof method === "string") {
-        out.push(`${method.toUpperCase()} ${path}`);
-      } else if (typeof path === "string") {
-        out.push(path);
+  }
+  /** Reads class-validator's metadata storage if the package is installed in the host app. Falls back to []. */
+  describeDtoFields(dtoClass) {
+    try {
+      if (!safeRequire) return [];
+      const cv = safeRequire("class-validator");
+      const storage = cv.getMetadataStorage?.();
+      const metas = storage?.getTargetValidationMetadatas?.(dtoClass, "", true, false) ?? [];
+      const byProperty = /* @__PURE__ */ new Map();
+      for (const meta of metas) {
+        const entry = byProperty.get(meta.propertyName) ?? { types: [], optional: false };
+        if (meta.name === "isOptional") entry.optional = true;
+        if (meta.name) entry.types.push(meta.name);
+        byProperty.set(meta.propertyName, entry);
       }
+      return [...byProperty.entries()].map(([name, info]) => ({
+        name,
+        type: info.types.find((t) => /^is[A-Z]/.test(t))?.replace(/^is/, "") ?? "unknown",
+        optional: info.optional,
+        rules: dedupe(info.types)
+      }));
+    } catch {
+      return [];
     }
-    return out;
+  }
+};
+function readMetaNames(R, key, target) {
+  try {
+    const value = R.getMetadata?.(key, target);
+    if (!Array.isArray(value)) return [];
+    return value.map((fn) => fn?.name).filter((name) => Boolean(name));
   } catch {
     return [];
   }
 }
+function normalizeSegment(segment) {
+  const s = Array.isArray(segment) ? segment[0] ?? "" : segment;
+  return String(s ?? "").replace(/^\/+|\/+$/g, "");
+}
+function dedupe(items) {
+  return [...new Set(items)];
+}
+function pushUnique(list, value) {
+  if (!list.includes(value)) list.push(value);
+}
+function classify(name, instance) {
+  if (name.endsWith("Gateway")) return "gateway";
+  if (name.endsWith("Guard")) return "guard";
+  if (name.endsWith("Interceptor")) return "interceptor";
+  if (name.endsWith("Pipe")) return "pipe";
+  if (name.endsWith("Filter")) return "filter";
+  if (instance && typeof instance.canActivate === "function") return "guard";
+  if (instance && typeof instance.intercept === "function") return "interceptor";
+  if (instance && typeof instance.transform === "function") return "pipe";
+  if (instance && typeof instance.catch === "function") return "filter";
+  return "provider";
+}
 
 // src/instrumentation/websockets.ts
 var import_devtools_core7 = require("@angelitosystems/devtools-core");
@@ -1428,7 +1549,7 @@ function detectNestJsVersion() {
 }
 
 // src/version.ts
-var SDK_VERSION = "1.0.14";
+var SDK_VERSION = "1.0.15";
 
 // src/banner.ts
 var RESET = "\x1B[0m";