@venok/http 1.1.0 → 2.0.1-next.1

package/dist/router/module.js

@@ -0,0 +1,89 @@
+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/router/module.ts
+import { Inject, Module, MODULE_PATH, ModulesContainer } from "@venok/core";
+import { normalizePath } from "../helpers/path.helper.js";
+import { flattenRoutePaths } from "../helpers/route.helper.js";
+var ROUTES = Symbol("ROUTES");
+var targetModulesByContainer = new WeakMap;
+
+class RouterModule {
+  modulesContainer;
+  routes;
+  constructor(modulesContainer, routes) {
+    this.modulesContainer = modulesContainer;
+    this.routes = routes;
+    this.routes = this.deepCloneRoutes(routes);
+    this.initialize();
+  }
+  static register(routes) {
+    return {
+      module: RouterModule,
+      providers: [{ provide: ROUTES, useValue: routes }]
+    };
+  }
+  deepCloneRoutes(routes) {
+    return routes.map((routeOrType) => {
+      if (typeof routeOrType === "function")
+        return routeOrType;
+      if (routeOrType.children) {
+        return {
+          ...routeOrType,
+          children: this.deepCloneRoutes(routeOrType.children)
+        };
+      }
+      return { ...routeOrType };
+    });
+  }
+  initialize() {
+    const flattenedRoutes = flattenRoutePaths(this.routes);
+    flattenedRoutes.forEach((route) => {
+      const modulePath = normalizePath(route.path);
+      this.registerModulePathMetadata(route.module, modulePath);
+      this.updateTargetModulesCache(route.module);
+    });
+  }
+  registerModulePathMetadata(moduleCtor, modulePath) {
+    Reflect.defineMetadata(MODULE_PATH + this.modulesContainer.applicationId, modulePath, moduleCtor);
+  }
+  updateTargetModulesCache(moduleCtor) {
+    let moduleClassSet;
+    if (targetModulesByContainer.has(this.modulesContainer)) {
+      moduleClassSet = targetModulesByContainer.get(this.modulesContainer);
+    } else {
+      moduleClassSet = new WeakSet;
+      targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
+    }
+    const moduleRef = Array.from(this.modulesContainer.values()).find((item) => item?.metatype === moduleCtor);
+    if (!moduleRef)
+      return;
+    moduleClassSet.add(moduleRef);
+  }
+}
+RouterModule = __legacyDecorateClassTS([
+  Module({}),
+  __legacyDecorateParamTS(1, Inject(ROUTES)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ModulesContainer === "undefined" ? Object : ModulesContainer,
+    typeof Routes === "undefined" ? Object : Routes
+  ])
+], RouterModule);
+export {
+  targetModulesByContainer,
+  RouterModule,
+  ROUTES
+};

package/dist/router/path-factory.js

