fulgur 0.0.1

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "fulgur",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Vite-native fullstack framework powered by Bun, Vite and Elysia.",
+  "author": {
+    "name": "Pierre Houllière",
+    "email": "hi@houlliere.com",
+    "url": "https://github.com/wiizzl"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "directory": "packages/core",
+    "url": "git+https://github.com/wiizzl/fulgur.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wiizzl/fulgur/issues"
+  },
+  "keywords": [
+    "vite",
+    "elysia",
+    "bun",
+    "framework",
+    "rpc",
+    "fullstack"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./server": {
+      "import": "./src/server.ts"
+    },
+    "./client": {
+      "import": "./src/client.ts"
+    },
+    "./vite": {
+      "import": "./src/plugin/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "vite": "^8.0.14"
+  },
+  "dependencies": {
+    "@elysia/static": "^1.4.11",
+    "@elysia/eden": "^1.4.10",
+    "elysia": "^1.4.28"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "typescript": "^6.0.3"
+  }
+}

package/src/client.ts

@@ -0,0 +1 @@
+export * from "@elysia/eden";

package/src/plugin/generator.ts

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Glob } from "bun";
+
+const ensureDir = (path: string) => {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+};
+
+export function generateTsConfig(root: string) {
+  const pluginDir = resolve(root, ".fulgur");
+  ensureDir(pluginDir);
+
+  const tsconfigContent = {
+    compilerOptions: {
+      moduleResolution: "bundler",
+      module: "ESNext",
+      paths: {
+        "fulgur/api": ["./api.ts"],
+      },
+    },
+  };
+
+  writeFileSync(join(pluginDir, "tsconfig.paths.json"), JSON.stringify(tsconfigContent, null, 2));
+}
+
+export function generateClient(root: string) {
+  const pluginDir = resolve(root, ".fulgur");
+
+  ensureDir(pluginDir);
+  generateTsConfig(root);
+
+  const normalizePath = (filePath: string) => filePath.replaceAll("\\", "/");
+  const shouldIgnore = (filePath: string) => {
+    const normalized = normalizePath(filePath);
+    return (
+      normalized.startsWith("node_modules/") ||
+      normalized.includes("/node_modules/") ||
+      normalized.startsWith("dist/") ||
+      normalized.startsWith(".fulgur/")
+    );
+  };
+
+  const toSafeName = (filePath: string) => {
+    const normalized = normalizePath(filePath);
+    const base = normalized.replace(/[^\w]/g, "_").replace(/^_+|_+$/g, "");
+    const hash = createHash("sha1").update(normalized).digest("hex").slice(0, 8);
+    const candidate = base ? `${base}_${hash}` : `route_${hash}`;
+    return /^\d/.test(candidate) ? `_${candidate}` : candidate;
+  };
+
+  const glob = new Glob("**/*.server.ts");
+  const files = Array.from(glob.scanSync(root))
+    .map((file) => normalizePath(file))
+    .filter((file) => !shouldIgnore(file))
+    .sort((a, b) => a.localeCompare(b));
+
+  const routeFiles = files.filter((file) => {
+    try {
+      const absolutePath = join(root, file);
+      const content = readFileSync(absolutePath, "utf-8");
+
+      return /export\s+(const|let|var)\s+fulgur\s*=/.test(content);
+    } catch {
+      return false;
+    }
+  });
+
+  const importsCode = routeFiles
+    .map((file) => {
+      const safeName = toSafeName(file);
+      const importPath = file.replace(/\.ts$/, "");
+      return `import { fulgur as ${safeName} } from "../${importPath}";`;
+    })
+    .join("\n");
+
+  const useCode = routeFiles
+    .map((file) => {
+      const safeName = toSafeName(file);
+      return `  .use(${safeName})`;
+    })
+    .join("\n");
+
+  const routerTemplate = `import { Elysia } from "fulgur/server";
+${importsCode}
+export const appRouter = new Elysia()
+${useCode};
+export type AppRouter = typeof appRouter;
+`;
+
+  const apiTemplate = `import { treaty } from "fulgur/client";
+import type { AppRouter } from "./router";
+export const api = treaty<AppRouter>(typeof window !== "undefined" ? \`\${window.location.origin}/api\` : "");
+`;
+
+  writeFileSync(join(pluginDir, "router.ts"), routerTemplate);
+  writeFileSync(join(pluginDir, "api.ts"), apiTemplate);
+}

package/src/plugin/index.ts

