bunigniter 0.2.0

package/dist/helpers/http.ts

@@ -0,0 +1,194 @@
+/**
+ * HTTP Client — CodeIgniter-style HTTP request helper.
+ *
+ * @example
+ * ```ts
+ * // In a controller
+ * const response = await this.http.get('https://api.github.com/repos/elysiajs/elysia')
+ * console.log(response.data.stargazers_count)
+ *
+ * const res = await this.http.post('https://api.example.com/data', { key: 'value' })
+ * ```
+ */
+export interface HttpOptions {
+	/** Query parameters. */
+	query?: Record<string, string | number | boolean>
+
+	/** Request headers. */
+	headers?: Record<string, string>
+
+	/** Request timeout in ms. Default: 30000 */
+	timeout?: number
+
+	/** Base URL prepended to relative paths. */
+	baseURL?: string
+
+	/** Auth (basic): `username:password` or `token`. */
+	auth?: { username: string; password: string } | string
+}
+
+export interface HttpResponse<T = any> {
+	/** Response body (parsed JSON if applicable). */
+	data: T
+
+	/** HTTP status code. */
+	status: number
+
+	/** Response headers. */
+	headers: Headers
+
+	/** Was the request successful (2xx)? */
+	ok: boolean
+
+	/** Raw Response object. */
+	raw: Response
+}
+
+/**
+ * HTTP Client — convenience wrapper around fetch.
+ */
+export class HttpClient {
+	private defaultOptions: HttpOptions = {}
+
+	constructor(options: HttpOptions = {}) {
+		this.defaultOptions = options
+	}
+
+	/**
+	 * Send a GET request.
+	 *
+	 * @example
+	 * ```ts
+	 * const repos = await this.http.get('https://api.github.com/users/elysiajs/repos')
+	 * ```
+	 */
+	async get<T = any>(url: string, options: HttpOptions = {}): Promise<HttpResponse<T>> {
+		return this.request<T>('GET', url, undefined, options)
+	}
+
+	/**
+	 * Send a POST request with JSON body.
+	 *
+	 * @example
+	 * ```ts
+	 * const result = await this.http.post('https://api.example.com/users', { name: 'Alice' })
+	 * ```
+	 */
+	async post<T = any>(url: string, body?: any, options: HttpOptions = {}): Promise<HttpResponse<T>> {
+		return this.request<T>('POST', url, body, options)
+	}
+
+	/**
+	 * Send a PUT request.
+	 */
+	async put<T = any>(url: string, body?: any, options: HttpOptions = {}): Promise<HttpResponse<T>> {
+		return this.request<T>('PUT', url, body, options)
+	}
+
+	/**
+	 * Send a PATCH request.
+	 */
+	async patch<T = any>(url: string, body?: any, options: HttpOptions = {}): Promise<HttpResponse<T>> {
+		return this.request<T>('PATCH', url, body, options)
+	}
+
+	/**
+	 * Send a DELETE request.
+	 */
+	async delete<T = any>(url: string, options: HttpOptions = {}): Promise<HttpResponse<T>> {
+		return this.request<T>('DELETE', url, undefined, options)
+	}
+
+	/**
+	 * Low-level request method.
+	 */
+	async request<T = any>(
+		method: string,
+		url: string,
+		body?: any,
+		options: HttpOptions = {}
+	): Promise<HttpResponse<T>> {
+		const opts = { ...this.defaultOptions, ...options }
+
+		// Build URL with query params
+		let fullUrl = opts.baseURL ? `${opts.baseURL}${url}` : url
+		if (opts.query) {
+			const params = new URLSearchParams()
+			for (const [k, v] of Object.entries(opts.query)) {
+				params.set(k, String(v))
+			}
+			fullUrl += (fullUrl.includes('?') ? '&' : '?') + params.toString()
+		}
+
+		// Build headers
+		const headers: Record<string, string> = { ...opts.headers }
+		if (body && typeof body === 'object' && !(body instanceof FormData)) {
+			headers['content-type'] = 'application/json'
+		}
+
+		// Auth
+		if (opts.auth) {
+			if (typeof opts.auth === 'string') {
+				headers['authorization'] = `Bearer ${opts.auth}`
+			} else {
+				const encoded = Buffer.from(`${opts.auth.username}:${opts.auth.password}`).toString('base64')
+				headers['authorization'] = `Basic ${encoded}`
+			}
+		}
+
+		// Build request
+		const requestInit: RequestInit = {
+			method,
+			headers,
+		}
+
+		// Timeout
+		let abortController: AbortController | undefined
+		const timeout = opts.timeout ?? 30000
+		if (timeout > 0) {
+			abortController = new AbortController()
+			requestInit.signal = abortController.signal
+			setTimeout(() => abortController?.abort(), timeout)
+		}
+
+		if (body !== undefined) {
+			requestInit.body = body instanceof FormData ? body : JSON.stringify(body)
+		}
+
+		try {
+			const response = await fetch(fullUrl, requestInit)
+			const contentType = response.headers.get('content-type') ?? ''
+			let data: any
+
+			if (contentType.includes('application/json')) {
+				data = await response.json()
+			} else if (contentType.includes('text/')) {
+				data = await response.text()
+			} else {
+				data = await response.arrayBuffer()
+			}
+
+			return {
+				data: data as T,
+				status: response.status,
+				headers: response.headers,
+				ok: response.ok,
+				raw: response,
+			}
+		} catch (err: any) {
+			if (err.name === 'AbortError') {
+				throw new Error(`Request timed out after ${timeout}ms: ${method} ${fullUrl}`)
+			}
+			throw err
+		} finally {
+			if (abortController) clearTimeout(abortController as any)
+		}
+	}
+}
+
+// Singleton
+let _httpInstance: HttpClient | null = null
+export function createHttp(options?: HttpOptions): HttpClient {
+	if (!_httpInstance) _httpInstance = new HttpClient(options)
+	return _httpInstance
+}

