@valkyrjaio/valkyrja 26.0.0

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

@@ -0,0 +1,244 @@
+/*
+ * 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 { ContainerData } from '../Data/ContainerData.js';
+import { InvalidReferenceMode } from '../Enum/InvalidReferenceMode.js';
+import { ContainerInvalidReferenceException } from '../Throwable/Exception/ContainerInvalidReferenceException.js';
+import { ContainerInvalidPublishCallbackException } from '../Throwable/Exception/ContainerInvalidPublishCallbackException.js';
+
+import type { ServiceProviderContract } from '../Provider/Contract/ServiceProviderContract.js';
+import type { ContainerContract } from './Contract/ContainerContract.js';
+
+export class Container implements ContainerContract {
+    protected aliases: Record<string, string> = {};
+    protected instances: Record<string, object> = {};
+    protected services: Record<string, (container: ContainerContract, args?: unknown[]) => object> = {};
+    protected singletons: Record<string, string> = {};
+    protected deferredCallback: Record<string, (container: ContainerContract) => void> = {};
+    protected published: Record<string, boolean> = {};
+
+    constructor(data: ContainerData = new ContainerData()) {
+        this.aliases = { ...data.aliases };
+        this.deferredCallback = { ...data.deferredCallback };
+        this.services = { ...data.services };
+        this.singletons = { ...data.singletons };
+    }
+
+    getData(): ContainerData {
+        return new ContainerData({
+            aliases: { ...this.aliases },
+            deferredCallback: { ...this.deferredCallback },
+            services: { ...this.services },
+            singletons: { ...this.singletons },
+        });
+    }
+
+    setFromData(data: ContainerData): void {
+        this.aliases = { ...this.aliases, ...data.aliases };
+        this.deferredCallback = { ...this.deferredCallback, ...data.deferredCallback };
+        this.services = { ...this.services, ...data.services };
+        this.singletons = { ...this.singletons, ...data.singletons };
+    }
+
+    has(id: string): boolean {
+        return this.isDeferred(id) || this.isSingleton(id) || this.isService(id) || this.isAlias(id);
+    }
+
+    bind<T extends object>(id: string, factory: (container: ContainerContract, args?: unknown[]) => T): this {
+        this.services[id] = factory;
+        this.published[id] = true;
+
+        return this;
+    }
+
+    bindAlias(alias: string, id: string): this {
+        this.aliases[alias] = id;
+
+        return this;
+    }
+
+    bindSingleton<T extends object>(id: string, factory: (container: ContainerContract, args?: unknown[]) => T): this {
+        this.singletons[id] = id;
+        this.bind(id, factory);
+
+        return this;
+    }
+
+    setSingleton<T extends object>(id: string, singleton: T): this {
+        this.instances[id] = singleton;
+        this.published[id] = true;
+
+        return this;
+    }
+
+    isAlias(id: string): boolean {
+        return id in this.aliases;
+    }
+
+    isService(id: string): boolean {
+        return id in this.services;
+    }
+
+    isSingleton(id: string): boolean {
+        return this.isSingletonBinding(id) || this.isSingletonInstance(id);
+    }
+
+    isSingletonBinding(id: string): boolean {
+        return id in this.singletons;
+    }
+
+    isSingletonInstance(id: string): boolean {
+        return id in this.instances;
+    }
+
+    get<T extends object>(
+        id: string,
+        args: unknown[] = [],
+        mode: InvalidReferenceMode = InvalidReferenceMode.NEW_INSTANCE_OR_THROW_EXCEPTION,
+    ): T {
+        this.publishUnpublishedProvided(id);
+
+        return (
+            this.getSingletonWithoutChecks<T>(id) ??
+            this.getServiceWithoutChecks<T>(id, args) ??
+            this.getAliasedWithoutChecks<T>(id, args) ??
+            this.getFallback<T>(id, args, mode)
+        );
+    }
+
+    getAliased<T extends object>(id: string, args: unknown[] = []): T {
+        return (
+            this.getAliasedWithoutChecks<T>(id, args) ??
+            (() => {
+                throw new ContainerInvalidReferenceException(id);
+            })()
+        );
+    }
+
+    getService<T extends object>(id: string, args: unknown[] = []): T {
+        this.publishUnpublishedProvided(id);
+
+        return (
+            this.getServiceWithoutChecks<T>(id, args) ??
+            (() => {
+                throw new ContainerInvalidReferenceException(id);
+            })()
+        );
+    }
+
+    getSingleton<T extends object>(id: string): T {
+        this.publishUnpublishedProvided(id);
+
+        return (
+            this.getSingletonWithoutChecks<T>(id) ??
+            (() => {
+                throw new ContainerInvalidReferenceException(id);
+            })()
+        );
+    }
+
+    register(provider: ServiceProviderContract): void {
+        for (const [id, callback] of Object.entries(provider.publishers())) {
+            if (typeof callback !== 'function') {
+                throw new ContainerInvalidPublishCallbackException(`${id} should have a valid callable`);
+            }
+
+            this.deferredCallback[id] = callback;
+        }
+    }
+
+    isDeferred(id: string): boolean {
+        return id in this.deferredCallback;
+    }
+
+    isPublished(id: string): boolean {
+        return id in this.published;
+    }
+
+    publish(id: string): void {
+        const publishCallback = this.getDeferredCallback(id);
+
+        if (publishCallback === undefined) {
+            return;
+        }
+
+        publishCallback(this);
+        this.published[id] = true;
+    }
+
+    protected getAliasedWithoutChecks<T extends object>(id: string, args: unknown[] = []): T | undefined {
+        const aliased = this.getAlias(id);
+
+        if (aliased === undefined) {
+            return undefined;
+        }
+
+        return this.get<T>(aliased, args);
+    }
+
+    protected getSingletonWithoutChecks<T extends object>(id: string): T | undefined {
+        const instance = this.getSingletonInstance<T>(id);
+
+        if (instance !== undefined) {
+            return instance;
+        }
+
+        if (!this.isSingletonBinding(id)) {
+            return undefined;
+        }
+
+        const singleton = this.getServiceWithoutChecks<T>(id);
+
+        if (singleton !== undefined) {
+            this.instances[id] = singleton;
+        }
+
+        return singleton;
+    }
+
+    protected getServiceWithoutChecks<T extends object>(id: string, args: unknown[] = []): T | undefined {
+        const factory = this.getServiceCallable(id);
+
+        if (factory === undefined) {
+            return undefined;
+        }
+
+        return factory(this, args) as T;
+    }
+
+    protected getAlias(id: string): string | undefined {
+        return this.aliases[id];
+    }
+
+    protected getSingletonInstance<T extends object>(id: string): T | undefined {
+        return this.instances[id] as T | undefined;
+    }
+
+    protected getServiceCallable(id: string): ((container: ContainerContract, args?: unknown[]) => object) | undefined {
+        return this.services[id];
+    }
+
+    protected getDeferredCallback(id: string): ((container: ContainerContract) => void) | undefined {
+        return this.deferredCallback[id];
+    }
+
+    protected getFallback<T extends object>(
+        id: string,
+        _args: unknown[] = [],
+        _mode: InvalidReferenceMode = InvalidReferenceMode.NEW_INSTANCE_OR_THROW_EXCEPTION,
+    ): T {
+        throw new ContainerInvalidReferenceException(id);
+    }
+
+    protected publishUnpublishedProvided(id: string): void {
+        if (this.isDeferred(id) && !this.isPublished(id)) {
+            this.publish(id);
+        }
+    }
+}

package/src/Valkyrja/Container/Manager/Contract/ContainerContract.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 { ContainerData } from '../../Data/ContainerData.js';
+import type { InvalidReferenceMode } from '../../Enum/InvalidReferenceMode.js';
+import type { ProvidersAwareContract } from './ProvidersAwareContract.js';
+
+export interface ContainerContract extends ProvidersAwareContract {
+    getData(): ContainerData;
+    setFromData(data: ContainerData): void;
+    has(id: string): boolean;
+    bind<T extends object>(id: string, factory: (container: ContainerContract, args?: unknown[]) => T): this;
+    bindAlias(alias: string, id: string): this;
+    bindSingleton<T extends object>(id: string, factory: (container: ContainerContract, args?: unknown[]) => T): this;
+    setSingleton<T extends object>(id: string, singleton: T): this;
+    isAlias(id: string): boolean;
+    isService(id: string): boolean;
+    isSingleton(id: string): boolean;
+    isSingletonBinding(id: string): boolean;
+    isSingletonInstance(id: string): boolean;
+    get<T extends object>(id: string, args?: unknown[], mode?: InvalidReferenceMode): T;
+    getAliased<T extends object>(id: string, args?: unknown[]): T;
+    getService<T extends object>(id: string, args?: unknown[]): T;
+    getSingleton<T extends object>(id: string): T;
+}

package/src/Valkyrja/Container/Manager/Contract/ProvidersAwareContract.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 { ServiceProviderContract } from '../../Provider/Contract/ServiceProviderContract.js';
+
+export interface ProvidersAwareContract {
+    register(provider: ServiceProviderContract): void;
+    isDeferred(id: string): boolean;
+    isPublished(id: string): boolean;
+    publish(id: string): void;
+}

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

package/src/Valkyrja/Container/Provider/ContainerServiceProvider.ts

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ApplicationServiceId } from '../../Application/Constant/ApplicationServiceId.js';
+import { ContainerServiceId } from '../Constant/ContainerServiceId.js';
+
+import type { ApplicationContract } from '../../Application/Kernel/Contract/ApplicationContract.js';
+import type { ContainerContract } from '../Manager/Contract/ContainerContract.js';
+import type { ServiceProviderContract } from './Contract/ServiceProviderContract.js';
+
+export class ContainerServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [ContainerServiceId.Data]: ContainerServiceProvider.publishData,
+        };
+    }
+
+    static publishData(this: void, container: ContainerContract): void {
+        const app = container.getSingleton<ApplicationContract>(ApplicationServiceId.ApplicationContract);
+
+        for (const provider of app.getContainerProviders()) {
+            container.register(provider);
+        }
+
+        container.setSingleton(ContainerServiceId.Data, container.getData());
+    }
+}

package/src/Valkyrja/Container/Provider/Contract/ServiceProviderContract.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 { ContainerContract } from '../../Manager/Contract/ContainerContract.js';
+
+export interface ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void>;
+}
+
+export namespace ServiceProviderContract {
+    export function instanceOf(value: unknown): value is ServiceProviderContract {
+        return typeof value === 'object' && value !== null && 'publishers' in value;
+    }
+}

package/src/Valkyrja/Container/Throwable/Contract/ContainerThrowable.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 ContainerThrowable = ValkyrjaThrowable;

package/src/Valkyrja/Container/Throwable/Exception/Abstract/ContainerInvalidArgumentException.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 { ValkyrjaInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/ValkyrjaInvalidArgumentException.js';
+
+import { type ContainerThrowable } from '../../Contract/ContainerThrowable.js';
+
+export abstract class ContainerInvalidArgumentException
+    extends ValkyrjaInvalidArgumentException
+    implements ContainerThrowable {}

package/src/Valkyrja/Container/Throwable/Exception/Abstract/ContainerRuntimeException.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 ContainerThrowable } from '../../Contract/ContainerThrowable.js';
+
+export abstract class ContainerRuntimeException extends ValkyrjaRuntimeException implements ContainerThrowable {}

package/src/Valkyrja/Container/Throwable/Exception/ContainerInvalidPublishCallbackException.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 { ContainerRuntimeException } from './Abstract/ContainerRuntimeException.js';
+
+export class ContainerInvalidPublishCallbackException extends ContainerRuntimeException {}

package/src/Valkyrja/Container/Throwable/Exception/ContainerInvalidReferenceException.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 { ContainerInvalidArgumentException } from './Abstract/ContainerInvalidArgumentException.js';
+
+export class ContainerInvalidReferenceException extends ContainerInvalidArgumentException {
+    constructor(id: string, options?: ErrorOptions) {
+        super(`Service with \`${id}\` not found`, options);
+        this.name = 'ContainerInvalidReferenceException';
+    }
+}

package/src/Valkyrja/Event/Constant/EventServiceId.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.
+ */
+
+export class EventServiceId {
+    static readonly EventData = 'Valkyrja.Event.Data.EventData' as const;
+}