@@ -0,0 +1,110 @@
+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/router/path-factory.ts
+import { flatten, isUndefined } from "@venok/core";
+import { VERSION_NEUTRAL } from "../interfaces/index.js";
+import { HttpVersioningType } from "../enums/version-type.enum.js";
+import { addLeadingSlash, stripEndSlash } from "../helpers/path.helper.js";
+import { isRouteExcluded } from "../helpers/route.helper.js";
+
+class RoutePathFactory {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  create(metadata, requestMethod) {
+    let paths = [""];
+    const versionOrVersions = this.getVersion(metadata);
+    if (versionOrVersions && metadata.versioningOptions?.type === HttpVersioningType.URI) {
+      const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
+      if (Array.isArray(versionOrVersions)) {
+        paths = flatten(paths.map((path) => versionOrVersions.map((version) => version === VERSION_NEUTRAL ? path : `${path}/${versionPrefix}${version}`)));
+      } else {
+        if (versionOrVersions !== VERSION_NEUTRAL) {
+          paths = paths.map((path) => `${path}/${versionPrefix}${versionOrVersions}`);
+        }
+      }
+    }
+    paths = this.appendToAllIfDefined(paths, metadata.modulePath);
+    paths = this.appendToAllIfDefined(paths, metadata.controllerPath);
+    paths = this.appendToAllIfDefined(paths, metadata.methodPath);
+    if (metadata.globalPrefix) {
+      paths = paths.map((path) => {
+        if (this.isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, metadata.versioningOptions)) {
+          return path;
+        }
+        return stripEndSlash(metadata.globalPrefix || "") + path;
+      });
+    }
+    return paths.map((path) => addLeadingSlash(path || "/")).map((path) => path !== "/" ? stripEndSlash(path) : path);
+  }
+  extractControllerPath(path) {
+    if (isUndefined(path))
+      return [];
+    if (Array.isArray(path))
+      return path.map((p) => addLeadingSlash(p));
+    return [addLeadingSlash(path)];
+  }
+  getVersion(metadata) {
+    return metadata.methodVersion || metadata.controllerVersion;
+  }
+  getVersionPrefix(versioningOptions) {
+    const defaultPrefix = "v";
+    if (versioningOptions.type === HttpVersioningType.URI) {
+      if (versioningOptions.prefix === false)
+        return "";
+      else if (versioningOptions.prefix !== undefined)
+        return versioningOptions.prefix;
+    }
+    return defaultPrefix;
+  }
+  appendToAllIfDefined(paths, fragmentToAppend) {
+    if (!fragmentToAppend)
+      return paths;
+    const concatPaths = (a, b) => stripEndSlash(a) + addLeadingSlash(b);
+    if (Array.isArray(fragmentToAppend)) {
+      const paths2dArray = paths.map((path) => fragmentToAppend.map((fragment) => concatPaths(path, fragment)));
+      return flatten(paths2dArray);
+    }
+    return paths.map((path) => concatPaths(path, fragmentToAppend));
+  }
+  isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, versioningOptions) {
+    if (isUndefined(requestMethod))
+      return false;
+    const options = this.config.getGlobalPrefixOptions();
+    const excludedRoutes = options.exclude;
+    if (versionOrVersions && versionOrVersions !== VERSION_NEUTRAL && versioningOptions?.type === HttpVersioningType.URI) {
+      path = this.truncateVersionPrefixFromPath(path, versionOrVersions, versioningOptions);
+    }
+    return Array.isArray(excludedRoutes) && isRouteExcluded(excludedRoutes, path, requestMethod);
+  }
+  truncateVersionPrefixFromPath(path, versionValue, versioningOptions) {
+    if (typeof versionValue !== "string") {
+      versionValue.forEach((version) => {
+        if (typeof version === "string") {
+          path = this.truncateVersionPrefixFromPath(path, version, versioningOptions);
+        }
+      });
+      return path;
+    }
+    const prefix = `/${this.getVersionPrefix(versioningOptions)}${versionValue}`;
+    return path.startsWith(prefix) ? path.replace(prefix, "") : path;
+  }
+}
+export {
+  RoutePathFactory
+};

package/dist/symbols.js

@@ -0,0 +1,33 @@
+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/symbols.ts
+var VENOK_ADAPTER_BUILD = Symbol("VENOK_ADAPTER_BUILD");
+var VENOK_ADAPTER_ADD_ROUTE = Symbol("VENOK_ADAPTER_ADD_ROUTE");
+var VENOK_ADAPTER_ADD_MIDDLEWARE = Symbol("VENOK_ADAPTER_ADD_MIDDLEWARE");
+var VENOK_ADAPTER_SET_EXCEPTION_FILTER = Symbol("VENOK_ADAPTER_SET_EXCEPTION_FILTER");
+var VENOK_APPLY_ROUTES_TO_INSTANCE = Symbol("VENOK_APPLY_ROUTES_TO_INSTANCE");
+var VENOK_ADAPTER_RESPONSE = Symbol("VENOK_ADAPTER_RESPONSE");
+var VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT = Symbol("VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT");
+export {
+  VENOK_APPLY_ROUTES_TO_INSTANCE,
+  VENOK_ADAPTER_TRANSFORM_NATIVE_ARGS_TO_CONTEXT,
+  VENOK_ADAPTER_SET_EXCEPTION_FILTER,
+  VENOK_ADAPTER_RESPONSE,
+  VENOK_ADAPTER_BUILD,
+  VENOK_ADAPTER_ADD_ROUTE,
+  VENOK_ADAPTER_ADD_MIDDLEWARE
+};

package/package.json

