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/router/file-router.ts ADDED Viewed

@@ -0,0 +1,541 @@
+/**
+ * File Router — CodeIgniter-style file-path routing.
+ *
+ * Maps file paths to URL routes automatically:
+ * ```
+ * pages/
+ * ├── users.ts        → GET/POST /api/users
+ * ├── users/
+ * │   └── [id].ts     → GET /api/users/:id
+ * ├── auth/
+ * │   └── login.ts    → GET/POST /api/auth/login
+ * └── index.ts        → GET /api
+ * ```
+ *
+ * Convention:
+ * - `pages/users.ts` → `/api/users`
+ * - `pages/users/[id].ts` → `/api/users/:id`
+ * - `pages/index.ts` → `/api/`
+ * - Exported class extending `Controller` is auto-registered
+ * - Method names map to HTTP verbs: `index`=GET, `show`=GET/:id, `create`=POST, `update`=PUT, `destroy`=DELETE
+ */
+import { readdirSync, statSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { type Elysia, t } from "elysia";
+import type { Controller } from "../base/controller";
+import type { DbClient } from "../db/drizzle";
+import type { Cache } from "../helpers/cache";
+import type { Queue } from "../helpers/queue";
+import type { Upload } from "../helpers/upload";
+import type { Mail } from "../helpers/mail";
+import { Session } from "../helpers/session";
+import { PageResponse } from "../view/page";
+import { ViewResponse } from "../view/view-response";
+import { renderView } from "../view/renderer";
+import { generateToolbar, getStore } from "../helpers/debug";
+import { setRequestContext } from "../helpers/request-context";
+export interface FileRouterOptions {
+	/** Directory containing route files. Default: `routes` */
+	directory?: string;
+	/** Views directory for module support. Overrides global views. */
+	viewsDir?: string;
+	/** URL prefix for all routes. Default: `/api` */
+	prefix?: string;
+	/** Database instance to inject into controllers. */
+	db?: DbClient;
+	/** Named databases (multi-database support). */
+	dbs?: Record<string, DbClient>;
+	/** Cache instance. */
+	cache?: Cache;
+	/** Queue instance. */
+	queue?: Queue;
+	/** Upload instance. */
+	upload?: Upload;
+	/** Mail instance. */
+	mail?: Mail;
+	/** Called when a controller is registered (for DI/decoration). */
+	onRegister?: (controller: Controller) => void;
+}
+interface LoaderExport {
+	loader?: (ctx: any) => Promise<Record<string, any>>;
+	action?:
+		| ((ctx: any, args?: any) => Promise<void>)
+		| { config?: any; fn?: any };
+}
+/** Render a page component to HTML (server-side). */
+function renderPage(component: string, props: Record<string, any>): string {
+	// Build props JSON to embed in HTML shell
+	const propsJson = escapeHtml(JSON.stringify(props));
+	return `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${escapeHtml(component)}</title></head><body><div id="app" data-page='${propsJson}'></div></body></html>`;
+}
+function escapeHtml(s: string): string {
+	return s
+		.replace(/&/g, "&amp;")
+		.replace(/'/g, "&#39;")
+		.replace(/"/g, "&quot;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;");
+}
+/** Default method-to-verb mapping (CodeIgniter-style). */
+const METHOD_MAP: Record<string, string> = Object.assign(Object.create(null), {
+	index: "GET",
+	show: "GET",
+	create: "POST",
+	store: "POST",
+	update: "PUT",
+	destroy: "DELETE",
+	edit: "GET",
+});
+/** Methods that need a param ID. */
+const ID_METHODS = new Set(["show", "update", "destroy", "edit"]);
+/**
+ * Scan a directory and auto-register routes.
+ *
+ * @example
+ * ```ts
+ * // routes/users.ts — handles GET /api/users, POST /api/users
+ * export class Users extends Controller {
+ *   async index() { return this.json(await this.db.query('SELECT * FROM users')) }
+ *   async show(id: number) { return this.json(await this.db.query('SELECT * FROM users WHERE id = ?', [id])) }
+ *   async create() { const body = await this.body; ... }
+ * }
+ * ```
+ */
+export async function registerFileRoutes(
+	app: Elysia,
+	options: FileRouterOptions = {},
+): Promise<void> {
+	const dir = options.directory ?? "routes";
+	const prefix = options.prefix ?? "/api";
+	// Ensure directory exists
+	try {
+		statSync(dir);
+	} catch {
+		console.warn(`[router] routes directory not found: ${dir}`);
+		return;
+	}
+	// First pass: register .server.ts loader/action routes
+	const serverFiles = scanDir(dir, ".server.ts");
+	for (const file of serverFiles) {
+		const fullPath = join(dir, file);
+		const serverMod = (await import(
+			/* @vite-ignore */ join(process.cwd(), dir, file)
+		)) as LoaderExport;
+		const componentName = file.replace(/\.server\.ts$/, "");
+		const urlPath = filePathToUrl(componentName + ".ts", prefix);
+		if (serverMod.loader) {
+			const handler = async (_ctx: any) => {
+				const props = await (serverMod.loader as Function)(_ctx);
+				// Serve as HTML shell (SSR placeholder) + JSON props
+				return new Response(renderPage(componentName, props), {
+					headers: { "content-type": "text/html; charset=utf-8" },
+				});
+			};
+			registerRoute(app, "GET", urlPath, handler, null as any, options);
+		}
+		if (serverMod.action) {
+			const action = serverMod.action as any;
+			const handler = async (_ctx: any) => {
+				let body;
+				try {
+					body = await _ctx.request.json();
+				} catch {
+					body = {};
+				}
+				if (action.fn) {
+					await action.fn(_ctx, { body });
+				} else {
+					await action(_ctx, { body });
+				}
+				return new Response(null, { status: 204 });
+			};
+			registerRoute(app, "POST", urlPath, handler, null as any, options);
+		}
+	}
+	// Second pass: register Controller routes
+	const files = scanDir(dir, ".ts");
+	for (const file of files) {
+		if (file.endsWith(".server.ts")) continue;
+		const fullPath = join(process.cwd(), dir, file);
+		const mod = await import(/* @vite-ignore */ fullPath);
+		// Find the Controller subclass
+		const ControllerClass = findController(mod);
+		// If file has ws.handle() calls without a Controller, still import it
+		// (WS handlers register via side-effect at module load time)
+		if (!ControllerClass) continue;
+		const controller = new ControllerClass() as Controller;
+		// Inject services
+		if (options.db) {
+			Object.defineProperty(controller, "db", {
+				value: options.db,
+				writable: false,
+			});
+		}
+		if (options.dbs) {
+			Object.defineProperty(controller, "dbs", {
+				value: options.dbs,
+				writable: false,
+			});
+		}
+		if (options.cache) {
+			Object.defineProperty(controller, "cache", {
+				value: options.cache,
+				writable: false,
+			});
+		}
+		if (options.queue) {
+			Object.defineProperty(controller, "queue", {
+				value: options.queue,
+				writable: false,
+			});
+		}
+		if (options.upload) {
+			Object.defineProperty(controller, "upload", {
+				value: options.upload,
+				writable: false,
+			});
+		}
+		if (options.mail) {
+			Object.defineProperty(controller, "mail", {
+				value: options.mail,
+				writable: false,
+			});
+		}
+		// Call onRegister hook
+		options.onRegister?.(controller);
+		// Convert file path to URL path
+		const urlPath = filePathToUrl(file, prefix);
+		// Register routes for each Controller method
+		const isIndex = basename(file, ".ts") === "index";
+		for (const method of ["index", "show", "create", "update", "destroy"]) {
+			if (typeof (controller as any)[method] !== "function") continue;
+			const verb = METHOD_MAP[method];
+			const handler = (controller as any)[method].bind(controller);
+			const methodPath = ID_METHODS.has(method)
+				? isIndex
+					? `${prefix}/:id`
+					: `${urlPath}/:id`
+				: isIndex
+					? prefix
+					: urlPath;
+			registerRoute(app, verb, methodPath, handler, controller, options);
+		}
+	}
+}
+// ─── Internal Helpers ──────────────────────────────────────────
+let startTime = 0;
+function formatBytes2(bytes: number): string {
+	if (bytes === 0) return "0 MB";
+	const mb = bytes / (1024 * 1024);
+	return `${mb.toFixed(1)} MB`;
+}
+/** Inject debug toolbar into HTML if enabled. */
+async function injectDebug(
+	html: string,
+	ctx: any,
+	controller: any,
+	status: number,
+): Promise<string> {
+	const dbgParam = new URL(
+		ctx.request?.url ?? "http://localhost",
+	).searchParams.get("debug");
+	const isDebug = dbgParam === "1" || process.env.DEBUG === "true";
+	if (!isDebug || !html.includes("</body>")) return html;
+	try {
+		const debugData = getStore(ctx);
+		debugData.status = status;
+		debugData.duration =
+			Math.round((performance.now() - startTime) * 100) / 100;
+		debugData.memory = formatBytes2((process as any).memoryUsage?.()?.rss ?? 0);
+		debugData.timestamp = new Date().toLocaleString();
+		if (controller?.session) debugData.session = controller.session.all();
+		if (ctx.request?.headers) {
+			const h: Record<string, string> = {};
+			for (const [k, v] of ctx.request.headers.entries()) h[k] = v;
+			debugData.headers = h;
+		}
+		const toolbar = await generateToolbar(debugData);
+		if (toolbar && toolbar.length > 50) {
+			const bodyIdx = html.lastIndexOf("</body>");
+			if (bodyIdx > 0) {
+				return html.slice(0, bodyIdx) + toolbar + "\n" + html.slice(bodyIdx);
+			}
+		}
+		return html;
+	} catch (e) {
+		console.error("[debug] toolbar error:", e, (e as Error).stack);
+	}
+	return html;
+}
+function scanDir(dir: string, ext: string, baseDir = ""): string[] {
+	const files: string[] = [];
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const relPath = baseDir ? `${baseDir}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			files.push(...scanDir(join(dir, entry.name), ext, relPath));
+		} else if (
+			entry.isFile() &&
+			entry.name.endsWith(ext) &&
+			!entry.name.startsWith("_")
+		) {
+			files.push(relPath);
+		}
+	}
+	return files.sort();
+}
+function filePathToUrl(file: string, prefix: string): string {
+	const url = file
+		.replace(/\.ts$/, "")
+		.replace(/\[\.\.\.\]/g, "*")
+		.replace(/\[([^\]]+)\]/g, ":$1")
+		.replace(/\/index$/, "")
+		.replace(/\\/g, "/");
+	return `${prefix}${url ? `/${url}` : ""}`;
+}
+function findController(
+	mod: Record<string, any>,
+): (new () => Controller) | null {
+	for (const key of Object.keys(mod)) {
+		const val = mod[key];
+		if (
+			typeof val === "function" &&
+			val.prototype &&
+			val.prototype.constructor
+		) {
+			// Check if it extends Controller
+			let proto = val.prototype;
+			while (proto) {
+				if (proto.constructor.name === "Controller") return val;
+				proto = Object.getPrototypeOf(proto);
+			}
+		}
+	}
+	return null;
+}
+function registerRoute(
+	app: Elysia,
+	verb: string,
+	path: string,
+	handler: (...args: any[]) => any,
+	controller: Controller,
+	options: FileRouterOptions,
+): void {
+	const lowerVerb = verb.toLowerCase() as
+		| "get"
+		| "post"
+		| "put"
+		| "delete"
+		| "patch";
+	// Determine if this route needs an ID param based on the path
+	const needsId = path.endsWith("/:id");
+	// Wrap handler: inject ctx + session + auth into controller
+	const wrappedHandler = async (_ctx: any) => {
+		setRequestContext(_ctx);
+		startTime = performance.now();
+		let session: Session | null = null;
+		const cookieName = "nexus_session";
+		if (controller) {
+			(controller as any).ctx = _ctx;
+			// Set upload body for auto-detection
+			if ((controller as any).upload) {
+				(controller as any).upload.body = _ctx.body;
+			}
+			// Create session from cookie
+			session = new Session();
+			const cookieHeader = _ctx.request?.headers?.get("cookie") ?? "";
+			const match = cookieHeader.match(new RegExp(cookieName + "=([^;]+)"));
+			session.load(match?.[1]);
+			(controller as any).session = session;
+			// Create auth facade
+			(controller as any).auth = {
+				user: () => session?.get("user"),
+				login: (user: any) => {
+					session?.set("user", user);
+					session?.regenerate();
+				},
+				logout: () => {
+					session?.delete("user");
+					session?.clear();
+				},
+				check: () => !!session?.get("user"),
+			};
+		}
+		try {
+			// Handle _method override for HTML forms (PUT/DELETE via POST)
+			const body = _ctx.body ?? {};
+			const overrideMethod = body?._method?.toUpperCase();
+			if (
+				overrideMethod &&
+				["PUT", "DELETE", "PATCH"].includes(overrideMethod)
+			) {
+				_ctx.__method = overrideMethod;
+			}
+			// Call _before() lifecycle hook (can short-circuit with a Response)
+			if (controller) {
+				const beforeResult = (controller as any)._before?.();
+				if (beforeResult instanceof Response) {
+					return beforeResult;
+				}
+			}
+			// Call handler — pass context for server routes, ID for Controller routes
+			const id = _ctx.params?.id ? Number(_ctx.params.id) : undefined;
+			let result;
+			if (controller) {
+				result = needsId ? await handler(id) : await handler();
+			} else {
+				result = await handler(_ctx);
+			}
+			// Save session cookie AFTER handler runs
+			if (session) {
+				const serialized = session.serialize();
+				if (serialized) {
+					if (!_ctx.set.headers) _ctx.set.headers = {};
+					_ctx.set.headers["Set-Cookie"] =
+						`${cookieName}=${serialized.value}; Max-Age=${serialized.maxAge}; Path=/; HttpOnly; SameSite=Lax`;
+				}
+			}
+			if (result instanceof Response) return result;
+			// Handle ViewResponse — SSR render (React or Rendu HTML)
+			if (result instanceof ViewResponse) {
+				const viewBase = options.viewsDir
+					? join(process.cwd(), options.viewsDir)
+					: undefined;
+				const htmlOrRes = await renderView(
+					result.name,
+					result.props,
+					result.options,
+					viewBase,
+				);
+				if (htmlOrRes instanceof Response) {
+					let text = await htmlOrRes.text();
+					text = await injectDebug(text, _ctx, controller, htmlOrRes.status);
+					return new Response(text, {
+						status: htmlOrRes.status,
+						headers: { "content-type": "text/html; charset=utf-8" },
+					});
+				}
+				const html = await injectDebug(htmlOrRes, _ctx, controller, 200);
+				return new Response(html, {
+					headers: { "content-type": "text/html; charset=utf-8" },
+				});
+			}
+			// Handle PageResponse — Inertia-style page
+			if (result instanceof PageResponse) {
+				const isInertia =
+					_ctx.headers?.["x-inertia"] === "true" ||
+					_ctx.request?.headers?.get("X-Inertia") === "true";
+				if (isInertia) {
+					return new Response(result.toInertiaJson(controller?._sharedProps), {
+						status: result.options.status ?? 200,
+						headers: {
+							"content-type": "application/json",
+							"x-inertia": "true",
+						},
+					});
+				}
+				// First load: full HTML shell
+				const url = _ctx.request?.url ?? "/";
+				let html = result.toHtml(controller?._sharedProps, url);
+				// Client script inject
+				if (html.includes("</body>")) {
+					const publicPath = join(process.cwd(), "public", "app.js");
+					if (existsSync(publicPath)) {
+						html = html.replace(
+							"</body>",
+							'<script src="/public/app.js"></script>\n</body>',
+						);
+					}
+					html = await injectDebug(
+						html,
+						_ctx,
+						controller,
+						result.options.status ?? 200,
+					);
+				}
+				return new Response(html, {
+					status: result.options.status ?? 200,
+					headers: { "content-type": "text/html; charset=utf-8" },
+				});
+			}
+			if (result !== undefined && result !== null) {
+				const status = (result as any)._status ?? 200;
+				return new Response(JSON.stringify(result), {
+					status,
+					headers: { "content-type": "application/json" },
+				});
+			}
+			return new Response(null, { status: 204 });
+		} catch (err) {
+			console.error(`[ERROR] ${verb} ${path}:`, (err as Error).message);
+			return new Response(JSON.stringify({ error: (err as Error).message }), {
+				status: 500,
+				headers: { "content-type": "application/json" },
+			});
+		}
+	};
+	// Elysia v2.0: .get(path, handler) — schema precedes handler in v2
+	(app as any)[lowerVerb](path, wrappedHandler);
+}

package/dist/router/server-router.ts ADDED Viewed

@@ -0,0 +1,103 @@
+/**
+ * Server Router — Void-style file-based routing with method exports.
+ *
+ * Scans `routes/` directory. Each file exports
+ * HTTP method constants (`GET`, `POST`, etc.) created via `defineHandler`.
+ *
+ * Directory structure:
+ * ```
+ * routes/
+ * ├── api/
+ * │   ├── hello.ts          → GET|POST /api/hello
+ * │   └── users/
+ * │       ├── index.ts       → GET|POST /api/users
+ * │       └── [id].ts        → GET|PUT|DELETE /api/users/:id
+ * └── webhooks/
+ *     └── stripe.ts          → POST /webhooks/stripe
+ * ```
+ *
+ * @example
+ * ```ts
+ * // routes/api/users.ts
+ * import { defineHandler } from 'nexusts'
+ *
+ * export const GET = defineHandler(async (c) => {
+ *   return db.select().from(users)
+ * })
+ *
+ * export const POST = defineHandler.withValidator({
+ *   body: insertUserSchema
+ * })(async (c, { body }) => {
+ *   return db.insert(users).values(body).returning()
+ * })
+ * ```
+ */
+import { readdirSync, statSync, existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { Elysia } from 'elysia'
+/**
+ * Register all routes from the `routes/` directory.
+ * Each file exports `GET`, `POST`, `PUT`, `DELETE`, `PATCH` named constants.
+ */
+export async function registerServerRoutes(app: Elysia, dir: string = 'routes', prefix: string = ''): Promise<void> {
+	if (!existsSync(dir)) return
+	const files = scanRouteFiles(dir)
+	for (const file of files) {
+		const fullPath = join(process.cwd(), dir, file)
+		let mod
+		try {
+			mod = await import(fullPath)
+		} catch (e: any) {
+			console.error('[server-router] Error importing', file, ':', e.message)
+			continue
+		}
+		// Build URL path from file path
+		const urlPath = routeFilePathToUrl(file, prefix)
+		// Register each exported HTTP method
+		const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const
+		for (const method of methods) {
+			const handler = mod[method]
+			if (typeof handler !== 'function') continue
+			const lower = method.toLowerCase() as 'get' | 'post' | 'put' | 'delete' | 'patch'
+			;(app as any)[lower](urlPath, async (ctx: any) => {
+				return handler(ctx)
+			})
+		}
+	}
+}
+/** Scan for route files, excluding _prefix and .server.ts. */
+function scanRouteFiles(baseDir: string, relativeDir = ''): string[] {
+	const dir = join(baseDir, relativeDir)
+	const files: string[] = []
+	const entries = readdirSync(dir, { withFileTypes: true })
+	for (const entry of entries) {
+		if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue
+		if (entry.isDirectory()) {
+			files.push(...scanRouteFiles(baseDir, relativeDir ? `${relativeDir}/${entry.name}` : entry.name))
+		} else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.server.ts') && !entry.name.endsWith('.test.ts')) {
+			files.push(relativeDir ? `${relativeDir}/${entry.name}` : entry.name)
+		}
+	}
+	return files.sort()
+}
+/** Convert file path to URL path, matching Void conventions. */
+function routeFilePathToUrl(file: string, prefix: string): string {
+	let url = file
+		.replace(/\.ts$/, '')
+		.replace(/\/index$/, '')
+		.replace(/\[\.\.\.\]/g, '*')
+		.replace(/\[(\w+)\]/g, ':$1')
+	return `${prefix}/${url}`
+}