@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Message/Uri/Factory/UriFactory.ts

@@ -0,0 +1,152 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { UriContract } from '../Contract/UriContract.js';
+import { Scheme } from '../Enum/Scheme.js';
+import { Port } from '../../Constant/Port.js';
+import { HttpUriInvalidFromStringException } from '../Throwable/Exception/HttpUriInvalidFromStringException.js';
+import { HttpUriInvalidPathException } from '../Throwable/Exception/HttpUriInvalidPathException.js';
+import { HttpUriInvalidPortException } from '../Throwable/Exception/HttpUriInvalidPortException.js';
+import { HttpUriInvalidQueryException } from '../Throwable/Exception/HttpUriInvalidQueryException.js';
+import { Uri } from '../Uri.js';
+
+export abstract class UriFactory {
+    static fromString(uri: string): UriContract {
+        if (uri !== '' && !uri.startsWith('/') && !uri.startsWith(Scheme.HTTP) && !uri.startsWith(Scheme.HTTPS)) {
+            uri = '//' + uri;
+        }
+        let parsed: URL;
+        try {
+            parsed = new URL(uri, 'http://placeholder');
+        } catch {
+            throw new HttpUriInvalidFromStringException(`Invalid uri \`${uri}\` provided`);
+        }
+        const scheme = UriFactory.filterScheme(uri.startsWith('//') ? '' : parsed.protocol.replace(/:$/, '') || '');
+        const username = parsed.username;
+        const password = parsed.password;
+        const host = parsed.hostname;
+        const port = parsed.port !== '' ? parseInt(parsed.port, 10) : 0;
+        const path = parsed.pathname === '/' && !uri.includes('/') ? '' : parsed.pathname;
+        const query = parsed.search.replace(/^\?/, '');
+        const fragment = parsed.hash.replace(/^#/, '');
+
+        return new Uri(scheme, username, password, host, port, path, query, fragment);
+    }
+
+    static toString(uri: UriContract): string {
+        return (
+            UriFactory.getSchemeStringPart(uri) +
+            UriFactory.getAuthorityStringPart(uri) +
+            UriFactory.getPathStringPart(uri) +
+            UriFactory.getQueryStringPart(uri) +
+            UriFactory.getFragmentStringPart(uri)
+        );
+    }
+
+    static filterScheme(scheme: string): Scheme {
+        scheme = scheme.toLowerCase().replace(/:(\/\/)?$/, '');
+        return (Object.values(Scheme) as string[]).includes(scheme) ? (scheme as Scheme) : Scheme.EMPTY;
+    }
+
+    static validatePort(port: number): void {
+        if (!Port.isValid(port)) {
+            throw new HttpUriInvalidPortException(
+                `Invalid port \`${String(port)}\` specified; must be a valid TCP/UDP port`,
+            );
+        }
+    }
+
+    static filterUserInfo(userInfo: string): string {
+        return userInfo;
+    }
+
+    static filterPath(path: string): string {
+        UriFactory.validatePath(path);
+        if (path.startsWith('/')) {
+            return '/' + path.replace(/^\/+/, '');
+        }
+        return path;
+    }
+
+    static validatePath(path: string): void {
+        if (path.includes('?')) {
+            throw new HttpUriInvalidPathException(
+                `Invalid path of \`${path}\` provided; must not contain a query string`,
+            );
+        }
+        if (path.includes('#')) {
+            throw new HttpUriInvalidPathException(
+                `Invalid path of \`${path}\` provided; must not contain a URI fragment`,
+            );
+        }
+    }
+
+    static filterQuery(query: string): string {
+        UriFactory.validateQuery(query);
+        return query.replace(/^\?/, '');
+    }
+
+    static validateQuery(query: string): void {
+        if (query.includes('#')) {
+            throw new HttpUriInvalidQueryException(
+                `Invalid query string of \`${query}\` provided; must not contain a URI fragment`,
+            );
+        }
+    }
+
+    static filterFragment(fragment: string): string {
+        return fragment.replace(/^#/, '');
+    }
+
+    static isStandardPort(scheme: Scheme, host: string, port: number): boolean {
+        if (scheme === Scheme.EMPTY) {
+            return host !== '' && port <= 0;
+        }
+        if (host === '' || port <= 0) {
+            return true;
+        }
+        return UriFactory.isStandardUnsecurePort(scheme, port) || UriFactory.isStandardSecurePort(scheme, port);
+    }
+
+    static isStandardUnsecurePort(scheme: Scheme, port: number): boolean {
+        return scheme === Scheme.HTTP && port === Port.HTTP;
+    }
+
+    static isStandardSecurePort(scheme: Scheme, port: number): boolean {
+        return scheme === Scheme.HTTPS && port === Port.HTTPS;
+    }
+
+    static getSchemeStringPart(uri: UriContract): string {
+        const scheme = uri.getScheme();
+        return scheme !== Scheme.EMPTY ? scheme + ':' : '';
+    }
+
+    static getAuthorityStringPart(uri: UriContract): string {
+        const authority = uri.getAuthority();
+        return authority !== '' ? '//' + authority : '';
+    }
+
+    static getPathStringPart(uri: UriContract): string {
+        const path = uri.getPath();
+        if (path !== '') {
+            return path.startsWith('/') ? path : '/' + path;
+        }
+        return '';
+    }
+
+    static getQueryStringPart(uri: UriContract): string {
+        const query = uri.getQuery();
+        return query !== '' ? '?' + query : '';
+    }
+
+    static getFragmentStringPart(uri: UriContract): string {
+        const fragment = uri.getFragment();
+        return fragment !== '' ? '#' + fragment : '';
+    }
+}

package/src/Valkyrja/Http/Message/Uri/Throwable/Contract/HttpUriThrowable.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { HttpMessageThrowable } from '../../../Throwable/Contract/HttpMessageThrowable.js';
+
+export type HttpUriThrowable = HttpMessageThrowable;

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/Abstract/HttpUriInvalidArgumentException.ts

@@ -0,0 +1,15 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { HttpUriThrowable } from '../../Contract/HttpUriThrowable.js';
+import { HttpMessageInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/HttpMessageInvalidArgumentException.js';
+
+export abstract class HttpUriInvalidArgumentException
+    extends HttpMessageInvalidArgumentException
+    implements HttpUriThrowable {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/Abstract/HttpUriRuntimeException.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { HttpUriThrowable } from '../../Contract/HttpUriThrowable.js';
+import { HttpMessageRuntimeException } from '../../../../Throwable/Exception/Abstract/HttpMessageRuntimeException.js';
+
+export abstract class HttpUriRuntimeException extends HttpMessageRuntimeException implements HttpUriThrowable {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/HttpUriInvalidFromStringException.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriInvalidArgumentException } from './Abstract/HttpUriInvalidArgumentException.js';
+
+export class HttpUriInvalidFromStringException extends HttpUriInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/HttpUriInvalidPathException.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriInvalidArgumentException } from './Abstract/HttpUriInvalidArgumentException.js';
+
+export class HttpUriInvalidPathException extends HttpUriInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/HttpUriInvalidPortException.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriInvalidArgumentException } from './Abstract/HttpUriInvalidArgumentException.js';
+
+export class HttpUriInvalidPortException extends HttpUriInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/HttpUriInvalidQueryException.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriInvalidArgumentException } from './Abstract/HttpUriInvalidArgumentException.js';
+
+export class HttpUriInvalidQueryException extends HttpUriInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Uri/Throwable/Exception/NoPortExceptionHttpUri.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriRuntimeException } from './Abstract/HttpUriRuntimeException.js';
+
+export class NoPortExceptionHttpUri extends HttpUriRuntimeException {}

