@valkyrjaio/valkyrja 26.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/Valkyrja/Http/Message/File/Throwable/Exception/UploadedFileUploadErrorException.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { UploadErrorExceptionMessage } from '../../Constant/UploadErrorExceptionMessage.js';
+import { UploadError } from '../../Enum/UploadError.js';
+import type { UploadedFileThrowable } from '../Contract/UploadedFileThrowable.js';
+import { UploadedFileInvalidUploadErrorException } from './UploadedFileInvalidUploadErrorException.js';
+import { UploadedFileRuntimeException } from './Abstract/UploadedFileRuntimeException.js';
+
+export class UploadedFileUploadErrorException extends UploadedFileRuntimeException {
+    constructor(uploadError: UploadError, _code: number = 0, _previous: UploadedFileThrowable | null = null) {
+        let message: string;
+
+        switch (uploadError) {
+            case UploadError.FORM_SIZE:
+                message = UploadErrorExceptionMessage.FORM_SIZE_MESSAGE;
+                break;
+            case UploadError.INI_SIZE:
+                message = UploadErrorExceptionMessage.INI_SIZE_MESSAGE;
+                break;
+            case UploadError.PARTIAL:
+                message = UploadErrorExceptionMessage.PARTIAL_MESSAGE;
+                break;
+            case UploadError.NO_FILE:
+                message = UploadErrorExceptionMessage.NO_FILE_MESSAGE;
+                break;
+            case UploadError.NO_TMP_DIR:
+                message = UploadErrorExceptionMessage.NO_TMP_DIR_MESSAGE;
+                break;
+            case UploadError.CANT_WRITE:
+                message = UploadErrorExceptionMessage.CANT_WRITE_MESSAGE;
+                break;
+            case UploadError.EXTENSION:
+                message = UploadErrorExceptionMessage.EXTENSION_MESSAGE;
+                break;
+            case UploadError.OK:
+                throw new UploadedFileInvalidUploadErrorException(UploadErrorExceptionMessage.OK_MESSAGE);
+        }
+
+        super(message);
+    }
+}

package/src/Valkyrja/Http/Message/File/UploadedFile.ts

