blumenjs 0.1.0

package/dist/templates/scripts/generate-routes.ts

@@ -0,0 +1,220 @@
+/**
+ * Blumen Route Generator
+ *
+ * Scans app/pages/ recursively for .tsx files and auto-generates:
+ *   1. node-ssr/generated-routes.ts    — SSR route map
+ *   2. app/client/generated-routes.ts — Client hydration route map
+ *
+ * Features:
+ *   - Nested folders (e.g. pages/dashboard/settings.tsx -> /dashboard/settings)
+ *   - Dynamic routes (e.g. pages/users/[id].tsx -> /users/:id)
+ *   - Default exports (any component name allowed internally)
+ *
+ * Convention:
+ *   - Home.tsx        → "/"  (index route)
+ *   - index.tsx       → "/"  (index route for folders)
+ *   - NotFound.tsx    → skipped (reserved 404)
+ *   - _app.tsx        → skipped (reserved prefix)
+ *
+ * Usage:  npx tsx scripts/generate-routes.ts
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const PAGES_DIR = path.resolve("app/pages");
+const SSR_OUTPUT = path.resolve("node-ssr/generated-routes.ts");
+const CLIENT_OUTPUT = path.resolve("app/client/generated-routes.ts");
+
+// Reserved filenames that should not become routes
+const RESERVED = new Set(["NotFound", "NotFound.tsx"]);
+
+interface RouteEntry {
+	/** The URL path, e.g. "/" or "/users/[id]" */
+	route: string;
+	/** The unique component identifier for imports, e.g. "Page_users_id" */
+	componentId: string;
+	/** The relative file path without extension, e.g. "users/[id]" */
+	importPath: string;
+	/** Regex string for matching the route */
+	patternStr: string;
+	/** Extracted parameter keys */
+	keys: string[];
+}
+
+function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
+	let results: RouteEntry[] = [];
+	const items = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (const item of items) {
+		const fullPath = path.join(dir, item.name);
+		const relPath = path.relative(baseDir, fullPath);
+
+		if (item.isDirectory()) {
+			results = results.concat(scanDir(fullPath, baseDir));
+		} else if (item.isFile() && item.name.endsWith(".tsx")) {
+			const name = item.name;
+			const nameNoExt = name.replace(".tsx", "");
+
+			// Skip reserved and underscore-prefixed files/folders
+			if (name.startsWith("_") || RESERVED.has(name) || relPath.includes("/_")) {
+				continue;
+			}
+
+			// Generate the URL route (lowercased for friendly URLs)
+			let routePath = "/" + relPath.replace(".tsx", "").replace(/\\/g, "/").toLowerCase();
+			
+			// Handle index files
+			if (nameNoExt.toLowerCase() === "home" && routePath === "/home") {
+				routePath = "/";
+			} else if (routePath.endsWith("/index")) {
+				routePath = routePath.replace("/index", "") || "/";
+			}
+
+			// Generate a safe identifier for import
+			const componentId = "Page_" + relPath.replace(".tsx", "").replace(/[^a-zA-Z0-9]/g, "_");
+			
+			// Parse bracket syntax for dynamic parameters
+			const keys: string[] = [];
+			let patternStr = routePath.replace(/\[([^\]]+)\]/g, (_, key) => {
+				keys.push(key);
+				return "([^/]+)";
+			});
+
+			if (patternStr === "/") {
+				patternStr = "^\\/$";
+			} else {
+				patternStr = `^${patternStr}$`;
+			}
+
+			results.push({
+				route: routePath,
+				componentId,
+				importPath: relPath.replace(".tsx", "").replace(/\\/g, "/"),
+				patternStr,
+				keys
+			});
+		}
+	}
+
+	return results;
+}
+
+function discoverPages(): RouteEntry[] {
+	const routes = scanDir(PAGES_DIR);
+
+	// Sort so specific routes come before dynamic ones, and "/" comes first
+	routes.sort((a, b) => {
+		if (a.route === "/") return -1;
+		if (b.route === "/") return 1;
+		// Push dynamic routes (with brackets) lower down the list
+		const aIsDynamic = a.route.includes("[");
+		const bIsDynamic = b.route.includes("[");
+		if (aIsDynamic && !bIsDynamic) return 1;
+		if (!aIsDynamic && bIsDynamic) return -1;
+		return a.route.localeCompare(b.route);
+	});
+
+	return routes;
+}
+
+function generateRouteFile(
+	routes: RouteEntry[],
+	importPathPrefix: string,
+	isServer: boolean,
+): string {
+	const header = [
+		"// ┌─────────────────────────────────────────────┐",
+		"// │  AUTO-GENERATED — DO NOT EDIT               │",
+		"// │  Run `npm run routes` to regenerate          │",
+		"// └─────────────────────────────────────────────┘",
+		"",
+		'import React from "react";',
+		"",
+	];
+
+	// Import default exports!
+	const imports = routes.map(
+		(r) =>
+			`import ${r.componentId} from "${importPathPrefix}/${r.importPath}";`,
+	);
+
+	const hasApp = fs.existsSync(path.join(PAGES_DIR, "_app.tsx"));
+	const hasDoc = fs.existsSync(path.join(PAGES_DIR, "_document.tsx"));
+
+	const appImport = hasApp 
+		? `import CustomApp from "${importPathPrefix}/_app";\nexport const App = CustomApp;` 
+		: `import { DefaultApp } from "${importPathPrefix}/../shared/DefaultApp";\nexport const App = DefaultApp;`;
+	
+	let docImport = "";
+	if (isServer) {
+		docImport = hasDoc 
+			? `import CustomDocument from "${importPathPrefix}/_document";\nexport const Document = CustomDocument;` 
+			: `import { DefaultDocument } from "${importPathPrefix}/../shared/DefaultDocument";\nexport const Document = DefaultDocument;`;
+	}
+
+	const routeObjects = routes.map(r => {
+		const keysArray = r.keys.length > 0 ? `["${r.keys.join('", "')}"]` : "[]";
+		return `\t{
+\t\tpath: "${r.route}",
+\t\tpattern: new RegExp("${r.patternStr.replace(/\\/g, '\\\\')}"),
+\t\tkeys: ${keysArray},
+\t\tcomponent: ${r.componentId}
+\t}`;
+	});
+
+	const map = [
+		"",
+		"export interface RouteDef {",
+		"\tpath: string;",
+		"\tpattern: RegExp;",
+		"\tkeys: string[];",
+		"\tcomponent: React.ComponentType<any>;",
+		"}",
+		"",
+		"export const routes: RouteDef[] = [",
+		routeObjects.join(",\n"),
+		"];",
+		"",
+		appImport,
+		docImport,
+		"",
+	];
+
+	return [...header, ...imports, ...map].join("\n");
+}
+
+function main() {
+	console.log("🌸 Blumen Route Generator (Next.js Style)");
+	console.log(`   Scanning: ${PAGES_DIR}`);
+
+	const routes = discoverPages();
+
+	if (routes.length === 0) {
+		console.error("   ❌ No pages found!");
+		process.exit(1);
+	}
+
+	console.log(`   Found ${routes.length} route(s):`);
+	for (const r of routes) {
+		console.log(`     ${r.route.padEnd(25)} → ${r.importPath}.tsx`);
+	}
+
+	// Generate SSR routes (node-ssr/ → ../app/pages)
+	const ssrContent = generateRouteFile(routes, "../app/pages", true);
+	fs.mkdirSync(path.dirname(SSR_OUTPUT), { recursive: true });
+	fs.writeFileSync(SSR_OUTPUT, ssrContent, "utf-8");
+	console.log(`   ✅ Written: ${path.relative(process.cwd(), SSR_OUTPUT)}`);
+
+	// Generate Client routes (app/client/ → ../pages)
+	const clientContent = generateRouteFile(routes, "../pages", false);
+	fs.mkdirSync(path.dirname(CLIENT_OUTPUT), { recursive: true });
+	fs.writeFileSync(CLIENT_OUTPUT, clientContent, "utf-8");
+	console.log(
+		`   ✅ Written: ${path.relative(process.cwd(), CLIENT_OUTPUT)}`,
+	);
+
+	console.log("   🎉 Routes generated successfully!");
+}
+
+main();