package/src/Valkyrja/Http/Message/Uri/Type/Port.ts

@@ -0,0 +1,39 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpUriInvalidPortException } from '../Throwable/Exception/HttpUriInvalidPortException.js';
+
+export class Port {
+    protected subject: number;
+
+    constructor(subject: number) {
+        if (subject >= 1 && subject <= 65535) {
+            this.subject = subject;
+            return;
+        }
+
+        throw new HttpUriInvalidPortException('Invalid port argument passed.');
+    }
+
+    static fromValue(value: unknown): Port {
+        if (typeof value !== 'number') {
+            throw new HttpUriInvalidPortException(`Int expected value of type \`${typeof value}\` provided`);
+        }
+
+        return new Port(value);
+    }
+
+    asFlatValue(): number {
+        return this.subject;
+    }
+
+    asValue(): number {
+        return this.subject;
+    }
+}

package/src/Valkyrja/Http/Message/Uri/Uri.ts

@@ -0,0 +1,191 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { UriContract } from './Contract/UriContract.js';
+import { Scheme } from './Enum/Scheme.js';
+import { UriFactory } from './Factory/UriFactory.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Uri implements UriContract {
+    protected userInfo: string;
+    protected uriString: string | null = null;
+
+    constructor(
+        protected scheme: Scheme = Scheme.EMPTY,
+        protected username: string = '',
+        protected password: string = '',
+        protected host: string = '',
+        protected port: number = 0,
+        protected path: string = '',
+        protected query: string = '',
+        protected fragment: string = '',
+    ) {
+        let userInfo = username;
+        if (password !== '') {
+            userInfo += ':' + password;
+        }
+        if (port === 0) {
+            port = this.getPortFromScheme(scheme);
+        } else {
+            UriFactory.validatePort(port);
+        }
+        this.port = port;
+        this.userInfo = UriFactory.filterUserInfo(userInfo);
+        this.host = host.toLowerCase();
+        this.path = UriFactory.filterPath(path);
+        this.query = UriFactory.filterQuery(query);
+        this.fragment = UriFactory.filterFragment(fragment);
+    }
+
+    getScheme(): Scheme {
+        return this.scheme;
+    }
+
+    isSecure(): boolean {
+        return this.scheme === Scheme.HTTPS;
+    }
+
+    getAuthority(): string {
+        if (this.host === '') {
+            return '';
+        }
+        let authority = this.host;
+        if (this.userInfo !== '') {
+            authority = this.userInfo + '@' + authority;
+        }
+        if (!UriFactory.isStandardPort(this.scheme, this.host, this.port)) {
+            authority += ':' + String(this.port);
+        }
+        return authority;
+    }
+
+    getUsername(): string {
+        return this.username;
+    }
+    getPassword(): string {
+        return this.password;
+    }
+    getUserInfo(): string {
+        return this.userInfo;
+    }
+    getHost(): string {
+        return this.host;
+    }
+    hasPort(): boolean {
+        return this.port !== 0;
+    }
+
+    getPort(): number {
+        return UriFactory.isStandardPort(this.scheme, this.host, this.port) ? 0 : this.port;
+    }
+
+    getHostPort(): string {
+        let host = this.host;
+        const port = this.getPort();
+        if (host !== '' && port !== 0) {
+            host += ':' + String(port);
+        }
+        return host;
+    }
+
+    getSchemeHostPort(): string {
+        const hostPort = this.getHostPort();
+        return hostPort !== '' && this.scheme !== Scheme.EMPTY ? this.scheme + '://' + hostPort : hostPort;
+    }
+
+    getPath(): string {
+        return this.path;
+    }
+    getQuery(): string {
+        return this.query;
+    }
+    getFragment(): string {
+        return this.fragment;
+    }
+
+    withScheme(scheme: Scheme): this {
+        const clone = ObjectFactory.clone(this);
+        clone.scheme = scheme;
+        clone.uriString = null;
+        if (this.port === 0) {
+            clone.port = this.getPortFromScheme(scheme);
+        }
+        return clone;
+    }
+
+    withUsername(username: string): this {
+        return this.withUserInfo(username, this.password);
+    }
+
+    withPassword(password: string): this {
+        return this.withUserInfo(this.username, password);
+    }
+
+    withUserInfo(user: string, password: string = ''): this {
+        let info = user;
+        if (user === '') {
+            password = '';
+        }
+        if (password !== '') {
+            info += ':' + password;
+        }
+        const clone = ObjectFactory.clone(this);
+        clone.userInfo = info;
+        clone.username = user;
+        clone.password = password;
+        clone.uriString = null;
+        return clone;
+    }
+
+    withHost(host: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.host = host;
+        clone.uriString = null;
+        return clone;
+    }
+
+    withPort(port: number): this {
+        UriFactory.validatePort(port);
+        const clone = ObjectFactory.clone(this);
+        clone.port = port;
+        clone.uriString = null;
+        return clone;
+    }
+
+    withPath(path: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.path = UriFactory.filterPath(path);
+        clone.uriString = null;
+        return clone;
+    }
+
+    withQuery(query: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.query = UriFactory.filterQuery(query);
+        clone.uriString = null;
+        return clone;
+    }
+
+    withFragment(fragment: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.fragment = UriFactory.filterFragment(fragment);
+        clone.uriString = null;
+        return clone;
+    }
+
+    toString(): string {
+        return (this.uriString ??= UriFactory.toString(this));
+    }
+
+    protected getPortFromScheme(scheme: Scheme): number {
+        if (scheme === Scheme.HTTPS) return 443;
+        if (scheme === Scheme.HTTP) return 80;
+        return 0;
+    }
+}