@@ -0,0 +1,156 @@
+/*
+ * 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 { rename, copyFile, unlink, access, constants } from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+import { dirname } from 'node:path';
+import type { UploadedFileContract } from './Contract/UploadedFileContract.js';
+import type { StreamContract } from '../Stream/Contract/StreamContract.js';
+import { Stream } from '../Stream/Stream.js';
+import { UploadedFileAlreadyMovedException } from './Throwable/Exception/UploadedFileAlreadyMovedException.js';
+import { UploadedFileInvalidDirectoryException } from './Throwable/Exception/UploadedFileInvalidDirectoryException.js';
+import { UploadedFileInvalidUploadedFileException } from './Throwable/Exception/UploadedFileInvalidUploadedFileException.js';
+import { UploadedFileMoveFailureException } from './Throwable/Exception/UploadedFileMoveFailureException.js';
+import { UploadedFileUnableToWriteFileException } from './Throwable/Exception/UploadedFileUnableToWriteFileException.js';
+
+export class UploadedFile implements UploadedFileContract {
+    protected hasBeenMoved: boolean = false;
+
+    constructor(
+        protected file: string | null = null,
+        protected stream: StreamContract | null = null,
+        protected uploadError: Error | null = null,
+        protected size: number = 0,
+        protected fileName: string = '',
+        protected mediaType: string = '',
+    ) {
+        if (uploadError === null && file === null && stream === null) {
+            throw new UploadedFileInvalidUploadedFileException('One of file or stream are required');
+        }
+    }
+
+    getStream(): StreamContract {
+        this.validateNoUploadError();
+        this.validateHasNotBeenMoved('Cannot retrieve stream after it has already been moved');
+
+        if (this.stream !== null) {
+            return this.stream;
+        }
+
+        if (this.file === null) {
+            throw new UploadedFileInvalidUploadedFileException('One of file or stream are required');
+        }
+
+        this.stream = new Stream(this.file);
+        return this.stream;
+    }
+
+    async moveTo(targetPath: string): Promise<void> {
+        this.validateNoUploadError();
+        this.validateHasNotBeenMoved();
+
+        const targetDir = dirname(targetPath);
+        await this.validateTargetDirectory(targetDir);
+
+        if (this.file === null || this.file === '') {
+            await this.moveViaStream(targetPath);
+        } else {
+            await this.moveViaFs(targetPath);
+        }
+
+        this.hasBeenMoved = true;
+    }
+
+    hasSize(): boolean {
+        return this.size !== 0;
+    }
+
+    getSize(): number {
+        return this.size;
+    }
+
+    getError(): Error | null {
+        return this.uploadError;
+    }
+
+    hasClientFilename(): boolean {
+        return this.fileName !== '';
+    }
+
+    getClientFilename(): string {
+        return this.fileName;
+    }
+
+    hasClientMediaType(): boolean {
+        return this.mediaType !== '';
+    }
+
+    getClientMediaType(): string {
+        return this.mediaType;
+    }
+
+    protected validateNoUploadError(): void {
+        if (this.uploadError !== null) {
+            throw this.uploadError;
+        }
+    }
+
+    protected validateHasNotBeenMoved(message?: string): void {
+        if (this.hasBeenMoved) {
+            throw new UploadedFileAlreadyMovedException(message ?? 'Cannot move file after it has already been moved');
+        }
+    }
+
+    protected async validateTargetDirectory(dir: string): Promise<void> {
+        try {
+            await access(dir, constants.W_OK);
+        } catch {
+            throw new UploadedFileInvalidDirectoryException(
+                `The target directory \`${dir}\` does not exist or is not writable`,
+            );
+        }
+    }
+
+    protected async moveViaStream(targetPath: string): Promise<void> {
+        const stream = this.getStream();
+        stream.rewind();
+
+        await new Promise<void>((resolve, reject) => {
+            const writer = createWriteStream(targetPath);
+            writer.on('error', () => {
+                reject(new UploadedFileUnableToWriteFileException('Unable to write to designated path'));
+            });
+            writer.on('finish', resolve);
+
+            while (!stream.eof()) {
+                writer.write(stream.read(4096));
+            }
+
+            writer.end();
+        });
+
+        this.stream?.close();
+    }
+
+    protected async moveViaFs(targetPath: string): Promise<void> {
+        if (this.file === null) {
+            throw new UploadedFileInvalidUploadedFileException('No file path available');
+        }
+        try {
+            await rename(this.file, targetPath);
+        } catch {
+            try {
+                await copyFile(this.file, targetPath);
+                await unlink(this.file);
+            } catch {
+                throw new UploadedFileMoveFailureException('Error occurred while moving uploaded file');
+            }
+        }
+    }
+}

package/src/Valkyrja/Http/Message/Header/Collection/Contract/HeaderCollectionContract.ts

@@ -0,0 +1,23 @@
+/*
+ * 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 { HeaderContract } from '../../Contract/HeaderContract.js';
+
+export interface HeaderCollectionContract {
+    has(name: string): boolean;
+    get(name: string): HeaderContract;
+    getHeaderLine(name: string): string;
+    getAll(): Record<string, HeaderContract>;
+    getOnly(...names: string[]): Record<string, HeaderContract>;
+    getAllExcept(...names: string[]): Record<string, HeaderContract>;
+    withHeader(header: HeaderContract): this;
+    withoutHeader(name: string): this;
+    withHeaders(...headers: HeaderContract[]): this;
+    withAddedHeaders(...headers: HeaderContract[]): this;
+}

package/src/Valkyrja/Http/Message/Header/Collection/HeaderCollection.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 type { HeaderCollectionContract } from './Contract/HeaderCollectionContract.js';
+import type { HeaderContract } from '../Contract/HeaderContract.js';
+import { HttpHeaderInvalidHeaderNameException } from '../Throwable/Exception/HttpHeaderInvalidHeaderNameException.js';
+import { HttpHeaderInvalidHeaderParamException } from '../Throwable/Exception/HttpHeaderInvalidHeaderParamException.js';
+import { ObjectFactory } from '../../../../Type/Object/Factory/ObjectFactory.js';
+
+export class HeaderCollection implements HeaderCollectionContract {
+    protected headers: Record<string, HeaderContract> = {};
+
+    constructor(...headers: HeaderContract[]) {
+        this.setHeaders(...headers);
+    }
+
+    static fromArray(data: Record<string, unknown>): HeaderCollection {
+        const headers: HeaderContract[] = [];
+        for (const param of Object.values(data)) {
+            HeaderCollection.validateHeader(param);
+            headers.push(param);
+        }
+        return new HeaderCollection(...headers);
+    }
+
+    protected static validateHeader(param: unknown): asserts param is HeaderContract {
+        if (param === null || typeof param !== 'object' || !('getName' in param)) {
+            throw new HttpHeaderInvalidHeaderParamException('Param must be header');
+        }
+    }
+
+    has(name: string): boolean {
+        return name.toLowerCase() in this.headers;
+    }
+
+    get(name: string): HeaderContract {
+        const header = this.headers[name.toLowerCase()];
+        if (header === undefined) {
+            throw new HttpHeaderInvalidHeaderNameException(`Header ${name} does not exist`);
+        }
+        return header;
+    }
+
+    getHeaderLine(name: string): string {
+        return this.has(name) ? this.get(name).getHeaderLine() : '';
+    }
+
+    getAll(): Record<string, HeaderContract> {
+        return { ...this.headers };
+    }
+
+    getOnly(...names: string[]): Record<string, HeaderContract> {
+        const lower = names.map((n) => n.toLowerCase());
+        const result: Record<string, HeaderContract> = {};
+        for (const [k, v] of Object.entries(this.headers)) {
+            if (lower.includes(k)) {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+
+    getAllExcept(...names: string[]): Record<string, HeaderContract> {
+        const lower = names.map((n) => n.toLowerCase());
+        const result: Record<string, HeaderContract> = {};
+        for (const [k, v] of Object.entries(this.headers)) {
+            if (!lower.includes(k)) {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+
+    withHeader(header: HeaderContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.headers = { ...this.headers };
+        clone.headers[header.getNormalizedName()] = header;
+        return clone;
+    }
+
+    withoutHeader(name: string): this {
+        const clone = ObjectFactory.clone(this);
+        const { [name.toLowerCase()]: _removed, ...rest } = this.headers;
+        clone.headers = rest;
+        return clone;
+    }
+
+    withHeaders(...headers: HeaderContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.headers = {};
+        this.setHeadersOnCollection(clone, ...headers);
+        return clone;
+    }
+
+    withAddedHeaders(...headers: HeaderContract[]): this {
+        const clone = ObjectFactory.clone(this);
+        clone.headers = { ...this.headers };
+        this.setHeadersOnCollection(clone, ...headers);
+        return clone;
+    }
+
+    protected setHeaders(...headers: HeaderContract[]): void {
+        this.setHeadersOnCollection(this, ...headers);
+    }
+
+    protected setHeadersOnCollection(collection: this, ...headers: HeaderContract[]): void {
+        for (const header of headers) {
+            collection.headers[header.getNormalizedName()] = header;
+        }
+    }
+}

package/src/Valkyrja/Http/Message/Header/ContentType.ts

@@ -0,0 +1,18 @@
+/*
+ * 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 { ValueContract } from './Value/Contract/ValueContract.js';
+import { Header } from './Header.js';
+import { HeaderName } from '../Constant/HeaderName.js';
+
+export class ContentType extends Header {
+    constructor(...values: Array<ValueContract | string>) {
+        super(HeaderName.CONTENT_TYPE, ...values);
+    }
+}

package/src/Valkyrja/Http/Message/Header/Contract/HeaderContract.ts

@@ -0,0 +1,21 @@
+/*
+ * 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 { ValueContract } from '../Value/Contract/ValueContract.js';
+
+export interface HeaderContract {
+    getName(): string;
+    getNormalizedName(): string;
+    withName(name: string): this;
+    getValues(): Array<ValueContract | string>;
+    withValues(...values: Array<ValueContract | string>): this;
+    withAddedValues(...values: Array<ValueContract | string>): this;
+    getHeaderLine(): string;
+    toString(): string;
+}

package/src/Valkyrja/Http/Message/Header/Factory/CookieFactory.ts

@@ -0,0 +1,35 @@
+/*
+ * 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 abstract class CookieFactory {
+    static parseCookieHeader(cookieHeader: string): Record<string, string> {
+        const cookies: Record<string, string> = {};
+        const pattern =
+            /(?:^[\n]?[ \t]*|;[ ])(?<name>[!#$%&'*+\-.0-9A-Z^_`a-z|~]+)=(?<DQUOTE>"?)(?<value>[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*)(?<DQCLOSE>"?)(?=[\n]?[ \t]*$|;[ ])/g;
+        let match: RegExpExecArray | null;
+        while ((match = pattern.exec(cookieHeader)) !== null) {
+            const name = match.groups?.['name'] ?? '';
+            const value = match.groups?.['value'] ?? '';
+            if (name !== '') {
+                cookies[name] = decodeURIComponent(value);
+            }
+        }
+        return cookies;
+    }
+
+    static convertCookieArrayToHeaderString(cookies: Record<string, string>): string {
+        return Object.entries(cookies)
+            .map(([key, value]) => CookieFactory.combineKeyAndValue(key, value))
+            .join('; ');
+    }
+
+    static combineKeyAndValue(key: string, value: string): string {
+        return `${key}=${value}`;
+    }
+}