@nattyjs/core 0.0.1-beta.60 → 0.0.1-beta.61

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 const common = require('@nattyjs/common');
-const tsyringe = require('tsyringe');
 const pathToRegexp = require('path-to-regexp');
+require('reflect-metadata');
 
 function defineNattyConfig(config) {
   return config;
@@ -277,6 +277,38 @@ class HttpException extends Error {
   }
 }
 
+class HttpRequest {
+  constructor(http) {
+    this.httpRequest = http;
+  }
+  get cookies() {
+    return this.httpRequest.cookies;
+  }
+  get url() {
+    return this.httpRequest.url;
+  }
+  get method() {
+    return this.httpRequest.method;
+  }
+  get headers() {
+    return this.httpRequest.headers;
+  }
+  get user() {
+    return null;
+  }
+  get body() {
+    return this.httpRequest.body;
+  }
+}
+
+class HttpContext {
+  constructor(request, context) {
+    this.request = new HttpRequest(request);
+    this.response = new HttpResponse();
+    this.context = context;
+  }
+}
+
 var RequestPipeline = /* @__PURE__ */ ((RequestPipeline2) => {
   RequestPipeline2[RequestPipeline2["onAuthentication"] = 0] = "onAuthentication";
   RequestPipeline2[RequestPipeline2["onAuthorization"] = 1] = "onAuthorization";
@@ -914,7 +946,7 @@ class AbstractExecutionContext {
     this.routeInfo = routeInfo;
   }
   resolveService(instance) {
-    return tsyringe.container.resolve(instance);
+    return this.context.services.get(instance);
   }
   get request() {
     return this.context.request;
@@ -1042,7 +1074,7 @@ class RequestProcessor extends RouteParser {
     }
   }
   resolveFilter(instance) {
-    return tsyringe.container.resolve(instance);
+    return this.httpContext.services.get(instance);
   }
   getAuthenticationClass() {
     let authentication = void 0;
@@ -1116,9 +1148,153 @@ class RequestProcessor extends RouteParser {
   }
 }
 
+const PARAM_TOKENS_KEY = Symbol.for("natty:di:paramtokens");
+function getParamTokens(Cls) {
+  return Reflect.getMetadata(PARAM_TOKENS_KEY, Cls);
+}
+
+function isClassToken(x) {
+  return typeof x === "function";
+}
+
+var Lifetime = /* @__PURE__ */ ((Lifetime2) => {
+  Lifetime2["Singleton"] = "singleton";
+  Lifetime2["Scoped"] = "scoped";
+  Lifetime2["Transient"] = "transient";
+  return Lifetime2;
+})(Lifetime || {});
+
+function isDisposable(x) {
+  return x && typeof x.dispose === "function";
+}
+
+class NattyScope {
+  constructor(root) {
+    this.root = root;
+    this.scoped = /* @__PURE__ */ new Map();
+    this.disposables = [];
+  }
+  createScope() {
+    return new NattyScope(this.root);
+  }
+  set(token, value) {
+    this.scoped.set(token, value);
+    if (isDisposable(value))
+      this.disposables.push(value);
+  }
+  tryGet(token) {
+    try {
+      return this.get(token);
+    } catch {
+      return void 0;
+    }
+  }
+  get(token) {
+    if (this.scoped.has(token))
+      return this.scoped.get(token);
+    const desc = this.root._getDescriptor(token);
+    if (!desc) {
+      if (typeof token === "function")
+        return this.root.construct(token, this);
+      throw new Error(`DI: No registration for token: ${String(token)}`);
+    }
+    if (desc.lifetime === Lifetime.Singleton) {
+      return this.root.get(token);
+    }
+    if (desc.lifetime === Lifetime.Scoped) {
+      const created = desc.useFactory ? desc.useFactory(this) : this.root.construct(desc.useClass, this);
+      this.scoped.set(token, created);
+      if (isDisposable(created))
+        this.disposables.push(created);
+      return created;
+    }
+    return desc.useFactory ? desc.useFactory(this) : this.root.construct(desc.useClass, this);
+  }
+  async dispose() {
+    for (let i = this.disposables.length - 1; i >= 0; i--) {
+      const d = this.disposables[i];
+      await d.dispose();
+    }
+    this.disposables.length = 0;
+    this.scoped.clear();
+  }
+}
+
+class NattyContainer {
+  constructor() {
+    this.regs = /* @__PURE__ */ new Map();
+    this.singletons = /* @__PURE__ */ new Map();
+  }
+  register(token, desc) {
+    this.regs.set(token, desc);
+  }
+  addTransient(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory });
+  }
+  addScoped(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory });
+  }
+  addSingleton(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory });
+  }
+  addInstance(token, value) {
+    this.register(token, { lifetime: Lifetime.Singleton, useValue: value });
+    this.singletons.set(token, value);
+  }
+  createScope() {
+    return new NattyScope(this);
+  }
+  set(_token, _value) {
+    throw new Error("Use scope.set(token, value) for per-request instances.");
+  }
+  tryGet(token) {
+    try {
+      return this.get(token);
+    } catch {
+      return void 0;
+    }
+  }
+  get(token) {
+    const desc = this.regs.get(token);
+    if (!desc) {
+      if (isClassToken(token))
+        return this.construct(token, this);
+      throw new Error(`DI: No registration for token: ${String(token)}`);
+    }
+    if (desc.lifetime === Lifetime.Singleton) {
+      if (desc.useValue !== void 0)
+        return desc.useValue;
+      if (this.singletons.has(token))
+        return this.singletons.get(token);
+      const created = desc.useFactory ? desc.useFactory(this) : this.construct(desc.useClass, this);
+      this.singletons.set(token, created);
+      return created;
+    }
+    throw new Error(
+      `DI: Tried to resolve ${desc.lifetime} service from root container. Use httpContext.services.get(...)`
+    );
+  }
+  construct(Cls, sp) {
+    const paramTypes = Reflect.getMetadata("design:paramtypes", Cls) || [];
+    const overrideTokens = getParamTokens(Cls) || [];
+    const args = paramTypes.map((t, i) => sp.get(overrideTokens[i] ?? t));
+    return new Cls(...args);
+  }
+  _getDescriptor(token) {
+    return this.regs.get(token);
+  }
+}
+
+const nattyServiceResolver = new NattyContainer();
+
 class Resolver extends RequestProcessor {
   constructor(httpContext) {
     super(httpContext);
+    this.registerDependency();
+  }
+  registerDependency() {
+    this.httpContext.services = nattyServiceResolver.createScope();
+    this.httpContext.services.set(HttpContext, this.httpContext);
   }
   getControllerInstance() {
     const controller = this.routeInfo.controller;
@@ -1127,7 +1303,7 @@ class Resolver extends RequestProcessor {
     return instance;
   }
   resolveClass(classConstruct) {
-    return tsyringe.container.resolve(classConstruct);
+    return nattyServiceResolver.get(classConstruct);
   }
   resolveConstructorParameters() {
     let parameters = [];
@@ -1261,42 +1437,15 @@ class HttpHandler {
   }
 }
 
-class HttpRequest {
-  constructor(http) {
-    this.httpRequest = http;
-  }
-  get cookies() {
-    return this.httpRequest.cookies;
-  }
-  get url() {
-    return this.httpRequest.url;
-  }
-  get method() {
-    return this.httpRequest.method;
-  }
-  get headers() {
-    return this.httpRequest.headers;
-  }
-  get user() {
-    return null;
-  }
-  get body() {
-    return this.httpRequest.body;
-  }
-}
-
-class HttpContext {
-  constructor(request, context) {
-    this.request = new HttpRequest(request);
-    this.response = new HttpResponse();
-    this.context = context;
-  }
-}
-
 function injectable(options = {}) {
   return (targetConstructor) => {
-    tsyringe.injectable()(targetConstructor);
-    common.commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
+    const lt = options.lifetime ?? Lifetime.Transient;
+    if (lt === Lifetime.Singleton)
+      nattyServiceResolver.addSingleton(targetConstructor);
+    else if (lt === Lifetime.Scoped)
+      nattyServiceResolver.addScoped(targetConstructor);
+    else
+      nattyServiceResolver.addTransient(targetConstructor);
   };
 }
 
@@ -1308,7 +1457,7 @@ function $request(request) {
 
 function filter(config) {
   return (targetConstructor) => {
-    tsyringe.injectable()(targetConstructor);
+    injectable({ lifetime: Lifetime.Transient })(targetConstructor);
   };
 }
 
@@ -1627,6 +1776,18 @@ function authorize(permission) {
   };
 }
 
+function scoped(token) {
+  return injectable({ lifetime: Lifetime.Scoped, token });
+}
+
+function transient(token) {
+  return injectable({ lifetime: Lifetime.Transient, token });
+}
+
+function singleton(token) {
+  return injectable({ lifetime: Lifetime.Singleton, token });
+}
+
 exports.$request = $request;
 exports.AbstractModelState = AbstractModelState;
 exports.AcceptedException = AcceptedException;
@@ -1696,8 +1857,11 @@ exports.redirect = redirect;
 exports.redirectPermanent = redirectPermanent;
 exports.registerDecorator = registerDecorator;
 exports.route = route;
+exports.scoped = scoped;
 exports.setEnvInfo = setEnvInfo;
+exports.singleton = singleton;
 exports.tooManyRequests = tooManyRequests;
+exports.transient = transient;
 exports.unAuthorized = unAuthorized;
 exports.unprocessableEntity = unprocessableEntity;
 exports.useFilter = useFilter;

package/dist/index.d.ts

@@ -279,6 +279,72 @@ declare class HttpResponse {
     write(responseInit: HttpResponseInit): void;
 }
 
+type DIClassType<T = any> = new (...args: any[]) => T;
+
+type Token<T = any> = DIClassType<T> | symbol | string;
+
+interface ServiceProvider {
+    get<T>(token: Token<T>): T;
+    tryGet<T>(token: Token<T>): T | undefined;
+    set<T>(token: Token<T>, value: T): void;
+    createScope(): Scope;
+}
+
+interface Scope extends ServiceProvider {
+    dispose(): Promise<void> | void;
+}
+
+type Factory<T = any> = (sp: ServiceProvider) => T;
+
+declare enum Lifetime {
+    Singleton = "singleton",
+    Scoped = "scoped",
+    Transient = "transient"
+}
+
+type Descriptor<T = any> = {
+    lifetime: Lifetime.Singleton;
+    useValue?: T;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+} | {
+    lifetime: Lifetime.Scoped;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+} | {
+    lifetime: Lifetime.Transient;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+};
+
+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;
+    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;
+}
+
+declare class NattyScope implements Scope {
+    private readonly root;
+    private readonly scoped;
+    private readonly disposables;
+    constructor(root: NattyContainer);
+    createScope(): NattyScope;
+    set<T>(token: Token<T>, value: T): void;
+    tryGet<T>(token: Token<T>): T | undefined;
+    get<T>(token: Token<T>): T;
+    dispose(): Promise<void>;
+}
+
 declare class HttpContext {
     constructor(request: HttpRequestInit, context: any);
     request: HttpRequest;
@@ -289,6 +355,7 @@ declare class HttpContext {
         [key: string]: RouteConfig;
     };
     user: UserIdentity<any>;
+    services: NattyScope;
 }
 
 declare class HttpHandler {
@@ -300,8 +367,11 @@ interface HttpModule {
     init: (config: NattyConfig) => void;
 }
 
-declare function injectable<T = unknown>(): Function;
-declare function injectable<T = unknown>(options: any): Function;
+declare function injectable<T = unknown>(): ClassDecorator;
+declare function injectable<T = unknown>(options: {
+    lifetime?: Lifetime;
+    token?: Token<T>;
+}): ClassDecorator;
 
 declare function $request(request: HttpRequestInit): Promise<HttpResponse>;
 
@@ -614,4 +684,10 @@ declare function authorize(permission: {
 
 declare function CreateProblemDetail(modelName: string, detail: any): ProblemDetail;
 
-export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, BuildOptions, ClassTypeInfo, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, 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, created, createdAt, createdWith, defineNattyConfig, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, post, problem, put, redirect, redirectPermanent, registerDecorator, route, setEnvInfo, tooManyRequests, unAuthorized, unprocessableEntity, useFilter, validationProblem };
+declare function scoped<T = unknown>(): ClassDecorator;
+
+declare function transient<T = unknown>(): ClassDecorator;
+
+declare function singleton<T = unknown>(): ClassDecorator;
+
+export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, BuildOptions, ClassTypeInfo, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, 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, created, createdAt, createdWith, defineNattyConfig, 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 };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { commonContainer, isObject, List, BLANK as BLANK$1, RIGHT_SLASH } from '@nattyjs/common';
-import { container, injectable as injectable$1 } from 'tsyringe';
 import { match } from 'path-to-regexp';
+import 'reflect-metadata';
 
 function defineNattyConfig(config) {
   return config;
@@ -275,6 +275,38 @@ class HttpException extends Error {
   }
 }
 
+class HttpRequest {
+  constructor(http) {
+    this.httpRequest = http;
+  }
+  get cookies() {
+    return this.httpRequest.cookies;
+  }
+  get url() {
+    return this.httpRequest.url;
+  }
+  get method() {
+    return this.httpRequest.method;
+  }
+  get headers() {
+    return this.httpRequest.headers;
+  }
+  get user() {
+    return null;
+  }
+  get body() {
+    return this.httpRequest.body;
+  }
+}
+
+class HttpContext {
+  constructor(request, context) {
+    this.request = new HttpRequest(request);
+    this.response = new HttpResponse();
+    this.context = context;
+  }
+}
+
 var RequestPipeline = /* @__PURE__ */ ((RequestPipeline2) => {
   RequestPipeline2[RequestPipeline2["onAuthentication"] = 0] = "onAuthentication";
   RequestPipeline2[RequestPipeline2["onAuthorization"] = 1] = "onAuthorization";
@@ -912,7 +944,7 @@ class AbstractExecutionContext {
     this.routeInfo = routeInfo;
   }
   resolveService(instance) {
-    return container.resolve(instance);
+    return this.context.services.get(instance);
   }
   get request() {
     return this.context.request;
@@ -1040,7 +1072,7 @@ class RequestProcessor extends RouteParser {
     }
   }
   resolveFilter(instance) {
-    return container.resolve(instance);
+    return this.httpContext.services.get(instance);
   }
   getAuthenticationClass() {
     let authentication = void 0;
@@ -1114,9 +1146,153 @@ class RequestProcessor extends RouteParser {
   }
 }
 
+const PARAM_TOKENS_KEY = Symbol.for("natty:di:paramtokens");
+function getParamTokens(Cls) {
+  return Reflect.getMetadata(PARAM_TOKENS_KEY, Cls);
+}
+
+function isClassToken(x) {
+  return typeof x === "function";
+}
+
+var Lifetime = /* @__PURE__ */ ((Lifetime2) => {
+  Lifetime2["Singleton"] = "singleton";
+  Lifetime2["Scoped"] = "scoped";
+  Lifetime2["Transient"] = "transient";
+  return Lifetime2;
+})(Lifetime || {});
+
+function isDisposable(x) {
+  return x && typeof x.dispose === "function";
+}
+
+class NattyScope {
+  constructor(root) {
+    this.root = root;
+    this.scoped = /* @__PURE__ */ new Map();
+    this.disposables = [];
+  }
+  createScope() {
+    return new NattyScope(this.root);
+  }
+  set(token, value) {
+    this.scoped.set(token, value);
+    if (isDisposable(value))
+      this.disposables.push(value);
+  }
+  tryGet(token) {
+    try {
+      return this.get(token);
+    } catch {
+      return void 0;
+    }
+  }
+  get(token) {
+    if (this.scoped.has(token))
+      return this.scoped.get(token);
+    const desc = this.root._getDescriptor(token);
+    if (!desc) {
+      if (typeof token === "function")
+        return this.root.construct(token, this);
+      throw new Error(`DI: No registration for token: ${String(token)}`);
+    }
+    if (desc.lifetime === Lifetime.Singleton) {
+      return this.root.get(token);
+    }
+    if (desc.lifetime === Lifetime.Scoped) {
+      const created = desc.useFactory ? desc.useFactory(this) : this.root.construct(desc.useClass, this);
+      this.scoped.set(token, created);
+      if (isDisposable(created))
+        this.disposables.push(created);
+      return created;
+    }
+    return desc.useFactory ? desc.useFactory(this) : this.root.construct(desc.useClass, this);
+  }
+  async dispose() {
+    for (let i = this.disposables.length - 1; i >= 0; i--) {
+      const d = this.disposables[i];
+      await d.dispose();
+    }
+    this.disposables.length = 0;
+    this.scoped.clear();
+  }
+}
+
+class NattyContainer {
+  constructor() {
+    this.regs = /* @__PURE__ */ new Map();
+    this.singletons = /* @__PURE__ */ new Map();
+  }
+  register(token, desc) {
+    this.regs.set(token, desc);
+  }
+  addTransient(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Transient, useClass: useClass ?? token, useFactory });
+  }
+  addScoped(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Scoped, useClass: useClass ?? token, useFactory });
+  }
+  addSingleton(token, useClass, useFactory) {
+    this.register(token, { lifetime: Lifetime.Singleton, useClass: useClass ?? token, useFactory });
+  }
+  addInstance(token, value) {
+    this.register(token, { lifetime: Lifetime.Singleton, useValue: value });
+    this.singletons.set(token, value);
+  }
+  createScope() {
+    return new NattyScope(this);
+  }
+  set(_token, _value) {
+    throw new Error("Use scope.set(token, value) for per-request instances.");
+  }
+  tryGet(token) {
+    try {
+      return this.get(token);
+    } catch {
+      return void 0;
+    }
+  }
+  get(token) {
+    const desc = this.regs.get(token);
+    if (!desc) {
+      if (isClassToken(token))
+        return this.construct(token, this);
+      throw new Error(`DI: No registration for token: ${String(token)}`);
+    }
+    if (desc.lifetime === Lifetime.Singleton) {
+      if (desc.useValue !== void 0)
+        return desc.useValue;
+      if (this.singletons.has(token))
+        return this.singletons.get(token);
+      const created = desc.useFactory ? desc.useFactory(this) : this.construct(desc.useClass, this);
+      this.singletons.set(token, created);
+      return created;
+    }
+    throw new Error(
+      `DI: Tried to resolve ${desc.lifetime} service from root container. Use httpContext.services.get(...)`
+    );
+  }
+  construct(Cls, sp) {
+    const paramTypes = Reflect.getMetadata("design:paramtypes", Cls) || [];
+    const overrideTokens = getParamTokens(Cls) || [];
+    const args = paramTypes.map((t, i) => sp.get(overrideTokens[i] ?? t));
+    return new Cls(...args);
+  }
+  _getDescriptor(token) {
+    return this.regs.get(token);
+  }
+}
+
+const nattyServiceResolver = new NattyContainer();
+
 class Resolver extends RequestProcessor {
   constructor(httpContext) {
     super(httpContext);
+    this.registerDependency();
+  }
+  registerDependency() {
+    this.httpContext.services = nattyServiceResolver.createScope();
+    this.httpContext.services.set(HttpContext, this.httpContext);
   }
   getControllerInstance() {
     const controller = this.routeInfo.controller;
@@ -1125,7 +1301,7 @@ class Resolver extends RequestProcessor {
     return instance;
   }
   resolveClass(classConstruct) {
-    return container.resolve(classConstruct);
+    return nattyServiceResolver.get(classConstruct);
   }
   resolveConstructorParameters() {
     let parameters = [];
@@ -1259,42 +1435,15 @@ class HttpHandler {
   }
 }
 
-class HttpRequest {
-  constructor(http) {
-    this.httpRequest = http;
-  }
-  get cookies() {
-    return this.httpRequest.cookies;
-  }
-  get url() {
-    return this.httpRequest.url;
-  }
-  get method() {
-    return this.httpRequest.method;
-  }
-  get headers() {
-    return this.httpRequest.headers;
-  }
-  get user() {
-    return null;
-  }
-  get body() {
-    return this.httpRequest.body;
-  }
-}
-
-class HttpContext {
-  constructor(request, context) {
-    this.request = new HttpRequest(request);
-    this.response = new HttpResponse();
-    this.context = context;
-  }
-}
-
 function injectable(options = {}) {
   return (targetConstructor) => {
-    injectable$1()(targetConstructor);
-    commonContainer.setMetadata(targetConstructor.name, targetConstructor, "services");
+    const lt = options.lifetime ?? Lifetime.Transient;
+    if (lt === Lifetime.Singleton)
+      nattyServiceResolver.addSingleton(targetConstructor);
+    else if (lt === Lifetime.Scoped)
+      nattyServiceResolver.addScoped(targetConstructor);
+    else
+      nattyServiceResolver.addTransient(targetConstructor);
   };
 }
 
@@ -1306,7 +1455,7 @@ function $request(request) {
 
 function filter(config) {
   return (targetConstructor) => {
-    injectable$1()(targetConstructor);
+    injectable({ lifetime: Lifetime.Transient })(targetConstructor);
   };
 }
 
@@ -1625,4 +1774,16 @@ function authorize(permission) {
   };
 }
 
-export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, Results, RunOn, TooManyRequestsException, TooManyRequestsResult, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, conflict, created, createdAt, createdWith, defineNattyConfig, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, post, problem, put, redirect, redirectPermanent, registerDecorator, route, setEnvInfo, tooManyRequests, unAuthorized, unprocessableEntity, useFilter, validationProblem };
+function scoped(token) {
+  return injectable({ lifetime: Lifetime.Scoped, token });
+}
+
+function transient(token) {
+  return injectable({ lifetime: Lifetime.Transient, token });
+}
+
+function singleton(token) {
+  return injectable({ lifetime: Lifetime.Singleton, token });
+}
+
+export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, ConflictResult, CreateProblemDetail, CreatedResult, Delete, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, Results, RunOn, TooManyRequestsException, TooManyRequestsResult, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, conflict, created, createdAt, createdWith, defineNattyConfig, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nattyjs/core",
-  "version": "0.0.1-beta.60",
+  "version": "0.0.1-beta.61",
   "description": "",
   "keywords": [],
   "author": "ajayojha",
@@ -16,9 +16,8 @@
   },
   "dependencies": {
     "reflect-metadata": "0.2.2",
-    "tsyringe": "^4.7.0",
     "path-to-regexp": "6.2.1",
-    "@nattyjs/common": "0.0.1-beta.60"
+    "@nattyjs/common": "0.0.1-beta.61"
   },
   "devDependencies": {
     "unbuild": "1.2.1"