package/package.json

@@ -0,0 +1,77 @@
+{
+	"name": "blumenjs",
+	"version": "0.1.0",
+	"description": "The React framework powered by Go. Lightning-fast SSR with the DX you deserve.",
+	"type": "module",
+	"bin": {
+		"blumen": "./dist/cli/blumen.js",
+		"blumenjs": "./dist/cli/blumen.js"
+	},
+	"files": [
+		"dist/cli/**/*",
+		"dist/templates/**/*",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"routes": "tsx scripts/generate-routes.ts",
+		"dev": "tsx cli/blumen.ts dev",
+		"build": "tsx cli/blumen.ts build",
+		"start": "tsx cli/blumen.ts start",
+		"create": "tsx cli/blumen.ts create",
+		"build:cli": "tsx cli/build-cli.ts",
+		"prepublishOnly": "npm run build:cli",
+		"dev:legacy": "npm run routes && concurrently \"npm run dev:client\" \"npm run dev:ssr\" \"npm run dev:go\"",
+		"dev:client": "webpack serve --mode development",
+		"dev:ssr": "NODE_ENV=development tsx watch node-ssr/server.ts",
+		"dev:go": "go run go-server/main.go",
+		"build:client": "webpack --mode production",
+		"build:ssr": "esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --external:react --external:react-dom",
+		"clean": "rm -rf dist static/js/bundle.js"
+	},
+	"keywords": [
+		"react",
+		"go",
+		"ssr",
+		"server-side-rendering",
+		"framework",
+		"blumen",
+		"hmr",
+		"cli"
+	],
+	"author": "",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": ""
+	},
+	"homepage": "",
+	"dependencies": {
+		"lucide-react": "^1.14.0",
+		"react": "^18.2.0",
+		"react-dom": "^18.2.0"
+	},
+	"devDependencies": {
+		"@babel/core": "^7.29.0",
+		"@babel/preset-env": "^7.29.5",
+		"@babel/preset-react": "^7.28.5",
+		"@babel/preset-typescript": "^7.28.5",
+		"@pmmmwh/react-refresh-webpack-plugin": "^0.6.2",
+		"@types/node": "^20.10.0",
+		"@types/react": "^18.2.0",
+		"@types/react-dom": "^18.2.0",
+		"babel-loader": "^10.1.1",
+		"concurrently": "^8.2.2",
+		"esbuild": "^0.19.0",
+		"react-refresh": "^0.18.0",
+		"ts-loader": "^9.5.1",
+		"tsx": "^4.6.0",
+		"typescript": "^5.3.0",
+		"webpack": "^5.89.0",
+		"webpack-cli": "^5.1.4",
+		"webpack-dev-server": "^5.2.3"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	}
+}