bun-router 0.7.4-experimental.5 → 0.7.4-experimental.7

package/examples/ssr/index.ts

@@ -2,6 +2,6 @@ import { Router } from '../../';
 
 const router = Router();
 
-router.static('/', './examples/ssr/pages');
+router.static('/page', './examples/ssr/pages');
 
 router.serve();

package/examples/static.ts

@@ -2,5 +2,6 @@ import { Router } from '..';
 
 const r = Router(3001);
 
-r.static('/', './pages');
+r.static('/page', './pages');
+
 r.serve();

package/lib/fs/filetree.ts

@@ -1,4 +1,3 @@
-import { splitFilePath } from '../fs/fsys';
 import path from 'node:path';
 
 type File = {
@@ -22,8 +21,8 @@ function createFile(name: string): File {
 const FileTree = (dir: string) => {
 	const root = createFile(dir);
 
-	const addFile = (_path: string) => {
-		const pathParts = splitFilePath(_path);
+	const addFile = (filepath: string) => {
+		const pathParts = filepath.split(path.sep);
 		let current = root;
 
 		for (let i = 0; i < pathParts.length; i++) {
@@ -35,8 +34,8 @@ const FileTree = (dir: string) => {
 		}
 
 		current.isLast = true;
-		current.path = _path;
-		current.extension = path.extname(_path);
+		current.path = filepath;
+		current.extension = path.extname(filepath);
 	};
 
 	const getFilesByExtension = (extension: string): string[] => {
@@ -53,9 +52,9 @@ const FileTree = (dir: string) => {
 		return files;
 	};
 
-	const getFileByName = (path: string): string | undefined => {
+	const getFileByName = (filepath: string): string | undefined => {
 		let current = root;
-		const pathParts = splitFilePath(path);
+		const pathParts = filepath.split(path.sep);
 		for (let i = 0; i < pathParts.length; i++) {
 			const part = pathParts[i];
 			if (current.children.has(part)) {

package/lib/fs/fsys.ts

@@ -22,19 +22,18 @@ async function readDir(dirpath: string, handler: (filepath: string, entry: BunFi
 	}
 }
 
-// get the extension of a file (unnecessary)
-function ext(p: string): string {
-	return path.extname(p);
-}
-
-// split a file path into an array of strings (unnecessary)
-function splitFilePath(p: string): string[] {
-	return p.split(path.sep);
-}
-
+// resolve module paths relative to the current working directory
 function resolveModulePath(module: string) {
 	return path.join(process.cwd(), module);
 }
 
+function exists(filepath: string): boolean {
+	try {
+		fs.access(filepath);
+		return true;
+	} catch (err) {
+		return false;
+	}
+}
 
-export { readDir, ext, splitFilePath, resolveModulePath };
+export { readDir, resolveModulePath, exists };

package/lib/logger/color.ts

@@ -1,36 +1,36 @@
 const Colors: Record<string,string> = {
-    reset: "\x1b[0m",
+	reset: '\x1b[0m',
   
-    // foreground
-    black: "\x1b[30m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-    white: "\x1b[37m",
+	// foreground
+	black: '\x1b[30m',
+	red: '\x1b[31m',
+	green: '\x1b[32m',
+	yellow: '\x1b[33m',
+	blue: '\x1b[34m',
+	magenta: '\x1b[35m',
+	cyan: '\x1b[36m',
+	white: '\x1b[37m',
   
-    // background
-    bgBlack: "\x1b[40m",
-    bgRed: "\x1b[41m",
-    bgGreen: "\x1b[42m",
-    bgYellow: "\x1b[43m",
-    bgBlue: "\x1b[44m",
-    bgMagenta: "\x1b[45m",
-    bgCyan: "\x1b[46m",
-    bgWhite: "\x1b[47m",
-  } as const;
+	// background
+	bgBlack: '\x1b[40m',
+	bgRed: '\x1b[41m',
+	bgGreen: '\x1b[42m',
+	bgYellow: '\x1b[43m',
+	bgBlue: '\x1b[44m',
+	bgMagenta: '\x1b[45m',
+	bgCyan: '\x1b[46m',
+	bgWhite: '\x1b[47m',
+} as const;
 
   
 
 function color(foreground: string, background: string, message: string) {
-  const _foreground = Colors[foreground];
-  const _background = Colors[background];
-  const reset = Colors.reset;
-  return `${_foreground}${_background}${message}${reset}`;
+	const _foreground = Colors[foreground];
+	const _background = Colors[background];
+	const reset = Colors.reset;
+	return `${_foreground}${_background}${message}${reset}`;
 }
 
 
   
-export { color }
+export { color };

package/lib/logger/logger.d.ts

@@ -5,4 +5,4 @@ type BunLogger = {
     message: (message: string) => void,
 }
 
-export { BunLogger }
+export { BunLogger };

package/lib/logger/logger.ts

@@ -9,7 +9,7 @@ _                          _
 |___|___|_|_|  |_| |___|___|_| |___|_|  
                                                                                     
 `;
-const VERSION = '0.7.4-experimental.5';
+const VERSION = '0.7.4-experimental.7';
 const Logger = (): BunLogger => {
 	return {
 		info: async (statusCode: number, routePath: string, method: string, message?: string) => {

package/lib/router/context.ts

@@ -6,8 +6,8 @@ import { http } from './router';
 import { ReactNode } from 'react';
 
 async function createContext(path: string, route: Route, request: Request): Promise<Context> {
-	const params = extractParams(path, route);
 	const query = new URLSearchParams(path);
+	const params = extractParams(path, route);
 	const formData = isMultiPartForm(request.headers) ? await request.formData() : new FormData();
 
 	return Promise.resolve({
@@ -21,16 +21,16 @@ async function createContext(path: string, route: Route, request: Request): Prom
 	});
 }
 
-function extractParams(path: string, route: Route): Map<string, string> {
+function extractParams(pattern: string, route: Route): Map<string, string> {
 	const params: Map<string, string> = new Map();
-	const pathSegments = path.split('/');
+	const pathSegments = pattern.split('/');
 	const routeSegments = route.path.split('/');
 
 	if (pathSegments.length !== routeSegments.length) return params;
 
 	for (let i = 0; i < pathSegments.length; i++) {
 		if (routeSegments[i][0] === ':') {
-			const key = routeSegments[i].replace(':', '');
+			const key = routeSegments[i].slice(1);
 			const value = pathSegments[i];
 			params.set(key, value);
 		}
@@ -41,8 +41,7 @@ function extractParams(path: string, route: Route): Map<string, string> {
 
 function getContentType(headers: Headers): string {
 	const contentType = headers.get('Content-Type');
-	if (!contentType) return '';
-	return contentType;
+	return contentType ?? '';
 }
 
 function isMultiPartForm(headers: Headers): boolean {

package/lib/router/{tree.ts → routeTree.ts}

@@ -1,7 +1,6 @@
 import { HttpHandler, Route } from './router.d';
 import { http } from '../http/http';
 import { createContext } from './context';
-import { splitPath } from '../util/strings';
 
 const createRoute = (path: string, method: string, handler: HttpHandler): Route => {
 	const route: Route = {
@@ -19,8 +18,8 @@ const createRoute = (path: string, method: string, handler: HttpHandler): Route
 const RouteTree = () => {
 	const root = createRoute('', 'GET', () => http.notFound());
 
-	const addRoute = (path: string, method: string, handler: HttpHandler) => {
-		const pathParts = splitPath(path);
+	const addRoute = (pattern: string, method: string, handler: HttpHandler) => {
+		const pathParts = pattern.split('/');
 		let current = root;
 
 		for (let i = 0; i < pathParts.length; i++) {
@@ -36,11 +35,11 @@ const RouteTree = () => {
 
 		current.handler = handler;
 		current.isLast = true;
-		current.path = path;
+		current.path = pattern;
 	};
 
-	function findRoute(path: string): Route | undefined {
-		const pathParts = splitPath(path);
+	function findRoute(pathname: string): Route | undefined {
+		const pathParts = pathname.split('/');
 		let current = root;
 		for (let i = 0; i < pathParts.length; i++) {
 			const part = pathParts[i];

package/lib/router/router.ts

@@ -2,21 +2,34 @@ import path from 'path';
 import { Database } from 'bun:sqlite';
 import { Route, BunRouter, RouterOptions, Options, HttpHandler } from './router.d';
 import { httpStatusCodes } from '../http/status';
-import { readDir, resolveModulePath } from '../fs/fsys';
+import { readDir, exists } from '../fs/fsys';
 import { Logger, startMessage } from '../logger/logger';
 import { http } from '../http/http';
-import { RouteTree } from './tree';
+import { RouteTree } from './routeTree';
 import { createContext } from './context';
 
 const Router: BunRouter = (port?: number | string, options?: RouterOptions<Options>) => {
 	const { addRoute, findRoute } = RouteTree();
 	const logger = Logger();
 
-	async function loadComponent(name: string) {
-		const module = await import(name);
+	async function loadComponent(root: string, name: string) {
+		const module = await import(path.join(process.cwd(), root, name));
 		return module.default;
 	}
 
+	function normalizePath(pattern: string, pathname: string) {
+		const extension = path.extname(pathname);
+		let base = path.basename(pathname);
+
+		if (extension === '.html' || extension === '.tsx') base = base.replace(extension, '');
+
+		let patternPath = [pattern, base].join('/');
+
+		if (base === 'index') patternPath = pattern;
+		
+		return { patternPath, extension, base }
+	}
+
 	return {
 		// add a route to the router tree 
 		add: (pattern, method, callback) => { addRoute(pattern, method, callback); },
@@ -26,35 +39,23 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 		delete: (pattern, callback) => { addRoute(pattern, 'DELETE', callback); },
         
 		// add static routes to the router tree
-		// .tsx and .html are rendered as components
+		// .tsx and .html are rendered as components, or pages
 		// all other file extensions are served as files
 		// the root directory is traversed recursively
 		static: async (pattern: string, root: string) => {
+			if (!exists(root)) console.log(`Cannot find directory ${root}`);
 			await readDir(root, async (fp) => {
-				const ext = path.extname(fp);
-
-				let base = path.basename(fp);
-
-				//FIXME: this can be improved
-				if (ext === '.html' || ext === '.tsx') base = base.replace(ext, '');
-
-				if (pattern[0] !== '/') pattern = '/' + pattern;
-
-				let patternPath = pattern + '/' + base;
-
-				if (base === 'index') patternPath = pattern;
-
-				const purePath = path.join(root, patternPath);
+				const { patternPath, extension, base } = normalizePath(pattern, fp);
 
 				const route: Route = {
 					children: new Map(),
 					dynamicPath: '',
 					isLast: true,
-					path: patternPath,
+					path: patternPath.slice(1),
 					method: 'GET',
 					handler: async () => {
-						if (ext === '.tsx') {
-							const component = await loadComponent(resolveModulePath(purePath.split('.')[0]));
+						if (extension === '.tsx') {
+							const component = await loadComponent(root, base);
 							return await http.render(component());
 						} else {
 							return await http.file(200, fp);
@@ -62,6 +63,8 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 					},
 				};
 
+				console.log(route.path);
+
 				addRoute(route.path, 'GET', route.handler);
 			});
 		},
@@ -75,7 +78,7 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 				...options,
 				async fetch(req) {
 					const url = new URL(req.url);
-					const path = url.pathname;
+					const pathname = url.pathname;
 
 					// set the database
 					if (options) {
@@ -83,16 +86,16 @@ const Router: BunRouter = (port?: number | string, options?: RouterOptions<Optio
 						opts.db = o.db;
 					}
 
-					const route = findRoute(path);
+					const route = findRoute(pathname);
 
-					// if the route exists, execute the handler
+					// if the route exists, call the handler
 					if (route) {
 						if (route.method !== req.method) {
 							logger.info(405, url.pathname, req.method, httpStatusCodes[405]);
 							return Promise.resolve(http.methodNotAllowed());
 						}
 
-						const context = await createContext(path, route, req);
+						const context = await createContext(pathname, route, req);
 						context.db = new Database(opts.db);
 
 						const response = await route.handler(context);

package/package.json

@@ -14,7 +14,7 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.7.4-experimental.5",
+  "version": "0.7.4-experimental.7",
   "dependencies": {
     "@types/react": "^18.2.22",
     "eslint-plugin-react-hooks": "^4.6.0",

package/tsconfig.json

@@ -19,7 +19,6 @@
       "bun-types" // add Bun global
     ],
     "paths": {
-      "examples/*": ["./examples/*"],
     }
   },
 }

package/lib/resolver/resolver.test.ts

@@ -1,5 +0,0 @@
-import { resolveModules } from './resolver';
-
-const modules = await resolveModules('../lib/resolver/testdir');
-
-console.log(modules.length);

package/lib/resolver/resolver.ts

@@ -1,43 +0,0 @@
-import { FileTree } from '../fs/filetree';
-import { readDir } from '../fs/fsys';
-import { ComponentType } from 'react';
-
-async function createFileTree(root: string) {
-	const tree = FileTree(root);
-
-	await readDir(root, (fp) => {
-		tree.addFile(fp);
-	});
-
-	return tree;
-}
-
-async function resolveModules(root: string) {
-
-	if (!await doesExist(root)) {
-		throw new Error(`Directory ${root} does not exist`);
-	}
-
-	const tree = await createFileTree(root);
-	const files = tree.getFilesByExtension('.tsx');
-	const modules: ComponentType[] = [];
-
-	for (const file of files) {
-		const module = await import(file);
-		modules.push(module);
-	}
-	return modules;
-}
-
-async function doesExist(root: string): Promise<boolean> {
-	const file =  Bun.file(root);
-	return await file.exists();
-}
-
-async function isDir(root: string): Promise<boolean> {
-	const file =  Bun.file(root);
-	return await file.isDir();
-}
-
-
-export { resolveModules };

package/lib/resolver/testdir/foo.tsx

@@ -1,5 +0,0 @@
-import React from 'react';
-
-export default function foo() {
-	return <div>foo</div>;
-}

package/lib/util/strings.ts

@@ -1,3 +0,0 @@
-const splitPath = (path: string): string[] => path.split('/').filter(Boolean);
-
-export { splitPath }