@venok/http 1.0.1-canary.0

package/interfaces/http/exclude-route.interface.d.ts

@@ -0,0 +1,15 @@
+import { RequestMethod } from "../../enums";
+export interface ExcludeRouteMetadata {
+    /**
+     * Route path.
+     */
+    path: string;
+    /**
+     * Regular expression representing the route path.
+     */
+    pathRegex: RegExp;
+    /**
+     * HTTP request method (e.g., GET, POST).
+     */
+    requestMethod: RequestMethod;
+}

package/interfaces/http/exclude-route.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./cors.interface";
+export * from "./exception.interface";
+export * from "./exclude-route.interface";
+export * from "./message-event.interface";
+export * from "./module.inteface";
+export * from "./options.interface";
+export * from "./path-metadata.interface";
+export * from "./prefix-options.interface";
+export * from "./routes.interface";
+export * from "./server.interface";

package/interfaces/http/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cors.interface"), exports);
+__exportStar(require("./exception.interface"), exports);
+__exportStar(require("./exclude-route.interface"), exports);
+__exportStar(require("./message-event.interface"), exports);
+__exportStar(require("./module.inteface"), exports);
+__exportStar(require("./options.interface"), exports);
+__exportStar(require("./path-metadata.interface"), exports);
+__exportStar(require("./prefix-options.interface"), exports);
+__exportStar(require("./routes.interface"), exports);
+__exportStar(require("./server.interface"), exports);

package/interfaces/http/message-event.interface.d.ts

@@ -0,0 +1,6 @@
+export interface MessageEvent {
+    data: string | object;
+    id?: string;
+    type?: string;
+    retry?: number;
+}

package/interfaces/http/message-event.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/module.inteface.d.ts

@@ -0,0 +1,5 @@
+import { VenokModule } from "@venok/core";
+import { MiddlewareConsumer } from "../middleware";
+export interface VenokHttpModule extends VenokModule {
+    configure(consumer: MiddlewareConsumer): void;
+}

package/interfaces/http/module.inteface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/options.interface.d.ts