@@ -1,46 +1,41 @@
-{
-  "name": "@venok/http",
-  "version": "1.1.0",
-  "description": "",
-  "author": "0x303133",
-  "homepage": "",
-  "main": "index.js",
-  "types": "./index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/venokjs/venok.git",
-    "directory": "packages/http"
-  },
-  "scripts": {
-    "build": "venok build",
-    "postbuild": "ts-node ../../tools/move.ts http",
-    "test": "mocha test/**/*.spec.ts"
-  },
-  "mocha": {
-    "require": [
-      "ts-node/register",
-      "tsconfig-paths/register",
-      "../../node_modules/reflect-metadata/Reflect.js",
-      "../../hooks/mocha-init-hook.ts"
-    ],
-    "exit": true
-  },
-  "devDependencies": {
-    "@types/eventsource": "^1.1.12",
-    "@types/http-errors": "^2.0.2",
-    "@types/path-to-regexp": "^1.7.0",
-    "eventsource": "^2.0.2",
-    "http-errors": "^2.0.0"
-  },
-  "peerDependencies": {
-    "@venok/core": "^1.1.0",
-    "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.1"
-  },
-  "dependencies": {
-    "path-to-regexp": "^6.2.1"
-  }
-}
+{
+  "name": "@venok/http",
+  "version": "2.0.1-next.1",
+  "description": "",
+  "author": "shiz-ceo",
+  "homepage": "",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "type": "module",
+  "files": ["package.json", "dist"],
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/http"
+  },
+  "scripts": {},
+  "peerDependencies": {
+    "@venok/core": "1.1.0",
+    "@venok/integration": "1.1.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "dependencies": {
+    "path-to-regexp": "^6.2.1"
+  }
+}

package/adapter/adapter.d.ts

@@ -1,57 +0,0 @@
-import { RequestMethod } from "@venok/http/enums";
-import { CorsOptions, CorsOptionsDelegate, HttpServer, RequestHandler, VenokApplicationOptions, VersioningOptions, VersionValue } from "@venok/http/interfaces";
-/**
- * @publicApi
- */
-export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any> implements HttpServer<TRequest, TResponse> {
-    protected instance?: any;
-    protected httpServer: TServer;
-    constructor(instance?: any);
-    init(): Promise<void>;
-    use(...args: any[]): any;
-    get(handler: RequestHandler): any;
-    get(path: any, handler: RequestHandler): any;
-    post(handler: RequestHandler): any;
-    post(path: any, handler: RequestHandler): any;
-    head(handler: RequestHandler): any;
-    head(path: any, handler: RequestHandler): any;
-    delete(handler: RequestHandler): any;
-    delete(path: any, handler: RequestHandler): any;
-    put(handler: RequestHandler): any;
-    put(path: any, handler: RequestHandler): any;
-    patch(handler: RequestHandler): any;
-    patch(path: any, handler: RequestHandler): any;
-    all(handler: RequestHandler): any;
-    all(path: any, handler: RequestHandler): any;
-    search(port: string | number, callback?: () => void): any;
-    search(port: string | number, hostname: string, callback?: () => void): any;
-    options(handler: RequestHandler): any;
-    options(path: any, handler: RequestHandler): any;
-    listen(port: string | number, callback?: () => void): void;
-    listen(port: string | number, hostname: string, callback?: () => void): void;
-    getHttpServer(): TServer;
-    setHttpServer(httpServer: TServer): void;
-    setInstance<T = any>(instance: T): void;
-    getInstance<T = any>(): T;
-    abstract close(): this | Promise<this>;
-    abstract initHttpServer(options: VenokApplicationOptions): this;
-    abstract useStaticAssets(...args: any[]): this;
-    abstract setViewEngine(engine: string): this;
-    abstract getRequestHostname(request: any): any;
-    abstract getRequestMethod(request: any): any;
-    abstract getRequestUrl(request: any): any;
-    abstract status(response: any, statusCode: number): any;
-    abstract reply(response: any, body: any, statusCode?: number): any;
-    abstract end(response: any, message?: string): any;
-    abstract render(response: any, view: string, options: any): any;
-    abstract redirect(response: any, statusCode: number, url: string): any;
-    abstract setErrorHandler(handler: Function, prefix?: string): any;
-    abstract setNotFoundHandler(handler: Function, prefix?: string): any;
-    abstract isHeadersSent(response: any): any;
-    abstract setHeader(response: any, name: string, value: string): any;
-    abstract registerParserMiddleware(prefix?: string, rawBody?: boolean): any;
-    abstract enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>, prefix?: string): any;
-    abstract createMiddlewareFactory(requestMethod: RequestMethod): ((path: string, callback: Function) => any) | Promise<(path: string, callback: Function) => any>;
-    abstract getType(): string;
-    abstract applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;
-}

