@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Cli/Server/Provider/CliServerServiceProvider.ts

@@ -0,0 +1,269 @@
+/*
+ * 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 { ConfigContract } from '../../../Application/Data/Contract/ConfigContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+import { CliInteractionServiceId } from '../../Interaction/Constant/CliInteractionServiceId.js';
+import type { CliInteractionConfigContract } from '../../Interaction/Data/Contract/CliInteractionConfigContract.js';
+import type { OutputFactoryContract } from '../../Interaction/Output/Factory/Contract/OutputFactoryContract.js';
+import { CliMiddlewareServiceId } from '../../Middleware/Constant/CliMiddlewareServiceId.js';
+import type { ExitedHandlerContract } from '../../Middleware/Handler/Contract/ExitedHandlerContract.js';
+import type { InputReceivedHandlerContract } from '../../Middleware/Handler/Contract/InputReceivedHandlerContract.js';
+import type { ThrowableCaughtHandlerContract } from '../../Middleware/Handler/Contract/ThrowableCaughtHandlerContract.js';
+import type { RouteCollectionContract } from '../../Routing/Collection/Contract/RouteCollectionContract.js';
+import { CliRoutingServiceId } from '../../Routing/Constant/CliRoutingServiceId.js';
+import type { RouteContract } from '../../Routing/Data/Contract/RouteContract.js';
+import type { RouterContract } from '../../Routing/Dispatcher/Contract/RouterContract.js';
+import { OptionName } from '../../Routing/Constant/OptionName.js';
+import { OptionShortName } from '../../Routing/Constant/OptionShortName.js';
+import { HelpCommand } from '../Command/HelpCommand.js';
+import { ListBashCommand } from '../Command/ListBashCommand.js';
+import { ListCommand } from '../Command/ListCommand.js';
+import { VersionCommand } from '../Command/VersionCommand.js';
+import { CliServerServiceId } from '../Constant/CliServerServiceId.js';
+import type { CliHelpCommandConfigContract } from '../Data/Contract/CliHelpCommandConfigContract.js';
+import type { CliNoInteractionConfigContract } from '../Data/Contract/CliNoInteractionConfigContract.js';
+import type { CliQuietInteractionConfigContract } from '../Data/Contract/CliQuietInteractionConfigContract.js';
+import type { CliSilentInteractionConfigContract } from '../Data/Contract/CliSilentInteractionConfigContract.js';
+import type { CliVersionCommandConfigContract } from '../Data/Contract/CliVersionCommandConfigContract.js';
+import type { InputHandlerContract } from '../Handler/Contract/InputHandlerContract.js';
+import { InputHandler } from '../Handler/InputHandler.js';
+import { CheckCommandForTypoMiddleware } from '../Middleware/RouteNotMatched/CheckCommandForTypoMiddleware.js';
+import { CheckForHelpOptionsMiddleware } from '../Middleware/InputReceived/CheckForHelpOptionsMiddleware.js';
+import { CheckForVersionOptionsMiddleware } from '../Middleware/InputReceived/CheckForVersionOptionsMiddleware.js';
+import { CheckGlobalInteractionOptionsMiddleware } from '../Middleware/InputReceived/CheckGlobalInteractionOptionsMiddleware.js';
+import { LogThrowableCaughtMiddleware } from '../Middleware/ThrowableCaught/LogThrowableCaughtMiddleware.js';
+import { OutputThrowableCaughtMiddleware } from '../Middleware/ThrowableCaught/OutputThrowableCaughtMiddleware.js';
+import { CliCommandName } from '../Constant/CommandName.js';
+import { LoggerContractId } from '../../../Log/Logger/Contract/LoggerContract.js';
+import type { LoggerContract } from '../../../Log/Logger/Contract/LoggerContract.js';
+
+export class CliServerServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [CliServerServiceId.InputHandlerContract]: CliServerServiceProvider.publishInputHandler,
+            [CliServerServiceId.HelpCommand]: CliServerServiceProvider.publishHelpCommand,
+            [CliServerServiceId.ListBashCommand]: CliServerServiceProvider.publishListBashCommand,
+            [CliServerServiceId.ListCommand]: CliServerServiceProvider.publishListCommand,
+            [CliServerServiceId.VersionCommand]: CliServerServiceProvider.publishVersionCommand,
+            [CliServerServiceId.LogThrowableCaughtMiddleware]:
+                CliServerServiceProvider.publishLogThrowableCaughtMiddleware,
+            [CliServerServiceId.OutputThrowableCaughtMiddleware]:
+                CliServerServiceProvider.publishOutputThrowableCaughtMiddleware,
+            [CliServerServiceId.CheckForHelpOptionsMiddleware]:
+                CliServerServiceProvider.publishCheckForHelpOptionsMiddleware,
+            [CliServerServiceId.CheckForVersionOptionsMiddleware]:
+                CliServerServiceProvider.publishCheckForVersionOptionsMiddleware,
+            [CliServerServiceId.CheckGlobalInteractionOptionsMiddleware]:
+                CliServerServiceProvider.publishCheckGlobalInteractionOptionsMiddleware,
+            [CliServerServiceId.CheckCommandForTypoMiddleware]:
+                CliServerServiceProvider.publishCheckCommandForTypoMiddleware,
+        };
+    }
+
+    static publishInputHandler(this: void, container: ContainerContract): void {
+        container.setSingleton<InputHandlerContract>(
+            CliServerServiceId.InputHandlerContract,
+            new InputHandler(
+                container,
+                container.getSingleton<RouterContract>(CliRoutingServiceId.RouterContract),
+                container.getSingleton<InputReceivedHandlerContract>(
+                    CliMiddlewareServiceId.InputReceivedHandlerContract,
+                ),
+                container.getSingleton<ThrowableCaughtHandlerContract>(
+                    CliMiddlewareServiceId.ThrowableCaughtHandlerContract,
+                ),
+                container.getSingleton<ExitedHandlerContract>(CliMiddlewareServiceId.ExitedHandlerContract),
+                container.getSingleton<CliInteractionConfigContract>(
+                    CliInteractionServiceId.CliInteractionConfigContract,
+                ),
+            ),
+        );
+    }
+
+    static publishHelpCommand(this: void, container: ContainerContract): void {
+        container.setSingleton<HelpCommand>(
+            CliServerServiceId.HelpCommand,
+            new HelpCommand(
+                container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract),
+                container.getSingleton<RouteContract>(CliRoutingServiceId.RouteContract),
+                container.getSingleton<RouteCollectionContract>(CliRoutingServiceId.RouteCollectionContract),
+                container.getSingleton<OutputFactoryContract>(CliInteractionServiceId.OutputFactoryContract),
+            ),
+        );
+    }
+
+    static publishListBashCommand(this: void, container: ContainerContract): void {
+        container.setSingleton<ListBashCommand>(
+            CliServerServiceId.ListBashCommand,
+            new ListBashCommand(
+                container.getSingleton<RouteContract>(CliRoutingServiceId.RouteContract),
+                container.getSingleton<RouteCollectionContract>(CliRoutingServiceId.RouteCollectionContract),
+                container.getSingleton<OutputFactoryContract>(CliInteractionServiceId.OutputFactoryContract),
+            ),
+        );
+    }
+
+    static publishListCommand(this: void, container: ContainerContract): void {
+        container.setSingleton<ListCommand>(
+            CliServerServiceId.ListCommand,
+            new ListCommand(
+                container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract),
+                container.getSingleton<RouteContract>(CliRoutingServiceId.RouteContract),
+                container.getSingleton<RouteCollectionContract>(CliRoutingServiceId.RouteCollectionContract),
+                container.getSingleton<OutputFactoryContract>(CliInteractionServiceId.OutputFactoryContract),
+            ),
+        );
+    }
+
+    static publishVersionCommand(this: void, container: ContainerContract): void {
+        container.setSingleton<VersionCommand>(
+            CliServerServiceId.VersionCommand,
+            new VersionCommand(
+                container.getSingleton<OutputFactoryContract>(CliInteractionServiceId.OutputFactoryContract),
+                container.getSingleton<CliConfigContract>(ApplicationServiceId.CliConfigContract),
+                container.getSingleton<RouteContract>(CliRoutingServiceId.RouteContract),
+            ),
+        );
+    }
+
+    static publishLogThrowableCaughtMiddleware(this: void, container: ContainerContract): void {
+        container.setSingleton<LogThrowableCaughtMiddleware>(
+            CliServerServiceId.LogThrowableCaughtMiddleware,
+            new LogThrowableCaughtMiddleware(container.getSingleton<LoggerContract>(LoggerContractId)),
+        );
+    }
+
+    static publishOutputThrowableCaughtMiddleware(this: void, container: ContainerContract): void {
+        container.setSingleton<OutputThrowableCaughtMiddleware>(
+            CliServerServiceId.OutputThrowableCaughtMiddleware,
+            new OutputThrowableCaughtMiddleware(),
+        );
+    }
+
+    static publishCheckForHelpOptionsMiddleware(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<ConfigContract>(ApplicationServiceId.ConfigContract);
+        let commandName: string = CliCommandName.HELP;
+        let name: string = OptionName.HELP;
+        let shortName: string = OptionShortName.HELP;
+
+        if (CliServerServiceProvider.isHelpCommandConfig(config)) {
+            commandName = config.helpCommandName;
+            name = config.helpOptionName;
+            shortName = config.helpOptionShortName;
+        }
+
+        container.setSingleton<CheckForHelpOptionsMiddleware>(
+            CliServerServiceId.CheckForHelpOptionsMiddleware,
+            new CheckForHelpOptionsMiddleware(commandName, name, shortName),
+        );
+    }
+
+    static publishCheckForVersionOptionsMiddleware(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<ConfigContract>(ApplicationServiceId.ConfigContract);
+        let commandName: string = CliCommandName.VERSION;
+        let name: string = OptionName.VERSION;
+        let shortName: string = OptionShortName.VERSION;
+
+        if (CliServerServiceProvider.isVersionCommandConfig(config)) {
+            commandName = config.versionCommandName;
+            name = config.versionOptionName;
+            shortName = config.versionOptionShortName;
+        }
+
+        container.setSingleton<CheckForVersionOptionsMiddleware>(
+            CliServerServiceId.CheckForVersionOptionsMiddleware,
+            new CheckForVersionOptionsMiddleware(commandName, name, shortName),
+        );
+    }
+
+    static publishCheckGlobalInteractionOptionsMiddleware(this: void, container: ContainerContract): void {
+        const config = container.getSingleton<ConfigContract>(ApplicationServiceId.ConfigContract);
+
+        let noInteractionOptionName: string = OptionName.NO_INTERACTION;
+        let noInteractionOptionShortName: string = OptionShortName.NO_INTERACTION;
+        let quietOptionName: string = OptionName.QUIET;
+        let quietOptionShortName: string = OptionShortName.QUIET;
+        let silentOptionName: string = OptionName.SILENT;
+        let silentOptionShortName: string = OptionShortName.SILENT;
+
+        if (CliServerServiceProvider.isNoInteractionConfig(config)) {
+            noInteractionOptionName = config.noInteractionOptionName;
+            noInteractionOptionShortName = config.noInteractionOptionShortName;
+        }
+
+        if (CliServerServiceProvider.isQuietConfig(config)) {
+            quietOptionName = config.quietOptionName;
+            quietOptionShortName = config.quietOptionShortName;
+        }
+
+        if (CliServerServiceProvider.isSilentConfig(config)) {
+            silentOptionName = config.silentOptionName;
+            silentOptionShortName = config.silentOptionShortName;
+        }
+
+        container.setSingleton<CheckGlobalInteractionOptionsMiddleware>(
+            CliServerServiceId.CheckGlobalInteractionOptionsMiddleware,
+            new CheckGlobalInteractionOptionsMiddleware(
+                container.getSingleton<CliInteractionConfigContract>(
+                    CliInteractionServiceId.CliInteractionConfigContract,
+                ),
+                noInteractionOptionName,
+                noInteractionOptionShortName,
+                quietOptionName,
+                quietOptionShortName,
+                silentOptionName,
+                silentOptionShortName,
+            ),
+        );
+    }
+
+    static publishCheckCommandForTypoMiddleware(this: void, container: ContainerContract): void {
+        container.setSingleton<CheckCommandForTypoMiddleware>(
+            CliServerServiceId.CheckCommandForTypoMiddleware,
+            new CheckCommandForTypoMiddleware(
+                container.getSingleton<RouterContract>(CliRoutingServiceId.RouterContract),
+                container.getSingleton<RouteCollectionContract>(CliRoutingServiceId.RouteCollectionContract),
+            ),
+        );
+    }
+
+    protected static isHelpCommandConfig(
+        config: ConfigContract,
+    ): config is ConfigContract & CliHelpCommandConfigContract {
+        return 'helpCommandName' in config;
+    }
+
+    protected static isVersionCommandConfig(
+        config: ConfigContract,
+    ): config is ConfigContract & CliVersionCommandConfigContract {
+        return 'versionCommandName' in config;
+    }
+
+    protected static isNoInteractionConfig(
+        config: ConfigContract,
+    ): config is ConfigContract & CliNoInteractionConfigContract {
+        return 'noInteractionOptionName' in config;
+    }
+
+    protected static isQuietConfig(
+        config: ConfigContract,
+    ): config is ConfigContract & CliQuietInteractionConfigContract {
+        return 'quietOptionName' in config;
+    }
+
+    protected static isSilentConfig(
+        config: ConfigContract,
+    ): config is ConfigContract & CliSilentInteractionConfigContract {
+        return 'silentOptionName' in config;
+    }
+}

package/src/Valkyrja/Cli/Server/Support/Exiter.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.
+ */
+
+export class Exiter {
+    protected static shouldExit: boolean = true;
+
+    static freeze(): void {
+        Exiter.shouldExit = false;
+    }
+
+    static unfreeze(): void {
+        Exiter.shouldExit = true;
+    }
+
+    static exit(code: number = 0): void {
+        if (Exiter.shouldExit) {
+            process.exit(code);
+        } else {
+            Exiter.frozenCallback(code);
+        }
+    }
+
+    static frozenCallback(code: number = 0): void {
+        process.stdout.write(String(code));
+    }
+}