@@ -0,0 +1,127 @@
+import { ApplicationContextOptions } from "@venok/core/interfaces/application/context-options.interface";
+import { CorsOptions, CorsOptionsDelegate } from "@venok/http/interfaces/http/cors.interface";
+/**
+ * Interface describing Https Options that can be set.
+ *
+ * @see https://nodejs.org/api/tls.html
+ *
+ * @publicApi
+ */
+export interface HttpsOptions {
+    /**
+     * PFX or PKCS12 encoded private key and certificate chain. pfx is an alternative
+     * to providing key and cert individually. PFX is usually encrypted, if it is,
+     * passphrase will be used to decrypt it. Multiple PFX can be provided either
+     * as an array of unencrypted PFX buffers, or an array of objects in the form
+     * {buf: <string|buffer>[, passphrase: <string>]}. The object form can only
+     * occur in an array. object.passphrase is optional. Encrypted PFX will be decrypted
+     * with object.passphrase if provided, or options.passphrase if it is not.
+     */
+    pfx?: any;
+    /**
+     * Private keys in PEM format. PEM allows the option of private keys being encrypted.
+     * Encrypted keys will be decrypted with options.passphrase. Multiple keys using
+     * different algorithms can be provided either as an array of unencrypted key
+     * strings or buffers, or an array of objects in the form {pem: <string|buffer>[, passphrase: <string>]}.
+     * The object form can only occur in an array. object.passphrase is optional.
+     * Encrypted keys will be decrypted with object.passphrase if provided, or options.passphrase
+     * if it is not
+     */
+    key?: any;
+    /**
+     * Shared passphrase used for a single private key and/or a PFX.
+     */
+    passphrase?: string;
+    /**
+     * Cert chains in PEM format. One cert chain should be provided per private key.
+     * Each cert chain should consist of the PEM formatted certificate for a provided
+     * private key, followed by the PEM formatted intermediate certificates (if any),
+     * in order, and not including the root CA (the root CA must be pre-known to the
+     * peer, see ca). When providing multiple cert chains, they do not have to be
+     * in the same order as their private keys in key. If the intermediate certificates
+     * are not provided, the peer will not be able to validate the certificate, and
+     * the handshake will fail.
+     */
+    cert?: any;
+    /**
+     * Optionally override the trusted CA certificates. Default is to trust the well-known
+     * CAs curated by Mozilla. Mozilla's CAs are completely replaced when CAs are
+     * explicitly specified using this option. The value can be a string or Buffer,
+     * or an Array of strings and/or Buffers. Any string or Buffer can contain multiple
+     * PEM CAs concatenated together. The peer's certificate must be chainable to
+     * a CA trusted by the server for the connection to be authenticated. When using
+     * certificates that are not chainable to a well-known CA, the certificate's CA
+     * must be explicitly specified as a trusted or the connection will fail to authenticate.
+     * If the peer uses a certificate that doesn't match or chain to one of the default
+     * CAs, use the ca option to provide a CA certificate that the peer's certificate
+     * can match or chain to. For self-signed certificates, the certificate is its
+     * own CA, and must be provided. For PEM encoded certificates, supported types
+     * are "TRUSTED CERTIFICATE", "X509 CERTIFICATE", and "CERTIFICATE". See also tls.rootCertificates.
+     */
+    ca?: any;
+    /**
+     * PEM formatted CRLs (Certificate Revocation Lists).
+     */
+    crl?: any;
+    /**
+     * Cipher suite specification, replacing the default. For more information, see
+     * modifying the default cipher suite. Permitted ciphers can be obtained via tls.getCiphers().
+     * Cipher names must be uppercased in order for OpenSSL to accept them.
+     */
+    ciphers?: string;
+    /**
+     * Attempt to use the server's cipher suite preferences instead of the client's.
+     * When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be set in secureOptions,
+     * see OpenSSL Options for more information.
+     */
+    honorCipherOrder?: boolean;
+    /**
+     * If true the server will request a certificate from clients that connect and
+     * attempt to verify that certificate. Default: false.
+     */
+    requestCert?: boolean;
+    /**
+     * If not false the server will reject any connection which is not authorized
+     * with the list of supplied CAs. This option only has an effect if requestCert is true. Default: true
+     */
+    rejectUnauthorized?: boolean;
+    /**
+     * An array or Buffer of possible NPN protocols. (Protocols should be ordered
+     * by their priority).
+     */
+    NPNProtocols?: any;
+    /**
+     * A function that will be called if the client supports SNI TLS extension. Two
+     * arguments will be passed when called: servername and cb. SNICallback should
+     * invoke cb(null, ctx), where ctx is a SecureContext instance. (tls.createSecureContext(...)
+     * can be used to get a proper SecureContext.) If SNICallback wasn't provided
+     * the default callback with high-level API will be used.
+     */
+    SNICallback?: (servername: string, cb: (err: Error, ctx: any) => any) => any;
+}
+/**
+ * @publicApi
+ */
+export interface VenokApplicationOptions extends ApplicationContextOptions {
+    /**
+     * CORS options from [CORS package](https://github.com/expressjs/cors#configuration-options)
+     */
+    cors?: boolean | CorsOptions | CorsOptionsDelegate<any>;
+    /**
+     * Whether to use underlying platform body parser.
+     */
+    bodyParser?: boolean;
+    /**
+     * Set of configurable HTTPS options
+     */
+    httpsOptions?: HttpsOptions;
+    /**
+     * Whether to register the raw request body on the request. Use `req.rawBody`.
+     */
+    rawBody?: boolean;
+    /**
+     * Force close open HTTP connections. Useful if restarting your application hangs due to
+     * keep-alive connections in the HTTP adapter.
+     */
+    forceCloseConnections?: boolean;
+}

package/interfaces/http/options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/path-metadata.interface.d.ts

@@ -0,0 +1,31 @@
+import { VersioningOptions, VersionValue } from "../router/version-options.interface";
+export interface RoutePathMetadata {
+    /**
+     * Controller-level path (e.g., @Controller('resource') = "resource").
+     */
+    ctrlPath?: string;
+    /**
+     * Method-level path (e.g., @Get('resource') = "resource").
+     */
+    methodPath?: string;
+    /**
+     * Global route prefix specified with the "NestApplication#setGlobalPrefix" method.
+     */
+    globalPrefix?: string;
+    /**
+     * Module-level path registered through the "RouterModule".
+     */
+    modulePath?: string;
+    /**
+     * Controller-level version (e.g., @Controller({ version: '1.0' }) = "1.0").
+     */
+    controllerVersion?: VersionValue;
+    /**
+     * Method-level version (e.g., @Version('1.0') = "1.0").
+     */
+    methodVersion?: VersionValue;
+    /**
+     * API versioning options object.
+     */
+    versioningOptions?: VersioningOptions;
+}