package/adapter/adapter.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractHttpAdapter = void 0;
-/**
- * @publicApi
- */
-class AbstractHttpAdapter {
-    constructor(instance) {
-        this.instance = instance;
-    }
-    async init() { }
-    use(...args) {
-        return this.instance.use(...args);
-    }
-    get(...args) {
-        return this.instance.get(...args);
-    }
-    post(...args) {
-        return this.instance.post(...args);
-    }
-    head(...args) {
-        return this.instance.head(...args);
-    }
-    delete(...args) {
-        return this.instance.delete(...args);
-    }
-    put(...args) {
-        return this.instance.put(...args);
-    }
-    patch(...args) {
-        return this.instance.patch(...args);
-    }
-    all(...args) {
-        return this.instance.all(...args);
-    }
-    search(port, hostname, callback) {
-        return this.instance.search(port, hostname, callback);
-    }
-    options(...args) {
-        return this.instance.options(...args);
-    }
-    listen(port, hostname, callback) {
-        return this.instance.listen(port, hostname, callback);
-    }
-    getHttpServer() {
-        return this.httpServer;
-    }
-    setHttpServer(httpServer) {
-        this.httpServer = httpServer;
-    }
-    setInstance(instance) {
-        this.instance = instance;
-    }
-    getInstance() {
-        return this.instance;
-    }
-}
-exports.AbstractHttpAdapter = AbstractHttpAdapter;

package/adapter/host.d.ts

@@ -1,27 +0,0 @@
-import { AbstractHttpAdapter } from "@venok/http/adapter/adapter";
-/**
- * Defines the `HttpAdapterHost` object.
- *
- * `HttpAdapterHost` wraps the underlying
- * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
- * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
- * provides methods to `get` and `set` the underlying HttpAdapter.
- *
- * @publicApi
- */
-export declare class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {
-    private _httpAdapter?;
-    /**
-     * Accessor for the underlying `HttpAdapter`
-     *
-     * @param httpAdapter reference to the `HttpAdapter` to be set
-     */
-    set httpAdapter(httpAdapter: T);
-    /**
-     * Accessor for the underlying `HttpAdapter`
-     *
-     * @example
-     * `const httpAdapter = adapterHost.httpAdapter;`
-     */
-    get httpAdapter(): T;
-}

package/adapter/host.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpAdapterHost = void 0;
-/**
- * Defines the `HttpAdapterHost` object.
- *
- * `HttpAdapterHost` wraps the underlying
- * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
- * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
- * provides methods to `get` and `set` the underlying HttpAdapter.
- *
- * @publicApi
- */
-class HttpAdapterHost {
-    /**
-     * Accessor for the underlying `HttpAdapter`
-     *
-     * @param httpAdapter reference to the `HttpAdapter` to be set
-     */
-    set httpAdapter(httpAdapter) {
-        this._httpAdapter = httpAdapter;
-    }
-    /**
-     * Accessor for the underlying `HttpAdapter`
-     *
-     * @example
-     * `const httpAdapter = adapterHost.httpAdapter;`
-     */
-    get httpAdapter() {
-        return this._httpAdapter;
-    }
-}
-exports.HttpAdapterHost = HttpAdapterHost;

package/application/application.d.ts

@@ -1,18 +0,0 @@
-import { CorsOptions, CorsOptionsDelegate, GlobalPrefixOptions, HttpServer, VersioningOptions } from "../interfaces";
-import { HttpConfig } from "./config";
-import { AbstractHttpAdapter } from "../adapter/adapter";
-export declare class HttpApplication {
-    private readonly httpAdapter;
-    private readonly config;
-    private start;
-    constructor(httpAdapter: HttpServer, config: HttpConfig);
-    use(...args: [any, any?]): this;
-    getHttpAdapter(): AbstractHttpAdapter;
-    enableCors(options?: CorsOptions | CorsOptionsDelegate<any>): this;
-    enableVersioning(options?: VersioningOptions): this;
-    setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this;
-    useStaticAssets(options: any): this;
-    useStaticAssets(path: string, options?: any): this;
-    setBaseViewsDir(path: string | string[]): this;
-    setViewEngine(engineOrOptions: any): this;
-}

package/application/application.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpApplication = void 0;
-const enums_1 = require("../enums");
-const utils_1 = require("../middleware/utils");
-class HttpApplication {
-    constructor(httpAdapter, config) {
-        this.httpAdapter = httpAdapter;
-        this.config = config;
-        this.start = false;
-    }
-    use(...args) {
-        this.httpAdapter.use(...args);
-        return this;
-    }
-    getHttpAdapter() {
-        return this.httpAdapter;
-    }
-    enableCors(options) {
-        this.httpAdapter.enableCors(options);
-        return this;
-    }
-    enableVersioning(options = { type: enums_1.VersioningType.URI }) {
-        this.config.enableVersioning(options);
-        return this;
-    }
-    setGlobalPrefix(prefix, options) {
-        this.config.setGlobalPrefix(prefix);
-        if (options) {
-            const exclude = options?.exclude ? (0, utils_1.mapToExcludeRoute)(options.exclude) : [];
-            this.config.setGlobalPrefixOptions({
-                ...options,
-                exclude,
-            });
-        }
-        return this;
-    }
-    useStaticAssets(pathOrOptions, options) {
-        this.httpAdapter.useStaticAssets && this.httpAdapter.useStaticAssets(pathOrOptions, options);
-        return this;
-    }
-    setBaseViewsDir(path) {
-        this.httpAdapter.setBaseViewsDir && this.httpAdapter.setBaseViewsDir(path);
-        return this;
-    }
-    setViewEngine(engineOrOptions) {
-        this.httpAdapter.setViewEngine && this.httpAdapter.setViewEngine(engineOrOptions);
-        return this;
-    }
-}
-exports.HttpApplication = HttpApplication;

