@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Message/Response/JsonResponse.ts

@@ -0,0 +1,111 @@
+/*
+ * 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 { JsonResponseContract } from './Contract/JsonResponseContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import { Response } from './Response.js';
+import { Message } from '../Trait/Message.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { Header } from '../Header/Header.js';
+import { ContentType } from '../Header/ContentType.js';
+import { HeaderName } from '../Constant/HeaderName.js';
+import { ContentTypeValue } from '../Constant/ContentTypeValue.js';
+import { Stream } from '../Stream/Stream.js';
+import { StatusCode } from '../Enum/StatusCode.js';
+import { HttpRequestInvalidJsonCallbackException } from './Throwable/Exception/HttpRequestInvalidJsonCallbackException.js';
+
+export class JsonResponse extends Response implements JsonResponseContract {
+    protected data: Record<string, unknown>;
+
+    constructor(
+        data: Record<string, unknown> = {},
+        statusCode: StatusCode = StatusCode.OK,
+        headers: HeaderCollectionContract = new HeaderCollection(),
+    ) {
+        const body = new Stream();
+        body.write(JSON.stringify(data));
+        body.rewind();
+        super(
+            body,
+            statusCode,
+            Message.injectHeader(new Header(HeaderName.CONTENT_TYPE, ContentTypeValue.APPLICATION_JSON), headers, true),
+        );
+        this.data = data;
+    }
+
+    static createFromData(
+        data: Record<string, unknown> | null = null,
+        statusCode: StatusCode | null = null,
+        headers: HeaderCollectionContract | null = null,
+    ): JsonResponse {
+        return new this(data ?? {}, statusCode ?? StatusCode.OK, headers ?? new HeaderCollection());
+    }
+
+    getBodyAsJson(): Record<string, unknown> {
+        return JSON.parse(this.stream.getContents()) as Record<string, unknown>;
+    }
+
+    withJsonAsBody(data: Record<string, unknown>): this {
+        const body = new Stream();
+        body.write(JSON.stringify(data));
+        body.rewind();
+        return this.withBody(body);
+    }
+
+    withCallback(callback: string): this {
+        this.verifyCallback(callback);
+        const clone = this.withHeaders(this.headers.withHeader(new ContentType(ContentTypeValue.TEXT_JAVASCRIPT)));
+        clone.stream = new Stream();
+        clone.stream.write(`/**/${callback}(${this.stream.getContents()});`);
+        clone.stream.rewind();
+        return clone;
+    }
+
+    withoutCallback(): this {
+        const clone = this.withHeaders(this.headers.withHeader(new ContentType(ContentTypeValue.APPLICATION_JSON)));
+        clone.stream = new Stream();
+        clone.stream.write(JSON.stringify(clone.data));
+        clone.stream.rewind();
+        return clone;
+    }
+
+    createFromData(
+        data?: Record<string, unknown> | null,
+        statusCode?: StatusCode | null,
+        headers?: HeaderCollectionContract | null,
+    ): this {
+        return (this.constructor as typeof JsonResponse).createFromData(
+            data ?? null,
+            statusCode ?? null,
+            headers ?? null,
+        ) as this;
+    }
+
+    override create(
+        content?: string | null,
+        statusCode?: StatusCode | null,
+        headers?: HeaderCollectionContract | null,
+    ): this {
+        const data = content ? (JSON.parse(content) as Record<string, unknown>) : {};
+        return (this.constructor as typeof JsonResponse).createFromData(
+            data,
+            statusCode ?? null,
+            headers ?? null,
+        ) as this;
+    }
+
+    protected verifyCallback(callback: string): void {
+        const pattern = /^[$_\p{L}][$_\p{L}\p{Mn}\p{Mc}\p{Nd}\p{Pc}‌‍]*$/u;
+        for (const part of callback.split('.')) {
+            if (!pattern.test(part)) {
+                throw new HttpRequestInvalidJsonCallbackException('The callback name is not valid.');
+            }
+        }
+    }
+}

package/src/Valkyrja/Http/Message/Response/RedirectResponse.ts

@@ -0,0 +1,101 @@
+/*
+ * 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 { RedirectResponseContract } from './Contract/RedirectResponseContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import type { ServerRequestContract } from '../Request/Contract/ServerRequestContract.js';
+import type { UriContract } from '../Uri/Contract/UriContract.js';
+import { Response } from './Response.js';
+import { Message } from '../Trait/Message.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { Location } from '../Header/Location.js';
+import { Uri } from '../Uri/Uri.js';
+import { UriFactory } from '../Uri/Factory/UriFactory.js';
+import { Stream } from '../Stream/Stream.js';
+import { Scheme } from '../Uri/Enum/Scheme.js';
+import { StatusCode, statusCodeIsRedirect } from '../Enum/StatusCode.js';
+import { HttpRequestInvalidRedirectStatusCodeException } from './Throwable/Exception/HttpRequestInvalidRedirectStatusCodeException.js';
+
+export class RedirectResponse extends Response implements RedirectResponseContract {
+    protected uri: UriContract;
+
+    constructor(
+        uri: UriContract = new Uri(Scheme.EMPTY, '', '', '', 0, '/'),
+        statusCode: StatusCode = StatusCode.FOUND,
+        headers: HeaderCollectionContract = new HeaderCollection(),
+    ) {
+        if (!statusCodeIsRedirect(statusCode)) {
+            throw new HttpRequestInvalidRedirectStatusCodeException(
+                `Invalid redirect status code ${String(statusCode)} used.`,
+            );
+        }
+        super(new Stream(), statusCode, Message.injectHeader(RedirectResponse.getHeaderFromUri(uri), headers, true));
+        this.uri = uri;
+    }
+
+    static createFromUri(
+        uri: UriContract | null = null,
+        statusCode: StatusCode | null = null,
+        headers: HeaderCollectionContract | null = null,
+    ): RedirectResponse {
+        return new this(
+            uri ?? new Uri(Scheme.EMPTY, '', '', '', 0, '/'),
+            statusCode ?? StatusCode.FOUND,
+            headers ?? new HeaderCollection(),
+        );
+    }
+
+    getUri(): UriContract {
+        return this.uri;
+    }
+
+    withUri(uri: UriContract): this {
+        const headers = this.headers.withHeader(RedirectResponse.getHeaderFromUri(uri));
+        const clone = this.withHeaders(headers);
+        clone.uri = uri;
+        return clone;
+    }
+
+    secure(path: string, request: ServerRequestContract): this {
+        const requestUri = request.getUri();
+        const uri = new Uri(Scheme.HTTPS, '', '', requestUri.getHost(), requestUri.getPort(), path);
+        return this.withUri(uri);
+    }
+
+    back(request: ServerRequestContract): this {
+        const refererLine = request.getHeaders().getHeaderLine('Referer') || '/';
+        const refererUri = UriFactory.fromString(refererLine);
+        const resolved = this.isInternalUri(request, refererUri)
+            ? refererUri
+            : new Uri(Scheme.EMPTY, '', '', '', 0, '/');
+        return this.withUri(resolved);
+    }
+
+    createFromUri(
+        uri?: UriContract | null,
+        statusCode?: StatusCode | null,
+        headers?: HeaderCollectionContract | null,
+    ): this {
+        return (this.constructor as typeof RedirectResponse).createFromUri(
+            uri ?? null,
+            statusCode ?? null,
+            headers ?? null,
+        ) as this;
+    }
+
+    protected isInternalUri(request: ServerRequestContract, uri: UriContract): boolean {
+        const host = uri.getHost();
+        return !host || host === request.getUri().getHost();
+    }
+
+    protected static getHeaderFromUri(uri: UriContract): Location {
+        const uriString = uri.toString() || '/';
+        return new Location(uriString);
+    }
+}

package/src/Valkyrja/Http/Message/Response/Response.ts

@@ -0,0 +1,81 @@
+/*
+ * 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 { ResponseContract } from './Contract/ResponseContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import type { StreamContract } from '../Stream/Contract/StreamContract.js';
+import type { CookieContract } from '../Header/Value/Contract/CookieContract.js';
+import { Message } from '../Trait/Message.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { SetCookie } from '../Header/SetCookie.js';
+import { Stream } from '../Stream/Stream.js';
+import { StatusCode, statusCodeAsPhrase } from '../Enum/StatusCode.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Response extends Message implements ResponseContract {
+    protected statusPhrase: string;
+
+    constructor(
+        body: StreamContract = new Stream(),
+        protected statusCode: StatusCode = StatusCode.OK,
+        protected override headers: HeaderCollectionContract = new HeaderCollection(),
+    ) {
+        super();
+        this.statusPhrase = statusCodeAsPhrase(statusCode).toString();
+        this.setBody(body);
+    }
+
+    static create(
+        content: string | null = null,
+        statusCode: StatusCode | null = null,
+        headers: HeaderCollectionContract | null = null,
+    ): Response {
+        const stream = new Stream();
+        stream.write(content ?? '');
+        stream.rewind();
+        return new this(stream, statusCode ?? StatusCode.OK, headers ?? new HeaderCollection());
+    }
+
+    getStatusCode(): StatusCode {
+        return this.statusCode;
+    }
+
+    withStatusCode(code: StatusCode): this {
+        const clone = ObjectFactory.clone(this);
+        clone.statusCode = code;
+        clone.statusPhrase = statusCodeAsPhrase(code).toString();
+        return clone;
+    }
+
+    getReasonPhrase(): string {
+        return this.statusPhrase;
+    }
+
+    withReasonPhrase(reasonPhrase: string): this {
+        const clone = ObjectFactory.clone(this);
+        clone.statusPhrase = reasonPhrase || statusCodeAsPhrase(this.statusCode).toString();
+        return clone;
+    }
+
+    withCookie(cookie: CookieContract): this {
+        return this.withHeaders(this.headers.withAddedHeaders(new SetCookie(cookie)));
+    }
+
+    withoutCookie(cookie: CookieContract): this {
+        return this.withHeaders(this.headers.withAddedHeaders(new SetCookie(cookie.delete())));
+    }
+
+    create(content?: string | null, statusCode?: StatusCode | null, headers?: HeaderCollectionContract | null): this {
+        return (this.constructor as typeof Response).create(
+            content ?? null,
+            statusCode ?? null,
+            headers ?? null,
+        ) as this;
+    }
+}

package/src/Valkyrja/Http/Message/Response/TextResponse.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 { TextResponseContract } from './Contract/TextResponseContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import { Response } from './Response.js';
+import { Message } from '../Trait/Message.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { Header } from '../Header/Header.js';
+import { HeaderName } from '../Constant/HeaderName.js';
+import { ContentTypeValue } from '../Constant/ContentTypeValue.js';
+import { Stream } from '../Stream/Stream.js';
+import { StatusCode } from '../Enum/StatusCode.js';
+
+export class TextResponse extends Response implements TextResponseContract {
+    constructor(
+        text: string = '',
+        statusCode: StatusCode = StatusCode.OK,
+        headers: HeaderCollectionContract = new HeaderCollection(),
+    ) {
+        const body = new Stream();
+        body.write(text);
+        body.rewind();
+        super(
+            body,
+            statusCode,
+            Message.injectHeader(new Header(HeaderName.CONTENT_TYPE, ContentTypeValue.TEXT_PLAIN_UTF8), headers, true),
+        );
+    }
+
+    static override create(
+        content: string | null = null,
+        statusCode: StatusCode | null = null,
+        headers: HeaderCollectionContract | null = null,
+    ): TextResponse {
+        return new this(content ?? '', statusCode ?? StatusCode.OK, headers ?? new HeaderCollection());
+    }
+}

package/src/Valkyrja/Http/Message/Response/Throwable/Contract/HttpResponseThrowable.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 { HttpMessageThrowable } from '../../../Throwable/Contract/HttpMessageThrowable.js';
+
+export type HttpResponseThrowable = HttpMessageThrowable;

package/src/Valkyrja/Http/Message/Response/Throwable/Exception/Abstract/HttpResponseInvalidArgumentException.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 { HttpResponseThrowable } from '../../Contract/HttpResponseThrowable.js';
+import { HttpMessageInvalidArgumentException } from '../../../../Throwable/Exception/Abstract/HttpMessageInvalidArgumentException.js';
+
+export abstract class HttpResponseInvalidArgumentException
+    extends HttpMessageInvalidArgumentException
+    implements HttpResponseThrowable {}

package/src/Valkyrja/Http/Message/Response/Throwable/Exception/Abstract/HttpResponseRuntimeException.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 { HttpResponseThrowable } from '../../Contract/HttpResponseThrowable.js';
+import { HttpMessageRuntimeException } from '../../../../Throwable/Exception/Abstract/HttpMessageRuntimeException.js';
+
+export abstract class HttpResponseRuntimeException
+    extends HttpMessageRuntimeException
+    implements HttpResponseThrowable {}

package/src/Valkyrja/Http/Message/Response/Throwable/Exception/HttpRequestInvalidJsonCallbackException.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 { HttpResponseInvalidArgumentException } from './Abstract/HttpResponseInvalidArgumentException.js';
+
+export class HttpRequestInvalidJsonCallbackException extends HttpResponseInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Response/Throwable/Exception/HttpRequestInvalidRedirectStatusCodeException.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 { HttpResponseInvalidArgumentException } from './Abstract/HttpResponseInvalidArgumentException.js';
+
+export class HttpRequestInvalidRedirectStatusCodeException extends HttpResponseInvalidArgumentException {}

package/src/Valkyrja/Http/Message/Response/XmlResponse.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 { HtmlResponseContract } from './Contract/HtmlResponseContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import { Response } from './Response.js';
+import { Message } from '../Trait/Message.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { Header } from '../Header/Header.js';
+import { HeaderName } from '../Constant/HeaderName.js';
+import { ContentTypeValue } from '../Constant/ContentTypeValue.js';
+import { Stream } from '../Stream/Stream.js';
+import { StatusCode } from '../Enum/StatusCode.js';
+
+export class XmlResponse extends Response implements HtmlResponseContract {
+    constructor(
+        xml: string = '',
+        statusCode: StatusCode = StatusCode.OK,
+        headers: HeaderCollectionContract = new HeaderCollection(),
+    ) {
+        const body = new Stream();
+        body.write(xml);
+        body.rewind();
+        super(
+            body,
+            statusCode,
+            Message.injectHeader(
+                new Header(HeaderName.CONTENT_TYPE, ContentTypeValue.APPLICATION_XML_UTF8),
+                headers,
+                true,
+            ),
+        );
+    }
+}

package/src/Valkyrja/Http/Message/Stream/Contract/StreamContract.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 StreamContract {
+    toString(): string;
+    close(): void;
+    detach(): Buffer | null;
+    getSize(): number;
+    tell(): number;
+    eof(): boolean;
+    isSeekable(): boolean;
+    seek(offset: number, whence?: number): void;
+    rewind(): void;
+    isWritable(): boolean;
+    write(string: string): number;
+    isReadable(): boolean;
+    read(length: number): string;
+    getContents(): string;
+    getMetadata(): Record<string, unknown>;
+    getMetadataItem(key: string): unknown;
+}

package/src/Valkyrja/Http/Message/Stream/Enum/Mode.ts

@@ -0,0 +1,47 @@
+/*
+ * 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 Mode {
+    READ = 'r',
+    READ_WRITE = 'r+',
+    WRITE = 'w',
+    WRITE_READ = 'w+',
+    WRITE_END = 'a',
+    WRITE_READ_END = 'a+',
+    CREATE_WRITE = 'x',
+    CREATE_WRITE_READ = 'x+',
+    WRITE_CREATE = 'c',
+    WRITE_READ_CREATE = 'c+',
+    CLOSE_ON_EXEC = 'e',
+}
+
+export function modeIsReadable(mode: Mode): boolean {
+    return [
+        Mode.READ,
+        Mode.READ_WRITE,
+        Mode.WRITE_READ,
+        Mode.WRITE_READ_END,
+        Mode.CREATE_WRITE_READ,
+        Mode.WRITE_READ_CREATE,
+    ].includes(mode);
+}
+
+export function modeIsWritable(mode: Mode): boolean {
+    return [
+        Mode.READ_WRITE,
+        Mode.WRITE,
+        Mode.WRITE_READ,
+        Mode.WRITE_END,
+        Mode.WRITE_READ_END,
+        Mode.CREATE_WRITE,
+        Mode.CREATE_WRITE_READ,
+        Mode.WRITE_CREATE,
+        Mode.WRITE_READ_CREATE,
+    ].includes(mode);
+}

package/src/Valkyrja/Http/Message/Stream/Enum/ModeTranslation.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.
+ */
+
+export enum ModeTranslation {
+    NONE = '',
+    WINDOWS = 't',
+    BINARY_SAFE = 'b',
+}

package/src/Valkyrja/Http/Message/Stream/Factory/StreamFactory.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 { StreamContract } from '../Contract/StreamContract.js';
+import { HttpStreamStreamReadException } from '../Throwable/Exception/HttpStreamStreamReadException.js';
+import { HttpStreamStreamSeekException } from '../Throwable/Exception/HttpStreamStreamSeekException.js';
+import { HttpStreamStreamTellException } from '../Throwable/Exception/HttpStreamStreamTellException.js';
+import { HttpStreamStreamWriteException } from '../Throwable/Exception/HttpStreamStreamWriteException.js';
+import { HttpStreamUnreadableStreamException } from '../Throwable/Exception/HttpStreamUnreadableStreamException.js';
+import { HttpStreamUnseekableStreamException } from '../Throwable/Exception/HttpStreamUnseekableStreamException.js';
+import { HttpStreamUnwritableStreamException } from '../Throwable/Exception/HttpStreamUnwritableStreamException.js';
+
+export abstract class StreamFactory {
+    static isModeWriteable(mode: string): boolean {
+        return (
+            mode.includes('x') || mode.includes('w') || mode.includes('c') || mode.includes('a') || mode.includes('+')
+        );
+    }
+
+    static isModeReadable(mode: string): boolean {
+        return mode.includes('r') || mode.includes('+');
+    }
+
+    static toString(stream: StreamContract): string {
+        if (!stream.isReadable()) {
+            return '';
+        }
+        try {
+            stream.rewind();
+            return stream.getContents();
+        } catch {
+            return '';
+        }
+    }
+
+    static verifyWritable(stream: StreamContract): void {
+        if (!stream.isWritable()) {
+            throw new HttpStreamUnwritableStreamException('Stream is not writable');
+        }
+    }
+
+    static verifyWriteResult(result: number | false): asserts result is number {
+        if (result === false) {
+            throw new HttpStreamStreamWriteException('Error writing to stream');
+        }
+    }
+
+    static verifySeekable(stream: StreamContract): void {
+        if (!stream.isSeekable()) {
+            throw new HttpStreamUnseekableStreamException('Stream is not seekable');
+        }
+    }
+
+    static verifySeekResult(result: number): void {
+        if (result !== 0) {
+            throw new HttpStreamStreamSeekException('Error seeking within stream');
+        }
+    }
+
+    static verifyReadable(stream: StreamContract): void {
+        if (!stream.isReadable()) {
+            throw new HttpStreamUnreadableStreamException('Stream is not readable');
+        }
+    }
+
+    static verifyReadResult(result: string | false): asserts result is string {
+        if (result === false) {
+            throw new HttpStreamStreamReadException('Error reading stream');
+        }
+    }
+
+    static verifyTellResult(result: number | false): asserts result is number {
+        if (result === false) {
+            throw new HttpStreamStreamTellException('Error occurred during tell operation');
+        }
+    }
+}