package/src/Valkyrja/Cli/Server/Throwable/Contract/CliServerThrowable.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 CliServerThrowable = CliThrowable;

package/src/Valkyrja/Cli/Server/Throwable/Exception/Abstract/CliServerInvalidArgumentException.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 { CliServerThrowable } from '../../Contract/CliServerThrowable.js';
+
+export abstract class CliServerInvalidArgumentException
+    extends CliInvalidArgumentException
+    implements CliServerThrowable {}

package/src/Valkyrja/Cli/Server/Throwable/Exception/Abstract/CliServerRuntimeException.ts

@@ -0,0 +1,14 @@
+/*
+ * 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 { CliRuntimeException } from '../../../../Throwable/Exception/Abstract/CliRuntimeException.js';
+
+import type { CliServerThrowable } from '../../Contract/CliServerThrowable.js';
+
+export abstract class CliServerRuntimeException extends CliRuntimeException implements CliServerThrowable {}

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

package/src/Valkyrja/Cli/Throwable/Exception/Abstract/CliInvalidArgumentException.ts

@@ -0,0 +1,14 @@
+/*
+ * 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 { ValkyrjaInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/ValkyrjaInvalidArgumentException.js';
+
+import type { CliThrowable } from '../../Contract/CliThrowable.js';
+
+export abstract class CliInvalidArgumentException extends ValkyrjaInvalidArgumentException implements CliThrowable {}

package/src/Valkyrja/Cli/Throwable/Exception/Abstract/CliRuntimeException.ts

@@ -0,0 +1,14 @@
+/*
+ * 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 { ValkyrjaRuntimeException } from '../../../../Throwable/Exception/Abstract/ValkyrjaRuntimeException.js';
+
+import type { CliThrowable } from '../../Contract/CliThrowable.js';
+
+export abstract class CliRuntimeException extends ValkyrjaRuntimeException implements CliThrowable {}

package/src/Valkyrja/Container/Constant/ContainerServiceId.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.
+ */
+
+export class ContainerServiceId {
+    static readonly Contract = 'Valkyrja.Container.Manager.ContainerContract' as const;
+    static readonly Data = 'Valkyrja.Container.Data.ContainerData' as const;
+}