@@ -0,0 +1,132 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { type AddressInfo, createServer } from "node:net";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Plugin, ResolvedConfig } from "vite";
+
+import { generateClient } from "./generator";
+
+const getAvailablePort = async (): Promise<number> => {
+  const server = createServer();
+
+  server.listen(0);
+
+  await once(server, "listening");
+
+  const { port } = server.address() as AddressInfo;
+
+  server.close();
+  await once(server, "close");
+
+  return port;
+};
+
+const runnerPath = fileURLToPath(import.meta.resolve("./runner.ts"));
+
+export default function fulgur(): Plugin {
+  let backendProcess: ReturnType<typeof spawn> | null = null;
+  let viteConfig: ResolvedConfig;
+  let port: number;
+  let restartTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  const killBackend = () => {
+    if (backendProcess && !backendProcess.killed) {
+      backendProcess.kill("SIGTERM");
+      backendProcess = null;
+    }
+  };
+
+  const startOrRestartBackend = () => {
+    killBackend();
+
+    backendProcess = spawn("bun", ["run", runnerPath], {
+      stdio: "pipe",
+      env: {
+        ...process.env,
+        FULGUR_PORT: port.toString(),
+        FULGUR_ROOT: viteConfig.root,
+      },
+    });
+
+    backendProcess.stdout?.on("data", (data) => {
+      process.stdout.write(`[Fulgur] ${data}`);
+    });
+
+    backendProcess.stderr?.on("data", (data) => {
+      process.stderr.write(`[Fulgur] ${data}`);
+    });
+  };
+
+  const debouncedRestart = () => {
+    if (restartTimeout) {
+      clearTimeout(restartTimeout);
+    }
+
+    restartTimeout = setTimeout(() => {
+      startOrRestartBackend();
+    }, 150);
+  };
+
+  return {
+    name: "vite-plugin-fulgur",
+    enforce: "pre",
+    load(id) {
+      if (id.includes(".server.ts")) {
+        throw new Error(`You can't import server code into the client in ${id}.`);
+      }
+    },
+    async config(userConfig) {
+      const root = userConfig.root || process.cwd();
+      port = await getAvailablePort();
+
+      return {
+        resolve: {
+          alias: {
+            "fulgur/api": resolve(root, ".fulgur/api.ts"),
+          },
+        },
+        server: {
+          proxy: {
+            "/api": {
+              target: `http://localhost:${port}`,
+              changeOrigin: true,
+              rewrite: (path) => path.replace(/^\/api/, ""),
+            },
+          },
+        },
+      };
+    },
+    configResolved(config) {
+      viteConfig = config;
+    },
+    buildStart() {
+      generateClient(viteConfig.root);
+    },
+    configureServer(server) {
+      startOrRestartBackend();
+
+      server.httpServer?.once("close", killBackend);
+      process.on("SIGINT", () => {
+        killBackend();
+        process.exit();
+      });
+      process.on("SIGTERM", () => {
+        killBackend();
+        process.exit();
+      });
+      process.on("exit", killBackend);
+
+      server.watcher.on("all", (_, path) => {
+        if (path.endsWith(".server.ts")) {
+          generateClient(viteConfig.root);
+          debouncedRestart();
+        }
+      });
+    },
+    configurePreviewServer() {
+      console.log("This command has been disabled by Fulgur.");
+      process.exit(1);
+    },
+  };
+}

package/src/plugin/runner.ts

@@ -0,0 +1,51 @@
+import { join } from "node:path";
+import { Glob } from "bun";
+import { Elysia } from "elysia";
+
+async function startServer() {
+  const root = process.env.FULGUR_ROOT;
+  const port = process.env.FULGUR_PORT;
+
+  if (!root || !port) {
+    console.error("Some environment variables not set");
+    return;
+  }
+
+  const glob = new Glob("**/*.server.ts");
+  const api = new Elysia();
+
+  const normalizePath = (filePath: string) => filePath.replaceAll("\\", "/");
+  const shouldIgnore = (filePath: string) => {
+    const normalized = normalizePath(filePath);
+    return (
+      normalized.startsWith("node_modules/") ||
+      normalized.includes("/node_modules/") ||
+      normalized.startsWith("dist/") ||
+      normalized.startsWith(".fulgur/")
+    );
+  };
+
+  for await (const relativePath of glob.scan(root)) {
+    const normalized = normalizePath(relativePath);
+    if (shouldIgnore(normalized)) {
+      continue;
+    }
+
+    const absolutePath = join(root, normalized);
+
+    try {
+      const module = await import(absolutePath);
+
+      if (module.fulgur && module.fulgur instanceof Elysia) {
+        api.use(module.fulgur);
+      }
+    } catch (error) {
+      console.error(`Error in ${absolutePath}:`, error);
+    }
+  }
+
+  console.log(`Server running on http://localhost:${port}`);
+  api.listen(port);
+}
+
+startServer();

package/src/server.ts

@@ -0,0 +1,3 @@
+export { staticPlugin } from "@elysia/static";
+
+export * from "elysia";

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}