package/src/Valkyrja/Http/Middleware/Constant/HttpMiddlewareServiceId.ts

@@ -0,0 +1,24 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export class HttpMiddlewareServiceId {
+    static readonly RequestReceivedHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.RequestReceivedHandlerContract' as const;
+    static readonly ThrowableCaughtHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.ThrowableCaughtHandlerContract' as const;
+    static readonly RouteMatchedHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.RouteMatchedHandlerContract' as const;
+    static readonly RouteNotMatchedHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.RouteNotMatchedHandlerContract' as const;
+    static readonly RouteDispatchedHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.RouteDispatchedHandlerContract' as const;
+    static readonly SendingResponseHandlerContract =
+        'Valkyrja.Http.Middleware.Handler.SendingResponseHandlerContract' as const;
+    static readonly TerminatedHandlerContract = 'Valkyrja.Http.Middleware.Handler.TerminatedHandlerContract' as const;
+}

package/src/Valkyrja/Http/Middleware/Contract/RequestReceivedMiddlewareContract.ts

@@ -0,0 +1,19 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { RequestReceivedHandlerContract } from '../Handler/Contract/RequestReceivedHandlerContract.js';
+
+export interface RequestReceivedMiddlewareContract {
+    requestReceived(
+        request: ServerRequestContract,
+        handler: RequestReceivedHandlerContract,
+    ): ServerRequestContract | ResponseContract;
+}