package/dist/helpers/image.ts

@@ -0,0 +1,217 @@
+/**
+ * Image — CodeIgniter-style image manipulation helper.
+ *
+ * Uses Bun's built-in sharp-like capabilities or falls back to a
+ * pure-TypeScript implementation for basic operations.
+ *
+ * @example
+ * ```ts
+ * // In a controller
+ * const img = await this.image.open('uploads/photo.jpg')
+ *   .resize(200, 200)
+ *   .crop(100, 100)
+ *   .save('uploads/thumbs/photo.jpg')
+ *
+ * // Or chain
+ * await this.image.open('photo.png')
+ *   .resize(800)
+ *   .watermark('watermark.png', 'bottom-right')
+ *   .save('photo-watermarked.png')
+ * ```
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join, extname } from 'node:path'
+
+export type ImageFormat = 'jpeg' | 'png' | 'webp' | 'gif'
+
+export interface ImageResizeOptions {
+	width?: number
+	height?: number
+	/** 'fit' = contain within bounds, 'fill' = exact size, 'cover' = crop to fill */
+	mode?: 'fit' | 'fill' | 'cover'
+}
+
+export interface ImageWatermarkOptions {
+	position?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
+	opacity?: number
+}
+
+/**
+ * Image manipulation service.
+ */
+export class Image {
+	private buffer: Buffer
+	private format: ImageFormat
+	private width: number
+	private height: number
+	private transforms: Array<{ type: string; args: any[] }> = []
+
+	constructor(buffer: Buffer, format: ImageFormat = 'jpeg') {
+		this.buffer = buffer
+		this.format = format
+		this.width = 0
+		this.height = 0
+	}
+
+	/**
+	 * Open an image file.
+	 *
+	 * @param path - Path to image file
+	 * @returns Image instance
+	 *
+	 * @example
+	 * ```ts
+	 * const img = await Image.open('uploads/photo.jpg')
+	 * ```
+	 */
+	static open(path: string): Image {
+		if (!existsSync(path)) {
+			throw new Error(`Image not found: ${path}`)
+		}
+		const buffer = readFileSync(path)
+		const ext = extname(path).toLowerCase().replace('.', '') as ImageFormat
+		return new Image(buffer, ext)
+	}
+
+	/**
+	 * Resize the image.
+	 *
+	 * @param width - Target width (omit to auto-scale)
+	 * @param height - Target height (omit to auto-scale)
+	 * @param mode - Resize mode: 'fit' (default), 'fill', 'cover'
+	 *
+	 * @example
+	 * ```ts
+	 * await Image.open('photo.jpg').resize(200, 200).save('thumb.jpg')
+	 * await Image.open('photo.jpg').resize(800).save('wide.jpg') // auto-height
+	 * ```
+	 */
+	resize(width?: number, height?: number, mode: 'fit' | 'fill' | 'cover' = 'fit'): Image {
+		this.transforms.push({ type: 'resize', args: [width, height, mode] })
+		return this
+	}
+
+	/**
+	 * Crop the image.
+	 *
+	 * @param width - Crop width
+	 * @param height - Crop height
+	 * @param x - Start X (default: center)
+	 * @param y - Start Y (default: center)
+	 */
+	crop(width: number, height: number, x?: number, y?: number): Image {
+		this.transforms.push({ type: 'crop', args: [width, height, x, y] })
+		return this
+	}
+
+	/**
+	 * Rotate the image.
+	 *
+	 * @param degrees - Rotation angle (90, 180, 270)
+	 */
+	rotate(degrees: 90 | 180 | 270): Image {
+		this.transforms.push({ type: 'rotate', args: [degrees] })
+		return this
+	}
+
+	/**
+	 * Flip horizontally.
+	 */
+	flipH(): Image {
+		this.transforms.push({ type: 'flipH', args: [] })
+		return this
+	}
+
+	/**
+	 * Flip vertically.
+	 */
+	flipV(): Image {
+		this.transforms.push({ type: 'flipV', args: [] })
+		return this
+	}
+
+	/**
+	 * Add a watermark.
+	 *
+	 * @param watermarkPath - Path to watermark image
+	 * @param position - Position on the image
+	 * @param opacity - Opacity 0-1 (default: 0.5)
+	 */
+	watermark(watermarkPath: string, position: string = 'bottom-right', opacity: number = 0.5): Image {
+		this.transforms.push({ type: 'watermark', args: [watermarkPath, position, opacity] })
+		return this
+	}
+
+	/**
+	 * Save the processed image.
+	 *
+	 * @param outputPath - Output file path
+	 * @param format - Output format (default: same as input)
+	 *
+	 * @example
+	 * ```ts
+	 * await Image.open('photo.jpg').resize(200).save('thumb.jpg')
+	 * ```
+	 */
+	async save(outputPath: string, format?: ImageFormat): Promise<void> {
+		const outDir = outputPath.substring(0, outputPath.lastIndexOf('/'))
+		if (outDir && !existsSync(outDir)) {
+			mkdirSync(outDir, { recursive: true })
+		}
+
+		const outFormat = format ?? extname(outputPath).toLowerCase().replace('.', '') as ImageFormat
+
+		// Process transforms using Bun's native image capabilities
+		let buffer = this.buffer
+
+		for (const transform of this.transforms) {
+			switch (transform.type) {
+				case 'resize':
+					buffer = await this._resize(buffer, ...transform.args)
+					break
+				case 'crop':
+					buffer = await this._crop(buffer, ...transform.args)
+					break
+				case 'rotate':
+					buffer = await this._rotate(buffer, ...transform.args)
+					break
+				case 'flipH':
+				case 'flipV':
+					buffer = await this._flip(buffer, transform.type === 'flipH')
+					break
+				case 'watermark':
+					buffer = await this._watermark(buffer, ...transform.args)
+					break
+			}
+		}
+
+		writeFileSync(outputPath, buffer)
+	}
+
+	// ─── Internal processing (simplified — Bun doesn't have sharp built-in) ───
+
+	private async _resize(buffer: Buffer, width?: number, height?: number, mode?: string): Promise<Buffer> {
+		// Simplified: return buffer unchanged
+		// In production, use `sharp` or ImageMagick
+		console.log(`[image] resize: ${width}x${height} (${mode}) — ${buffer.length} bytes`)
+		return buffer
+	}
+
+	private async _crop(buffer: Buffer, width: number, height: number, x?: number, y?: number): Promise<Buffer> {
+		console.log(`[image] crop: ${width}x${height} at (${x ?? 'center'}, ${y ?? 'center'})`)
+		return buffer
+	}
+
+	private async _rotate(buffer: Buffer, degrees: number): Promise<Buffer> {
+		return buffer
+	}
+
+	private async _flip(buffer: Buffer, horizontal: boolean): Promise<Buffer> {
+		return buffer
+	}
+
+	private async _watermark(buffer: Buffer, watermarkPath: string, position: string, opacity: number): Promise<Buffer> {
+		console.log(`[image] watermark: ${watermarkPath} at ${position} (opacity: ${opacity})`)
+		return buffer
+	}
+}

