return (injector: InjectorService, target: any) => {
    if (injector.has(interceptor)) {
      const originalMethod = target[method];
      const intcpt = injector.get<IInterceptor>(interceptor)!;

      function interceptedMethod(...args: any[]) {
        const context = {
          target,
          method,
          args,
          proceed(err?: Error) {
            if (!err) {
              return originalMethod.apply(target, args);
            }

            throw err;
          }
        };

        return intcpt.aroundInvoke(context, options);
      }

      target[method] = interceptedMethod;
    }
  };

  static resolve(obj: any | EndpointMetadata, injector: InjectorService) {
    let options: IHandlerOptions;

    if (obj instanceof EndpointMetadata) {
      const provider = injector.getProvider(obj.target)!;

      options = {
        token: provider.provide,
        target: provider.useClass,
        type: HandlerType.CONTROLLER,
        method: obj.methodClassName
      };
    } else {
      const provider = injector.getProvider(obj);

      if (provider) {
        options = {
          token: provider.provide,
          target: provider.useClass,
          type: HandlerType.MIDDLEWARE,
          method: "use"
        };
      } else {
        options = {
          target: obj,
          type: HandlerType.FUNCTION
        };
      }
    }

    return new HandlerMetadata(options);
  }

function createSettingsService(injector: InjectorService) {
  const provider = GlobalProviders.get(ServerSettingsService)!;
  const settingsService = injector.invoke<ServerSettingsService>(provider.useClass);

  injector.forkProvider(ServerSettingsService, settingsService);

  return settingsService;
}

export function createHttpServer(injector: InjectorService): Http.Server {
  const expressApp = injector.get<ExpressApplication>(ExpressApplication);
  const httpServer = Http.createServer(expressApp);
  // TODO to be removed
  /* istanbul ignore next */
  (httpServer as any).get = () => httpServer;

  injector.forkProvider(HttpServer, httpServer);

  return httpServer;
}

    args = args.map(arg => {
      if (injector.has(arg)) {
        arg = HandlerBuilder.from(arg).build(injector);
      }

      return arg;
    });

  /**
   *
   * @param {Type<IFilter>} target
   * @param args
   * @returns {any}
   */
  private invoke(target: Type<IFilter>, ...args: any[]): any {
    const instance = this.injector.get<IFilter>(target);

    if (!instance || !instance.transform) {
      throw new UnknowFilterError(target);
    }

    const [expression, request, response] = args;

    return instance.transform(expression, request, response);
  }

  /**
   *
   */
  private getHandler(locals: Map<string | Function, any>): Function {
    const {token, method} = this.handlerMetadata;
    const provider = this.injector.getProvider(token);

    /* istanbul ignore next */
    if (!provider) {
      throw new Error(`${nameOf(token)} component not found in the injector`);
    }

    let instance: any;

    if (provider.scope !== ProviderScope.SINGLETON) {
      instance = this.injector.invoke<any>(provider.useClass, locals, undefined, true);
      locals.set(token, instance);
    } else {
      instance = this.injector.get<any>(token);
    }

    return instance[method!].bind(instance);
  }

    dependencies.forEach((child: Type<any>) => {
      const provider = injector.getProvider(child) as ControllerProvider;

      /* istanbul ignore next */
      if (!provider) {
        throw new Error("Controller component not found in the ControllerRegistry");
      }

      new ControllerBuilder(provider).build(injector);

      router.use(provider.path, provider.router);
    });

  return async (request: Express.Request, response: Express.Response, next: Express.NextFunction) => {
    request.ctx = new Context({id: getId()});
    request.id = request.ctx.id;

    await injector.emit("$onRequest", request, response);

    applyBefore(response, "end", async () => {
      await injector.emit("$onResponse", request, response);
      request.ctx.destroy();
    });

    next();
  };

  /**
   *
   * @param filter
   * @param param
   * @returns {(value: any) => any}
   */
  private appendConverterFilter(filter: any, param: ParamMetadata): Function {
    if (!param.useConverter) {
      return filter;
    }

    const converterService = this.injector.get<ConverterService>(ConverterService)!;

    return FilterBuilder.pipe(
      filter,
      converterService.deserialize.bind(converterService),
      param.collectionType || param.type,
      param.type
    );
  }