create-phoenixjs 0.1.0

package/template/framework/http/Request.ts

@@ -0,0 +1,608 @@
+/**
+ * PhoenixJS - Request Wrapper
+ * 
+ * Wraps the native Bun Request with helpful methods.
+ * Inspired by Laravel's Request class.
+ */
+
+import { UploadedFile } from '@framework/http/UploadedFile';
+
+export class FrameworkRequest {
+	private request: Request;
+	private parsedUrl: URL;
+	private queryParams: URLSearchParams;
+	private pathParams: Record<string, string> = {};
+	private parsedBody: unknown = null;
+	private bodyParsed = false;
+	private bodyText: string | null = null;
+	private bodyTextParsed = false;
+	private parsedCookies: Record<string, string> | null = null;
+	private parsedFiles: Map<string, UploadedFile[]> | null = null;
+
+	constructor(request: Request) {
+		this.request = request;
+		this.parsedUrl = new URL(request.url);
+		this.queryParams = this.parsedUrl.searchParams;
+	}
+
+	// ==========================================
+	// Basic Request Information
+	// ==========================================
+
+	/**
+	 * Get the original Request object
+	 */
+	getOriginal(): Request {
+		return this.request;
+	}
+
+	/**
+	 * Get the request method
+	 */
+	method(): string {
+		return this.request.method;
+	}
+
+	/**
+	 * Get the full URL
+	 */
+	url(): string {
+		return this.request.url;
+	}
+
+	/**
+	 * Get the pathname
+	 */
+	path(): string {
+		return this.parsedUrl.pathname;
+	}
+
+	/**
+	 * Get the hostname
+	 */
+	host(): string {
+		return this.parsedUrl.host;
+	}
+
+	/**
+	 * Get the protocol (http or https)
+	 */
+	protocol(): string {
+		return this.parsedUrl.protocol.replace(':', '');
+	}
+
+	/**
+	 * Check if the request is secure (HTTPS)
+	 */
+	secure(): boolean {
+		return this.parsedUrl.protocol === 'https:';
+	}
+
+	// ==========================================
+	// Query Parameters
+	// ==========================================
+
+	/**
+	 * Get all query parameters
+	 */
+	query(): Record<string, string> {
+		const result: Record<string, string> = {};
+		this.queryParams.forEach((value, key) => {
+			result[key] = value;
+		});
+		return result;
+	}
+
+	/**
+	 * Get a specific query parameter
+	 */
+	queryParam(key: string, defaultValue?: string): string | undefined {
+		return this.queryParams.get(key) ?? defaultValue;
+	}
+
+	// ==========================================
+	// Path Parameters
+	// ==========================================
+
+	/**
+	 * Set path parameters (used by router)
+	 */
+	setParams(params: Record<string, string>): void {
+		this.pathParams = params;
+	}
+
+	/**
+	 * Get all path parameters
+	 */
+	params(): Record<string, string> {
+		return { ...this.pathParams };
+	}
+
+	/**
+	 * Get a specific path parameter
+	 */
+	param(key: string, defaultValue?: string): string | undefined {
+		return this.pathParams[key] ?? defaultValue;
+	}
+
+	// ==========================================
+	// Headers
+	// ==========================================
+
+	/**
+	 * Get request headers
+	 */
+	headers(): Headers {
+		return this.request.headers;
+	}
+
+	/**
+	 * Get a specific header
+	 */
+	header(name: string, defaultValue?: string): string | undefined {
+		return this.request.headers.get(name) ?? defaultValue;
+	}
+
+	/**
+	 * Check if a header exists
+	 */
+	hasHeader(name: string): boolean {
+		return this.request.headers.has(name);
+	}
+
+	// ==========================================
+	// Body Parsing
+	// ==========================================
+
+	/**
+	 * Parse and return the request body as JSON
+	 */
+	async json<T = unknown>(): Promise<T> {
+		if (!this.bodyParsed) {
+			try {
+				const text = await this.text();
+				this.parsedBody = JSON.parse(text);
+			} catch {
+				this.parsedBody = null;
+			}
+			this.bodyParsed = true;
+		}
+		return this.parsedBody as T;
+	}
+
+	/**
+	 * Get the request body as text
+	 */
+	async text(): Promise<string> {
+		if (!this.bodyTextParsed) {
+			this.bodyText = await this.request.text();
+			this.bodyTextParsed = true;
+		}
+		return this.bodyText ?? '';
+	}
+
+	/**
+	 * Get the request body as FormData
+	 */
+	async formData() {
+		return this.request.formData();
+	}
+
+	// ==========================================
+	// Input Methods (Laravel-like)
+	// ==========================================
+
+	/**
+	 * Get all input (query + body merged)
+	 * Body parameters override query parameters
+	 */
+	async all(): Promise<Record<string, unknown>> {
+		const queryData = this.query();
+		const bodyData = await this.json<Record<string, unknown>>() ?? {};
+		return { ...queryData, ...bodyData };
+	}
+
+	/**
+	 * Get an input value from query or body
+	 * If no key is provided, returns all input
+	 */
+	async input<T = unknown>(key?: string, defaultValue?: T): Promise<T | Record<string, unknown>> {
+		const allInput = await this.all();
+
+		if (key === undefined) {
+			return allInput;
+		}
+
+		// Support dot notation for nested values
+		const value = this.getNestedValue(allInput, key);
+		return (value !== undefined ? value : defaultValue) as T;
+	}
+
+	/**
+	 * Check if input has given key(s)
+	 */
+	async has(...keys: string[]): Promise<boolean> {
+		const allInput = await this.all();
+		return keys.every(key => this.getNestedValue(allInput, key) !== undefined);
+	}
+
+	/**
+	 * Check if input has non-empty value for given key(s)
+	 */
+	async filled(...keys: string[]): Promise<boolean> {
+		const allInput = await this.all();
+		return keys.every(key => {
+			const value = this.getNestedValue(allInput, key);
+			return value !== undefined && value !== null && value !== '';
+		});
+	}
+
+	/**
+	 * Check if any of the given keys are missing
+	 */
+	async missing(...keys: string[]): Promise<boolean> {
+		return !(await this.has(...keys));
+	}
+
+	/**
+	 * Get only specified keys from input
+	 */
+	async only(...keys: string[]): Promise<Record<string, unknown>> {
+		const allInput = await this.all();
+		const result: Record<string, unknown> = {};
+
+		for (const key of keys) {
+			const value = this.getNestedValue(allInput, key);
+			if (value !== undefined) {
+				result[key] = value;
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Get all input except specified keys
+	 */
+	async except(...keys: string[]): Promise<Record<string, unknown>> {
+		const allInput = await this.all();
+		const result: Record<string, unknown> = { ...allInput };
+
+		for (const key of keys) {
+			delete result[key];
+		}
+
+		return result;
+	}
+
+	/**
+	 * Get nested value using dot notation
+	 */
+	private getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+		const keys = path.split('.');
+		let current: unknown = obj;
+
+		for (const key of keys) {
+			if (current === null || current === undefined || typeof current !== 'object') {
+				return undefined;
+			}
+			current = (current as Record<string, unknown>)[key];
+		}
+
+		return current;
+	}
+
+	// ==========================================
+	// Authentication Helpers
+	// ==========================================
+
+	/**
+	 * Get the Bearer token from Authorization header
+	 */
+	bearerToken(): string | null {
+		const auth = this.header('authorization');
+		if (!auth || !auth.toLowerCase().startsWith('bearer ')) {
+			return null;
+		}
+		return auth.substring(7).trim();
+	}
+
+	/**
+	 * Get Basic auth credentials
+	 */
+	basicCredentials(): { username: string; password: string } | null {
+		const auth = this.header('authorization');
+		if (!auth || !auth.toLowerCase().startsWith('basic ')) {
+			return null;
+		}
+
+		try {
+			const decoded = Buffer.from(auth.substring(6), 'base64').toString('utf-8');
+			const [username, password] = decoded.split(':');
+			return { username, password };
+		} catch {
+			return null;
+		}
+	}
+
+	// ==========================================
+	// Client Information
+	// ==========================================
+
+	/**
+	 * Get the client IP address
+	 */
+	ip(): string | null {
+		// Check common proxy headers first
+		const xForwardedFor = this.header('x-forwarded-for');
+		if (xForwardedFor) {
+			return xForwardedFor.split(',')[0].trim();
+		}
+
+		const xRealIp = this.header('x-real-ip');
+		if (xRealIp) {
+			return xRealIp;
+		}
+
+		// CF-Connecting-IP for Cloudflare
+		const cfConnectingIp = this.header('cf-connecting-ip');
+		if (cfConnectingIp) {
+			return cfConnectingIp;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get all possible IP addresses
+	 */
+	ips(): string[] {
+		const xForwardedFor = this.header('x-forwarded-for');
+		if (xForwardedFor) {
+			return xForwardedFor.split(',').map(ip => ip.trim());
+		}
+
+		const ip = this.ip();
+		return ip ? [ip] : [];
+	}
+
+	/**
+	 * Get the User-Agent header
+	 */
+	userAgent(): string | null {
+		return this.header('user-agent') ?? null;
+	}
+
+	/**
+	 * Get the referer URL
+	 */
+	referer(): string | null {
+		return this.header('referer') ?? this.header('referrer') ?? null;
+	}
+
+	// ==========================================
+	// Route Matching
+	// ==========================================
+
+	/**
+	 * Check if the path matches a pattern
+	 * Supports wildcards: /users/* matches /users/123
+	 */
+	is(pattern: string): boolean {
+		const path = this.path();
+		const regexPattern = pattern
+			.replace(/\*/g, '.*')
+			.replace(/\//g, '\\/');
+		const regex = new RegExp(`^${regexPattern}$`);
+		return regex.test(path);
+	}
+
+	/**
+	 * Check if the HTTP method matches
+	 */
+	isMethod(method: string | string[]): boolean {
+		const currentMethod = this.method().toUpperCase();
+		if (Array.isArray(method)) {
+			return method.some(m => m.toUpperCase() === currentMethod);
+		}
+		return method.toUpperCase() === currentMethod;
+	}
+
+	// ==========================================
+	// Content Type Detection
+	// ==========================================
+
+	/**
+	 * Check if the request expects JSON
+	 */
+	expectsJson(): boolean {
+		const accept = this.header('accept', '');
+		return accept !== undefined && accept.includes('application/json');
+	}
+
+	/**
+	 * Check if the request content is JSON
+	 */
+	isJson(): boolean {
+		const contentType = this.header('content-type', '');
+		return contentType !== undefined && contentType.includes('application/json');
+	}
+
+	/**
+	 * Check if request is form data
+	 */
+	isFormData(): boolean {
+		const contentType = this.contentType() ?? '';
+		return contentType.includes('multipart/form-data') ||
+			contentType.includes('application/x-www-form-urlencoded');
+	}
+
+	/**
+	 * Get the content type
+	 */
+	contentType(): string | undefined {
+		return this.header('content-type');
+	}
+
+	/**
+	 * Check if request wants HTML
+	 */
+	wantsHtml(): boolean {
+		const accept = this.header('accept', '');
+		return accept !== undefined && accept.includes('text/html');
+	}
+
+	// ==========================================
+	// Cookies
+	// ==========================================
+
+	/**
+	 * Get all cookies
+	 */
+	cookies(): Record<string, string> {
+		if (this.parsedCookies === null) {
+			this.parsedCookies = this.parseCookieHeader();
+		}
+		return { ...this.parsedCookies };
+	}
+
+	/**
+	 * Get a specific cookie
+	 */
+	cookie(name: string, defaultValue?: string): string | undefined {
+		const cookies = this.cookies();
+		return cookies[name] ?? defaultValue;
+	}
+
+	/**
+	 * Check if a cookie exists
+	 */
+	hasCookie(name: string): boolean {
+		return this.cookie(name) !== undefined;
+	}
+
+	/**
+	 * Parse the Cookie header
+	 */
+	private parseCookieHeader(): Record<string, string> {
+		const cookieHeader = this.header('cookie');
+		if (!cookieHeader) {
+			return {};
+		}
+
+		const cookies: Record<string, string> = {};
+		const pairs = cookieHeader.split(';');
+
+		for (const pair of pairs) {
+			const [name, ...valueParts] = pair.split('=');
+			if (name) {
+				const trimmedName = name.trim();
+				const value = valueParts.join('=').trim();
+				// Decode URI encoded values
+				try {
+					cookies[trimmedName] = decodeURIComponent(value);
+				} catch {
+					cookies[trimmedName] = value;
+				}
+			}
+		}
+
+		return cookies;
+	}
+
+	// ==========================================
+	// File Uploads
+	// ==========================================
+
+	/**
+	 * Get an uploaded file by name
+	 */
+	async file(name: string): Promise<UploadedFile | null> {
+		const files = await this.files();
+		const fileList = files.get(name);
+		return fileList && fileList.length > 0 ? fileList[0] : null;
+	}
+
+	/**
+	 * Get all uploaded files
+	 */
+	async files(): Promise<Map<string, UploadedFile[]>> {
+		if (this.parsedFiles !== null) {
+			return this.parsedFiles;
+		}
+
+		this.parsedFiles = new Map();
+
+		if (!this.isFormData()) {
+			return this.parsedFiles;
+		}
+
+		try {
+			const formData = await this.request.formData();
+
+			for (const [key, value] of formData.entries()) {
+				if (value instanceof File) {
+					const arrayBuffer = await value.arrayBuffer();
+					const uploadedFile = new UploadedFile({
+						name: key,
+						originalName: value.name,
+						mimeType: value.type || 'application/octet-stream',
+						size: value.size,
+						content: arrayBuffer,
+					});
+
+					const existing = this.parsedFiles.get(key) ?? [];
+					existing.push(uploadedFile);
+					this.parsedFiles.set(key, existing);
+				}
+			}
+		} catch {
+			// If formData parsing fails, return empty map
+		}
+
+		return this.parsedFiles;
+	}
+
+	/**
+	 * Check if request has an uploaded file
+	 */
+	async hasFile(name: string): Promise<boolean> {
+		const file = await this.file(name);
+		return file !== null;
+	}
+
+	// ==========================================
+	// Request Fingerprinting
+	// ==========================================
+
+	/**
+	 * Generate a unique fingerprint for the request
+	 */
+	fingerprint(): string {
+		const components = [
+			this.method(),
+			this.path(),
+			this.ip() ?? 'unknown',
+			this.userAgent() ?? 'unknown',
+		];
+		return components.join('|');
+	}
+
+	// ==========================================
+	// AJAX / API Detection
+	// ==========================================
+
+	/**
+	 * Check if request is an AJAX/XHR request
+	 */
+	ajax(): boolean {
+		return this.header('x-requested-with')?.toLowerCase() === 'xmlhttprequest';
+	}
+
+	/**
+	 * Check if request is a preflight request
+	 */
+	isPreflight(): boolean {
+		return this.isMethod('OPTIONS') && this.hasHeader('access-control-request-method');
+	}
+}