npm - bunigniter - Versions diffs - 0.2.0 - Mend

bunigniter 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/LICENSE +21 -0
package/README.md +229 -0
package/dist/LICENSE +21 -0
package/dist/README.md +229 -0
package/dist/base/controller.ts +324 -0
package/dist/base/index.ts +5 -0
package/dist/base/service.ts +21 -0
package/dist/cli/index.ts +318 -0
package/dist/cli/list-routes.ts +72 -0
package/dist/cli/repl.ts +461 -0
package/dist/cli/templates.ts +283 -0
package/dist/client/index.ts +159 -0
package/dist/db/drizzle.ts +550 -0
package/dist/db/validators.ts +229 -0
package/dist/edge-builder.ts +120 -0
package/dist/edge.ts +69 -0
package/dist/helpers/cache.ts +173 -0
package/dist/helpers/cors.ts +103 -0
package/dist/helpers/csrf.ts +155 -0
package/dist/helpers/debug.ts +158 -0
package/dist/helpers/env.ts +147 -0
package/dist/helpers/handler.ts +158 -0
package/dist/helpers/http.ts +194 -0
package/dist/helpers/image.ts +217 -0
package/dist/helpers/jwt.ts +147 -0
package/dist/helpers/logger.ts +96 -0
package/dist/helpers/mail.ts +272 -0
package/dist/helpers/middleware-loader.ts +116 -0
package/dist/helpers/middleware.ts +57 -0
package/dist/helpers/modules.ts +115 -0
package/dist/helpers/openapi.ts +140 -0
package/dist/helpers/pagination.ts +159 -0
package/dist/helpers/queue.ts +186 -0
package/dist/helpers/request-context.ts +13 -0
package/dist/helpers/request.ts +376 -0
package/dist/helpers/schedule.ts +173 -0
package/dist/helpers/session-middleware.ts +89 -0
package/dist/helpers/session.ts +286 -0
package/dist/helpers/sse.ts +90 -0
package/dist/helpers/throttle.ts +156 -0
package/dist/helpers/upload.ts +417 -0
package/dist/helpers/validator.ts +287 -0
package/dist/helpers/ws.ts +123 -0
package/dist/index.ts +221 -0
package/dist/package.json +70 -0
package/dist/router/file-router.ts +541 -0
package/dist/router/server-router.ts +103 -0
package/dist/view/page.ts +96 -0
package/dist/view/renderer.tsx +390 -0
package/dist/view/view-response.ts +10 -0
package/package.json +70 -0

package/dist/view/page.ts ADDED Viewed