package/src/Valkyrja/Container/Data/ContainerData.ts

@@ -0,0 +1,31 @@
+/*
+ * 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 { ContainerContract } from '../Manager/Contract/ContainerContract.js';
+
+export class ContainerData {
+    readonly aliases: Record<string, string>;
+    readonly deferredCallback: Record<string, (container: ContainerContract) => void>;
+    readonly services: Record<string, (container: ContainerContract, args?: unknown[]) => object>;
+    readonly singletons: Record<string, string>;
+
+    constructor(
+        data: {
+            aliases?: Record<string, string>;
+            deferredCallback?: Record<string, (container: ContainerContract) => void>;
+            services?: Record<string, (container: ContainerContract, args?: unknown[]) => object>;
+            singletons?: Record<string, string>;
+        } = {},
+    ) {
+        this.aliases = data.aliases ?? {};
+        this.deferredCallback = data.deferredCallback ?? {};
+        this.services = data.services ?? {};
+        this.singletons = data.singletons ?? {};
+    }
+}

package/src/Valkyrja/Container/Enum/InvalidReferenceMode.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.
+ */
+
+export enum InvalidReferenceMode {
+    NEW_INSTANCE_OR_THROW_EXCEPTION,
+    THROW_EXCEPTION,
+}

package/src/Valkyrja/Container/Manager/ChildContainer.ts

