@nattyjs/core 0.0.1-beta.64 → 0.0.1-beta.66

package/dist/index.cjs

@@ -2,8 +2,13 @@
 
 const common = require('@nattyjs/common');
 const pathToRegexp = require('path-to-regexp');
+const path = require('node:path');
 require('reflect-metadata');
 
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
 function defineNattyConfig(config) {
   return config;
 }
@@ -54,6 +59,7 @@ function Delete() {
   };
 }
 
+const HTTP_METHODS = ["get", "post", "put", "delete"];
 const _StaticContainer = class {
   setup(types) {
     _StaticContainer.types = types;
@@ -65,14 +71,56 @@ const nattyContainer = new class {
   constructor() {
     this.container = /* @__PURE__ */ new Map();
     this.containerState = /* @__PURE__ */ new Map();
+    this.compiledRoutes = {};
   }
   get types() {
     return common.commonContainer.types;
   }
   setup(config, routes, resolver) {
     this.config = config;
-    this.routes = routes;
     this.resolver = resolver;
+    this.applyRouteSnapshot(routes);
+  }
+  replaceRoutes(manifest) {
+    if (manifest.resolver)
+      this.resolver = manifest.resolver;
+    this.applyRouteSnapshot(manifest.routes);
+  }
+  applyRouteSnapshot(routes) {
+    this.routes = routes;
+    this.compiledRoutes = this.createCompiledRoutes(routes);
+  }
+  createCompiledRoutes(routes) {
+    const compiledRoutes = {};
+    for (const method of HTTP_METHODS)
+      compiledRoutes[method] = [];
+    for (const [rootPath, routeConfig] of Object.entries(routes)) {
+      for (const method of HTTP_METHODS) {
+        const childRoutes = routeConfig[method];
+        if (!childRoutes)
+          continue;
+        for (const [childRoutePath, routeInfo] of Object.entries(childRoutes)) {
+          const childPath = this.normalizeChildPath(childRoutePath);
+          const configuredRoutePath = `${rootPath}${childPath}`;
+          compiledRoutes[method].push({
+            requestMethod: method,
+            configuredRoutePath,
+            matcher: pathToRegexp.match(configuredRoutePath, { decode: decodeURIComponent }),
+            routeConfig,
+            methodInfo: routeInfo
+          });
+        }
+      }
+    }
+    return compiledRoutes;
+  }
+  normalizeChildPath(childRoutePath) {
+    if (childRoutePath.indexOf("/") === 0)
+      return childRoutePath === "/" ? BLANK : childRoutePath;
+    return `/${childRoutePath}`;
+  }
+  getCompiledRoutes(method) {
+    return this.compiledRoutes[method] || [];
   }
   getTypes() {
     return StaticContainer.types;
@@ -163,8 +211,10 @@ function setupLegacyTypes(types) {
 function defaultResolver(path) {
   if (typeof path === "function")
     return path();
-  if (typeof path === "string")
-    return require(path);
+  if (typeof path === "string") {
+    const normalizedPath = path.startsWith("/") ? `.${path}` : path;
+    return require(normalizedPath);
+  }
   return {};
 }
 function initializeModule(config) {
@@ -514,6 +564,15 @@ class BaseResponse {
   notFound() {
     throw new HttpNotFoundException({});
   }
+  normalizeHttpResponse(result) {
+    if (result instanceof HttpResponse)
+      return result;
+    if (result instanceof HttpException)
+      return result.getResponse();
+    if (result && typeof result === "object" && ("status" in result || "body" in result || "headers" in result || "cookies" in result || "isBuffer" in result))
+      return new HttpResponse(result);
+    return result;
+  }
 }
 
 function getTypedErrorMessage(type, value) {
@@ -848,8 +907,8 @@ class RouteParser extends ParameterTypeConverter {
   get httpMethod() {
     return this.httpContext.request.method.toLowerCase();
   }
-  get appRoutes() {
-    return nattyContainer.routes;
+  get compiledRoutes() {
+    return nattyContainer.getCompiledRoutes(this.httpMethod);
   }
   init() {
     const isMatched = this.matchRoute();
@@ -862,47 +921,46 @@ class RouteParser extends ParameterTypeConverter {
     return controllerInfo[name];
   }
   matchRoute() {
-    let isMatched = false;
-    const requestPathname = this.getRequestPathname();
-    for (const [key, value] of Object.entries(this.appRoutes)) {
-      const rootPath = key;
-      const routeConfig = value;
-      const childRoutes = routeConfig[this.httpMethod];
-      if (childRoutes) {
-        for (const [key2, value2] of Object.entries(childRoutes)) {
-          const childPath = key2.indexOf(common.RIGHT_SLASH) == 0 ? key2 === common.RIGHT_SLASH ? common.BLANK : key2 : `/${key2}`;
-          const methodInfo = value2;
-          const configuredRoutePath = `${rootPath}${childPath}`;
-          const routeMatch = pathToRegexp.match(`${rootPath}${childPath}`, { decode: decodeURIComponent });
-          const matched = routeMatch(requestPathname);
-          if (matched) {
-            isMatched = true;
-            this.routeInfo = {
-              path: `${common.commonContainer.nattyConfig.api.rootPath}/${requestPathname}`,
-              configuredRoutePath: `${common.commonContainer.nattyConfig.api.rootPath}/${configuredRoutePath}`,
-              controller: this.getController(routeConfig),
-              parameters: routeConfig.parameters,
-              methodInfo,
-              params: this.convert(methodInfo, matched.params),
-              queryParams: this.getQueryParams()
-            };
-            break;
-          }
-        }
+    const requestUrl = this.getRequestUrl();
+    const requestPathname = this.getRequestPathname(requestUrl);
+    for (const route of this.compiledRoutes) {
+      const matched = route.matcher(requestPathname);
+      if (matched) {
+        this.routeInfo = {
+          path: `${common.commonContainer.nattyConfig.api.rootPath}/${requestPathname}`,
+          configuredRoutePath: `${common.commonContainer.nattyConfig.api.rootPath}/${route.configuredRoutePath}`,
+          controller: this.getController(route.routeConfig),
+          parameters: route.routeConfig.parameters,
+          methodInfo: route.methodInfo,
+          params: this.convert(route.methodInfo, matched.params),
+          queryParams: this.getQueryParams(requestUrl)
+        };
+        return true;
       }
     }
-    return isMatched;
-  }
-  getRequestPathname() {
-    const apiRootPath = common.commonContainer.nattyConfig.api.rootPath;
-    const url = new URL(this.httpContext.request.url);
-    let splitUrl = url.pathname.split(`${apiRootPath}/`);
-    if (splitUrl.length > 1)
-      return splitUrl[1];
-    return url.pathname;
-  }
-  getQueryParams() {
-    const url = new URL(this.httpContext.request.url);
+    return false;
+  }
+  getRequestUrl() {
+    if (!this.parsedRequestUrl)
+      this.parsedRequestUrl = new URL(this.httpContext.request.url);
+    return this.parsedRequestUrl;
+  }
+  getRequestPathname(url) {
+    const apiRootPath = String(common.commonContainer.nattyConfig.api.rootPath || "").replace(/^\/+|\/+$/g, "");
+    const normalizedPathname = url.pathname.replace(/^\/+/, "");
+    if (!apiRootPath) {
+      return normalizedPathname;
+    }
+    if (normalizedPathname === apiRootPath) {
+      return "";
+    }
+    const apiPrefix = `${apiRootPath}/`;
+    if (normalizedPathname.startsWith(apiPrefix)) {
+      return normalizedPathname.slice(apiPrefix.length);
+    }
+    return normalizedPathname;
+  }
+  getQueryParams(url) {
     const queryParams = {};
     for (const param of url.searchParams.keys())
       queryParams[param] = url.searchParams.get(param);
@@ -913,8 +971,10 @@ class RouteParser extends ParameterTypeConverter {
 const decoratorStateContainer = new class {
   constructor() {
     this.controllerConfig = {};
+    this.controllerSources = /* @__PURE__ */ new Map();
+    this.sourceControllers = /* @__PURE__ */ new Map();
   }
-  register(params, type, additionalConfig) {
+  register(params, type, additionalConfig, sourceFile) {
     const name = params.target.name || params.target.constructor.name;
     let controllerInfo = this.controllerConfig[name] || null;
     let controllerMethodInfo = null;
@@ -927,6 +987,9 @@ const decoratorStateContainer = new class {
       controllerMethodInfo[type] = additionalConfig;
     } else
       controllerInfo.config[type] = additionalConfig;
+    if (sourceFile) {
+      this.trackControllerSource(name, sourceFile);
+    }
   }
   getInfo(controllerName, methodName, type) {
     const controllerInfo = this.controllerConfig[controllerName];
@@ -939,6 +1002,55 @@ const decoratorStateContainer = new class {
       methodConfig = methodInfo[type];
     return { controllerConfig, methodConfig };
   }
+  clearFromSource(sourceFile) {
+    const normalizedSourceFile = this.normalizeFilePath(sourceFile);
+    const controllerNames = Array.from(
+      this.sourceControllers.get(normalizedSourceFile) || []
+    );
+    this.clearControllers(controllerNames);
+    this.sourceControllers.delete(normalizedSourceFile);
+    return controllerNames;
+  }
+  clearControllers(controllerNames) {
+    const removedControllers = [];
+    for (const controllerName of controllerNames) {
+      const previousSource = this.controllerSources.get(controllerName);
+      delete this.controllerConfig[controllerName];
+      this.controllerSources.delete(controllerName);
+      removedControllers.push(controllerName);
+      if (previousSource) {
+        const controllers = this.sourceControllers.get(previousSource);
+        controllers?.delete(controllerName);
+        if (controllers && controllers.size === 0) {
+          this.sourceControllers.delete(previousSource);
+        }
+      }
+    }
+    return removedControllers;
+  }
+  reset() {
+    this.controllerConfig = {};
+    this.controllerSources.clear();
+    this.sourceControllers.clear();
+  }
+  trackControllerSource(controllerName, sourceFile) {
+    const normalizedSourceFile = this.normalizeFilePath(sourceFile);
+    const previousSource = this.controllerSources.get(controllerName);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceControllers.get(previousSource)?.delete(controllerName);
+      if (this.sourceControllers.get(previousSource)?.size === 0) {
+        this.sourceControllers.delete(previousSource);
+      }
+    }
+    this.controllerSources.set(controllerName, normalizedSourceFile);
+    if (!this.sourceControllers.has(normalizedSourceFile)) {
+      this.sourceControllers.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceControllers.get(normalizedSourceFile)?.add(controllerName);
+  }
+  normalizeFilePath(filePath) {
+    return path__default.resolve(filePath).replace(/\\/g, "/");
+  }
 }();
 
 var DecoratorType = /* @__PURE__ */ ((DecoratorType2) => {
@@ -1239,25 +1351,47 @@ class NattyScope {
   }
 }
 
+function normalizeFilePath$1(filePath) {
+  return path__default.resolve(filePath).replace(/\\/g, "/");
+}
 class NattyContainer {
   constructor() {
     this.regs = /* @__PURE__ */ new Map();
     this.singletons = /* @__PURE__ */ new Map();
+    this.tokenSources = /* @__PURE__ */ new Map();
+    this.sourceTokens = /* @__PURE__ */ new Map();
+    this.metadataKeySources = /* @__PURE__ */ new Map();
+    this.sourceMetadataKeys = /* @__PURE__ */ new Map();
   }
-  register(token, desc) {
+  register(token, desc, sourceFile) {
     this.regs.set(token, desc);
+    if (sourceFile) {
+      this.trackTokenSource(token, sourceFile);
+    }
   }
-  addTransient(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory });
+  addTransient(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addScoped(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory });
+  addScoped(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addSingleton(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory });
+  addSingleton(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addInstance(token, value) {
-    this.register(token, { lifetime: Lifetime.Singleton, useValue: value });
+  addInstance(token, value, sourceFile) {
+    this.register(token, { lifetime: Lifetime.Singleton, useValue: value }, sourceFile);
     this.singletons.set(token, value);
   }
   createScope() {
@@ -1302,6 +1436,57 @@ class NattyContainer {
   _getDescriptor(token) {
     return this.regs.get(token);
   }
+  trackMetadataKey(sourceFile, key) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const previousSource = this.metadataKeySources.get(key);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceMetadataKeys.get(previousSource)?.delete(key);
+      if (this.sourceMetadataKeys.get(previousSource)?.size === 0) {
+        this.sourceMetadataKeys.delete(previousSource);
+      }
+    }
+    this.metadataKeySources.set(key, normalizedSourceFile);
+    if (!this.sourceMetadataKeys.has(normalizedSourceFile)) {
+      this.sourceMetadataKeys.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceMetadataKeys.get(normalizedSourceFile)?.add(key);
+  }
+  clearRegistrationsFromSource(sourceFile) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const tokens = Array.from(this.sourceTokens.get(normalizedSourceFile) || []);
+    const metadataKeys = Array.from(
+      this.sourceMetadataKeys.get(normalizedSourceFile) || []
+    );
+    for (const token of tokens) {
+      this.regs.delete(token);
+      this.singletons.delete(token);
+      this.tokenSources.delete(token);
+    }
+    for (const metadataKey of metadataKeys) {
+      this.metadataKeySources.delete(metadataKey);
+    }
+    this.sourceTokens.delete(normalizedSourceFile);
+    this.sourceMetadataKeys.delete(normalizedSourceFile);
+    return {
+      metadataKeys,
+      tokens
+    };
+  }
+  trackTokenSource(token, sourceFile) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const previousSource = this.tokenSources.get(token);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceTokens.get(previousSource)?.delete(token);
+      if (this.sourceTokens.get(previousSource)?.size === 0) {
+        this.sourceTokens.delete(previousSource);
+      }
+    }
+    this.tokenSources.set(token, normalizedSourceFile);
+    if (!this.sourceTokens.has(normalizedSourceFile)) {
+      this.sourceTokens.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceTokens.get(normalizedSourceFile)?.add(token);
+  }
 }
 
 const nattyServiceResolver = new NattyContainer();
@@ -1407,14 +1592,14 @@ class Resolver extends RequestProcessor {
       if (onException) {
         const instance = this.resolveClass(onException);
         if (instance.onException)
-          result = instance.onException({
+          result = this.normalizeHttpResponse(instance.onException({
             error: ex,
             request: this.httpContext.request,
             routeInfo: this.routeInfo
-          });
+          }));
       } else
         result = new HttpException({
-          body: getPreResponseBody({ message: ex.message, stack: ex.stack }),
+          body: { message: ex.message, stack: ex.stack },
           status: HttpStatusCode.serverError
         }).getResponse();
     }
@@ -1442,14 +1627,17 @@ class RequestHandler extends Resolver {
       if (onException) {
         const instance = this.resolveClass(onException);
         if (instance.onException)
-          return instance.onException({
+          return this.normalizeHttpResponse(instance.onException({
             error: ex,
             request: this.httpContext.request,
             routeInfo: this.routeInfo
-          });
+          }));
       } else
         return new HttpException({
-          body: ex,
+          body: {
+            message: ex?.message,
+            stack: ex?.stack
+          },
           status: HttpStatusCode.serverError
         });
     }
@@ -1462,20 +1650,59 @@ class HttpHandler {
   async processRequest(httpContext) {
     const requestProcessor = new RequestHandler(httpContext);
     const result = await requestProcessor.onRequest();
-    return result;
+    if (result instanceof HttpResponse) {
+      return result;
+    }
+    if (result instanceof HttpException) {
+      return result.getResponse();
+    }
+    return new HttpResponse({ body: result });
+  }
+}
+
+const STACK_PATH_REGEX = /\bat (?:(?:.+?) \()?(.+):(\d+):(\d+)\)?$/;
+function normalizeFilePath(filePath) {
+  return path__default.resolve(filePath).replace(/\\/g, "/");
+}
+function isInternalRegistrationFrame(filePath) {
+  const normalizedPath = normalizeFilePath(filePath);
+  return normalizedPath.includes("/packages/core/decorators/") || normalizedPath.includes("/packages/core/functions/") || normalizedPath.includes("/packages/core/domain/di/") || normalizedPath.includes("/packages/core/const/") || normalizedPath.includes("/packages/core/dist/") || normalizedPath.includes("/node_modules/@nattyjs/core/dist/");
+}
+function getRegistrationSourceFile() {
+  const stack = new Error().stack;
+  return getRegistrationSourceFileFromStack(stack);
+}
+function getRegistrationSourceFileFromStack(stack) {
+  if (!stack) {
+    return void 0;
   }
+  const lines = stack.split("\n").slice(1);
+  for (const line of lines) {
+    const match = line.trim().match(STACK_PATH_REGEX);
+    if (!match) {
+      continue;
+    }
+    const filePath = normalizeFilePath(match[1]);
+    if (!isInternalRegistrationFrame(filePath)) {
+      return filePath;
+    }
+  }
+  return void 0;
 }
 
 function injectable(options = {}) {
   return (targetConstructor) => {
     const lt = options.lifetime ?? Lifetime.Transient;
+    const sourceFile = getRegistrationSourceFile();
     if (lt === Lifetime.Singleton)
-      nattyServiceResolver.addSingleton(targetConstructor);
+      nattyServiceResolver.addSingleton(targetConstructor, void 0, void 0, sourceFile);
     else if (lt === Lifetime.Scoped)
-      nattyServiceResolver.addScoped(targetConstructor);
+      nattyServiceResolver.addScoped(targetConstructor, void 0, void 0, sourceFile);
     else
-      nattyServiceResolver.addTransient(targetConstructor);
+      nattyServiceResolver.addTransient(targetConstructor, void 0, void 0, sourceFile);
     common.commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
+    if (sourceFile)
+      nattyServiceResolver.trackMetadataKey(sourceFile, targetConstructor.name);
   };
 }
 
@@ -1761,7 +1988,12 @@ const Results = {
 };
 
 function base(params, type, additionaConfig) {
-  decoratorStateContainer.register(params, type, additionaConfig);
+  decoratorStateContainer.register(
+    params,
+    type,
+    additionaConfig,
+    getRegistrationSourceFile()
+  );
 }
 
 function useFilter(config) {
@@ -1786,6 +2018,12 @@ function authenticationOnly() {
   };
 }
 
+function onException(exceptionFilter) {
+  return function(target, propertyKey, descriptor) {
+    base({ target, propertyKey, descriptor }, DecoratorType.onException, exceptionFilter);
+  };
+}
+
 function setEnvInfo(envTsDefinition, envValueInfo) {
   if (envTsDefinition && envValueInfo) {
     common.commonContainer.setEnvTsDefinition(envTsDefinition);
@@ -1833,30 +2071,40 @@ function getTokenTypeName(token) {
   return key.slice(separatorIndex + 1);
 }
 
-function registerLifetime(targetConstructor, lifetime) {
+function registerLifetime(targetConstructor, sourceFile, lifetime) {
   if (lifetime === Lifetime.Singleton) {
-    nattyServiceResolver.addSingleton(targetConstructor);
+    nattyServiceResolver.addSingleton(targetConstructor, void 0, void 0, sourceFile);
     return;
   }
   if (lifetime === Lifetime.Scoped) {
-    nattyServiceResolver.addScoped(targetConstructor);
+    nattyServiceResolver.addScoped(targetConstructor, void 0, void 0, sourceFile);
     return;
   }
   if (lifetime === Lifetime.Transient) {
-    nattyServiceResolver.addTransient(targetConstructor);
+    nattyServiceResolver.addTransient(targetConstructor, void 0, void 0, sourceFile);
   }
 }
-function registerAliasTypeName(token) {
+function registerAliasTypeName(token, sourceFile) {
   const typeName = getTokenTypeName(token);
   if (typeName) {
     common.commonContainer.setMetadata(typeName, token, "services");
+    if (sourceFile)
+      nattyServiceResolver.trackMetadataKey(sourceFile, typeName);
   }
 }
 function registerDiToken(targetConstructor, token, options = {}) {
+  const sourceFile = getRegistrationSourceFile();
   common.commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
-  registerAliasTypeName(token);
-  registerLifetime(targetConstructor, options.lifetime);
-  nattyServiceResolver.addTransient(token, void 0, (serviceProvider) => serviceProvider.get(targetConstructor));
+  if (sourceFile)
+    nattyServiceResolver.trackMetadataKey(sourceFile, targetConstructor.name);
+  registerAliasTypeName(token, sourceFile);
+  registerLifetime(targetConstructor, sourceFile, options.lifetime);
+  nattyServiceResolver.addTransient(
+    token,
+    void 0,
+    (serviceProvider) => serviceProvider.get(targetConstructor),
+    sourceFile
+  );
 }
 
 function di(token, options = {}) {
@@ -1869,6 +2117,24 @@ function createServiceScope() {
   return nattyServiceResolver.createScope();
 }
 
+function clearHotReloadRegistrations(files) {
+  for (const filePath of files || []) {
+    const result = nattyServiceResolver.clearRegistrationsFromSource(filePath);
+    decoratorStateContainer.clearFromSource(filePath);
+    for (const metadataKey of result.metadataKeys) {
+      common.commonContainer.deleteMetadataValue(metadataKey, "services");
+    }
+  }
+}
+
+function clearHotReloadControllerMetadata(controllerNames) {
+  decoratorStateContainer.clearControllers(controllerNames || []);
+}
+
+function replaceRoutes(manifest) {
+  nattyContainer.replaceRoutes(manifest);
+}
+
 exports.$request = $request;
 exports.AbstractModelState = AbstractModelState;
 exports.AcceptedException = AcceptedException;
@@ -1915,6 +2181,8 @@ exports.anonymous = anonymous;
 exports.authenticationOnly = authenticationOnly;
 exports.authorize = authorize;
 exports.badRequest = badRequest;
+exports.clearHotReloadControllerMetadata = clearHotReloadControllerMetadata;
+exports.clearHotReloadRegistrations = clearHotReloadRegistrations;
 exports.conflict = conflict;
 exports.createServiceScope = createServiceScope;
 exports.created = created;
@@ -1934,12 +2202,14 @@ exports.noContent = noContent;
 exports.notFound = notFound;
 exports.notFoundWith = notFoundWith;
 exports.ok = ok;
+exports.onException = onException;
 exports.post = post;
 exports.problem = problem;
 exports.put = put;
 exports.redirect = redirect;
 exports.redirectPermanent = redirectPermanent;
 exports.registerDecorator = registerDecorator;
+exports.replaceRoutes = replaceRoutes;
 exports.route = route;
 exports.scoped = scoped;
 exports.setEnvInfo = setEnvInfo;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NattyConfig, UserIdentity } from '@nattyjs/common';
+import { NattyConfig, UserIdentity, ClassType, ExceptionFilter } from '@nattyjs/common';
 import { GlobalConfig } from '@nattyjs/common/interfaces/global-config';
 
 interface DecoratorInfo$1 {
@@ -305,20 +305,31 @@ type Descriptor<T = any> = {
     useFactory?: Factory<T>;
 };
 
+type ClearRegistrationsResult = {
+    metadataKeys: string[];
+    tokens: Token[];
+};
 declare class NattyContainer implements ServiceProvider {
     private readonly regs;
     private readonly singletons;
-    register<T>(token: Token<T>, desc: Descriptor<T>): void;
-    addTransient<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>): void;
-    addScoped<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>): void;
-    addSingleton<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>): void;
-    addInstance<T>(token: Token<T>, value: T): void;
+    private readonly tokenSources;
+    private readonly sourceTokens;
+    private readonly metadataKeySources;
+    private readonly sourceMetadataKeys;
+    register<T>(token: Token<T>, desc: Descriptor<T>, sourceFile?: string): void;
+    addTransient<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addScoped<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addSingleton<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addInstance<T>(token: Token<T>, value: T, sourceFile?: string): void;
     createScope(): NattyScope;
     set<T>(_token: Token<T>, _value: T): void;
     tryGet<T>(token: Token<T>): T | undefined;
     get<T>(token: Token<T>): T;
     construct<T>(Cls: DIClassType<T>, sp: ServiceProvider): T;
     _getDescriptor<T>(token: Token<T>): Descriptor<T> | undefined;
+    trackMetadataKey(sourceFile: string, key: string): void;
+    clearRegistrationsFromSource(sourceFile: string): ClearRegistrationsResult;
+    private trackTokenSource;
 }
 
 declare class NattyScope implements Scope {
@@ -391,6 +402,7 @@ declare abstract class BaseResponse {
     badRequest(): void;
     success(body: any): HttpResponse;
     notFound(): void;
+    protected normalizeHttpResponse(result: any): any;
 }
 
 declare abstract class ParameterTypeConverter extends BaseResponse {
@@ -402,9 +414,9 @@ declare abstract class ParameterTypeConverter extends BaseResponse {
     };
     get types(): TypesInfo;
     getObjectTypeInfo(typeName: string): {
-        path?: string | any | Function;
-        props?: Array<TypeInfo>;
-        values?: Array<any>;
+        path?: any;
+        props?: TypeInfo[];
+        values?: any[];
     };
     isArrayType(typeName: string): boolean;
     getTypeName(typeName: string): string;
@@ -563,21 +575,21 @@ declare class StatusCodeResult<T = unknown> extends BaseResult implements IHttpR
 
 declare const Results: {
     readonly ok: <T = unknown>(value?: T, extras?: ResponseExtras) => OkResult<T>;
-    readonly created: <T = unknown>(value?: T, extras?: ResponseExtras) => CreatedResult<T>;
-    readonly createdWith: <T = unknown>(location: string, value?: T, extras?: ResponseExtras) => CreatedResult<T>;
-    readonly createdAt: <T = unknown>(location: string, value?: T, extras?: ResponseExtras) => CreatedResult<T>;
-    readonly accepted: <T = unknown>(value?: T, extras?: ResponseExtras) => AcceptedResult<T>;
+    readonly created: <T_1 = unknown>(value?: T_1, extras?: ResponseExtras) => CreatedResult<T_1>;
+    readonly createdWith: <T_2 = unknown>(location: string, value?: T_2, extras?: ResponseExtras) => CreatedResult<T_2>;
+    readonly createdAt: <T_3 = unknown>(location: string, value?: T_3, extras?: ResponseExtras) => CreatedResult<T_3>;
+    readonly accepted: <T_4 = unknown>(value?: T_4, extras?: ResponseExtras) => AcceptedResult<T_4>;
     readonly noContent: (extras?: ResponseExtras) => NoContentResult;
     readonly file: (buffer?: Buffer, extras?: ResponseExtras) => FileResult;
-    readonly statusCode: <T = unknown>(status: number, value?: T, extras?: ResponseExtras) => StatusCodeResult<T>;
-    readonly badRequest: <T = ExceptionTypeInfo>(value?: T, extras?: ResponseExtras) => BadRequestResult<T>;
+    readonly statusCode: <T_5 = unknown>(status: number, value?: T_5, extras?: ResponseExtras) => StatusCodeResult<T_5>;
+    readonly badRequest: <T_6 = ExceptionTypeInfo>(value?: T_6, extras?: ResponseExtras) => BadRequestResult<T_6>;
     readonly notFound: (extras?: ResponseExtras) => NotFoundResult<any>;
-    readonly notFoundWith: <T = unknown>(value?: T, extras?: ResponseExtras) => NotFoundResult<T>;
-    readonly unAuthorized: <T = ExceptionTypeInfo>(value?: T, extras?: ResponseExtras) => UnAuthorizedResult<T>;
-    readonly forbid: <T = ExceptionTypeInfo>(value?: T, extras?: ResponseExtras) => ForbiddenAccessInfoResult<unknown>;
-    readonly conflict: <T = unknown>(value?: T, extras?: ResponseExtras) => ConflictResult<T>;
-    readonly unprocessableEntity: <T = unknown>(value?: T, extras?: ResponseExtras) => UnprocessableEntityResult<T>;
-    readonly tooManyRequests: <T = unknown>(value?: T, retryAfterSeconds?: number, extras?: ResponseExtras) => TooManyRequestsResult<T>;
+    readonly notFoundWith: <T_7 = unknown>(value?: T_7, extras?: ResponseExtras) => NotFoundResult<T_7>;
+    readonly unAuthorized: <T_8 = ExceptionTypeInfo>(value?: T_8, extras?: ResponseExtras) => UnAuthorizedResult<T_8>;
+    readonly forbid: <T_9 = ExceptionTypeInfo>(value?: T_9, extras?: ResponseExtras) => ForbiddenAccessInfoResult<unknown>;
+    readonly conflict: <T_10 = unknown>(value?: T_10, extras?: ResponseExtras) => ConflictResult<T_10>;
+    readonly unprocessableEntity: <T_11 = unknown>(value?: T_11, extras?: ResponseExtras) => UnprocessableEntityResult<T_11>;
+    readonly tooManyRequests: <T_12 = unknown>(value?: T_12, retryAfterSeconds?: number, extras?: ResponseExtras) => TooManyRequestsResult<T_12>;
     readonly redirect: (location: string, extras?: ResponseExtras) => RedirectResult;
     readonly redirectPermanent: (location: string, extras?: ResponseExtras) => RedirectResult;
     readonly problem: (p: ProblemDetails, extras?: ResponseExtras) => ProblemResult;
@@ -644,6 +656,8 @@ declare function anonymous(): (target: any, propertyKey?: string, descriptor?: a
 
 declare function authenticationOnly(): (target: any, propertyKey?: string, descriptor?: any) => void;
 
+declare function onException(exceptionFilter: ClassType<ExceptionFilter>): (target: any, propertyKey?: string, descriptor?: any) => void;
+
 declare function setEnvInfo(envTsDefinition: {
     [key: string]: string;
 }, envValueInfo: {
@@ -690,4 +704,17 @@ declare function registerType<T>(): unknown;
 
 declare function createServiceScope(): NattyScope;
 
-export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, BuildOptions, ClassTypeInfo, ConflictResult, CreateProblemDetail, CreatedResult, Delete, DiOptions, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, Lifetime, MethodInfo$1 as MethodInfo, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ParameterInfo, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, ResponseExtras, Results, RetryAfter, RunOn, TooManyRequestsException, TooManyRequestsResult, TypeInfo$1 as TypeInfo, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, conflict, createServiceScope, created, createdAt, createdWith, defineNattyConfig, di, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, post, problem, put, redirect, redirectPermanent, registerDecorator, registerType, route, scoped, setEnvInfo, singleton, tooManyRequests, transient, unAuthorized, unprocessableEntity, useFilter, validationProblem };
+declare function clearHotReloadRegistrations(files: string[]): void;
+
+declare function clearHotReloadControllerMetadata(controllerNames: string[]): void;
+
+interface RuntimeManifest {
+    routes: {
+        [key: string]: RouteConfig;
+    };
+    resolver?: (path: string) => any;
+}
+
+declare function replaceRoutes(manifest: RuntimeManifest): void;
+
+export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, BuildOptions, ClassTypeInfo, ConflictResult, CreateProblemDetail, CreatedResult, Delete, DiOptions, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, Lifetime, MethodInfo$1 as MethodInfo, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ParameterInfo, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, ResponseExtras, Results, RetryAfter, RunOn, RuntimeManifest, TooManyRequestsException, TooManyRequestsResult, TypeInfo$1 as TypeInfo, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, clearHotReloadControllerMetadata, clearHotReloadRegistrations, conflict, createServiceScope, created, createdAt, createdWith, defineNattyConfig, di, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, onException, post, problem, put, redirect, redirectPermanent, registerDecorator, registerType, replaceRoutes, route, scoped, setEnvInfo, singleton, tooManyRequests, transient, unAuthorized, unprocessableEntity, useFilter, validationProblem };

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import { commonContainer, isObject, List, BLANK as BLANK$1, RIGHT_SLASH } from '@nattyjs/common';
+import { commonContainer, isObject, List, BLANK as BLANK$1 } from '@nattyjs/common';
 import { match } from 'path-to-regexp';
+import path from 'node:path';
 import 'reflect-metadata';
 
 function defineNattyConfig(config) {
@@ -52,6 +53,7 @@ function Delete() {
   };
 }
 
+const HTTP_METHODS = ["get", "post", "put", "delete"];
 const _StaticContainer = class {
   setup(types) {
     _StaticContainer.types = types;
@@ -63,14 +65,56 @@ const nattyContainer = new class {
   constructor() {
     this.container = /* @__PURE__ */ new Map();
     this.containerState = /* @__PURE__ */ new Map();
+    this.compiledRoutes = {};
   }
   get types() {
     return commonContainer.types;
   }
   setup(config, routes, resolver) {
     this.config = config;
-    this.routes = routes;
     this.resolver = resolver;
+    this.applyRouteSnapshot(routes);
+  }
+  replaceRoutes(manifest) {
+    if (manifest.resolver)
+      this.resolver = manifest.resolver;
+    this.applyRouteSnapshot(manifest.routes);
+  }
+  applyRouteSnapshot(routes) {
+    this.routes = routes;
+    this.compiledRoutes = this.createCompiledRoutes(routes);
+  }
+  createCompiledRoutes(routes) {
+    const compiledRoutes = {};
+    for (const method of HTTP_METHODS)
+      compiledRoutes[method] = [];
+    for (const [rootPath, routeConfig] of Object.entries(routes)) {
+      for (const method of HTTP_METHODS) {
+        const childRoutes = routeConfig[method];
+        if (!childRoutes)
+          continue;
+        for (const [childRoutePath, routeInfo] of Object.entries(childRoutes)) {
+          const childPath = this.normalizeChildPath(childRoutePath);
+          const configuredRoutePath = `${rootPath}${childPath}`;
+          compiledRoutes[method].push({
+            requestMethod: method,
+            configuredRoutePath,
+            matcher: match(configuredRoutePath, { decode: decodeURIComponent }),
+            routeConfig,
+            methodInfo: routeInfo
+          });
+        }
+      }
+    }
+    return compiledRoutes;
+  }
+  normalizeChildPath(childRoutePath) {
+    if (childRoutePath.indexOf("/") === 0)
+      return childRoutePath === "/" ? BLANK : childRoutePath;
+    return `/${childRoutePath}`;
+  }
+  getCompiledRoutes(method) {
+    return this.compiledRoutes[method] || [];
   }
   getTypes() {
     return StaticContainer.types;
@@ -161,8 +205,10 @@ function setupLegacyTypes(types) {
 function defaultResolver(path) {
   if (typeof path === "function")
     return path();
-  if (typeof path === "string")
-    return require(path);
+  if (typeof path === "string") {
+    const normalizedPath = path.startsWith("/") ? `.${path}` : path;
+    return require(normalizedPath);
+  }
   return {};
 }
 function initializeModule(config) {
@@ -512,6 +558,15 @@ class BaseResponse {
   notFound() {
     throw new HttpNotFoundException({});
   }
+  normalizeHttpResponse(result) {
+    if (result instanceof HttpResponse)
+      return result;
+    if (result instanceof HttpException)
+      return result.getResponse();
+    if (result && typeof result === "object" && ("status" in result || "body" in result || "headers" in result || "cookies" in result || "isBuffer" in result))
+      return new HttpResponse(result);
+    return result;
+  }
 }
 
 function getTypedErrorMessage(type, value) {
@@ -846,8 +901,8 @@ class RouteParser extends ParameterTypeConverter {
   get httpMethod() {
     return this.httpContext.request.method.toLowerCase();
   }
-  get appRoutes() {
-    return nattyContainer.routes;
+  get compiledRoutes() {
+    return nattyContainer.getCompiledRoutes(this.httpMethod);
   }
   init() {
     const isMatched = this.matchRoute();
@@ -860,47 +915,46 @@ class RouteParser extends ParameterTypeConverter {
     return controllerInfo[name];
   }
   matchRoute() {
-    let isMatched = false;
-    const requestPathname = this.getRequestPathname();
-    for (const [key, value] of Object.entries(this.appRoutes)) {
-      const rootPath = key;
-      const routeConfig = value;
-      const childRoutes = routeConfig[this.httpMethod];
-      if (childRoutes) {
-        for (const [key2, value2] of Object.entries(childRoutes)) {
-          const childPath = key2.indexOf(RIGHT_SLASH) == 0 ? key2 === RIGHT_SLASH ? BLANK$1 : key2 : `/${key2}`;
-          const methodInfo = value2;
-          const configuredRoutePath = `${rootPath}${childPath}`;
-          const routeMatch = match(`${rootPath}${childPath}`, { decode: decodeURIComponent });
-          const matched = routeMatch(requestPathname);
-          if (matched) {
-            isMatched = true;
-            this.routeInfo = {
-              path: `${commonContainer.nattyConfig.api.rootPath}/${requestPathname}`,
-              configuredRoutePath: `${commonContainer.nattyConfig.api.rootPath}/${configuredRoutePath}`,
-              controller: this.getController(routeConfig),
-              parameters: routeConfig.parameters,
-              methodInfo,
-              params: this.convert(methodInfo, matched.params),
-              queryParams: this.getQueryParams()
-            };
-            break;
-          }
-        }
+    const requestUrl = this.getRequestUrl();
+    const requestPathname = this.getRequestPathname(requestUrl);
+    for (const route of this.compiledRoutes) {
+      const matched = route.matcher(requestPathname);
+      if (matched) {
+        this.routeInfo = {
+          path: `${commonContainer.nattyConfig.api.rootPath}/${requestPathname}`,
+          configuredRoutePath: `${commonContainer.nattyConfig.api.rootPath}/${route.configuredRoutePath}`,
+          controller: this.getController(route.routeConfig),
+          parameters: route.routeConfig.parameters,
+          methodInfo: route.methodInfo,
+          params: this.convert(route.methodInfo, matched.params),
+          queryParams: this.getQueryParams(requestUrl)
+        };
+        return true;
       }
     }
-    return isMatched;
-  }
-  getRequestPathname() {
-    const apiRootPath = commonContainer.nattyConfig.api.rootPath;
-    const url = new URL(this.httpContext.request.url);
-    let splitUrl = url.pathname.split(`${apiRootPath}/`);
-    if (splitUrl.length > 1)
-      return splitUrl[1];
-    return url.pathname;
-  }
-  getQueryParams() {
-    const url = new URL(this.httpContext.request.url);
+    return false;
+  }
+  getRequestUrl() {
+    if (!this.parsedRequestUrl)
+      this.parsedRequestUrl = new URL(this.httpContext.request.url);
+    return this.parsedRequestUrl;
+  }
+  getRequestPathname(url) {
+    const apiRootPath = String(commonContainer.nattyConfig.api.rootPath || "").replace(/^\/+|\/+$/g, "");
+    const normalizedPathname = url.pathname.replace(/^\/+/, "");
+    if (!apiRootPath) {
+      return normalizedPathname;
+    }
+    if (normalizedPathname === apiRootPath) {
+      return "";
+    }
+    const apiPrefix = `${apiRootPath}/`;
+    if (normalizedPathname.startsWith(apiPrefix)) {
+      return normalizedPathname.slice(apiPrefix.length);
+    }
+    return normalizedPathname;
+  }
+  getQueryParams(url) {
     const queryParams = {};
     for (const param of url.searchParams.keys())
       queryParams[param] = url.searchParams.get(param);
@@ -911,8 +965,10 @@ class RouteParser extends ParameterTypeConverter {
 const decoratorStateContainer = new class {
   constructor() {
     this.controllerConfig = {};
+    this.controllerSources = /* @__PURE__ */ new Map();
+    this.sourceControllers = /* @__PURE__ */ new Map();
   }
-  register(params, type, additionalConfig) {
+  register(params, type, additionalConfig, sourceFile) {
     const name = params.target.name || params.target.constructor.name;
     let controllerInfo = this.controllerConfig[name] || null;
     let controllerMethodInfo = null;
@@ -925,6 +981,9 @@ const decoratorStateContainer = new class {
       controllerMethodInfo[type] = additionalConfig;
     } else
       controllerInfo.config[type] = additionalConfig;
+    if (sourceFile) {
+      this.trackControllerSource(name, sourceFile);
+    }
   }
   getInfo(controllerName, methodName, type) {
     const controllerInfo = this.controllerConfig[controllerName];
@@ -937,6 +996,55 @@ const decoratorStateContainer = new class {
       methodConfig = methodInfo[type];
     return { controllerConfig, methodConfig };
   }
+  clearFromSource(sourceFile) {
+    const normalizedSourceFile = this.normalizeFilePath(sourceFile);
+    const controllerNames = Array.from(
+      this.sourceControllers.get(normalizedSourceFile) || []
+    );
+    this.clearControllers(controllerNames);
+    this.sourceControllers.delete(normalizedSourceFile);
+    return controllerNames;
+  }
+  clearControllers(controllerNames) {
+    const removedControllers = [];
+    for (const controllerName of controllerNames) {
+      const previousSource = this.controllerSources.get(controllerName);
+      delete this.controllerConfig[controllerName];
+      this.controllerSources.delete(controllerName);
+      removedControllers.push(controllerName);
+      if (previousSource) {
+        const controllers = this.sourceControllers.get(previousSource);
+        controllers?.delete(controllerName);
+        if (controllers && controllers.size === 0) {
+          this.sourceControllers.delete(previousSource);
+        }
+      }
+    }
+    return removedControllers;
+  }
+  reset() {
+    this.controllerConfig = {};
+    this.controllerSources.clear();
+    this.sourceControllers.clear();
+  }
+  trackControllerSource(controllerName, sourceFile) {
+    const normalizedSourceFile = this.normalizeFilePath(sourceFile);
+    const previousSource = this.controllerSources.get(controllerName);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceControllers.get(previousSource)?.delete(controllerName);
+      if (this.sourceControllers.get(previousSource)?.size === 0) {
+        this.sourceControllers.delete(previousSource);
+      }
+    }
+    this.controllerSources.set(controllerName, normalizedSourceFile);
+    if (!this.sourceControllers.has(normalizedSourceFile)) {
+      this.sourceControllers.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceControllers.get(normalizedSourceFile)?.add(controllerName);
+  }
+  normalizeFilePath(filePath) {
+    return path.resolve(filePath).replace(/\\/g, "/");
+  }
 }();
 
 var DecoratorType = /* @__PURE__ */ ((DecoratorType2) => {
@@ -1237,25 +1345,47 @@ class NattyScope {
   }
 }
 
+function normalizeFilePath$1(filePath) {
+  return path.resolve(filePath).replace(/\\/g, "/");
+}
 class NattyContainer {
   constructor() {
     this.regs = /* @__PURE__ */ new Map();
     this.singletons = /* @__PURE__ */ new Map();
+    this.tokenSources = /* @__PURE__ */ new Map();
+    this.sourceTokens = /* @__PURE__ */ new Map();
+    this.metadataKeySources = /* @__PURE__ */ new Map();
+    this.sourceMetadataKeys = /* @__PURE__ */ new Map();
   }
-  register(token, desc) {
+  register(token, desc, sourceFile) {
     this.regs.set(token, desc);
+    if (sourceFile) {
+      this.trackTokenSource(token, sourceFile);
+    }
   }
-  addTransient(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory });
+  addTransient(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addScoped(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory });
+  addScoped(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addSingleton(token, useClass, useFactory) {
-    this.register(token, { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory });
+  addSingleton(token, useClass, useFactory, sourceFile) {
+    this.register(
+      token,
+      { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory },
+      sourceFile
+    );
   }
-  addInstance(token, value) {
-    this.register(token, { lifetime: Lifetime.Singleton, useValue: value });
+  addInstance(token, value, sourceFile) {
+    this.register(token, { lifetime: Lifetime.Singleton, useValue: value }, sourceFile);
     this.singletons.set(token, value);
   }
   createScope() {
@@ -1300,6 +1430,57 @@ class NattyContainer {
   _getDescriptor(token) {
     return this.regs.get(token);
   }
+  trackMetadataKey(sourceFile, key) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const previousSource = this.metadataKeySources.get(key);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceMetadataKeys.get(previousSource)?.delete(key);
+      if (this.sourceMetadataKeys.get(previousSource)?.size === 0) {
+        this.sourceMetadataKeys.delete(previousSource);
+      }
+    }
+    this.metadataKeySources.set(key, normalizedSourceFile);
+    if (!this.sourceMetadataKeys.has(normalizedSourceFile)) {
+      this.sourceMetadataKeys.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceMetadataKeys.get(normalizedSourceFile)?.add(key);
+  }
+  clearRegistrationsFromSource(sourceFile) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const tokens = Array.from(this.sourceTokens.get(normalizedSourceFile) || []);
+    const metadataKeys = Array.from(
+      this.sourceMetadataKeys.get(normalizedSourceFile) || []
+    );
+    for (const token of tokens) {
+      this.regs.delete(token);
+      this.singletons.delete(token);
+      this.tokenSources.delete(token);
+    }
+    for (const metadataKey of metadataKeys) {
+      this.metadataKeySources.delete(metadataKey);
+    }
+    this.sourceTokens.delete(normalizedSourceFile);
+    this.sourceMetadataKeys.delete(normalizedSourceFile);
+    return {
+      metadataKeys,
+      tokens
+    };
+  }
+  trackTokenSource(token, sourceFile) {
+    const normalizedSourceFile = normalizeFilePath$1(sourceFile);
+    const previousSource = this.tokenSources.get(token);
+    if (previousSource && previousSource !== normalizedSourceFile) {
+      this.sourceTokens.get(previousSource)?.delete(token);
+      if (this.sourceTokens.get(previousSource)?.size === 0) {
+        this.sourceTokens.delete(previousSource);
+      }
+    }
+    this.tokenSources.set(token, normalizedSourceFile);
+    if (!this.sourceTokens.has(normalizedSourceFile)) {
+      this.sourceTokens.set(normalizedSourceFile, /* @__PURE__ */ new Set());
+    }
+    this.sourceTokens.get(normalizedSourceFile)?.add(token);
+  }
 }
 
 const nattyServiceResolver = new NattyContainer();
@@ -1405,14 +1586,14 @@ class Resolver extends RequestProcessor {
       if (onException) {
         const instance = this.resolveClass(onException);
         if (instance.onException)
-          result = instance.onException({
+          result = this.normalizeHttpResponse(instance.onException({
             error: ex,
             request: this.httpContext.request,
             routeInfo: this.routeInfo
-          });
+          }));
       } else
         result = new HttpException({
-          body: getPreResponseBody({ message: ex.message, stack: ex.stack }),
+          body: { message: ex.message, stack: ex.stack },
           status: HttpStatusCode.serverError
         }).getResponse();
     }
@@ -1440,14 +1621,17 @@ class RequestHandler extends Resolver {
       if (onException) {
         const instance = this.resolveClass(onException);
         if (instance.onException)
-          return instance.onException({
+          return this.normalizeHttpResponse(instance.onException({
             error: ex,
             request: this.httpContext.request,
             routeInfo: this.routeInfo
-          });
+          }));
       } else
         return new HttpException({
-          body: ex,
+          body: {
+            message: ex?.message,
+            stack: ex?.stack
+          },
           status: HttpStatusCode.serverError
         });
     }
@@ -1460,20 +1644,59 @@ class HttpHandler {
   async processRequest(httpContext) {
     const requestProcessor = new RequestHandler(httpContext);
     const result = await requestProcessor.onRequest();
-    return result;
+    if (result instanceof HttpResponse) {
+      return result;
+    }
+    if (result instanceof HttpException) {
+      return result.getResponse();
+    }
+    return new HttpResponse({ body: result });
   }
 }
 
+const STACK_PATH_REGEX = /\bat (?:(?:.+?) \()?(.+):(\d+):(\d+)\)?$/;
+function normalizeFilePath(filePath) {
+  return path.resolve(filePath).replace(/\\/g, "/");
+}
+function isInternalRegistrationFrame(filePath) {
+  const normalizedPath = normalizeFilePath(filePath);
+  return normalizedPath.includes("/packages/core/decorators/") || normalizedPath.includes("/packages/core/functions/") || normalizedPath.includes("/packages/core/domain/di/") || normalizedPath.includes("/packages/core/const/") || normalizedPath.includes("/packages/core/dist/") || normalizedPath.includes("/node_modules/@nattyjs/core/dist/");
+}
+function getRegistrationSourceFile() {
+  const stack = new Error().stack;
+  return getRegistrationSourceFileFromStack(stack);
+}
+function getRegistrationSourceFileFromStack(stack) {
+  if (!stack) {
+    return void 0;
+  }
+  const lines = stack.split("\n").slice(1);
+  for (const line of lines) {
+    const match = line.trim().match(STACK_PATH_REGEX);
+    if (!match) {
+      continue;
+    }
+    const filePath = normalizeFilePath(match[1]);
+    if (!isInternalRegistrationFrame(filePath)) {
+      return filePath;
+    }
+  }
+  return void 0;
+}
+
 function injectable(options = {}) {
   return (targetConstructor) => {
     const lt = options.lifetime ?? Lifetime.Transient;
+    const sourceFile = getRegistrationSourceFile();
     if (lt === Lifetime.Singleton)
-      nattyServiceResolver.addSingleton(targetConstructor);
+      nattyServiceResolver.addSingleton(targetConstructor, void 0, void 0, sourceFile);
     else if (lt === Lifetime.Scoped)
-      nattyServiceResolver.addScoped(targetConstructor);
+      nattyServiceResolver.addScoped(targetConstructor, void 0, void 0, sourceFile);
     else
-      nattyServiceResolver.addTransient(targetConstructor);
+      nattyServiceResolver.addTransient(targetConstructor, void 0, void 0, sourceFile);
     commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
+    if (sourceFile)
+      nattyServiceResolver.trackMetadataKey(sourceFile, targetConstructor.name);
   };
 }
 
@@ -1759,7 +1982,12 @@ const Results = {
 };
 
 function base(params, type, additionaConfig) {
-  decoratorStateContainer.register(params, type, additionaConfig);
+  decoratorStateContainer.register(
+    params,
+    type,
+    additionaConfig,
+    getRegistrationSourceFile()
+  );
 }
 
 function useFilter(config) {
@@ -1784,6 +2012,12 @@ function authenticationOnly() {
   };
 }
 
+function onException(exceptionFilter) {
+  return function(target, propertyKey, descriptor) {
+    base({ target, propertyKey, descriptor }, DecoratorType.onException, exceptionFilter);
+  };
+}
+
 function setEnvInfo(envTsDefinition, envValueInfo) {
   if (envTsDefinition && envValueInfo) {
     commonContainer.setEnvTsDefinition(envTsDefinition);
@@ -1831,30 +2065,40 @@ function getTokenTypeName(token) {
   return key.slice(separatorIndex + 1);
 }
 
-function registerLifetime(targetConstructor, lifetime) {
+function registerLifetime(targetConstructor, sourceFile, lifetime) {
   if (lifetime === Lifetime.Singleton) {
-    nattyServiceResolver.addSingleton(targetConstructor);
+    nattyServiceResolver.addSingleton(targetConstructor, void 0, void 0, sourceFile);
     return;
   }
   if (lifetime === Lifetime.Scoped) {
-    nattyServiceResolver.addScoped(targetConstructor);
+    nattyServiceResolver.addScoped(targetConstructor, void 0, void 0, sourceFile);
     return;
   }
   if (lifetime === Lifetime.Transient) {
-    nattyServiceResolver.addTransient(targetConstructor);
+    nattyServiceResolver.addTransient(targetConstructor, void 0, void 0, sourceFile);
   }
 }
-function registerAliasTypeName(token) {
+function registerAliasTypeName(token, sourceFile) {
   const typeName = getTokenTypeName(token);
   if (typeName) {
     commonContainer.setMetadata(typeName, token, "services");
+    if (sourceFile)
+      nattyServiceResolver.trackMetadataKey(sourceFile, typeName);
   }
 }
 function registerDiToken(targetConstructor, token, options = {}) {
+  const sourceFile = getRegistrationSourceFile();
   commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
-  registerAliasTypeName(token);
-  registerLifetime(targetConstructor, options.lifetime);
-  nattyServiceResolver.addTransient(token, void 0, (serviceProvider) => serviceProvider.get(targetConstructor));
+  if (sourceFile)
+    nattyServiceResolver.trackMetadataKey(sourceFile, targetConstructor.name);
+  registerAliasTypeName(token, sourceFile);
+  registerLifetime(targetConstructor, sourceFile, options.lifetime);
+  nattyServiceResolver.addTransient(
+    token,
+    void 0,
+    (serviceProvider) => serviceProvider.get(targetConstructor),
+    sourceFile
+  );
 }
 
 function di(token, options = {}) {
@@ -1867,4 +2111,22 @@ function createServiceScope() {
   return nattyServiceResolver.createScope();
 }
 
-export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, Lifetime, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, Results, RunOn, TooManyRequestsException, TooManyRequestsResult, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, conflict, createServiceScope, created, createdAt, createdWith, defineNattyConfig, di, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, post, problem, put, redirect, redirectPermanent, registerDecorator, route, scoped, setEnvInfo, singleton, tooManyRequests, transient, unAuthorized, unprocessableEntity, useFilter, validationProblem };
+function clearHotReloadRegistrations(files) {
+  for (const filePath of files || []) {
+    const result = nattyServiceResolver.clearRegistrationsFromSource(filePath);
+    decoratorStateContainer.clearFromSource(filePath);
+    for (const metadataKey of result.metadataKeys) {
+      commonContainer.deleteMetadataValue(metadataKey, "services");
+    }
+  }
+}
+
+function clearHotReloadControllerMetadata(controllerNames) {
+  decoratorStateContainer.clearControllers(controllerNames || []);
+}
+
+function replaceRoutes(manifest) {
+  nattyContainer.replaceRoutes(manifest);
+}
+
+export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, Lifetime, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, Results, RunOn, TooManyRequestsException, TooManyRequestsResult, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, clearHotReloadControllerMetadata, clearHotReloadRegistrations, conflict, createServiceScope, created, createdAt, createdWith, defineNattyConfig, di, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, onException, post, problem, put, redirect, redirectPermanent, registerDecorator, replaceRoutes, route, scoped, setEnvInfo, singleton, tooManyRequests, transient, unAuthorized, unprocessableEntity, useFilter, validationProblem };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nattyjs/core",
-  "version": "0.0.1-beta.64",
+  "version": "0.0.1-beta.66",
   "description": "",
   "keywords": [],
   "author": "ajayojha",
@@ -17,7 +17,7 @@
   "dependencies": {
     "reflect-metadata": "0.2.2",
     "path-to-regexp": "6.2.1",
-    "@nattyjs/common": "0.0.1-beta.64"
+    "@nattyjs/common": "0.0.1-beta.66"
   },
   "devDependencies": {
     "unbuild": "1.2.1"