package/src/Valkyrja/Http/Middleware/Contract/RouteDispatchedMiddlewareContract.ts

@@ -0,0 +1,22 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouteDispatchedHandlerContract } from '../Handler/Contract/RouteDispatchedHandlerContract.js';
+
+export interface RouteDispatchedMiddlewareContract {
+    routeDispatched(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        route: RouteContract,
+        handler: RouteDispatchedHandlerContract,
+    ): ResponseContract;
+}

package/src/Valkyrja/Http/Middleware/Contract/RouteMatchedMiddlewareContract.ts

@@ -0,0 +1,21 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouteMatchedHandlerContract } from '../Handler/Contract/RouteMatchedHandlerContract.js';
+
+export interface RouteMatchedMiddlewareContract {
+    routeMatched(
+        request: ServerRequestContract,
+        route: RouteContract,
+        handler: RouteMatchedHandlerContract,
+    ): RouteContract | ResponseContract;
+}

package/src/Valkyrja/Http/Middleware/Contract/RouteNotMatchedMiddlewareContract.ts

@@ -0,0 +1,20 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { RouteNotMatchedHandlerContract } from '../Handler/Contract/RouteNotMatchedHandlerContract.js';
+
+export interface RouteNotMatchedMiddlewareContract {
+    routeNotMatched(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        handler: RouteNotMatchedHandlerContract,
+    ): ResponseContract;
+}

package/src/Valkyrja/Http/Middleware/Contract/SendingResponseMiddlewareContract.ts

@@ -0,0 +1,20 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { SendingResponseHandlerContract } from '../Handler/Contract/SendingResponseHandlerContract.js';
+
+export interface SendingResponseMiddlewareContract {
+    sendingResponse(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        handler: SendingResponseHandlerContract,
+    ): ResponseContract;
+}

package/src/Valkyrja/Http/Middleware/Contract/TerminatedMiddlewareContract.ts

@@ -0,0 +1,16 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { TerminatedHandlerContract } from '../Handler/Contract/TerminatedHandlerContract.js';
+
+export interface TerminatedMiddlewareContract {
+    terminated(request: ServerRequestContract, response: ResponseContract, handler: TerminatedHandlerContract): void;
+}

package/src/Valkyrja/Http/Middleware/Contract/ThrowableCaughtMiddlewareContract.ts

@@ -0,0 +1,21 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from '../../Message/Request/Contract/ServerRequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { ThrowableCaughtHandlerContract } from '../Handler/Contract/ThrowableCaughtHandlerContract.js';
+
+export interface ThrowableCaughtMiddlewareContract {
+    throwableCaught(
+        request: ServerRequestContract,
+        response: ResponseContract,
+        throwable: Error,
+        handler: ThrowableCaughtHandlerContract,
+    ): ResponseContract;
+}