@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Cli/Server/Handler/InputHandler.ts

@@ -0,0 +1,112 @@
+/*
+ * 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 { CliInteractionConfig } from '../../Interaction/Data/CliInteractionConfig.js';
+import type { CliInteractionConfigContract } from '../../Interaction/Data/Contract/CliInteractionConfigContract.js';
+import { ExitCode } from '../../Interaction/Enum/ExitCode.js';
+import type { InputContract } from '../../Interaction/Input/Contract/InputContract.js';
+import { Banner } from '../../Interaction/Message/Banner.js';
+import { ErrorMessage } from '../../Interaction/Message/ErrorMessage.js';
+import { Message } from '../../Interaction/Message/Message.js';
+import { NewLine } from '../../Interaction/Message/NewLine.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import { OutputFactory } from '../../Interaction/Output/Factory/OutputFactory.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.js';
+import { ExitedHandler } from '../../Middleware/Handler/ExitedHandler.js';
+import type { InputReceivedHandlerContract } from '../../Middleware/Handler/Contract/InputReceivedHandlerContract.js';
+import { InputReceivedHandler } from '../../Middleware/Handler/InputReceivedHandler.js';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+import { ThrowableCaughtHandler } from '../../Middleware/Handler/ThrowableCaughtHandler.js';
+import { Router } from '../../Routing/Dispatcher/Router.js';
+import type { RouterContract } from '../../Routing/Dispatcher/Contract/RouterContract.js';
+import { CliInteractionServiceId } from '../../Interaction/Constant/CliInteractionServiceId.js';
+import { Exiter } from '../Support/Exiter.js';
+import type { InputHandlerContract } from './Contract/InputHandlerContract.js';
+
+export class InputHandler implements InputHandlerContract {
+    constructor(
+        protected container: ContainerContract = new Container(),
+        protected router: RouterContract = new Router(),
+        protected inputReceivedHandler: InputReceivedHandlerContract = new InputReceivedHandler(),
+        protected throwableCaughtHandler: ThrowableCaughtHandlerContract = new ThrowableCaughtHandler(),
+        protected exitedHandler: ExitedHandlerContract = new ExitedHandler(),
+        protected interactionConfig: CliInteractionConfigContract = new CliInteractionConfig(),
+        protected outputFactory: OutputFactoryContract = new OutputFactory(),
+    ) {}
+
+    handle(input: InputContract): OutputContract {
+        let output: OutputContract;
+
+        try {
+            output = this.dispatchRouter(input);
+        } catch (throwable: unknown) {
+            output = this.getOutputFromThrowable(input, throwable);
+            output = this.throwableCaughtHandler.throwableCaught(input, output, throwable);
+        }
+
+        this.container.setSingleton<OutputContract>(CliInteractionServiceId.OutputContract, output);
+
+        return output;
+    }
+
+    exit(input: InputContract, output: OutputContract): void {
+        this.exitedHandler.exited(input, output);
+    }
+
+    run(input: InputContract): void {
+        const output = this.handle(input);
+
+        output.writeMessages();
+
+        this.exit(input, output);
+
+        const exitCode = output.getExitCode();
+
+        Exiter.exit(exitCode);
+    }
+
+    protected dispatchRouter(input: InputContract): OutputContract {
+        this.container.setSingleton<InputContract>(CliInteractionServiceId.InputContract, input);
+
+        const inputAfterMiddleware = this.inputReceivedHandler.inputReceived(input);
+
+        if (this.isOutputContract(inputAfterMiddleware)) {
+            return inputAfterMiddleware;
+        }
+
+        this.container.setSingleton<InputContract>(CliInteractionServiceId.InputContract, inputAfterMiddleware);
+
+        return this.router.dispatch(inputAfterMiddleware);
+    }
+
+    protected getOutputFromThrowable(input: InputContract, throwable: unknown): OutputContract {
+        const commandName = input.getCommandName();
+        const message = throwable instanceof Error ? throwable.message : String(throwable);
+
+        return this.outputFactory
+            .createOutput(ExitCode.ERROR)
+            .withMessages(
+                new Banner(new ErrorMessage('Cli Server Error:')),
+                new NewLine(),
+                new ErrorMessage('Command:'),
+                new Message(` ${commandName}`),
+                new NewLine(),
+                new NewLine(),
+                new ErrorMessage('Message:'),
+                new Message(` ${message}`),
+            );
+    }
+
+    protected isOutputContract(value: InputContract | OutputContract): value is OutputContract {
+        return 'writeMessages' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/InputReceived/CheckForHelpOptionsMiddleware.ts

@@ -0,0 +1,30 @@
+/*
+ * 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 { Option } from '../../../Interaction/Option/Option.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { InputReceivedMiddlewareContract } from '../../../Middleware/Contract/InputReceivedMiddlewareContract.js';
+import type { InputReceivedHandlerContract } from '../../../Middleware/Handler/Contract/InputReceivedHandlerContract.js';
+
+export class CheckForHelpOptionsMiddleware implements InputReceivedMiddlewareContract {
+    constructor(
+        protected commandName: string,
+        protected optionName: string,
+        protected optionShortName: string,
+    ) {}
+
+    inputReceived(input: InputContract, handler: InputReceivedHandlerContract): InputContract | OutputContract {
+        if (input.hasOption(this.optionShortName) || input.hasOption(this.optionName)) {
+            input = input.withCommandName(this.commandName).withOptions(new Option('command', input.getCommandName()));
+        }
+
+        return handler.inputReceived(input);
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/InputReceived/CheckForVersionOptionsMiddleware.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 { InputReceivedMiddlewareContract } from '../../../Middleware/Contract/InputReceivedMiddlewareContract.js';
+import type { InputReceivedHandlerContract } from '../../../Middleware/Handler/Contract/InputReceivedHandlerContract.js';
+
+export class CheckForVersionOptionsMiddleware implements InputReceivedMiddlewareContract {
+    constructor(
+        protected commandName: string,
+        protected optionName: string,
+        protected optionShortName: string,
+    ) {}
+
+    inputReceived(input: InputContract, handler: InputReceivedHandlerContract): InputContract | OutputContract {
+        if (input.hasOption(this.optionShortName) || input.hasOption(this.optionName)) {
+            input = input.withCommandName(this.commandName).withOptions();
+        }
+
+        return handler.inputReceived(input);
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/InputReceived/CheckGlobalInteractionOptionsMiddleware.ts

@@ -0,0 +1,52 @@
+/*
+ * 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 { CliInteractionConfigContract } from '../../../Interaction/Data/Contract/CliInteractionConfigContract.js';
+import type { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { InputReceivedMiddlewareContract } from '../../../Middleware/Contract/InputReceivedMiddlewareContract.js';
+import type { InputReceivedHandlerContract } from '../../../Middleware/Handler/Contract/InputReceivedHandlerContract.js';
+
+export class CheckGlobalInteractionOptionsMiddleware implements InputReceivedMiddlewareContract {
+    constructor(
+        protected config: CliInteractionConfigContract,
+        protected noInteractionOptionName: string,
+        protected noInteractionOptionShortName: string,
+        protected quietOptionName: string,
+        protected quietOptionShortName: string,
+        protected silentOptionName: string,
+        protected silentOptionShortName: string,
+    ) {}
+
+    inputReceived(input: InputContract, handler: InputReceivedHandlerContract): InputContract | OutputContract {
+        this.setIsInteractive(input);
+        this.setIsQuiet(input);
+        this.setIsSilent(input);
+
+        return handler.inputReceived(input);
+    }
+
+    protected setIsInteractive(input: InputContract): void {
+        if (input.hasOption(this.noInteractionOptionShortName) || input.hasOption(this.noInteractionOptionName)) {
+            this.config.isInteractive = false;
+        }
+    }
+
+    protected setIsQuiet(input: InputContract): void {
+        if (input.hasOption(this.quietOptionShortName) || input.hasOption(this.quietOptionName)) {
+            this.config.isQuiet = true;
+        }
+    }
+
+    protected setIsSilent(input: InputContract): void {
+        if (input.hasOption(this.silentOptionShortName) || input.hasOption(this.silentOptionName)) {
+            this.config.isSilent = true;
+        }
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/RouteNotMatched/CheckCommandForTypoMiddleware.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 type { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import { Answer } from '../../../Interaction/Message/Answer.js';
+import type { AnswerContract } from '../../../Interaction/Message/Contract/AnswerContract.js';
+import { NewLine } from '../../../Interaction/Message/NewLine.js';
+import { Question } from '../../../Interaction/Message/Question.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { RouteNotMatchedMiddlewareContract } from '../../../Middleware/Contract/RouteNotMatchedMiddlewareContract.js';
+import type { RouteNotMatchedHandlerContract } from '../../../Middleware/Handler/Contract/RouteNotMatchedHandlerContract.js';
+import type { RouteCollectionContract } from '../../../Routing/Collection/Contract/RouteCollectionContract.js';
+import type { RouteContract } from '../../../Routing/Data/Contract/RouteContract.js';
+import type { RouterContract } from '../../../Routing/Dispatcher/Contract/RouterContract.js';
+
+export class CheckCommandForTypoMiddleware implements RouteNotMatchedMiddlewareContract {
+    protected matchedRoute: RouteContract | null = null;
+
+    constructor(
+        protected router: RouterContract,
+        protected collection: RouteCollectionContract,
+        protected defaultAnswer: string = 'no',
+    ) {}
+
+    routeNotMatched(
+        input: InputContract,
+        output: OutputContract,
+        handler: RouteNotMatchedHandlerContract,
+    ): OutputContract {
+        const routeOrOutput = this.checkCommandNameForTypo(input, output);
+
+        if (this.isRouteContract(routeOrOutput)) {
+            output = this.router.dispatch(input.withCommandName(routeOrOutput.getName()));
+        }
+
+        return handler.routeNotMatched(input, output);
+    }
+
+    protected checkCommandNameForTypo(input: InputContract, output: OutputContract): RouteContract | OutputContract {
+        const name = input.getCommandName();
+        const commands = Object.values(this.collection.all()).filter((command) => {
+            const percent = this.similarText(command.getName(), name);
+            return percent >= 60;
+        });
+
+        if (commands.length > 0) {
+            return this.askToRunSimilarCommands(output, commands);
+        }
+
+        return output;
+    }
+
+    protected askToRunSimilarCommands(
+        output: OutputContract,
+        commands: RouteContract[],
+    ): RouteContract | OutputContract {
+        const commandNames = commands.map((c) => c.getName());
+
+        output = output
+            .withAddedMessages(
+                new NewLine(),
+                new Question(
+                    'Did you mean to run one of the following commands?',
+                    (out: OutputContract, answer: AnswerContract): OutputContract =>
+                        this.questionCallback(out, answer, commands),
+                    new Answer(this.defaultAnswer, null, false, 'You answered: `%s`', null, commandNames),
+                ),
+            )
+            .writeMessages();
+
+        return this.matchedRoute ?? output;
+    }
+
+    protected questionCallback(
+        output: OutputContract,
+        answer: AnswerContract,
+        commands: RouteContract[],
+    ): OutputContract {
+        const response = answer.getUserResponse();
+        this.matchedRoute = response !== 'no' ? this.getMatchedRoute(commands, response) : null;
+        return output;
+    }
+
+    protected getMatchedRoute(commands: RouteContract[], response: string): RouteContract | null {
+        return commands.find((c) => c.getName() === response) ?? null;
+    }
+
+    protected similarText(a: string, b: string): number {
+        if (a === b) return 100;
+        if (a.length === 0 || b.length === 0) return 0;
+
+        let common = 0;
+        const aUsed = new Array<boolean>(a.length).fill(false);
+        const bUsed = new Array<boolean>(b.length).fill(false);
+
+        for (let i = 0; i < a.length; i++) {
+            for (let j = 0; j < b.length; j++) {
+                if (!aUsed[i] && !bUsed[j] && a[i] === b[j]) {
+                    aUsed[i] = true;
+                    bUsed[j] = true;
+                    common++;
+                    break;
+                }
+            }
+        }
+
+        return ((2 * common) / (a.length + b.length)) * 100;
+    }
+
+    protected isRouteContract(value: RouteContract | OutputContract): value is RouteContract {
+        return 'getHandler' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/ThrowableCaught/LogThrowableCaughtMiddleware.ts

@@ -0,0 +1,32 @@
+/*
+ * 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 '../../../Middleware/Contract/ThrowableCaughtMiddlewareContract.js';
+import type { ThrowableCaughtHandlerContract } from '../../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+import type { LoggerContract } from '../../../../Log/Logger/Contract/LoggerContract.js';
+
+export class LogThrowableCaughtMiddleware implements ThrowableCaughtMiddlewareContract {
+    constructor(protected logger: LoggerContract) {}
+
+    throwableCaught(
+        input: InputContract,
+        output: OutputContract,
+        throwable: unknown,
+        handler: ThrowableCaughtHandlerContract,
+    ): OutputContract {
+        const commandName = input.getCommandName();
+        const logMessage = `Cli Server Error\nUrl: ${commandName}`;
+
+        this.logger.throwable(throwable instanceof Error ? throwable : new Error(String(throwable)), logMessage);
+
+        return handler.throwableCaught(input, output, throwable);
+    }
+}

package/src/Valkyrja/Cli/Server/Middleware/ThrowableCaught/OutputThrowableCaughtMiddleware.ts

@@ -0,0 +1,57 @@
+/*
+ * 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 { ExitCode } from '../../../Interaction/Enum/ExitCode.js';
+import type { InputContract } from '../../../Interaction/Input/Contract/InputContract.js';
+import { Banner } from '../../../Interaction/Message/Banner.js';
+import { ErrorMessage } from '../../../Interaction/Message/ErrorMessage.js';
+import { Message } from '../../../Interaction/Message/Message.js';
+import { NewLine } from '../../../Interaction/Message/NewLine.js';
+import type { OutputContract } from '../../../Interaction/Output/Contract/OutputContract.js';
+import type { ThrowableCaughtMiddlewareContract } from '../../../Middleware/Contract/ThrowableCaughtMiddlewareContract.js';
+import type { ThrowableCaughtHandlerContract } from '../../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+
+export class OutputThrowableCaughtMiddleware implements ThrowableCaughtMiddlewareContract {
+    throwableCaught(
+        input: InputContract,
+        output: OutputContract,
+        throwable: unknown,
+        handler: ThrowableCaughtHandlerContract,
+    ): OutputContract {
+        const commandName = input.getCommandName();
+        const err = throwable instanceof Error ? throwable : null;
+        const message = err?.message ?? String(throwable);
+        const line = err?.stack?.split('\n')[1]?.trim() ?? '';
+        const trace = err?.stack ?? '';
+
+        output = output
+            .withExitCode(ExitCode.ERROR)
+            .withMessages(
+                new Banner(new ErrorMessage('Cli Server Error:')),
+                new NewLine(),
+                new ErrorMessage('Command:'),
+                new Message(` ${commandName}`),
+                new NewLine(),
+                new NewLine(),
+                new ErrorMessage('Message:'),
+                new Message(` ${message}`),
+                new NewLine(),
+                new NewLine(),
+                new ErrorMessage('Line:'),
+                new Message(` ${line}`),
+                new NewLine(),
+                new NewLine(),
+                new ErrorMessage('Trace:'),
+                new NewLine(),
+                new Message(`${trace}\n`),
+            );
+
+        return handler.throwableCaught(input, output, throwable);
+    }
+}

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