@venok/http 1.1.0 → 2.0.1-next.1

package/dist/http/starter-module.js

@@ -0,0 +1,85 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/http/src/http/starter-module.ts
+import { ApplicationConfig, Inject, Injectable, Logger, VenokContainer } from "@venok/core";
+import {
+  VENOK_ADAPTER_ADD_ROUTE,
+  VENOK_ADAPTER_BUILD,
+  VENOK_ADAPTER_SET_EXCEPTION_FILTER,
+  VENOK_APPLY_ROUTES_TO_INSTANCE
+} from "../symbols.js";
+import { HTTP_APP_OPTIONS } from "../http/configurable-module.js";
+import { HttpExplorerService } from "../http/explorer.js";
+import { HttpConfig } from "../http/config.js";
+import { HttpMiddlewareService } from "../middleware/service.js";
+import { HttpMiddlewareModule } from "../middleware/module.js";
+import { Controller } from "../decorators/controller.decorator.js";
+import { VENOK_HTTP_SERVER_START } from "../helpers/messages.helper.js";
+class HttpStarterModule {
+  options;
+  httpExplorerService;
+  middlewareService;
+  container;
+  httpConfig;
+  logger = new Logger(HttpStarterModule.name, { timestamp: true });
+  adapter;
+  constructor(options, httpExplorerService, middlewareService, container, httpConfig) {
+    this.options = options;
+    this.httpExplorerService = httpExplorerService;
+    this.middlewareService = middlewareService;
+    this.container = container;
+    this.httpConfig = httpConfig;
+  }
+  async onModuleInit() {
+    this.adapter = this.httpConfig.getHttpAdapterRef();
+    this.adapter[VENOK_ADAPTER_SET_EXCEPTION_FILTER](this.container, new ApplicationConfig);
+    this.options.callback && this.options.callback(this.httpConfig);
+    await this.middlewareService.explore(HttpMiddlewareModule);
+    await this.middlewareService.build();
+    this.httpExplorerService.explore(Controller.KEY).forEach((item) => this.registerRoutes(item));
+    const routes = this.adapter[VENOK_ADAPTER_BUILD]();
+    this.adapter[VENOK_APPLY_ROUTES_TO_INSTANCE](routes);
+    this.adapter.registerNotFoundHandler();
+    this.adapter.registerExceptionHandler();
+    const listenCallback = async (...args) => {
+      this.logger.log(VENOK_HTTP_SERVER_START(this.options.port));
+      if (this.options.listenCallback)
+        await this.options.listenCallback(...args);
+    };
+    await this.adapter.listen(this.options.port, this.options.hostname || "", listenCallback);
+  }
+  registerRoutes(controllerDiscovery) {
+    controllerDiscovery.getItems().forEach((item) => {
+      const { path, ...metadata } = item.getMeta();
+      this.adapter[VENOK_ADAPTER_ADD_ROUTE](path, metadata);
+    });
+  }
+}
+HttpStarterModule = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(HTTP_APP_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Required === "undefined" ? Object : Required,
+    typeof HttpExplorerService === "undefined" ? Object : HttpExplorerService,
+    typeof HttpMiddlewareService === "undefined" ? Object : HttpMiddlewareService,
+    typeof VenokContainer === "undefined" ? Object : VenokContainer,
+    typeof HttpConfig === "undefined" ? Object : HttpConfig
+  ])
+], HttpStarterModule);
+export {
+  HttpStarterModule
+};