@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Cli/Server/Command/HelpCommand.ts

@@ -0,0 +1,313 @@
+/*
+ * 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 { CliConfigContract } from '../../../Application/Data/Contract/CliConfigContract.js';
+import { ExitCode } from '../../Interaction/Enum/ExitCode.js';
+import { TextColor } from '../../Interaction/Enum/TextColor.js';
+import { TextColorFormat } from '../../Interaction/Format/TextColorFormat.js';
+import { Formatter } from '../../Interaction/Formatter/Formatter.js';
+import { HighlightedTextFormatter } from '../../Interaction/Formatter/HighlightedTextFormatter.js';
+import { Banner } from '../../Interaction/Message/Banner.js';
+import type { MessageContract } from '../../Interaction/Message/Contract/MessageContract.js';
+import { ErrorMessage } from '../../Interaction/Message/ErrorMessage.js';
+import { Header } from '../../Interaction/Message/Header.js';
+import { Message } from '../../Interaction/Message/Message.js';
+import { Messages } from '../../Interaction/Message/Messages.js';
+import { NewLine } from '../../Interaction/Message/NewLine.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import { HelpOptionParameter } from '../../Routing/Data/Option/HelpOptionParameter.js';
+import { NoInteractionOptionParameter } from '../../Routing/Data/Option/NoInteractionOptionParameter.js';
+import { QuietOptionParameter } from '../../Routing/Data/Option/QuietOptionParameter.js';
+import { SilentOptionParameter } from '../../Routing/Data/Option/SilentOptionParameter.js';
+import { VersionOptionParameter } from '../../Routing/Data/Option/VersionOptionParameter.js';
+import type { ArgumentParameterContract } from '../../Routing/Data/Contract/ArgumentParameterContract.js';
+import type { OptionParameterContract } from '../../Routing/Data/Contract/OptionParameterContract.js';
+import type { RouteCollectionContract } from '../../Routing/Collection/Contract/RouteCollectionContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import { ArgumentValueMode } from '../../Routing/Enum/ArgumentValueMode.js';
+import { OptionMode } from '../../Routing/Enum/OptionMode.js';
+import { OptionValueMode } from '../../Routing/Enum/OptionValueMode.js';
+
+export class HelpCommand {
+    protected helpRoute!: RouteContract;
+
+    constructor(
+        protected config: CliConfigContract,
+        protected route: RouteContract,
+        protected collection: RouteCollectionContract,
+        protected outputFactory: OutputFactoryContract,
+    ) {}
+
+    static help(): MessageContract {
+        return new Message('A command to get help for a specific command.');
+    }
+
+    run(): OutputContract {
+        const commandName = this.route.getOption('command').getFirstValue();
+
+        if (!this.collection.has(commandName)) {
+            return this.outputFactory
+                .createOutput()
+                .withExitCode(ExitCode.ERROR)
+                .withAddedMessages(new Banner(new ErrorMessage(`Command \`${commandName}\` was not found.`)));
+        }
+
+        this.helpRoute = this.collection.get(commandName);
+
+        const output = this.outputFactory
+            .createOutput()
+            .withMessages(new Header(this.config.namespace, this.config.version, this.route));
+
+        return this.getHelpText(output);
+    }
+
+    protected getHelpText(output: OutputContract): OutputContract {
+        const route = this.helpRoute;
+        const argumentMessages = this.getArgumentsMessages();
+        const optionMessages = this.getOptionsMessages();
+
+        output = output.withAddedMessages(
+            new NewLine(),
+            this.getNameMessages(),
+            new NewLine(),
+            new NewLine(),
+            this.getDescriptionMessages(),
+            new NewLine(),
+            new NewLine(),
+            this.getUsageMessages(),
+            new NewLine(),
+            new NewLine(),
+            ...argumentMessages,
+            ...optionMessages,
+        );
+
+        if (route.hasHelpText()) {
+            const helpText = route.getHelpTextMessage();
+
+            return output.withAddedMessages(this.getHelpTextMessages(helpText), new NewLine());
+        }
+
+        return output;
+    }
+
+    protected getOptionsMessages(): MessageContract[] {
+        const route = this.helpRoute;
+        const optionMessages: MessageContract[] = [];
+
+        if (route.hasOptions()) {
+            optionMessages.push(this.getOptionsHeadingMessages());
+            optionMessages.push(new NewLine());
+
+            for (const option of route.getOptions()) {
+                optionMessages.push(this.getOptionMessages(option));
+            }
+        }
+
+        optionMessages.push(this.getGlobalOptionsHeadingMessages());
+        optionMessages.push(new NewLine());
+        optionMessages.push(this.getOptionMessages(new QuietOptionParameter()));
+        optionMessages.push(this.getOptionMessages(new SilentOptionParameter()));
+        optionMessages.push(this.getOptionMessages(new NoInteractionOptionParameter()));
+        optionMessages.push(this.getOptionMessages(new HelpOptionParameter()));
+        optionMessages.push(this.getOptionMessages(new VersionOptionParameter()));
+
+        return optionMessages;
+    }
+
+    protected getArgumentsMessages(): MessageContract[] {
+        const route = this.helpRoute;
+        const argumentMessages: MessageContract[] = [];
+
+        if (route.hasArguments()) {
+            argumentMessages.push(this.getArgumentsHeadingMessages());
+            argumentMessages.push(new NewLine());
+
+            for (const argument of route.getArguments()) {
+                argumentMessages.push(this.getArgumentMessages(argument));
+            }
+        }
+
+        return argumentMessages;
+    }
+
+    protected getNameMessages(): Messages {
+        return new Messages(
+            new Message('Name: ', new HighlightedTextFormatter()),
+            new Message(this.helpRoute.getName()),
+        );
+    }
+
+    protected getDescriptionMessages(): Messages {
+        return new Messages(
+            new Message('Description:', new HighlightedTextFormatter()),
+            new NewLine(),
+            this.getIndentedText(new Message(this.helpRoute.getDescription())),
+        );
+    }
+
+    protected getHelpTextMessages(helpText: MessageContract): Messages {
+        return new Messages(
+            new Message('Help:', new HighlightedTextFormatter()),
+            new NewLine(),
+            this.getIndentedText(helpText),
+            new NewLine(),
+        );
+    }
+
+    protected getUsageMessages(): Messages {
+        const route = this.helpRoute;
+        let usage = route.getName();
+
+        if (route.hasOptions()) {
+            usage += ' [options]';
+        }
+
+        usage += ' [global options]';
+
+        if (route.hasArguments()) {
+            for (const argument of route.getArguments()) {
+                usage +=
+                    ' [' +
+                    argument.getName() +
+                    (argument.getValueMode() === ArgumentValueMode.ARRAY ? '...' : '') +
+                    ']';
+            }
+        }
+
+        return new Messages(
+            new Message('Usage:', new HighlightedTextFormatter()),
+            new NewLine(),
+            this.getIndentedText(new Message(usage)),
+        );
+    }
+
+    protected getOptionsHeadingMessages(): Messages {
+        return new Messages(new Message('Options:', new HighlightedTextFormatter()));
+    }
+
+    protected getGlobalOptionsHeadingMessages(): Messages {
+        return new Messages(new Message('Global Options:', new HighlightedTextFormatter()));
+    }
+
+    protected getOptionMessages(option: OptionParameterContract): Messages {
+        const msgs: MessageContract[] = [];
+
+        msgs.push(new Message('  '));
+        msgs.push(new Message('--' + option.getName(), new Formatter(new TextColorFormat(TextColor.MAGENTA))));
+
+        this.addShortNamesOptionMessages(msgs, option);
+        this.addValueDisplayNameOptionMessages(msgs, option);
+
+        msgs.push(new NewLine());
+        msgs.push(new Message('    '));
+        msgs.push(new Message(option.getDescription()));
+
+        this.addValidValuesOptionMessages(msgs, option);
+
+        msgs.push(new NewLine());
+        msgs.push(new NewLine());
+
+        return new Messages(...msgs);
+    }
+
+    protected addShortNamesOptionMessages(messages: MessageContract[], option: OptionParameterContract): void {
+        const shortNames = option.getShortNames();
+
+        if (shortNames.length > 0) {
+            messages.push(new Message(', '));
+            messages.push(
+                new Message('-' + shortNames.join('|'), new Formatter(new TextColorFormat(TextColor.MAGENTA))),
+            );
+        }
+    }
+
+    protected addValueDisplayNameOptionMessages(messages: MessageContract[], option: OptionParameterContract): void {
+        if (option.hasValueDisplayName()) {
+            const valueDisplayName = option.getValueDisplayName();
+
+            messages.push(new Message(' '));
+
+            let text = '';
+
+            if (option.getValueMode() === OptionValueMode.ARRAY) {
+                text = '...';
+            }
+
+            if (option.getMode() === OptionMode.REQUIRED) {
+                text += '=' + valueDisplayName;
+            } else {
+                text += '[=' + valueDisplayName + ']';
+            }
+
+            messages.push(new Message(text, new HighlightedTextFormatter()));
+        }
+    }
+
+    protected addValidValuesOptionMessages(messages: MessageContract[], option: OptionParameterContract): void {
+        const validValues = option.getValidValues();
+
+        if (validValues.length > 0) {
+            const defaultValue = option.getDefaultValue();
+            const valueSpacing = '\n      - ';
+
+            messages.push(new NewLine());
+            messages.push(new NewLine());
+            messages.push(new Message('    '));
+            messages.push(new Message('Valid values:'));
+
+            for (const validValue of validValues) {
+                messages.push(new Message(`${valueSpacing}\`${validValue}\``));
+
+                if (validValue === defaultValue) {
+                    messages.push(new Message(' (default)', new HighlightedTextFormatter()));
+                }
+            }
+        }
+    }
+
+    protected getArgumentsHeadingMessages(): Messages {
+        return new Messages(new Message('Arguments:', new HighlightedTextFormatter()));
+    }
+
+    protected getArgumentMessages(argument: ArgumentParameterContract): Messages {
+        return new Messages(
+            new Message('  '),
+            new Message(argument.getName()),
+            new NewLine(),
+            new Message('    '),
+            new Message(argument.getDescription()),
+            new NewLine(),
+            new NewLine(),
+        );
+    }
+
+    protected getIndentedText(message: MessageContract): MessageContract {
+        const spaces = '  ';
+        const maxWidth = 100;
+        const words = (spaces + message.getText()).split(' ');
+        const lines: string[] = [];
+        let currentLine = '';
+
+        for (const word of words) {
+            if (currentLine.length + word.length + 1 <= maxWidth) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            } else {
+                lines.push(currentLine);
+                currentLine = spaces + word;
+            }
+        }
+
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+
+        return message.withText(lines.join('\n'));
+    }
+}

package/src/Valkyrja/Cli/Server/Command/ListBashCommand.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 { MessageContract } from '../../Interaction/Message/Contract/MessageContract.js';
+import { Message } from '../../Interaction/Message/Message.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import type { RouteCollectionContract } from '../../Routing/Collection/Contract/RouteCollectionContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+
+export class ListBashCommand {
+    constructor(
+        protected route: RouteContract,
+        protected collection: RouteCollectionContract,
+        protected outputFactory: OutputFactoryContract,
+    ) {}
+
+    static help(): MessageContract {
+        return new Message('A command to list all the commands present within the Cli component for bash completion.');
+    }
+
+    run(): OutputContract {
+        const output = this.outputFactory.createOutput();
+        let routes = Object.values(this.collection.all());
+        let colonAt: number | false = false;
+
+        if (this.route.hasArgument('namespace')) {
+            const namespace = this.route.getArgument('namespace').getFirstValue();
+            colonAt = namespace.indexOf(':');
+
+            routes = routes.filter((r) => r.getName().startsWith(namespace));
+        }
+
+        const routesForBash = routes.map((r) => (colonAt !== false ? r.getName().substring(colonAt + 1) : r.getName()));
+
+        return output.withAddedMessages(new Message(routesForBash.join(' ')));
+    }
+}

package/src/Valkyrja/Cli/Server/Command/ListCommand.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 { CliConfigContract } from '../../../Application/Data/Contract/CliConfigContract.js';
+import { ExitCode } from '../../Interaction/Enum/ExitCode.js';
+import { TextColor } from '../../Interaction/Enum/TextColor.js';
+import { TextColorFormat } from '../../Interaction/Format/TextColorFormat.js';
+import { Formatter } from '../../Interaction/Formatter/Formatter.js';
+import { HighlightedTextFormatter } from '../../Interaction/Formatter/HighlightedTextFormatter.js';
+import { Banner } from '../../Interaction/Message/Banner.js';
+import type { MessageContract } from '../../Interaction/Message/Contract/MessageContract.js';
+import { ErrorMessage } from '../../Interaction/Message/ErrorMessage.js';
+import { Header } from '../../Interaction/Message/Header.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 { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import type { RouteCollectionContract } from '../../Routing/Collection/Contract/RouteCollectionContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+
+export class ListCommand {
+    constructor(
+        protected config: CliConfigContract,
+        protected route: RouteContract,
+        protected collection: RouteCollectionContract,
+        protected outputFactory: OutputFactoryContract,
+    ) {}
+
+    static help(): MessageContract {
+        return new Message('A command to list all the commands present within the Cli component.');
+    }
+
+    run(): OutputContract {
+        let namespace = '';
+        let routes = Object.values(this.collection.all());
+
+        if (this.route.hasOption('namespace')) {
+            namespace = this.route.getOption('namespace').getFirstValue();
+            routes = routes.filter((r) => r.getName().startsWith(namespace));
+        }
+
+        if (routes.length === 0) {
+            return this.getNoRoutesErrorOutput(namespace);
+        }
+
+        routes.sort((a, b) => a.getName().localeCompare(b.getName()));
+
+        let output = this.outputFactory
+            .createOutput()
+            .withMessages(new Header(this.config.namespace, this.config.version, this.route));
+
+        output = this.addHeaderMessages(output, namespace);
+        output = this.addRoutesMessages(output, routes);
+
+        return output.withAddedMessages(new NewLine());
+    }
+
+    protected getNoRoutesErrorOutput(namespace: string): OutputContract {
+        const errorMessage = namespace !== '' ? `Namespace \`${namespace}\` was not found.` : 'No routes found.';
+
+        return this.outputFactory
+            .createOutput()
+            .withExitCode(ExitCode.ERROR)
+            .withAddedMessages(new Banner(new ErrorMessage(errorMessage)));
+    }
+
+    protected addHeaderMessages(output: OutputContract, namespace: string): OutputContract {
+        return output.withAddedMessages(
+            new Message('Commands' + (namespace !== '' ? ` [${namespace}]:` : ':'), new HighlightedTextFormatter()),
+            new NewLine(),
+        );
+    }
+
+    protected addRoutesMessages(output: OutputContract, routes: RouteContract[]): OutputContract {
+        for (const route of routes) {
+            output = this.addRouteMessages(output, route);
+        }
+
+        return output;
+    }
+
+    protected addRouteMessages(output: OutputContract, route: RouteContract): OutputContract {
+        return output.withAddedMessages(
+            new Message('  '),
+            new Message(route.getName(), new Formatter(new TextColorFormat(TextColor.MAGENTA))),
+            new NewLine(),
+            new Message('    - '),
+            new Message(route.getDescription(), new HighlightedTextFormatter()),
+            new NewLine(),
+        );
+    }
+}

package/src/Valkyrja/Cli/Server/Command/VersionCommand.ts

@@ -0,0 +1,34 @@
+/*
+ * 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 { CliConfigContract } from '../../../Application/Data/Contract/CliConfigContract.js';
+import type { MessageContract } from '../../Interaction/Message/Contract/MessageContract.js';
+import { Header } from '../../Interaction/Message/Header.js';
+import { Message } from '../../Interaction/Message/Message.js';
+import type { OutputContract } from '../../Interaction/Output/Contract/OutputContract.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+
+export class VersionCommand {
+    constructor(
+        protected outputFactory: OutputFactoryContract,
+        protected config: CliConfigContract,
+        protected route: RouteContract,
+    ) {}
+
+    static help(): MessageContract {
+        return new Message('A command to show the application version and info.');
+    }
+
+    run(): OutputContract {
+        return this.outputFactory
+            .createOutput()
+            .withMessages(new Header(this.config.namespace, this.config.version, this.route));
+    }
+}

package/src/Valkyrja/Cli/Server/Constant/CliServerServiceId.ts

@@ -0,0 +1,28 @@
+/*
+ * 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 CliServerServiceId {
+    static readonly InputHandlerContract = 'Valkyrja.Cli.Server.Handler.InputHandlerContract' as const;
+    static readonly HelpCommand = 'Valkyrja.Cli.Server.Command.HelpCommand' as const;
+    static readonly ListBashCommand = 'Valkyrja.Cli.Server.Command.ListBashCommand' as const;
+    static readonly ListCommand = 'Valkyrja.Cli.Server.Command.ListCommand' as const;
+    static readonly VersionCommand = 'Valkyrja.Cli.Server.Command.VersionCommand' as const;
+    static readonly LogThrowableCaughtMiddleware =
+        'Valkyrja.Cli.Server.Middleware.LogThrowableCaughtMiddleware' as const;
+    static readonly OutputThrowableCaughtMiddleware =
+        'Valkyrja.Cli.Server.Middleware.OutputThrowableCaughtMiddleware' as const;
+    static readonly CheckForHelpOptionsMiddleware =
+        'Valkyrja.Cli.Server.Middleware.CheckForHelpOptionsMiddleware' as const;
+    static readonly CheckForVersionOptionsMiddleware =
+        'Valkyrja.Cli.Server.Middleware.CheckForVersionOptionsMiddleware' as const;
+    static readonly CheckGlobalInteractionOptionsMiddleware =
+        'Valkyrja.Cli.Server.Middleware.CheckGlobalInteractionOptionsMiddleware' as const;
+    static readonly CheckCommandForTypoMiddleware =
+        'Valkyrja.Cli.Server.Middleware.CheckCommandForTypoMiddleware' as const;
+}

package/src/Valkyrja/Cli/Server/Constant/CommandName.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.
+ */
+
+export class CliCommandName {
+    static readonly HELP: string = 'help' as const;
+    static readonly LIST: string = 'list' as const;
+    static readonly LIST_BASH: string = 'list:bash' as const;
+    static readonly VERSION: string = 'version' as const;
+    static readonly DATA_GENERATE: string = 'data:generate' as const;
+}

