@valkyrjaio/valkyrja 26.0.0

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

@@ -0,0 +1,27 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouteMatchedHandlerContract } from '../Handler/Contract/RouteMatchedHandlerContract.js';
+
+export interface RouteMatchedMiddlewareContract {
+    routeMatched(
+        input: InputContract,
+        route: RouteContract,
+        handler: RouteMatchedHandlerContract,
+    ): RouteContract | OutputContract;
+}
+
+export namespace RouteMatchedMiddlewareContract {
+    export function instanceOf(value: unknown): value is RouteMatchedMiddlewareContract {
+        return typeof value === 'object' && value !== null && 'routeMatched' in value;
+    }
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteNotMatchedHandlerContract } from '../Handler/Contract/RouteNotMatchedHandlerContract.js';
+
+export interface RouteNotMatchedMiddlewareContract {
+    routeNotMatched(
+        input: InputContract,
+        output: OutputContract,
+        handler: RouteNotMatchedHandlerContract,
+    ): OutputContract;
+}
+
+export namespace RouteNotMatchedMiddlewareContract {
+    export function instanceOf(value: unknown): value is RouteNotMatchedMiddlewareContract {
+        return typeof value === 'object' && value !== null && 'routeNotMatched' in value;
+    }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { ThrowableCaughtHandlerContract } from '../Handler/Contract/ThrowableCaughtHandlerContract.js';
+
+export interface ThrowableCaughtMiddlewareContract {
+    throwableCaught(
+        input: InputContract,
+        output: OutputContract,
+        throwable: unknown,
+        handler: ThrowableCaughtHandlerContract,
+    ): OutputContract;
+}
+
+export namespace ThrowableCaughtMiddlewareContract {
+    export function instanceOf(value: unknown): value is ThrowableCaughtMiddlewareContract {
+        return typeof value === 'object' && value !== null && 'throwableCaught' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Abstract/Handler.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { Container } from '../../../../Container/Manager/Container.js';
+
+import type { ContainerContract } from '../../../../Container/Manager/Contract/ContainerContract.js';
+import type { HandlerContract } from '../Contract/HandlerContract.js';
+
+export abstract class Handler implements HandlerContract {
+    protected middleware: string[] = [];
+    protected next: string | null = null;
+    protected index: number = 0;
+
+    constructor(
+        protected container: ContainerContract = new Container(),
+        ...middleware: string[]
+    ) {
+        this.middleware = middleware;
+
+        this.updateNext();
+    }
+
+    add(...middleware: string[]): void {
+        this.middleware = [...this.middleware, ...middleware];
+
+        this.updateNext();
+    }
+
+    protected getMiddleware<T extends object>(middleware: string): T {
+        const item = this.container.get<T>(middleware);
+
+        this.index++;
+
+        this.updateNext();
+
+        return item;
+    }
+
+    protected updateNext(): void {
+        this.next = this.middleware[this.index] ?? null;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/ExitedHandlerContract.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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface ExitedHandlerContract extends HandlerContract {
+    exited(input: InputContract, output: OutputContract): void;
+}
+
+export namespace ExitedHandlerContract {
+    export function instanceOf(value: unknown): value is ExitedHandlerContract {
+        return typeof value === 'object' && value !== null && 'exited' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/HandlerContract.ts

@@ -0,0 +1,33 @@
+/*
+ * 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 { ExitedMiddlewareContract } from '../../Contract/ExitedMiddlewareContract.js';
+import type { InputReceivedMiddlewareContract } from '../../Contract/InputReceivedMiddlewareContract.js';
+import type { RouteDispatchedMiddlewareContract } from '../../Contract/RouteDispatchedMiddlewareContract.js';
+import type { RouteMatchedMiddlewareContract } from '../../Contract/RouteMatchedMiddlewareContract.js';
+import type { RouteNotMatchedMiddlewareContract } from '../../Contract/RouteNotMatchedMiddlewareContract.js';
+import type { ThrowableCaughtMiddlewareContract } from '../../Contract/ThrowableCaughtMiddlewareContract.js';
+
+export type AnyMiddlewareContract =
+    | InputReceivedMiddlewareContract
+    | RouteMatchedMiddlewareContract
+    | RouteNotMatchedMiddlewareContract
+    | RouteDispatchedMiddlewareContract
+    | ThrowableCaughtMiddlewareContract
+    | ExitedMiddlewareContract;
+
+export interface HandlerContract {
+    add(...middleware: string[]): void;
+}
+
+export namespace HandlerContract {
+    export function instanceOf(value: unknown): value is HandlerContract {
+        return typeof value === 'object' && value !== null && 'add' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/InputReceivedHandlerContract.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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface InputReceivedHandlerContract extends HandlerContract {
+    inputReceived(input: InputContract): InputContract | OutputContract;
+}
+
+export namespace InputReceivedHandlerContract {
+    export function instanceOf(value: unknown): value is InputReceivedHandlerContract {
+        return typeof value === 'object' && value !== null && 'inputReceived' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/RouteDispatchedHandlerContract.ts

@@ -0,0 +1,23 @@
+/*
+ * 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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../../Routing/Data/Contract/RouteContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface RouteDispatchedHandlerContract extends HandlerContract {
+    routeDispatched(input: InputContract, output: OutputContract, route: RouteContract): OutputContract;
+}
+
+export namespace RouteDispatchedHandlerContract {
+    export function instanceOf(value: unknown): value is RouteDispatchedHandlerContract {
+        return typeof value === 'object' && value !== null && 'routeDispatched' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/RouteMatchedHandlerContract.ts

@@ -0,0 +1,23 @@
+/*
+ * 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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../../Routing/Data/Contract/RouteContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface RouteMatchedHandlerContract extends HandlerContract {
+    routeMatched(input: InputContract, route: RouteContract): RouteContract | OutputContract;
+}
+
+export namespace RouteMatchedHandlerContract {
+    export function instanceOf(value: unknown): value is RouteMatchedHandlerContract {
+        return typeof value === 'object' && value !== null && 'routeMatched' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/RouteNotMatchedHandlerContract.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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface RouteNotMatchedHandlerContract extends HandlerContract {
+    routeNotMatched(input: InputContract, output: OutputContract): OutputContract;
+}
+
+export namespace RouteNotMatchedHandlerContract {
+    export function instanceOf(value: unknown): value is RouteNotMatchedHandlerContract {
+        return typeof value === 'object' && value !== null && 'routeNotMatched' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/Contract/ThrowableCaughtHandlerContract.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 { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { HandlerContract } from './HandlerContract.js';
+
+export interface ThrowableCaughtHandlerContract extends HandlerContract {
+    throwableCaught(input: InputContract, output: OutputContract, throwable: unknown): OutputContract;
+}
+
+export namespace ThrowableCaughtHandlerContract {
+    export function instanceOf(value: unknown): value is ThrowableCaughtHandlerContract {
+        return typeof value === 'object' && value !== null && 'throwableCaught' in value;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/ExitedHandler.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.
+ */
+
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { ExitedMiddlewareContract } from '../Contract/ExitedMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { ExitedHandlerContract } from './Contract/ExitedHandlerContract.js';
+
+export class ExitedHandler extends Handler implements ExitedHandlerContract {
+    exited(input: InputContract, output: OutputContract): void {
+        const next = this.next;
+
+        if (next !== null) {
+            this.getMiddleware<ExitedMiddlewareContract>(next).exited(input, output, this);
+        }
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/InputReceivedHandler.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.
+ */
+
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { InputReceivedMiddlewareContract } from '../Contract/InputReceivedMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { InputReceivedHandlerContract } from './Contract/InputReceivedHandlerContract.js';
+
+export class InputReceivedHandler extends Handler implements InputReceivedHandlerContract {
+    inputReceived(input: InputContract): InputContract | OutputContract {
+        const next = this.next;
+
+        return next !== null
+            ? this.getMiddleware<InputReceivedMiddlewareContract>(next).inputReceived(input, this)
+            : input;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/RouteDispatchedHandler.ts

@@ -0,0 +1,25 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouteDispatchedMiddlewareContract } from '../Contract/RouteDispatchedMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { RouteDispatchedHandlerContract } from './Contract/RouteDispatchedHandlerContract.js';
+
+export class RouteDispatchedHandler extends Handler implements RouteDispatchedHandlerContract {
+    routeDispatched(input: InputContract, output: OutputContract, route: RouteContract): OutputContract {
+        const next = this.next;
+
+        return next !== null
+            ? this.getMiddleware<RouteDispatchedMiddlewareContract>(next).routeDispatched(input, output, route, this)
+            : output;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/RouteMatchedHandler.ts

@@ -0,0 +1,25 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouteMatchedMiddlewareContract } from '../Contract/RouteMatchedMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { RouteMatchedHandlerContract } from './Contract/RouteMatchedHandlerContract.js';
+
+export class RouteMatchedHandler extends Handler implements RouteMatchedHandlerContract {
+    routeMatched(input: InputContract, route: RouteContract): RouteContract | OutputContract {
+        const next = this.next;
+
+        return next !== null
+            ? this.getMiddleware<RouteMatchedMiddlewareContract>(next).routeMatched(input, route, this)
+            : route;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/RouteNotMatchedHandler.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.
+ */
+
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteNotMatchedMiddlewareContract } from '../Contract/RouteNotMatchedMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { RouteNotMatchedHandlerContract } from './Contract/RouteNotMatchedHandlerContract.js';
+
+export class RouteNotMatchedHandler extends Handler implements RouteNotMatchedHandlerContract {
+    routeNotMatched(input: InputContract, output: OutputContract): OutputContract {
+        const next = this.next;
+
+        return next !== null
+            ? this.getMiddleware<RouteNotMatchedMiddlewareContract>(next).routeNotMatched(input, output, this)
+            : output;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Handler/ThrowableCaughtHandler.ts

@@ -0,0 +1,29 @@
+/*
+ * 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 { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { ThrowableCaughtMiddlewareContract } from '../Contract/ThrowableCaughtMiddlewareContract.js';
+import { Handler } from './Abstract/Handler.js';
+import type { ThrowableCaughtHandlerContract } from './Contract/ThrowableCaughtHandlerContract.js';
+
+export class ThrowableCaughtHandler extends Handler implements ThrowableCaughtHandlerContract {
+    throwableCaught(input: InputContract, output: OutputContract, throwable: unknown): OutputContract {
+        const next = this.next;
+
+        return next !== null
+            ? this.getMiddleware<ThrowableCaughtMiddlewareContract>(next).throwableCaught(
+                  input,
+                  output,
+                  throwable,
+                  this,
+              )
+            : output;
+    }
+}

package/src/Valkyrja/Cli/Middleware/Provider/CliMiddlewareComponentProvider.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 { CliMiddlewareServiceProvider } from './CliMiddlewareServiceProvider.js';
+
+import type { ApplicationContract } from '../../../Application/Kernel/Contract/ApplicationContract.js';
+import type { ComponentProviderContract } from '../../../Application/Provider/Contract/ComponentProviderContract.js';
+import type { CliRouteProviderContract } from '../../Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { HttpRouteProviderContract } from '../../../Http/Routing/Provider/Contract/HttpRouteProviderContract.js';
+
+export class CliMiddlewareComponentProvider implements ComponentProviderContract {
+    getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [];
+    }
+
+    getContainerProviders(_app: ApplicationContract): ServiceProviderContract[] {
+        return [new CliMiddlewareServiceProvider()];
+    }
+
+    getEventProviders(_app: ApplicationContract): ListenerProviderContract[] {
+        return [];
+    }
+
+    getCliProviders(_app: ApplicationContract): CliRouteProviderContract[] {
+        return [];
+    }
+
+    getHttpProviders(_app: ApplicationContract): HttpRouteProviderContract[] {
+        return [];
+    }
+}

package/src/Valkyrja/Cli/Middleware/Provider/CliMiddlewareServiceProvider.ts

@@ -0,0 +1,119 @@
+/*
+ * 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 { ApplicationServiceId } from '../../../Application/Constant/ApplicationServiceId.js';
+import type { CliConfigContract } from '../../../Application/Data/Contract/CliConfigContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+import { CliMiddlewareServiceId } from '../Constant/CliMiddlewareServiceId.js';
+import type { ExitedHandlerContract } from '../Handler/Contract/ExitedHandlerContract.js';
+import type { InputReceivedHandlerContract } from '../Handler/Contract/InputReceivedHandlerContract.js';
+import type { RouteDispatchedHandlerContract } from '../Handler/Contract/RouteDispatchedHandlerContract.js';
+import type { RouteMatchedHandlerContract } from '../Handler/Contract/RouteMatchedHandlerContract.js';
+import type { RouteNotMatchedHandlerContract } from '../Handler/Contract/RouteNotMatchedHandlerContract.js';
+import type { ThrowableCaughtHandlerContract } from '../Handler/Contract/ThrowableCaughtHandlerContract.js';
+import { ExitedHandler } from '../Handler/ExitedHandler.js';
+import { InputReceivedHandler } from '../Handler/InputReceivedHandler.js';
+import { RouteDispatchedHandler } from '../Handler/RouteDispatchedHandler.js';
+import { RouteMatchedHandler } from '../Handler/RouteMatchedHandler.js';
+import { RouteNotMatchedHandler } from '../Handler/RouteNotMatchedHandler.js';
+import { ThrowableCaughtHandler } from '../Handler/ThrowableCaughtHandler.js';
+
+export class CliMiddlewareServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [CliMiddlewareServiceId.InputReceivedHandlerContract]:
+                CliMiddlewareServiceProvider.publishInputReceivedHandler,
+            [CliMiddlewareServiceId.ThrowableCaughtHandlerContract]:
+                CliMiddlewareServiceProvider.publishThrowableCaughtHandler,
+            [CliMiddlewareServiceId.RouteMatchedHandlerContract]:
+                CliMiddlewareServiceProvider.publishRouteMatchedHandler,
+            [CliMiddlewareServiceId.RouteNotMatchedHandlerContract]:
+                CliMiddlewareServiceProvider.publishRouteNotMatchedHandler,
+            [CliMiddlewareServiceId.RouteDispatchedHandlerContract]:
+                CliMiddlewareServiceProvider.publishRouteDispatchedHandler,
+            [CliMiddlewareServiceId.ExitedHandlerContract]: CliMiddlewareServiceProvider.publishExitedHandler,
+        };
+    }
+
+    static publishInputReceivedHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new InputReceivedHandler(container);
+
+        container.setSingleton<InputReceivedHandlerContract>(
+            CliMiddlewareServiceId.InputReceivedHandlerContract,
+            handler,
+        );
+
+        handler.add(...config.inputReceivedMiddleware);
+    }
+
+    static publishRouteDispatchedHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new RouteDispatchedHandler(container);
+
+        container.setSingleton<RouteDispatchedHandlerContract>(
+            CliMiddlewareServiceId.RouteDispatchedHandlerContract,
+            handler,
+        );
+
+        handler.add(...config.routeDispatchedMiddleware);
+    }
+
+    static publishThrowableCaughtHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new ThrowableCaughtHandler(container);
+
+        container.setSingleton<ThrowableCaughtHandlerContract>(
+            CliMiddlewareServiceId.ThrowableCaughtHandlerContract,
+            handler,
+        );
+
+        handler.add(...config.throwableCaughtMiddleware);
+    }
+
+    static publishRouteMatchedHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new RouteMatchedHandler(container);
+
+        container.setSingleton<RouteMatchedHandlerContract>(
+            CliMiddlewareServiceId.RouteMatchedHandlerContract,
+            handler,
+        );
+
+        handler.add(...config.routeMatchedMiddleware);
+    }
+
+    static publishRouteNotMatchedHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new RouteNotMatchedHandler(container);
+
+        container.setSingleton<RouteNotMatchedHandlerContract>(
+            CliMiddlewareServiceId.RouteNotMatchedHandlerContract,
+            handler,
+        );
+
+        handler.add(...config.routeNotMatchedMiddleware);
+    }
+
+    static publishExitedHandler(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract);
+
+        const handler = new ExitedHandler(container);
+
+        container.setSingleton<ExitedHandlerContract>(CliMiddlewareServiceId.ExitedHandlerContract, handler);
+
+        handler.add(...config.exitedMiddleware);
+    }
+}

package/src/Valkyrja/Cli/Middleware/Throwable/Contract/CliMiddlewareThrowable.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 { CliThrowable } from '../../../Throwable/Contract/CliThrowable.js';
+
+export type CliMiddlewareThrowable = CliThrowable;

package/src/Valkyrja/Cli/Middleware/Throwable/Exception/Abstract/CliMiddlewareInvalidArgumentException.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 { CliInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/CliInvalidArgumentException.js';
+
+import type { CliMiddlewareThrowable } from '../../Contract/CliMiddlewareThrowable.js';
+
+export abstract class CliMiddlewareInvalidArgumentException
+    extends CliInvalidArgumentException
+    implements CliMiddlewareThrowable {}