@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Application/Entry/Abstract/App.ts

@@ -0,0 +1,117 @@
+/*
+ * 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 { Valkyrja } from '../../Kernel/Valkyrja.js';
+import { Directory } from '../../Directory/Directory.js';
+import { Config } from '../../Data/Config.js';
+import { ContainerServiceProvider } from '../../../Container/Provider/ContainerServiceProvider.js';
+import { Container } from '../../../Container/Manager/Container.js';
+import { ApplicationServiceId } from '../../Constant/ApplicationServiceId.js';
+import { ContainerServiceId } from '../../../Container/Constant/ContainerServiceId.js';
+import { ThrowableServiceId } from '../../../Throwable/Constant/ThrowableServiceId.js';
+
+import type { ApplicationContract } from '../../Kernel/Contract/ApplicationContract.js';
+import type { ConfigContract } from '../../Data/Contract/ConfigContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ContainerData } from '../../../Container/Data/ContainerData.js';
+import type { ThrowableHandlerContract } from '../../../Throwable/Handler/Contract/ThrowableHandlerContract.js';
+
+let appStartTime: number | undefined;
+
+export abstract class App {
+    static start(config: ConfigContract = new Config()): ApplicationContract {
+        if (config.debugMode) {
+            this.defaultExceptionHandler();
+        }
+
+        this.appStart();
+        this.directory(config.dir);
+
+        return this.app(config);
+    }
+
+    static appStart(): void {
+        if (appStartTime === undefined) {
+            appStartTime = performance.now();
+        }
+    }
+
+    static directory(dir: string): void {
+        Directory.basePath = dir;
+    }
+
+    static app(config: ConfigContract = new Config()): ApplicationContract {
+        const container = this.getContainer();
+        const app = this.getApplication(container, config);
+
+        this.bootstrapServices(app, container, config);
+
+        return app;
+    }
+
+    static getApplication(container: ContainerContract, config: ConfigContract = new Config()): ApplicationContract {
+        return new Valkyrja(container, config);
+    }
+
+    static bootstrapServices(app: ApplicationContract, container: ContainerContract, config: ConfigContract): void {
+        container.setSingleton(ApplicationServiceId.ConfigContract, config);
+        container.setSingleton(ApplicationServiceId.Config, config);
+
+        const concreteConfigId = (config.constructor as { id?: string }).id;
+
+        if (concreteConfigId !== undefined && concreteConfigId !== ApplicationServiceId.Config) {
+            container.setSingleton(concreteConfigId, config);
+        }
+
+        container.setSingleton(ContainerServiceId.Contract, container);
+        container.setSingleton(ApplicationServiceId.ApplicationContract, app);
+
+        app.publishProviderCallbacks();
+
+        this.loadContainerData(container);
+    }
+
+    static loadContainerData(container: ContainerContract): void {
+        if (!container.isSingleton(ContainerServiceId.Data)) {
+            this.publishContainerData(container);
+        }
+
+        const containerData = container.getSingleton<ContainerData>(ContainerServiceId.Data);
+
+        container.setFromData(containerData);
+    }
+
+    static publishContainerData(container: ContainerContract): void {
+        ContainerServiceProvider.publishData(container);
+    }
+
+    static defaultExceptionHandler(): void {
+        // Override to register a throwable handler for debug mode.
+    }
+
+    static bootstrapThrowableHandler(app: ApplicationContract, container: ContainerContract): void {
+        if (app.getDebugMode()) {
+            const errorHandler = this.getThrowableHandler();
+
+            container.setSingleton(ThrowableServiceId.HandlerContract, errorHandler);
+
+            (errorHandler.constructor as { enable?: (opts: { displayErrors: boolean }) => void }).enable?.({
+                displayErrors: true,
+            });
+        }
+    }
+
+    static getThrowableHandler(): ThrowableHandlerContract {
+        return { enable: () => {} };
+    }
+
+    static getContainer(): ContainerContract {
+        return new Container();
+    }
+}

package/src/Valkyrja/Application/Entry/Abstract/WorkerHttp.ts

@@ -0,0 +1,83 @@
+/*
+ * 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 { IncomingMessage, ServerResponse } from 'node:http';
+
+import { ChildApplication } from '../../Kernel/ChildApplication.js';
+import { ChildContainer } from '../../../Container/Manager/ChildContainer.js';
+import { ApplicationServiceId } from '../../Constant/ApplicationServiceId.js';
+import { ContainerServiceId } from '../../../Container/Constant/ContainerServiceId.js';
+import { HttpServerServiceId } from '../../../Http/Server/Constant/HttpServerServiceId.js';
+import { HttpRoutingServiceId } from '../../../Http/Routing/Constant/HttpRoutingServiceId.js';
+import { RequestFactory } from '../../../Http/Message/Request/Factory/RequestFactory.js';
+import { App } from './App.js';
+
+import type { ApplicationContract } from '../../Kernel/Contract/ApplicationContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ContainerData } from '../../../Container/Data/ContainerData.js';
+import type { HttpConfigContract } from '../../Data/Contract/HttpConfigContract.js';
+import type { ServerRequestContract } from '../../../Http/Message/Request/Contract/ServerRequestContract.js';
+import type { RequestHandlerContract } from '../../../Http/Server/Handler/Contract/RequestHandlerContract.js';
+import type { RouteCollectionContract } from '../../../Http/Routing/Collection/Contract/RouteCollectionContract.js';
+
+export abstract class WorkerHttp extends App {
+    static bootstrap(config: HttpConfigContract): ApplicationContract {
+        const app = this.start(config);
+        const container = app.getContainer();
+
+        this.bootstrapThrowableHandler(app, container);
+        this.bootstrapParentServices(app);
+
+        return app;
+    }
+
+    static handle(
+        app: ApplicationContract,
+        data: ContainerData,
+        nodeRequest: IncomingMessage,
+        nodeResponse: ServerResponse,
+    ): void {
+        const request = this.getRequest(nodeRequest);
+        const childContainer = this.getChildContainer(app, data);
+        const childApp = this.getChildApplication(app, childContainer);
+
+        this.bootstrapChildContainer(childApp, childContainer);
+        this.handleRequest(childContainer, request, nodeResponse);
+    }
+
+    static getChildApplication(app: ApplicationContract, container: ContainerContract): ApplicationContract {
+        return new ChildApplication(app, container);
+    }
+
+    static getChildContainer(app: ApplicationContract, data: ContainerData): ContainerContract {
+        return new ChildContainer(app.getContainer(), data);
+    }
+
+    static bootstrapChildContainer(app: ApplicationContract, container: ContainerContract): void {
+        container.setSingleton(ApplicationServiceId.ApplicationContract, app);
+        container.setSingleton(ContainerServiceId.Contract, container);
+    }
+
+    static handleRequest(
+        container: ContainerContract,
+        request: ServerRequestContract,
+        nodeResponse: ServerResponse,
+    ): void {
+        const handler = container.getSingleton<RequestHandlerContract>(HttpServerServiceId.RequestHandlerContract);
+        handler.run(request, nodeResponse);
+    }
+
+    static getRequest(nodeRequest: IncomingMessage): ServerRequestContract {
+        return RequestFactory.fromNodeRequest(nodeRequest);
+    }
+
+    static bootstrapParentServices(app: ApplicationContract): void {
+        app.getContainer().getSingleton<RouteCollectionContract>(HttpRoutingServiceId.RouteCollectionContract);
+    }
+}

package/src/Valkyrja/Application/Entry/Cli.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 { App } from './Abstract/App.js';
+import { InputFactory } from '../../Cli/Interaction/Input/Factory/InputFactory.js';
+import { CliServerServiceId } from '../../Cli/Server/Constant/CliServerServiceId.js';
+
+import type { CliConfigContract } from '../Data/Contract/CliConfigContract.js';
+import type { InputContract } from '../../Cli/Interaction/Input/Contract/InputContract.js';
+import type { InputHandlerContract } from '../../Cli/Server/Handler/Contract/InputHandlerContract.js';
+
+export class Cli extends App {
+    static run(config: CliConfigContract): void {
+        const app = this.start(config);
+        const container = app.getContainer();
+
+        this.bootstrapThrowableHandler(app, container);
+
+        const handler = container.getSingleton<InputHandlerContract>(CliServerServiceId.InputHandlerContract);
+        const input = this.getInput(config);
+
+        handler.run(input);
+    }
+
+    static getInput(config: CliConfigContract): InputContract {
+        return InputFactory.fromGlobals(process.argv, config.applicationName, config.defaultCommandName);
+    }
+}

package/src/Valkyrja/Application/Entry/Http.ts

@@ -0,0 +1,41 @@
+/*
+ * 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 { createServer } from 'node:http';
+import type { IncomingMessage } from 'node:http';
+
+import { App } from './Abstract/App.js';
+import { HttpServerServiceId } from '../../Http/Server/Constant/HttpServerServiceId.js';
+import { RequestFactory } from '../../Http/Message/Request/Factory/RequestFactory.js';
+
+import type { HttpConfigContract } from '../Data/Contract/HttpConfigContract.js';
+import type { ServerRequestContract } from '../../Http/Message/Request/Contract/ServerRequestContract.js';
+import type { RequestHandlerContract } from '../../Http/Server/Handler/Contract/RequestHandlerContract.js';
+
+export class Http extends App {
+    static run(config: HttpConfigContract, port: number = 3000): void {
+        const app = this.start(config);
+        const container = app.getContainer();
+
+        this.bootstrapThrowableHandler(app, container);
+
+        const handler = container.getSingleton<RequestHandlerContract>(HttpServerServiceId.RequestHandlerContract);
+
+        const server = createServer((req, res) => {
+            const request = this.getRequest(req);
+            handler.run(request, res);
+        });
+
+        server.listen(port);
+    }
+
+    static getRequest(nodeRequest: IncomingMessage): ServerRequestContract {
+        return RequestFactory.fromNodeRequest(nodeRequest);
+    }
+}

package/src/Valkyrja/Application/Kernel/ChildApplication.ts

@@ -0,0 +1,63 @@
+/*
+ * 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 { ApplicationContract } from './Contract/ApplicationContract.js';
+import type { ComponentProviderContract } from '../Provider/Contract/ComponentProviderContract.js';
+import type { ContainerContract } from '../../Container/Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from '../../Container/Provider/Contract/ServiceProviderContract.js';
+import type { ListenerProviderContract } from '../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { CliRouteProviderContract } from '../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { HttpRouteProviderContract } from '../../Http/Routing/Provider/Contract/HttpRouteProviderContract.js';
+
+export class ChildApplication implements ApplicationContract {
+    constructor(
+        protected readonly parent: ApplicationContract,
+        protected readonly container: ContainerContract,
+    ) {}
+
+    getContainer(): ContainerContract {
+        return this.container;
+    }
+
+    publishProviderCallbacks(): void {
+        this.parent.publishProviderCallbacks();
+    }
+
+    getProviders(): ComponentProviderContract[] {
+        return this.parent.getProviders();
+    }
+
+    getContainerProviders(): ServiceProviderContract[] {
+        return this.parent.getContainerProviders();
+    }
+
+    getEventProviders(): ListenerProviderContract[] {
+        return this.parent.getEventProviders();
+    }
+
+    getCliProviders(): CliRouteProviderContract[] {
+        return this.parent.getCliProviders();
+    }
+
+    getHttpProviders(): HttpRouteProviderContract[] {
+        return this.parent.getHttpProviders();
+    }
+
+    getDebugMode(): boolean {
+        return this.parent.getDebugMode();
+    }
+
+    getEnvironment(): string {
+        return this.parent.getEnvironment();
+    }
+
+    getVersion(): string {
+        return this.parent.getVersion();
+    }
+}

package/src/Valkyrja/Application/Kernel/Contract/ApplicationContract.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 { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { HttpRouteProviderContract } from '../../../Http/Routing/Provider/Contract/HttpRouteProviderContract.js';
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+import type { ComponentProviderContract } from '../../Provider/Contract/ComponentProviderContract.js';
+
+export interface ApplicationContract {
+    getContainer(): ContainerContract;
+    publishProviderCallbacks(): void;
+    getProviders(): ComponentProviderContract[];
+    getContainerProviders(): ServiceProviderContract[];
+    getEventProviders(): ListenerProviderContract[];
+    getCliProviders(): CliRouteProviderContract[];
+    getHttpProviders(): HttpRouteProviderContract[];
+    getDebugMode(): boolean;
+    getEnvironment(): string;
+    getVersion(): string;
+}
+
+export namespace ApplicationContract {
+    export function instanceOf(value: unknown): value is ApplicationContract {
+        return typeof value === 'object' && value !== null && 'getContainer' in value;
+    }
+}

package/src/Valkyrja/Application/Kernel/Valkyrja.ts

@@ -0,0 +1,141 @@
+/*
+ * 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 { Config } from '../Data/Config.js';
+
+import type { ApplicationContract } from './Contract/ApplicationContract.js';
+import type { ConfigContract } from '../Data/Contract/ConfigContract.js';
+import type { ComponentProviderContract } from '../Provider/Contract/ComponentProviderContract.js';
+import type { ContainerContract } from '../../Container/Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from '../../Container/Provider/Contract/ServiceProviderContract.js';
+import type { ListenerProviderContract } from '../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { CliRouteProviderContract } from '../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { HttpRouteProviderContract } from '../../Http/Routing/Provider/Contract/HttpRouteProviderContract.js';
+
+export class Valkyrja implements ApplicationContract {
+    protected providers: ComponentProviderContract[] = [];
+    protected serviceProviders: ServiceProviderContract[] = [];
+    protected eventProviders: ListenerProviderContract[] = [];
+    protected cliRouteProviders: CliRouteProviderContract[] = [];
+    protected httpRouteProviders: HttpRouteProviderContract[] = [];
+
+    constructor(
+        protected readonly container: ContainerContract,
+        protected readonly config: ConfigContract = new Config(),
+    ) {
+        this.bootstrapTimezone();
+    }
+
+    getContainer(): ContainerContract {
+        return this.container;
+    }
+
+    publishProviderCallbacks(): void {
+        for (const callback of this.config.callbacks) {
+            callback(this);
+        }
+    }
+
+    getProviders(): ComponentProviderContract[] {
+        if (this.providers.length > 0) {
+            return this.providers;
+        }
+
+        const providers: ComponentProviderContract[][] = [];
+
+        for (const provider of this.config.providers) {
+            providers.push(provider.getComponentProviders(this));
+            providers.push([provider]);
+        }
+
+        this.providers = [...new Set(providers.flat())];
+
+        return this.providers;
+    }
+
+    getContainerProviders(): ServiceProviderContract[] {
+        if (this.serviceProviders.length > 0) {
+            return this.serviceProviders;
+        }
+
+        const providers: ServiceProviderContract[][] = [];
+
+        for (const provider of this.getProviders()) {
+            providers.push(provider.getContainerProviders(this));
+        }
+
+        this.serviceProviders = [...new Set(providers.flat())];
+
+        return this.serviceProviders;
+    }
+
+    getEventProviders(): ListenerProviderContract[] {
+        if (this.eventProviders.length > 0) {
+            return this.eventProviders;
+        }
+
+        const providers: ListenerProviderContract[][] = [];
+
+        for (const provider of this.getProviders()) {
+            providers.push(provider.getEventProviders(this));
+        }
+
+        this.eventProviders = [...new Set(providers.flat())];
+
+        return this.eventProviders;
+    }
+
+    getCliProviders(): CliRouteProviderContract[] {
+        if (this.cliRouteProviders.length > 0) {
+            return this.cliRouteProviders;
+        }
+
+        const providers: CliRouteProviderContract[][] = [];
+
+        for (const provider of this.getProviders()) {
+            providers.push(provider.getCliProviders(this));
+        }
+
+        this.cliRouteProviders = [...new Set(providers.flat())];
+
+        return this.cliRouteProviders;
+    }
+
+    getHttpProviders(): HttpRouteProviderContract[] {
+        if (this.httpRouteProviders.length > 0) {
+            return this.httpRouteProviders;
+        }
+
+        const providers: HttpRouteProviderContract[][] = [];
+
+        for (const provider of this.getProviders()) {
+            providers.push(provider.getHttpProviders(this));
+        }
+
+        this.httpRouteProviders = [...new Set(providers.flat())];
+
+        return this.httpRouteProviders;
+    }
+
+    getDebugMode(): boolean {
+        return this.config.debugMode;
+    }
+
+    getEnvironment(): string {
+        return this.config.environment;
+    }
+
+    getVersion(): string {
+        return this.config.version;
+    }
+
+    protected bootstrapTimezone(): void {
+        process.env['TZ'] = this.config.timezone;
+    }
+}

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

package/src/Valkyrja/Application/Provider/CliApplicationComponentProvider.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 { ContainerComponentProvider } from '../../Container/Provider/ContainerComponentProvider.js';
+import { CliInteractionComponentProvider } from '../../Cli/Interaction/Provider/CliInteractionComponentProvider.js';
+import { CliMiddlewareComponentProvider } from '../../Cli/Middleware/Provider/CliMiddlewareComponentProvider.js';
+import { CliRoutingComponentProvider } from '../../Cli/Routing/Provider/CliRoutingComponentProvider.js';
+import { CliServerComponentProvider } from '../../Cli/Server/Provider/CliServerComponentProvider.js';
+import { ApplicationComponentProvider } from './ApplicationComponentProvider.js';
+
+import type { ApplicationContract } from '../Kernel/Contract/ApplicationContract.js';
+import type { ComponentProviderContract } from './Contract/ComponentProviderContract.js';
+
+export class CliApplicationComponentProvider extends ApplicationComponentProvider {
+    override getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [
+            new ContainerComponentProvider(),
+            new CliInteractionComponentProvider(),
+            new CliMiddlewareComponentProvider(),
+            new CliRoutingComponentProvider(),
+            new CliServerComponentProvider(),
+        ];
+    }
+}

package/src/Valkyrja/Application/Provider/CliWithHttpApplicationComponentProvider.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 { ContainerComponentProvider } from '../../Container/Provider/ContainerComponentProvider.js';
+import { CliInteractionComponentProvider } from '../../Cli/Interaction/Provider/CliInteractionComponentProvider.js';
+import { CliMiddlewareComponentProvider } from '../../Cli/Middleware/Provider/CliMiddlewareComponentProvider.js';
+import { CliRoutingComponentProvider } from '../../Cli/Routing/Provider/CliRoutingComponentProvider.js';
+import { CliServerComponentProvider } from '../../Cli/Server/Provider/CliServerComponentProvider.js';
+import { HttpRoutingCliComponentProvider } from '../../Http/Routing/Provider/HttpRoutingCliComponentProvider.js';
+import { ApplicationComponentProvider } from './ApplicationComponentProvider.js';
+
+import type { ApplicationContract } from '../Kernel/Contract/ApplicationContract.js';
+import type { ComponentProviderContract } from './Contract/ComponentProviderContract.js';
+
+export class CliWithHttpApplicationComponentProvider extends ApplicationComponentProvider {
+    override getComponentProviders(_app: ApplicationContract): ComponentProviderContract[] {
+        return [
+            new ContainerComponentProvider(),
+            new CliInteractionComponentProvider(),
+            new CliMiddlewareComponentProvider(),
+            new CliRoutingComponentProvider(),
+            new CliServerComponentProvider(),
+            new HttpRoutingCliComponentProvider(),
+        ];
+    }
+}

package/src/Valkyrja/Application/Provider/Contract/ComponentProviderContract.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.
+ */
+
+import type { CliRouteProviderContract } from '../../../Cli/Routing/Provider/Contract/CliRouteProviderContract.js';
+import type { ListenerProviderContract } from '../../../Event/Provider/Contract/ListenerProviderContract.js';
+import type { HttpRouteProviderContract } from '../../../Http/Routing/Provider/Contract/HttpRouteProviderContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+import type { ApplicationContract } from '../../Kernel/Contract/ApplicationContract.js';
+
+export interface ComponentProviderContract {
+    getComponentProviders(app: ApplicationContract): ComponentProviderContract[];
+    getContainerProviders(app: ApplicationContract): ServiceProviderContract[];
+    getEventProviders(app: ApplicationContract): ListenerProviderContract[];
+    getCliProviders(app: ApplicationContract): CliRouteProviderContract[];
+    getHttpProviders(app: ApplicationContract): HttpRouteProviderContract[];
+}
+
+export namespace ComponentProviderContract {
+    export function instanceOf(value: unknown): value is ComponentProviderContract {
+        return typeof value === 'object' && value !== null && 'getComponentProviders' in value;
+    }
+}

package/src/Valkyrja/Application/Provider/Contract/PublishableComponentProviderContract.ts

@@ -0,0 +1,20 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ApplicationContract } from '../../Kernel/Contract/ApplicationContract.js';
+
+export interface PublishableComponentProviderContract {
+    publish(app: ApplicationContract): void;
+}
+
+export namespace PublishableComponentProviderContract {
+    export function instanceOf(value: unknown): value is PublishableComponentProviderContract {
+        return typeof value === 'object' && value !== null && 'publish' in value;
+    }
+}