package/application/config.d.ts

@@ -1,16 +0,0 @@
-import { ExcludeRouteMetadata, GlobalPrefixOptions, VersioningOptions } from "../interfaces";
-export declare class HttpConfig {
-    private globalPrefix;
-    private globalPrefixOptions;
-    private versioningOptions;
-    private readonly httpInstanceStorage;
-    setHttpAdapter(httpAdapter: any): void;
-    getHttpAdapterRef(): import("../adapter/adapter").AbstractHttpAdapter<any, any, any>;
-    getHttpAdapterHostRef(): import("../adapter/host").HttpAdapterHost<import("../adapter/adapter").AbstractHttpAdapter<any, any, any>>;
-    setGlobalPrefix(prefix: string): void;
-    getGlobalPrefix(): string;
-    setGlobalPrefixOptions(options: GlobalPrefixOptions<ExcludeRouteMetadata>): void;
-    getGlobalPrefixOptions(): GlobalPrefixOptions<ExcludeRouteMetadata>;
-    enableVersioning(options: VersioningOptions): void;
-    getVersioning(): VersioningOptions | undefined;
-}

package/application/config.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpConfig = void 0;
-const http_instance_storage_1 = require("../storage/http-instance.storage");
-class HttpConfig {
-    constructor() {
-        this.globalPrefix = "";
-        this.globalPrefixOptions = {};
-        this.httpInstanceStorage = new http_instance_storage_1.HttpInstanceStorage();
-    }
-    setHttpAdapter(httpAdapter) {
-        this.httpInstanceStorage.httpAdapter = httpAdapter;
-        if (!this.httpInstanceStorage.httpAdapterHost)
-            return;
-        const host = this.httpInstanceStorage.httpAdapterHost;
-        host.httpAdapter = httpAdapter;
-    }
-    getHttpAdapterRef() {
-        return this.httpInstanceStorage.httpAdapter;
-    }
-    getHttpAdapterHostRef() {
-        return this.httpInstanceStorage.httpAdapterHost;
-    }
-    setGlobalPrefix(prefix) {
-        this.globalPrefix = prefix;
-    }
-    getGlobalPrefix() {
-        return this.globalPrefix;
-    }
-    setGlobalPrefixOptions(options) {
-        this.globalPrefixOptions = options;
-    }
-    getGlobalPrefixOptions() {
-        return this.globalPrefixOptions;
-    }
-    enableVersioning(options) {
-        if (Array.isArray(options.defaultVersion)) {
-            // Drop duplicated versions
-            options.defaultVersion = Array.from(new Set(options.defaultVersion));
-        }
-        this.versioningOptions = options;
-    }
-    getVersioning() {
-        return this.versioningOptions;
-    }
-}
-exports.HttpConfig = HttpConfig;

package/application/http.module-defenition.d.ts

@@ -1,8 +0,0 @@
-import { HttpApplication } from "./application";
-import { AbstractHttpAdapter } from "../adapter/adapter";
-export interface HttpAppOptions {
-    port: number;
-    callback?: (app: HttpApplication) => void;
-    adapter?: AbstractHttpAdapter;
-}
-export declare const HttpConfigurableModuleClass: import("@venok/core/module").ConfigurableModuleCls<HttpAppOptions, "register", "create", {}>, HTTP_APP_OPTIONS: string | symbol;

package/application/http.module-defenition.js

@@ -1,6 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_APP_OPTIONS = exports.HttpConfigurableModuleClass = void 0;
-const module_1 = require("../../core/module");
-_a = new module_1.ConfigurableModuleBuilder().build(), exports.HttpConfigurableModuleClass = _a.ConfigurableModuleClass, exports.HTTP_APP_OPTIONS = _a.MODULE_OPTIONS_TOKEN;

package/application/http.module.d.ts

@@ -1,3 +0,0 @@
-import { HttpConfigurableModuleClass } from "./http.module-defenition";
-export declare class HttpModule extends HttpConfigurableModuleClass {
-}