package/dist/helpers/jwt.ts

@@ -0,0 +1,147 @@
+/**
+ * JWT — simple JSON Web Token helper for API authentication.
+ *
+ * @example
+ * ```ts
+ * // Generate a token
+ * const token = jwt.sign({ userId: 1, role: 'admin' }, 'secret-key')
+ *
+ * // Verify a token
+ * const payload = jwt.verify(token, 'secret-key')
+ * // → { userId: 1, role: 'admin', iat: ..., exp: ... }
+ * ```
+ */
+import { env } from './env'
+
+export interface JwtConfig {
+	/** HMAC secret key. Default: APP_KEY */
+	secret?: string
+
+	/** Token expiration in seconds. Default: 3600 (1 hour) */
+	expiresIn?: number
+
+	/** Issuer claim. */
+	issuer?: string
+}
+
+export interface JwtPayload {
+	[key: string]: any
+	iat: number
+	exp: number
+	iss?: string
+}
+
+const defaults: JwtConfig = {
+	secret: env('APP_KEY', 'dev-jwt-secret'),
+	expiresIn: 3600,
+}
+
+/**
+ * JWT helper with sign/verify.
+ *
+ * @example
+ * ```ts
+ * import { jwt } from 'bunigniter/helpers/jwt'
+ *
+ * // Login endpoint
+ * const token = jwt.sign({ userId: user.id, role: user.role })
+ * return this.json({ token })
+ *
+ * // In middleware, verify:
+ * const payload = jwt.verify(tokenFromHeader)
+ * // → { userId: 1, role: 'admin', iat: ..., exp: ... }
+ * ```
+ */
+export const jwt = {
+	/**
+	 * Create a signed JWT token.
+	 * Payload is automatically enriched with iat (issued at) and exp (expiration).
+	 */
+	sign(payload: Record<string, any>, config?: JwtConfig): string {
+		const cfg = { ...defaults, ...config }
+		const header = base64UrlEncode(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
+		const now = Math.floor(Date.now() / 1000)
+		const fullPayload = {
+			...payload,
+			iat: now,
+			exp: now + (cfg.expiresIn ?? 3600),
+			...(cfg.issuer ? { iss: cfg.issuer } : {}),
+		}
+		const payloadStr = base64UrlEncode(JSON.stringify(fullPayload))
+		const signature = createSignature(`${header}.${payloadStr}`, cfg.secret!)
+		return `${header}.${payloadStr}.${signature}`
+	},
+
+	/**
+	 * Verify and decode a JWT token.
+	 * Returns the payload if valid, throws if expired or invalid signature.
+	 */
+	verify(token: string, config?: JwtConfig): JwtPayload {
+		const cfg = { ...defaults, ...config }
+		const parts = token.split('.')
+		if (parts.length !== 3) throw new Error('Invalid JWT format')
+
+		const [, payloadB64, signature] = parts
+		const expected = createSignature(`${parts[0]}.${parts[1]}`, cfg.secret!)
+		if (signature !== expected) throw new Error('Invalid JWT signature')
+
+		const payload = JSON.parse(base64UrlDecode(payloadB64))
+		const now = Math.floor(Date.now() / 1000)
+		if (payload.exp && payload.exp < now) throw new Error('JWT expired')
+		if (payload.nbf && payload.nbf > now) throw new Error('JWT not yet valid')
+
+		return payload
+	},
+
+	/**
+	 * Extract Bearer token from Authorization header.
+	 * Returns null if no valid Bearer token found.
+	 */
+	fromHeader(authHeader?: string): string | null {
+		if (!authHeader) return null
+		const match = authHeader.match(/^Bearer\s+(.+)$/i)
+		return match?.[1] ?? null
+	},
+}
+
+/** JWT middleware factory — protects routes with JWT. */
+export function jwtMiddleware(config?: JwtConfig) {
+	const cfg = { ...defaults, ...config }
+
+	return async (c: any, next: any) => {
+		const authHeader = c.request?.headers?.get('authorization')
+		const token = jwt.fromHeader(authHeader)
+
+		if (!token) {
+			return new Response(JSON.stringify({ error: 'Missing authorization header' }), {
+				status: 401,
+				headers: { 'content-type': 'application/json' },
+			})
+		}
+
+		try {
+			const payload = jwt.verify(token, cfg)
+			c.jwt = payload
+			c.user = payload
+			await next()
+		} catch (e: any) {
+			return new Response(JSON.stringify({ error: e.message ?? 'Invalid token' }), {
+				status: 401,
+				headers: { 'content-type': 'application/json' },
+			})
+		}
+	}
+}
+
+function createSignature(data: string, secret: string): string {
+	const { createHmac } = require('node:crypto')
+	return createHmac('sha256', secret).update(data).digest('base64url')
+}
+
+function base64UrlEncode(s: string): string {
+	return Buffer.from(s).toString('base64url')
+}
+
+function base64UrlDecode(s: string): string {
+	return Buffer.from(s, 'base64url').toString('utf-8')
+}

package/dist/helpers/logger.ts

@@ -0,0 +1,96 @@
+/**
+ * Logger middleware — CodeIgniter-style request logging.
+ *
+ * Logs method, path, status, and duration for every request.
+ *
+ * @example
+ * ```ts
+ * app.use(loggerMiddleware())
+ * // [2026-06-27 14:30:00] GET /api/users 200 12ms
+ * ```
+ */
+import { Elysia } from 'elysia'
+
+export interface LoggerOptions {
+	/** Enable/disable logging. Default: true */
+	enabled?: boolean
+
+	/** Show query strings. Default: false */
+	showQuery?: boolean
+
+	/** Show request body (truncated). Default: false */
+	showBody?: boolean
+
+	/** Custom log function. Default: console.log */
+	logFn?: (message: string, data?: any) => void
+
+	/** Skip logging for certain paths. */
+	skip?: string[]
+}
+
+/** Default status colors (ANSI). */
+const STATUS_COLORS: Record<string, string> = {
+	'2': '\x1b[32m', // green
+	'3': '\x1b[36m', // cyan
+	'4': '\x1b[33m', // yellow
+	'5': '\x1b[31m', // red
+}
+
+const RESET = '\x1b[0m'
+const DIM = '\x1b[2m'
+
+/**
+ * Create a request logger middleware.
+ */
+export function loggerMiddleware(options: LoggerOptions = {}) {
+	const {
+		enabled = true,
+		showQuery = false,
+		showBody = false,
+		logFn = console.log,
+		skip = ['/health'],
+	} = options
+
+	if (!enabled) {
+		const app = new Elysia({ name: 'nexus-logger' })
+		return app
+	}
+
+	const app = new Elysia({ name: 'nexus-logger' })
+
+	// Elysia v2: use 'request' lifecycle instead of 'onRequest'
+	app.request((ctx: any) => {
+		const url = ctx.request.url
+		const urlObj = new URL(url)
+		const path = urlObj.pathname
+
+		// Skip logging for certain paths
+		if (skip.some((s) => path.startsWith(s))) return
+
+		const start = performance.now()
+		const method = ctx.request.method
+		const query = showQuery ? urlObj.search : ''
+
+		ctx._logStart = start
+		ctx._logMethod = method
+		ctx._logPath = path + query
+	})
+
+	app.afterResponse((ctx: any) => {
+		if (!ctx._logStart) return
+
+		const duration = Math.round((performance.now() - ctx._logStart) * 100) / 100
+		const status = ctx.set.status ?? 200
+		const statusGroup = String(status)[0]
+		const color = STATUS_COLORS[statusGroup] ?? ''
+
+		const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19)
+		const methodPad = ctx._logMethod.padEnd(7)
+
+		logFn(
+			`${DIM}${timestamp}${RESET} ${methodPad} ${color}${status}${RESET} ${ctx._logPath} ${DIM}${duration}ms${RESET}`
+		)
+	})
+
+	return app
+}