package/src/Valkyrja/Cli/Server/Data/Contract/CliHelpCommandConfigContract.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.
+ */
+
+export interface CliHelpCommandConfigContract {
+    readonly helpCommandName: string;
+    readonly helpOptionName: string;
+    readonly helpOptionShortName: string;
+}
+
+export namespace CliHelpCommandConfigContract {
+    export function instanceOf(value: unknown): value is CliHelpCommandConfigContract {
+        return typeof value === 'object' && value !== null && 'helpCommandName' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Data/Contract/CliNoInteractionConfigContract.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.
+ */
+
+export interface CliNoInteractionConfigContract {
+    readonly noInteractionOptionName: string;
+    readonly noInteractionOptionShortName: string;
+}
+
+export namespace CliNoInteractionConfigContract {
+    export function instanceOf(value: unknown): value is CliNoInteractionConfigContract {
+        return typeof value === 'object' && value !== null && 'noInteractionOptionName' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Data/Contract/CliQuietInteractionConfigContract.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.
+ */
+
+export interface CliQuietInteractionConfigContract {
+    readonly quietOptionName: string;
+    readonly quietOptionShortName: string;
+}
+
+export namespace CliQuietInteractionConfigContract {
+    export function instanceOf(value: unknown): value is CliQuietInteractionConfigContract {
+        return typeof value === 'object' && value !== null && 'quietOptionName' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Data/Contract/CliSilentInteractionConfigContract.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.
+ */
+
+export interface CliSilentInteractionConfigContract {
+    readonly silentOptionName: string;
+    readonly silentOptionShortName: string;
+}
+
+export namespace CliSilentInteractionConfigContract {
+    export function instanceOf(value: unknown): value is CliSilentInteractionConfigContract {
+        return typeof value === 'object' && value !== null && 'silentOptionName' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Data/Contract/CliVersionCommandConfigContract.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.
+ */
+
+export interface CliVersionCommandConfigContract {
+    readonly versionCommandName: string;
+    readonly versionOptionName: string;
+    readonly versionOptionShortName: string;
+}
+
+export namespace CliVersionCommandConfigContract {
+    export function instanceOf(value: unknown): value is CliVersionCommandConfigContract {
+        return typeof value === 'object' && value !== null && 'versionCommandName' in value;
+    }
+}

package/src/Valkyrja/Cli/Server/Handler/Contract/InputHandlerContract.ts

@@ -0,0 +1,17 @@
+/*
+ * 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';
+
+export interface InputHandlerContract {
+    handle(input: InputContract): OutputContract;
+    exit(input: InputContract, output: OutputContract): void;
+    run(input: InputContract): void;
+}