package/src/Valkyrja/Event/Data/Contract/ListenerContract.ts

@@ -0,0 +1,25 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+
+export interface ListenerContract {
+    getEventId(): string;
+    withEventId(eventId: string): ListenerContract;
+    getName(): string;
+    withName(name: string): ListenerContract;
+    getHandler(): (container: ContainerContract, args?: unknown[]) => unknown;
+    withHandler(handler: (container: ContainerContract, args?: unknown[]) => unknown): ListenerContract;
+}
+
+export namespace ListenerContract {
+    export function instanceOf(value: unknown): value is ListenerContract {
+        return typeof value === 'object' && value !== null && 'getEventId' in value;
+    }
+}

package/src/Valkyrja/Event/Data/EventData.ts

@@ -0,0 +1,15 @@
+/*
+ * 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 EventData {
+    constructor(
+        public readonly events: Record<string, string[]> = {},
+        public readonly listeners: Record<string, () => object> = {},
+    ) {}
+}

package/src/Valkyrja/Event/Provider/Contract/ListenerProviderContract.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 { ListenerContract } from '../../Data/Contract/ListenerContract.js';
+
+export interface ListenerProviderContract {
+    getListeners(): ListenerContract[];
+}
+
+export namespace ListenerProviderContract {
+    export function instanceOf(value: unknown): value is ListenerProviderContract {
+        return typeof value === 'object' && value !== null && 'getListeners' in value;
+    }
+}

package/src/Valkyrja/Http/Client/Manager/Contract/ClientContract.ts

@@ -0,0 +1,15 @@
+/*
+ * 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 { RequestContract } from '../../../Message/Request/Contract/RequestContract.js';
+import type { ResponseContract } from '../../../Message/Response/Contract/ResponseContract.js';
+
+export interface ClientContract {
+    sendRequest(request: RequestContract): ResponseContract;
+}

package/src/Valkyrja/Http/Client/Manager/LogClient.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 { LoggerContract } from '../../../Log/Logger/Contract/LoggerContract.js';
+import { EmptyResponse } from '../../Message/Response/EmptyResponse.js';
+import type { ClientContract } from './Contract/ClientContract.js';
+import type { RequestContract } from '../../Message/Request/Contract/RequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+
+export class LogClient implements ClientContract {
+    constructor(protected readonly logger: LoggerContract) {}
+
+    sendRequest(request: RequestContract): ResponseContract {
+        const optionsString = JSON.stringify(request);
+
+        this.logger.info(
+            `${LogClient.name} request: ${request.getMethod()}, uri ${request.getUri().toString()}, options ${optionsString}`,
+        );
+
+        return new EmptyResponse();
+    }
+}

package/src/Valkyrja/Http/Client/Manager/NullClient.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 { EmptyResponse } from '../../Message/Response/EmptyResponse.js';
+
+import type { RequestContract } from '../../Message/Request/Contract/RequestContract.js';
+import type { ResponseContract } from '../../Message/Response/Contract/ResponseContract.js';
+import type { ClientContract } from './Contract/ClientContract.js';
+
+export class NullClient implements ClientContract {
+    sendRequest(_request: RequestContract): ResponseContract {
+        return new EmptyResponse();
+    }
+}

package/src/Valkyrja/Http/Client/Throwable/Contract/HttpClientThrowable.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 { HttpThrowable } from '../../../Throwable/Contract/HttpThrowable.js';
+
+export type HttpClientThrowable = HttpThrowable;

package/src/Valkyrja/Http/Client/Throwable/Exception/Abstract/HttpClientInvalidArgumentException.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 { HttpInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/HttpInvalidArgumentException.js';
+
+import type { HttpClientThrowable } from '../../Contract/HttpClientThrowable.js';
+
+export abstract class HttpClientInvalidArgumentException
+    extends HttpInvalidArgumentException
+    implements HttpClientThrowable {}

package/src/Valkyrja/Http/Client/Throwable/Exception/Abstract/HttpClientRuntimeException.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 { HttpRuntimeException } from '../../../../Throwable/Exception/Abstract/HttpRuntimeException.js';
+
+import type { HttpClientThrowable } from '../../Contract/HttpClientThrowable.js';
+
+export abstract class HttpClientRuntimeException extends HttpRuntimeException implements HttpClientThrowable {}