package/interfaces/http/path-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/prefix-options.interface.d.ts

@@ -0,0 +1,7 @@
+import { RouteInfo } from "../middleware";
+/**
+ * @publicApi
+ */
+export interface GlobalPrefixOptions<T = string | RouteInfo> {
+    exclude?: T[];
+}

package/interfaces/http/prefix-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/raw-request.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export type RawBodyRequest<T> = T & {
+    rawBody?: Buffer;
+};

package/interfaces/http/raw-request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/routes.interface.d.ts

@@ -0,0 +1,7 @@
+import { Type } from "@venok/core";
+export interface RouteTree {
+    path: string;
+    module?: Type;
+    children?: Routes | Type[];
+}
+export type Routes = RouteTree[];

package/interfaces/http/routes.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/server.interface.d.ts

@@ -0,0 +1,54 @@
+import { VersioningOptions, VersionValue } from "../router/version-options.interface";
+import { CorsOptions, CorsOptionsDelegate } from "@venok/http/interfaces/http/cors.interface";
+import { RequestMethod } from "@venok/http/enums";
+import { VenokApplicationOptions } from "@venok/http/interfaces/http/options.interface";
+export type ErrorHandler<TRequest = any, TResponse = any> = (error: any, req: TRequest, res: TResponse, next?: Function) => any;
+export type RequestHandler<TRequest = any, TResponse = any> = (req: TRequest, res: TResponse, next?: Function) => any;
+export interface HttpServer<TRequest = any, TResponse = any, ServerInstance = any> {
+    use(handler: RequestHandler<TRequest, TResponse> | ErrorHandler<TRequest, TResponse>): any;
+    use(path: string, handler: RequestHandler<TRequest, TResponse> | ErrorHandler<TRequest, TResponse>): any;
+    useBodyParser?(...args: any[]): any;
+    get(handler: RequestHandler<TRequest, TResponse>): any;
+    get(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    post(handler: RequestHandler<TRequest, TResponse>): any;
+    post(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    head(handler: RequestHandler<TRequest, TResponse>): any;
+    head(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    delete(handler: RequestHandler<TRequest, TResponse>): any;
+    delete(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    put(handler: RequestHandler<TRequest, TResponse>): any;
+    put(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    patch(handler: RequestHandler<TRequest, TResponse>): any;
+    patch(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    all(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    all(handler: RequestHandler<TRequest, TResponse>): any;
+    options(handler: RequestHandler<TRequest, TResponse>): any;
+    options(path: string, handler: RequestHandler<TRequest, TResponse>): any;
+    listen(port: number | string, callback?: () => void): any;
+    listen(port: number | string, hostname: string, callback?: () => void): any;
+    reply(response: any, body: any, statusCode?: number): any;
+    status(response: any, statusCode: number): any;
+    end(response: any, message?: string): any;
+    render(response: any, view: string, options: any): any;
+    redirect(response: any, statusCode: number, url: string): any;
+    isHeadersSent(response: any): boolean;
+    setHeader(response: any, name: string, value: string): any;
+    setErrorHandler?(handler: Function, prefix?: string): any;
+    setNotFoundHandler?(handler: Function, prefix?: string): any;
+    useStaticAssets?(...args: any[]): this;
+    setBaseViewsDir?(path: string | string[]): this;
+    setViewEngine?(engineOrOptions: any): this;
+    createMiddlewareFactory(method: RequestMethod): ((path: string, callback: Function) => any) | Promise<(path: string, callback: Function) => any>;
+    getRequestHostname?(request: TRequest): string;
+    getRequestMethod?(request: TRequest): string;
+    getRequestUrl?(request: TRequest): string;
+    getInstance(): ServerInstance;
+    registerParserMiddleware(...args: any[]): any;
+    enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>): any;
+    getHttpServer(): any;
+    initHttpServer(options: VenokApplicationOptions): void;
+    close(): any;
+    getType(): string;
+    init?(): Promise<void>;
+    applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;
+}

package/interfaces/http/server.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./http";
+export * from "./middleware";
+export * from "./router";

package/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./router"), exports);

package/interfaces/middleware/config-proxy.interface.d.ts

@@ -0,0 +1,23 @@
+import { RouteInfo } from "./configuration.interface";
+import { Type } from "@venok/core";
+import { MiddlewareConsumer } from "./consumer.interface";
+/**
+ * @publicApi
+ */
+export interface MiddlewareConfigProxy {
+    /**
+     * Excludes routes from the currently processed middleware.
+     *
+     * @param {(string | RouteInfo)[]} routes
+     * @returns {MiddlewareConfigProxy}
+     */
+    exclude(...routes: (string | RouteInfo)[]): MiddlewareConfigProxy;
+    /**
+     * Attaches passed either routes or controllers to the currently configured middleware.
+     * If you pass a class, Venok would attach middleware to every path defined within this controller.
+     *
+     * @param {(string | Type | RouteInfo)[]} routes
+     * @returns {MiddlewareConsumer}
+     */
+    forRoutes(...routes: (string | Type | RouteInfo)[]): MiddlewareConsumer;
+}

package/interfaces/middleware/config-proxy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/middleware/configuration.interface.d.ts

@@ -0,0 +1,12 @@
+import { RequestMethod } from "../../enums";
+import { VersionValue } from "../router/version-options.interface";
+import { Type } from "@venok/core";
+export interface RouteInfo {
+    path: string;
+    method: RequestMethod;
+    version?: VersionValue;
+}
+export interface MiddlewareConfiguration<T = any> {
+    middleware: T;
+    forRoutes: (Type | string | RouteInfo)[];
+}

package/interfaces/middleware/configuration.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/middleware/consumer.interface.d.ts

@@ -0,0 +1,16 @@
+import { Type } from "@venok/core";
+import { MiddlewareConfigProxy } from "./config-proxy.interface";
+/**
+ * Interface defining method for applying user defined middleware to routes.
+ *
+ * @publicApi
+ */
+export interface MiddlewareConsumer {
+    /**
+     * @param {...(Type | Function)} middleware middleware class/function or array of classes/functions
+     * to be attached to the passed routes.
+     *
+     * @returns {MiddlewareConfigProxy}
+     */
+    apply(...middleware: (Type | Function)[]): MiddlewareConfigProxy;
+}

package/interfaces/middleware/consumer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/middleware/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./config-proxy.interface";
+export * from "./configuration.interface";
+export * from "./consumer.interface";
+export * from "./middleware.interface";

package/interfaces/middleware/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config-proxy.interface"), exports);
+__exportStar(require("./configuration.interface"), exports);
+__exportStar(require("./consumer.interface"), exports);
+__exportStar(require("./middleware.interface"), exports);

package/interfaces/middleware/middleware.interface.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @publicApi
+ */
+export interface VenokMiddleware<TRequest = any, TResponse = any> {
+    use(req: TRequest, res: TResponse, next: (error?: Error | any) => void): any;
+}

package/interfaces/middleware/middleware.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/router/callback-paramtypes.interface.d.ts

@@ -0,0 +1 @@
+export type RouterProxyCallback = <TRequest, TResponse>(req?: TRequest, res?: TResponse, next?: () => void) => void;

package/interfaces/router/callback-paramtypes.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/router/definition.interface.d.ts

@@ -0,0 +1,10 @@
+import { VersionValue } from "./version-options.interface";
+import { RequestMethod } from "../../enums";
+import { RouterProxyCallback } from "./callback-paramtypes.interface";
+export interface RouteDefinition {
+    path: string[];
+    requestMethod: RequestMethod;
+    targetCallback: RouterProxyCallback;
+    methodName: string;
+    version?: VersionValue;
+}

package/interfaces/router/definition.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./callback-paramtypes.interface";
+export * from "./definition.interface";
+export * from "./version-options.interface";

package/interfaces/router/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./callback-paramtypes.interface"), exports);
+__exportStar(require("./definition.interface"), exports);
+__exportStar(require("./version-options.interface"), exports);

package/interfaces/router/version-options.interface.d.ts

@@ -0,0 +1,92 @@
+import { VersioningType } from "../../enums";
+/**
+ * Indicates that this will work for any version passed in the request, or no version.
+ *
+ * @publicApi
+ */
+export declare const VERSION_NEUTRAL: unique symbol;
+/**
+ * @publicApi
+ */
+export type VersionValue = string | typeof VERSION_NEUTRAL | Array<string | typeof VERSION_NEUTRAL>;
+/**
+ * @publicApi
+ */
+export interface VersionOptions {
+    /**
+     * Specifies an optional API Version. When configured, methods
+     * within the controller will only be routed if the request version
+     * matches the specified value.
+     *
+     * Supported only by HTTP-based application (does not apply to non-HTTP microservices).
+     *
+     * @see [Versioning](https://docs.nestjs.com/techniques/versioning)
+     */
+    version?: VersionValue;
+}
+/**
+ * @publicApi
+ */
+export interface HeaderVersioningOptions {
+    type: VersioningType.HEADER;
+    /**
+     * The name of the Request Header that contains the version.
+     */
+    header: string;
+}
+/**
+ * @publicApi
+ */
+export interface UriVersioningOptions {
+    type: VersioningType.URI;
+    /**
+     * Optional prefix that will prepend the version within the URI.
+     *
+     * Defaults to `v`.
+     *
+     * Ex. Assuming a version of `1`, for `/api/v1/route`, `v` is the prefix.
+     */
+    prefix?: string | false;
+}
+/**
+ * @publicApi
+ */
+export interface MediaTypeVersioningOptions {
+    type: VersioningType.MEDIA_TYPE;
+    /**
+     * The key within the Media Type Header to determine the version from.
+     *
+     * Ex. For `application/json;v=1`, the key is `v=`.
+     */
+    key: string;
+}
+/**
+ * @publicApi
+ */
+export interface CustomVersioningOptions {
+    type: VersioningType.CUSTOM;
+    /**
+     * A function that accepts a request object (specific to the underlying platform, ie Express or Fastify)
+     * and returns a single version value or an ordered array of versions, in order from HIGHEST to LOWEST.
+     *
+     * Ex. Returned version array = ['3.1', '3.0', '2.5', '2', '1.9']
+     *
+     * Use type assertion or narrowing to identify the specific request type.
+     */
+    extractor: (request: unknown) => string | string[];
+}
+/**
+ * @publicApi
+ */
+interface VersioningCommonOptions {
+    /**
+     * The default version to be used as a fallback when you did not provide some
+     * version to `@Controller()` nor `@Version()`.
+     */
+    defaultVersion?: VersionOptions["version"];
+}
+/**
+ * @publicApi
+ */
+export type VersioningOptions = VersioningCommonOptions & (HeaderVersioningOptions | UriVersioningOptions | MediaTypeVersioningOptions | CustomVersioningOptions);
+export {};

package/interfaces/router/version-options.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_NEUTRAL = void 0;
+/**
+ * Indicates that this will work for any version passed in the request, or no version.
+ *
+ * @publicApi
+ */
+exports.VERSION_NEUTRAL = Symbol("VERSION_NEUTRAL");

package/middleware/builder.d.ts

@@ -0,0 +1,15 @@
+import { RoutesMapper } from "./routes-mapper";
+import { MiddlewareConfigProxy, MiddlewareConfiguration, MiddlewareConsumer, HttpServer } from "../interfaces";
+import { RouteInfoPathExtractor } from "./extractor";
+import { Type } from "@venok/core";
+export declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly routesMapper;
+    private readonly httpAdapter;
+    private readonly routeInfoPathExtractor;
+    private readonly middlewareCollection;
+    constructor(routesMapper: RoutesMapper, httpAdapter: HttpServer, routeInfoPathExtractor: RouteInfoPathExtractor);
+    apply(...middleware: Array<Type | Function | any>): MiddlewareConfigProxy;
+    build(): MiddlewareConfiguration[];
+    getHttpAdapter(): HttpServer;
+    private static readonly ConfigProxy;
+}