@@ -0,0 +1,69 @@
+/*
+ * 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.js';
+
+import type { ContainerData } from '../Data/ContainerData.js';
+import type { ContainerContract } from './Contract/ContainerContract.js';
+
+export class ChildContainer extends Container {
+    constructor(
+        protected parent: ContainerContract,
+        data: ContainerData,
+    ) {
+        super();
+
+        this.singletons = { ...data.singletons };
+        this.deferredCallback = { ...data.deferredCallback };
+    }
+
+    override isAlias(id: string): boolean {
+        return super.isAlias(id) || this.parent.isAlias(id);
+    }
+
+    override isService(id: string): boolean {
+        return super.isService(id) || this.parent.isService(id);
+    }
+
+    override isSingletonInstance(id: string): boolean {
+        return super.isSingletonInstance(id) || this.parent.isSingletonInstance(id);
+    }
+
+    override isDeferred(id: string): boolean {
+        return super.isDeferred(id) || this.parent.isDeferred(id);
+    }
+
+    override isPublished(id: string): boolean {
+        return super.isPublished(id) || this.parent.isPublished(id);
+    }
+
+    protected override getSingletonWithoutChecks<T extends object>(id: string): T | undefined {
+        if (!super.isSingletonInstance(id) && this.parent.isSingletonInstance(id)) {
+            return this.parent.getSingleton<T>(id);
+        }
+
+        return super.getSingletonWithoutChecks<T>(id);
+    }
+
+    protected override getServiceWithoutChecks<T extends object>(id: string, args: unknown[] = []): T | undefined {
+        if (!super.isService(id) && this.parent.isService(id)) {
+            return this.parent.getService<T>(id, args);
+        }
+
+        return super.getServiceWithoutChecks<T>(id, args);
+    }
+
+    protected override getAliasedWithoutChecks<T extends object>(id: string, args: unknown[] = []): T | undefined {
+        if (!super.isAlias(id) && this.parent.isAlias(id)) {
+            return this.parent.getAliased<T>(id, args);
+        }
+
+        return super.getAliasedWithoutChecks<T>(id, args);
+    }
+}