@@ -0,0 +1,96 @@
+/**
+ * Page — Inertia-style page response for server-rendered views.
+ *
+ * Combines a component name with props and renders either:
+ * - Full HTML (first request, SEO-friendly)
+ * - JSON page object (subsequent Inertia navigation)
+ *
+ * @example
+ * ```ts
+ * // pages/users.ts
+ * export class Users extends Controller {
+ *   async index() {
+ *     const users = await this.db.query('SELECT * FROM users')
+ *     return this.page('Users/Index', { users })
+ *   }
+ * }
+ * ```
+ */
+export interface PageOptions {
+	/** HTTP status code. Default: 200 */
+	status?: number
+	/** Page title (injected into HTML shell). */
+	title?: string
+	/** Shared props merged with component props. */
+	shared?: Record<string, any>
+	/** Layout to wrap the page. */
+	layout?: string | false
+	/** Flash data (shown once then cleared). */
+	flash?: Record<string, any>
+	/** Asset version for cache busting. */
+	version?: string
+}
+/**
+ * Page response — returned from a controller to render a full page.
+ */
+export class PageResponse {
+	public readonly component: string
+	public readonly props: Record<string, any>
+	public readonly options: PageOptions
+	constructor(component: string, props: Record<string, any> = {}, options: PageOptions = {}) {
+		this.component = component
+		this.props = props
+		this.options = options
+	}
+	/** Get the page object as JSON (for Inertia protocol). */
+	toInertiaJson(sharedProps: Record<string, any> = {}): string {
+		return JSON.stringify({
+			component: this.component,
+			props: { ...sharedProps, ...this.props },
+			url: '', // set by the router
+			version: this.options.version ?? null,
+			flash: this.options.flash ?? null,
+		})
+	}
+	/** Render full HTML shell with embedded page data. */
+	toHtml(sharedProps: Record<string, any> = {}, url = '/'): string {
+		const pageJson = JSON.stringify({
+			component: this.component,
+			props: { ...sharedProps, ...this.props },
+			url,
+			version: this.options.version ?? null,
+			flash: this.options.flash ?? null,
+		})
+		const title = this.options.title ?? this.component
+		const escapedPage = pageJson
+			.replace(/&/g, '&amp;')
+			.replace(/'/g, '&#39;')
+			.replace(/"/g, '&quot;')
+		return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+</head>
+<body>
+  <div id="app" data-page='${escapedPage}'></div>
+</body>
+</html>`
+	}
+}
+function escapeHtml(s: string): string {
+	return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+}

package/dist/view/renderer.tsx ADDED Viewed

@@ -0,0 +1,390 @@
+/**
+ * View Renderer — Simple server-side React rendering for Bunigniter.
+ *
+ * Controllers return `this.view('ComponentName', { props })` and the
+ * framework SSR-renders the React component to HTML.
+ *
+ * @example
+ * ```tsx
+ * // views/TodoList.tsx (React component)
+ * export default function TodoList({ todos, stats }: any) {
+ *   return (
+ *     <div>
+ *       <h1>📋 Todo App</h1>
+ *       <ul>{todos.map((t: any) => <li key={t.id}>{t.title}</li>)}</ul>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * ```ts
+ * // pages/todos.ts (Controller)
+ * async index() {
+ *   const todos = await this.db.query('SELECT * FROM todos')
+ *   return this.view('TodoList', { todos: todos.rows })
+ * }
+ * ```
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join, extname } from 'node:path'
+import React from 'react'
+import { renderToString } from 'react-dom/server'
+/** Registry of view components. */
+const registry = new Map<string, any>()
+/** MDX modules cache. */
+const mdxCache = new Map<string, any>()
+/** Views directory. */
+let viewsDir = 'views'
+/**
+ * Set the views directory.
+ * Called automatically from config.
+ */
+export function setViewsDir(dir: string): void {
+	viewsDir = dir
+}
+/**
+ * Register a view component.
+ * Called automatically when the view file is first loaded.
+ */
+export function registerView(name: string, component: any): void {
+	registry.set(name, component)
+}
+/**
+ * Render a view component to an HTML string.
+ *
+ * @param name - Component name (e.g. 'TodoList')
+ * @param props - Props object passed to the component
+ * @param options - Rendering options
+ * @returns HTML string
+ */
+export async function renderView(
+	name: string,
+	props: Record<string, any> = {},
+	options: { title?: string; scripts?: string[] } = {},
+	viewBase?: string
+): Promise<string | Response> {
+	// Try to load the component from views/ directory
+	let Component = registry.get(name)
+	if (!Component) {
+		const base = viewBase ?? join(process.cwd(), viewsDir)
+		const candidates = [
+			join(base, `${name}.tsx`),
+			join(base, `${name}.mdx`),
+			join(base, `${name}.md`),
+			join(base, `${name}.html`),
+			join(base, name, 'index.tsx'),
+		]
+		let targetPath: string | null = null
+		for (const p of candidates) {
+			if (existsSync(p)) { targetPath = p; break }
+		}
+		if (targetPath) {
+			const ext = extname(targetPath)
+			if (ext === '.html') {
+				// HTML templates use Rendu engine (PHP-like <?= ?> syntax)
+				return renderHTML(targetPath, props)
+			} else if (ext === '.mdx' || ext === '.md') {
+				// MDX with Rendu support (<?= ?>, {{ }}) + markdown rendering
+				return renderMDXView(targetPath, props)
+			} else {
+				const mod = await import(targetPath)
+				Component = mod.default ?? mod[name]
+			}
+			if (Component) {
+				registry.set(name, Component)
+			}
+		}
+	}
+	if (!Component) {
+		return renderFallback(name, props, options)
+	}
+	try {
+		const html = renderToString(React.createElement(Component, props))
+		const title = options.title ?? name
+		const serialized = JSON.stringify({ component: name, props })
+		const scripts = (options.scripts ?? []).map(s => `<script src="${s}"></script>`).join('\n')
+		return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+</head>
+<body>
+  <div id="app">${html}</div>
+  <script id="__NEXUS_DATA__" type="application/json">${escapeHtml(serialized)}</script>
+  ${scripts}
+</body>
+</html>`
+	} catch (err: any) {
+		return renderError(err, name, props)
+	}
+}
+/** Fallback: render data-page shell (same as before). */
+function renderFallback(name: string, props: Record<string, any>, options: { title?: string; scripts?: string[] }): string {
+	const title = options.title ?? name
+	const serialized = JSON.stringify({ component: name, props })
+	const scripts = (options.scripts ?? []).map(s => `<script src="${s}"></script>`).join('\n')
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+</head>
+<body>
+  <div id="app" data-page='${escapeHtml(serialized)}'></div>
+  ${scripts}
+</body>
+</html>`
+}
+/**
+ * Compile a plain HTML file using Rendu (PHP-like template engine).
+ * Supports <?= expr ?>, <?js code ?>, {{ expr }}, {{{ expr }}} syntax.
+ */
+function compileHTML(filePath: string, props: Record<string, any>): any {
+	const source = readFileSync(filePath, 'utf-8')
+	// Build a component that renders the template at request time
+	const HtmlComponent = () => {
+		// Use React state/effect to render on mount, but for SSR we need sync
+		// Actually, return a placeholder that gets stream-rendered
+		throw new Error('Use renderHTML() instead of React for .html templates')
+	}
+	return HtmlComponent
+}
+/**
+ * Render an HTML template using Rendu engine.
+ * Handles PHP-style <?= ?>, control flow <?js ?>, and {{ }} mustache syntax.
+ * Returns a Promise<Response> with rendered HTML.
+ */
+export async function renderHTML(filePath: string, props: Record<string, any> = {}): Promise<Response> {
+	const source = readFileSync(filePath, 'utf-8')
+	// Compile template using Rendu
+	const { compileTemplate } = await import('rendu')
+	/** Include a sub-template (partial) file. */
+	const includeSub = async (name: string): Promise<string> => {
+		const dir = filePath.substring(0, filePath.lastIndexOf('/'))
+		let subPath = join(dir, name)
+		if (!existsSync(subPath)) {
+			const ext = name.endsWith('.html') ? '' : '.html'
+			subPath = join(dir, name + ext)
+		}
+		if (!existsSync(subPath)) return `<!-- missing partial: ${name} -->`
+		const subSource = readFileSync(subPath, 'utf-8')
+		const subFn = compileTemplate(subSource)
+		const subStream = await subFn(ctx)
+		const reader = subStream.getReader()
+		let result = ''
+		while (true) {
+			const { done, value } = await reader.read()
+			if (done) break
+			result += new TextDecoder().decode(value)
+		}
+		return result
+	}
+	const fn = compileTemplate(source)
+	const ctx = {
+		htmlspecialchars: (s: unknown) =>
+			String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+		include: async (name: string) => await includeSub(name),
+		...props,
+	}
+	// Execute with props + rendu context
+	const stream = await fn(ctx)
+	// Collect stream into string
+	const reader = stream.getReader()
+	const chunks: Uint8Array[] = []
+	while (true) {
+		const { done, value } = await reader.read()
+		if (done) break
+		chunks.push(value)
+	}
+	let html = new TextDecoder().decode(concatUint8Arrays(chunks))
+	// Auto-layout: wrap with _layout.html from same directory
+	const layoutPath = join(filePath.substring(0, filePath.lastIndexOf('/')), '_layout.html')
+	if (existsSync(layoutPath)) {
+		const layoutSource = readFileSync(layoutPath, 'utf-8')
+		const layoutFn = compileTemplate(layoutSource)
+		const layoutStream = await layoutFn({
+			htmlspecialchars: (s: unknown) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+			slot: html,
+			...props,
+		})
+		const layoutReader = layoutStream.getReader()
+		const layoutChunks: Uint8Array[] = []
+		while (true) {
+			const { done, value } = await layoutReader.read()
+			if (done) break
+			layoutChunks.push(value)
+		}
+		html = new TextDecoder().decode(concatUint8Arrays(layoutChunks))
+	}
+	return new Response(html, {
+		headers: { 'content-type': 'text/html; charset=utf-8' }
+	})
+}
+function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+	const total = arrays.reduce((s, a) => s + a.length, 0)
+	const result = new Uint8Array(total)
+	let offset = 0
+	for (const a of arrays) {
+		result.set(a, offset)
+		offset += a.length
+	}
+	return result
+}
+/**
+ * Render an MDX view file to HTML using Rendu for interpolation
+ * and Bun.markdown.react() for markdown rendering.
+ *
+ * Supports:
+ *   <?= expr ?>   — PHP-style output (Rendu)
+ *   {{ expr }}    — Jinja-style escaped output (Rendu)
+ *   {{{ expr }}}  — Jinja-style raw output (Rendu)
+ *   <?js code ?>  — JavaScript control flow (Rendu)
+ *
+ * Then standard markdown via Bun.markdown.react().
+ */
+export async function renderMDXView(filePath: string, props: Record<string, any> = {}): Promise<Response> {
+	const source = readFileSync(filePath, 'utf-8')
+	let content = source.replace(/^---[\s\S]*?---\n?/, '')
+	// Step 1: Pre-render partials (_*.html) and replace include() calls
+	// with their rendered HTML (added AFTER markdown rendering to avoid conflicts)
+	const renderedPartials: string[] = []
+	let processed = content.replace(
+		/<\?=\s*await\s+include\s*\(\s*['"]([^'"]+)['"]\s*\)\s*\?>/g,
+		(_match: string, partialName: string) => {
+			const placeholder = `<!--INCLUDE_PLACEHOLDER_${renderedPartials.length}-->`
+			renderedPartials.push(partialName)
+			return placeholder
+		}
+	)
+	.replace(/`<\?=(.+?)`/g, '`&lt;?=$1`')
+		.replace(/`<\?js(.+?)\?>`/g, '`&lt;?js$1?&gt;`')
+	// Step 2: Render through Rendu for <?= ?> and {{ }} interpolation
+	const { compileTemplate } = await import('rendu')
+	const fn = compileTemplate(processed)
+	const ctx = {
+		htmlspecialchars: (s: unknown) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+		...props,
+	}
+	const stream = await fn(ctx)
+	const reader = stream.getReader()
+	let interpolated = ''
+	while (true) {
+		const { done, value } = await reader.read()
+		if (done) break
+		interpolated += new TextDecoder().decode(value)
+	}
+	// Step 3: Split at placeholders, render markdown parts, insert rendered partials
+	const parts = interpolated.split(/<!--INCLUDE_PLACEHOLDER_\d+-->/)
+	let finalHtml = ''
+	const mdOverrides = {
+		h1: function(p: any) { return React.createElement('h1', { id: p.id, style: { color: '#e94560' } }, p.children) },
+		a: function(p: any) { return React.createElement('a', { href: p.href, style: { color: '#70a1ff' } }, p.children) },
+		pre: function(p: any) { return React.createElement('pre', { style: { background: '#1a1a3e', padding: 16, borderRadius: 8, overflow: 'auto' } }, p.children) },
+		code: function(p: any) { return React.createElement('code', { style: { background: '#333', padding: '2px 6px', borderRadius: 3, fontSize: '0.9em' } }, p.children) },
+	}
+	const mdOptions = { tables: true, strikethrough: true, tasklists: true, autolinks: true, headings: { ids: true } }
+	for (let i = 0; i < parts.length; i++) {
+		const mdPart = parts[i].trim()
+		if (mdPart) {
+			const elements = Bun.markdown.react(mdPart, mdOverrides, mdOptions)
+			finalHtml += renderToString(elements)
+		}
+		// Insert rendered partial after each markdown part (except the last)
+		if (i < renderedPartials.length) {
+			const partialName = renderedPartials[i]
+			const dir = filePath.substring(0, filePath.lastIndexOf('/'))
+			let subPath = join(dir, partialName)
+			if (!existsSync(subPath)) subPath = join(dir, partialName + (partialName.endsWith('.html') ? '' : '.html'))
+			if (existsSync(subPath)) {
+				const subSource = readFileSync(subPath, 'utf-8')
+				const subFn = compileTemplate(subSource)
+				const subStream = await subFn(ctx)
+				const subReader = subStream.getReader()
+				let subHtml = ''
+				while (true) {
+					const { done, value } = await subReader.read()
+					if (done) break
+					subHtml += new TextDecoder().decode(value)
+				}
+				finalHtml += subHtml
+			}
+		}
+	}
+	// Auto-layout: wrap with _layout.html from same directory
+	const mdxLayoutPath = join(filePath.substring(0, filePath.lastIndexOf('/')), '_layout.html')
+	if (existsSync(mdxLayoutPath)) {
+		const layoutSource = readFileSync(mdxLayoutPath, 'utf-8')
+		const layoutFn = compileTemplate(layoutSource)
+		const layoutStream = await layoutFn({
+			htmlspecialchars: (s: unknown) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+			slot: finalHtml,
+			...props,
+		})
+		const lr = layoutStream.getReader()
+		const lc: Uint8Array[] = []
+		while (true) { const { done, value } = await lr.read(); if (done) break; lc.push(value) }
+		finalHtml = new TextDecoder().decode(concatUint8Arrays(lc))
+	}
+	// Wrap in full HTML document
+	return new Response(finalHtml, {
+		headers: { 'content-type': 'text/html; charset=utf-8' }
+	})
+}
+/** Error page. */
+function renderError(err: Error, name: string, props: Record<string, any>): string {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><title>View Error</title></head>
+<body>
+  <h1>Failed to render view: ${escapeHtml(name)}</h1>
+  <pre style="color:red">${escapeHtml(err.message)}</pre>
+  <pre>${escapeHtml(JSON.stringify(props, null, 2))}</pre>
+</body>
+</html>`
+}
+function escapeHtml(s: string): string {
+	return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+}

package/dist/view/view-response.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * ViewResponse — returned by Controller.view() for SSR-rendered views.
+ */
+export class ViewResponse {
+	constructor(
+		public readonly name: string,
+		public readonly props: Record<string, any> = {},
+		public readonly options: { title?: string; scripts?: string[] } = {}
+	) {}
+}

package/package.json ADDED Viewed

@@ -0,0 +1,70 @@
+{
+  "name": "bunigniter",
+  "version": "0.2.0",
+  "description": "Bun-native fullstack framework — CodeIgniter spirit × Elysia performance × Edge-ready",
+  "homepage": "https://github.com/nexus-ts/bunigniter",
+  "type": "module",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "dist/index.ts",
+  "module": "dist/index.ts",
+  "exports": {
+    ".": "./dist/index.ts",
+    "./base": "./dist/base/index.ts",
+    "./controller": "./dist/base/controller.ts",
+    "./helpers/env": "./dist/helpers/env.ts",
+    "./helpers/validator": "./dist/helpers/validator.ts",
+    "./helpers/http": "./dist/helpers/http.ts",
+    "./helpers/image": "./dist/helpers/image.ts",
+    "./helpers/pagination": "./dist/helpers/pagination.ts",
+    "./helpers/session": "./dist/helpers/session.ts",
+    "./helpers/cache": "./dist/helpers/cache.ts",
+    "./helpers/queue": "./dist/helpers/queue.ts",
+    "./helpers/upload": "./dist/helpers/upload.ts",
+    "./helpers/mail": "./dist/helpers/mail.ts",
+    "./helpers/modules": "./dist/helpers/modules.ts",
+    "./helpers/openapi": "./dist/helpers/openapi.ts",
+    "./helpers/jwt": "./dist/helpers/jwt.ts",
+    "./helpers/ws": "./dist/helpers/ws.ts",
+    "./helpers/sse": "./dist/helpers/sse.ts",
+    "./helpers/schedule": "./dist/helpers/schedule.ts"
+  },
+  "scripts": {
+    "build:dist": "bun run scripts/build-dist.ts",
+    "prepublishOnly": "bun run build:dist",
+    "postpublish": "rm -rf dist",
+    "dev": "bun --hot run src/index.ts",
+    "start": "bun run src/index.ts",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "bi": "bun run src/cli/index.ts",
+    "make:controller": "bun run src/cli/index.ts make:controller",
+    "make:model": "bun run src/cli/index.ts make:model",
+    "test": "bun x vitest run",
+    "test:smoke": "bun x vitest run tests/smoke.test.ts",
+    "test:unit": "bun x vitest run tests/ --exclude 'tests/smoke*' ",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.0",
+    "elysia": "2.0.0-exp.9",
+    "openapi-types": "^12.1.3",
+    "rendu": "^0.1.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.9"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT"
+}