@nattyjs/core 0.0.1-beta.63 → 0.0.1-beta.65

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;
@@ -145,13 +193,28 @@ async function startWebSchedule(config) {
 function init(config, appConfig) {
   common.commonContainer.setupConfig(config);
   common.commonContainer.setEnvTsDefinition(appConfig.envTsDefinition);
-  nattyContainer.setup(config, appConfig.routes, appConfig.resolver);
+  setupLegacyTypes(appConfig.types);
+  nattyContainer.setup(config, appConfig.routes, appConfig.resolver || defaultResolver);
   callLifeCycleEvents(config, true);
   const result = initializeModule(config);
   callLifeCycleEvents(config);
   startWebSchedules(config.webSchedules);
   return result;
 }
+function setupLegacyTypes(types) {
+  if (types) {
+    common.commonContainer.types = {};
+    for (const [name, type] of Object.entries(types))
+      common.commonContainer.registerType({ name, ...type });
+  }
+}
+function defaultResolver(path) {
+  if (typeof path === "function")
+    return path();
+  if (typeof path === "string")
+    return require(path);
+  return {};
+}
 function initializeModule(config) {
   if (config.app) {
     return config.app.init(config);
@@ -833,8 +896,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();
@@ -847,47 +910,38 @@ 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;
+    return false;
+  }
+  getRequestUrl() {
+    if (!this.parsedRequestUrl)
+      this.parsedRequestUrl = new URL(this.httpContext.request.url);
+    return this.parsedRequestUrl;
   }
-  getRequestPathname() {
+  getRequestPathname(url) {
     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);
+  getQueryParams(url) {
     const queryParams = {};
     for (const param of url.searchParams.keys())
       queryParams[param] = url.searchParams.get(param);
@@ -898,8 +952,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;
@@ -912,6 +968,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];
@@ -924,6 +983,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) => {
@@ -1016,11 +1124,12 @@ function getTypeName(typeName) {
 }
 
 class ModelBindingContext extends ParameterTypeConverter {
-  constructor(type, typeInfo, data) {
+  constructor(type, typeInfo, data, throwOnValidationError = false) {
     super();
     this.type = type;
     this.typeInfo = typeInfo;
     this.data = data;
+    this.throwOnValidationError = throwOnValidationError;
     this.serialize();
   }
   serialize() {
@@ -1030,7 +1139,7 @@ class ModelBindingContext extends ParameterTypeConverter {
     else
       this.data = body;
     this.instance = this.convertToInstance(this.type, this.data);
-    if (!this.isValid)
+    if (this.throwOnValidationError && !this.isValid)
       throw new HttpBadRequestException(CreateProblemDetail(this.type, this.errors));
   }
   get isValid() {
@@ -1091,8 +1200,11 @@ class RequestProcessor extends RouteParser {
     const authentication = this.getAuthenticationClass();
     const authenticationFilter = authentication ? this.resolveFilter(authentication) : void 0;
     const anonymousInfo = decoratorStateContainer.getInfo(this.routeInfo.controller.name, this.routeInfo.methodInfo.name, DecoratorType.anonymous);
-    if (!anonymousInfo.controllerConfig && !anonymousInfo.methodConfig && !authenticationFilter)
-      throw new UnauthorizedAccessException(DENY_BY_DEFAULT);
+    if (!authenticationFilter) {
+      if (common.commonContainer.nattyConfig?.secure?.denyByDefault && !anonymousInfo.controllerConfig && !anonymousInfo.methodConfig)
+        throw new UnauthorizedAccessException(DENY_BY_DEFAULT);
+      return;
+    }
     if (authenticationFilter) {
       const result = await authenticationFilter.onAuthentication(this.httpContext);
       this.httpContext.user = result;
@@ -1112,7 +1224,7 @@ class RequestProcessor extends RouteParser {
         this.routeInfo,
         authorizeConfig.methodConfig || authorizeConfig.controllerConfig
       );
-      const result = await authorizationFilter.onAuthorization(authorizationContext);
+      const result = await authorizationFilter.onAuthorization(authorizationContext, authorizationContext.config);
       if (!result)
         throw new ForbiddenAccessException(authorizationFilter.onFailedAuthorization());
     }
@@ -1220,25 +1332,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() {
@@ -1283,6 +1417,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();
@@ -1303,18 +1488,27 @@ class Resolver extends RequestProcessor {
     const instance = new controller(...parameters);
     return instance;
   }
-  resolveClass(classConstruct) {
-    return this.httpContext.services.get(classConstruct);
+  resolveClass(token) {
+    return this.httpContext.services.get(token);
   }
   resolveConstructorParameters() {
     let parameters = [];
     for (const parameter of this.routeInfo.parameters) {
-      const classConstruct = this.getClass(parameter.type);
-      if (classConstruct)
-        parameters.push(this.resolveClass(classConstruct));
+      const token = this.getConstructorParameterToken(parameter);
+      if (token)
+        parameters.push(this.resolveClass(token));
     }
     return parameters;
   }
+  getConstructorParameterToken(parameter) {
+    if (parameter.tokenKey) {
+      return Symbol.for(parameter.tokenKey);
+    }
+    if (parameter.type) {
+      return this.getClass(parameter.type);
+    }
+    return void 0;
+  }
   getMethodParameters() {
     const parameters = new Array();
     for (const parameter of this.routeInfo.methodInfo.parameters) {
@@ -1326,7 +1520,7 @@ class Resolver extends RequestProcessor {
       else if (queryParams[parameter.name] !== void 0)
         parameters.push(queryParams[parameter.name]);
       else if (typeInfo && this.httpContext.request.body.json) {
-        const context = new ModelBindingContext(parameter.type, typeInfo.props, this.httpContext.request.body.json);
+        const context = new ModelBindingContext(parameter.type, typeInfo.props, this.httpContext.request.body.json, true);
         parameters.push(context);
       }
     }
@@ -1386,7 +1580,7 @@ class Resolver extends RequestProcessor {
           });
       } else
         result = new HttpException({
-          body: getPreResponseBody({ message: ex.message, stack: ex.stack }),
+          body: { message: ex.message, stack: ex.stack },
           status: HttpStatusCode.serverError
         }).getResponse();
     }
@@ -1421,7 +1615,10 @@ class RequestHandler extends Resolver {
           });
       } else
         return new HttpException({
-          body: ex,
+          body: {
+            message: ex?.message,
+            stack: ex?.stack
+          },
           status: HttpStatusCode.serverError
         });
     }
@@ -1434,20 +1631,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);
   };
 }
 
@@ -1733,7 +1969,12 @@ const Results = {
 };
 
 function base(params, type, additionaConfig) {
-  decoratorStateContainer.register(params, type, additionaConfig);
+  decoratorStateContainer.register(
+    params,
+    type,
+    additionaConfig,
+    getRegistrationSourceFile()
+  );
 }
 
 function useFilter(config) {
@@ -1758,6 +1999,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);
@@ -1790,6 +2037,85 @@ function singleton(token) {
   return injectable({ lifetime: Lifetime.Singleton, token });
 }
 
+function getTokenTypeName(token) {
+  if (typeof token !== "symbol") {
+    return void 0;
+  }
+  const key = Symbol.keyFor(token);
+  if (!key) {
+    return void 0;
+  }
+  const separatorIndex = key.lastIndexOf("#");
+  if (separatorIndex < 0 || separatorIndex === key.length - 1) {
+    return void 0;
+  }
+  return key.slice(separatorIndex + 1);
+}
+
+function registerLifetime(targetConstructor, sourceFile, lifetime) {
+  if (lifetime === Lifetime.Singleton) {
+    nattyServiceResolver.addSingleton(targetConstructor, void 0, void 0, sourceFile);
+    return;
+  }
+  if (lifetime === Lifetime.Scoped) {
+    nattyServiceResolver.addScoped(targetConstructor, void 0, void 0, sourceFile);
+    return;
+  }
+  if (lifetime === Lifetime.Transient) {
+    nattyServiceResolver.addTransient(targetConstructor, void 0, void 0, sourceFile);
+  }
+}
+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");
+  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 = {}) {
+  return (targetConstructor) => {
+    registerDiToken(targetConstructor, token, options);
+  };
+}
+
+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;
@@ -1813,6 +2139,7 @@ exports.HttpNotFoundException = HttpNotFoundException;
 exports.HttpResponse = HttpResponse;
 exports.HttpStatusCode = HttpStatusCode;
 exports.HttpUnprocessableEntityException = HttpUnprocessableEntityException;
+exports.Lifetime = Lifetime;
 exports.ModelBindingContext = ModelBindingContext;
 exports.NoContentResult = NoContentResult;
 exports.NotFoundResult = NotFoundResult;
@@ -1835,11 +2162,15 @@ 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;
 exports.createdAt = createdAt;
 exports.createdWith = createdWith;
 exports.defineNattyConfig = defineNattyConfig;
+exports.di = di;
 exports.entityContainer = entityContainer;
 exports.file = file;
 exports.filter = filter;
@@ -1852,12 +2183,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;