elm-ssr 0.5.1 → 0.6.0

package/bin/elm-ssr.mjs

@@ -1,21 +1,14 @@
 #!/usr/bin/env bun
 
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { watch } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { createAppScaffold } from "../lib/scaffold.mjs";
 import { readWorkspaceConfig } from "../lib/workspace.mjs";
 import { build } from "../lib/build.mjs";
 import { migrate } from "../lib/migrate.mjs";
 
 const defaultRootPath = process.cwd();
-const packageJsonPath = resolve(defaultRootPath, "package.json");
-
-let packageJson = { name: "unknown" };
-try {
-  packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-} catch {
-  // Not in a package root, that's okay for some commands
-}
 const args = process.argv.slice(2);
 const command = args[0] ?? "help";
 
@@ -24,7 +17,34 @@ const findFlagValue = (flagName) => {
   return index >= 0 ? args[index + 1] : undefined;
 };
 
-const rootPath = resolve(findFlagValue("--root") ?? defaultRootPath);
+const findWorkspaceRoot = async (startPath) => {
+  let current = startPath;
+  while (true) {
+    try {
+      const configPath = resolve(current, "elm-ssr.config.json");
+      await stat(configPath);
+      return current;
+    } catch {
+      const parent = dirname(current);
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  return startPath;
+};
+
+const userRoot = findFlagValue("--root");
+const rootPath = resolve(userRoot ?? await findWorkspaceRoot(defaultRootPath));
+const packageJsonPath = resolve(rootPath, "package.json");
+
+let packageJson = { name: "unknown" };
+try {
+  packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+} catch {
+  // Not in a package root, that's okay for some commands
+}
 
 const run = async (cmd, cmdArgs, cwd = rootPath) => {
   const child = Bun.spawn([cmd, ...cmdArgs], {
@@ -48,6 +68,7 @@ const printHelp = () => {
   build         Generate wrapper modules and compile configured Elm SSR apps
   compress      Pre-compress island and app bundles using Gzip for faster edge delivery
   dev           Build and start wrangler dev using the current workspace config
+  init <name>   Initialize a self-contained single-app project in the current directory
   new <name>    Create a new app at <workspace>/<name>/ (or <workspace>/<subdir>/<name>/
                 with --in <subdir>) and register it in elm-ssr.config.json
   routes        Print configured apps and their public modules
@@ -80,11 +101,98 @@ switch (command) {
     await build({ rootPath, config });
     break;
 
-  case "dev":
+  case "dev": {
     requireConfig();
-    await run("bun", ["run", "build"], rootPath);
-    await run("./node_modules/.bin/wrangler", ["dev"], rootPath);
+    if (packageJson && packageJson.scripts && packageJson.scripts.build) {
+      await run("bun", ["run", "build"], rootPath);
+    } else {
+      await build({ rootPath, config });
+    }
+
+    let buildTimeout = null;
+    const triggerBuild = () => {
+      if (buildTimeout) clearTimeout(buildTimeout);
+      buildTimeout = setTimeout(async () => {
+        console.log("\n[elm-ssr] File change detected. Rebuilding...");
+        try {
+          await build({ rootPath, config });
+          console.log("[elm-ssr] Rebuild successful.");
+        } catch (err) {
+          console.error("[elm-ssr] Rebuild failed:", err);
+        }
+      }, 100);
+    };
+
+    const watchers = [];
+    for (const app of config.apps) {
+      const srcDir = resolve(rootPath, app.root, "src");
+      try {
+        const watcher = watch(srcDir, { recursive: true }, (eventType, filename) => {
+          if (filename && filename.endsWith(".elm")) {
+            triggerBuild();
+          }
+        });
+        watchers.push(watcher);
+      } catch (err) {
+        console.warn(`[elm-ssr] Could not watch directory ${srcDir}:`, err);
+      }
+    }
+
+    const cleanup = () => {
+      for (const w of watchers) w.close();
+    };
+
+    process.on("SIGINT", cleanup);
+    process.on("exit", cleanup);
+
+    let wranglerCmd = "./node_modules/.bin/wrangler";
+    let wranglerArgs = ["dev"];
+    try {
+      await readFile(resolve(rootPath, wranglerCmd));
+    } catch {
+      wranglerCmd = "bunx";
+      wranglerArgs = ["wrangler", "dev"];
+    }
+
+    let hasWranglerConfig = false;
+    try {
+      const tomlContent = await readFile(resolve(rootPath, "wrangler.toml"), "utf8");
+      if (tomlContent.trim().length > 0) hasWranglerConfig = true;
+    } catch {}
+    try {
+      const jsonContent = await readFile(resolve(rootPath, "wrangler.jsonc"), "utf8");
+      if (jsonContent.trim().length > 0) hasWranglerConfig = true;
+    } catch {}
+
+    if (!hasWranglerConfig) {
+      const app = config.apps[0];
+      if (app) {
+        wranglerArgs.push(`${app.root}/worker.ts`);
+        wranglerArgs.push("--compatibility-date", "2026-05-28");
+        wranglerArgs.push("--compatibility-flags", "nodejs_compat");
+      }
+    }
+
+    try {
+      await run(wranglerCmd, wranglerArgs, rootPath);
+    } finally {
+      cleanup();
+    }
     break;
+  }
+
+  case "init": {
+    const name = args[1];
+
+    if (!name) {
+      console.error("Usage: elm-ssr init <name>");
+      process.exit(1);
+    }
+
+    const created = await createAppScaffold(rootPath, name, { root: "." });
+    console.log(`Initialized ${created.name} in current directory`);
+    break;
+  }
 
   case "new": {
     const name = args[1];

package/lib/scaffold.mjs

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { readWorkspaceConfig, writeWorkspaceConfig } from "./workspace.mjs";
 
@@ -276,8 +276,8 @@ const runtimeTemplate = (appRoot) => {
   // appRoot is a slash-separated path like "my-app" or "apps/my-app".
   // The generated bundles live at <workspaceRoot>/generated/<appRoot>/. From
   // <workspaceRoot>/<appRoot>/runtime.ts, we climb out by one ".." per segment.
-  const upToRoot = appRoot.split("/").map(() => "..").join("/");
-  const generatedPrefix = `${upToRoot}/generated/${appRoot}`;
+  const upToRoot = appRoot === "." ? "." : appRoot.split("/").map(() => "..").join("/");
+  const generatedPrefix = `${upToRoot}/generated/${appRoot === "." ? "" : appRoot}`.replace(/\/+$/, "");
   return `import { createWorkerApp } from "elm-ssr";
 import { renderApp, type CompiledElmModule } from "elm-ssr/render";
 import type { RouteCatalog } from "elm-ssr/http";
@@ -467,6 +467,38 @@ const normalizeAppRoot = (rawRoot, name) => {
   return candidate;
 };
 
+const ensurePackageJson = async (rootPath, appName) => {
+  const packageJsonPath = resolve(rootPath, "package.json");
+  let packageJson = {};
+  try {
+    packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  } catch {
+    packageJson = {
+      name: appName,
+      version: "0.1.0",
+      type: "module",
+      scripts: {},
+      devDependencies: {}
+    };
+  }
+
+  packageJson.scripts = {
+    build: "elm-ssr build",
+    dev: "elm-ssr dev",
+    routes: "elm-ssr routes",
+    migrate: "elm-ssr migrate",
+    ...packageJson.scripts
+  };
+
+  packageJson.devDependencies = {
+    "elm-ssr": "latest",
+    wrangler: "^4.0.0",
+    ...packageJson.devDependencies
+  };
+
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
+};
+
 /**
  * Scaffold a new elm-ssr app under `<rootPath>/<appRoot>/` and register it in
  * elm-ssr.config.json. `appRoot` defaults to the app's `name`; pass an
@@ -502,6 +534,8 @@ export const createAppScaffold = async (rootPath, name, options = {}) => {
     apps: [...config.apps, configEntry]
   });
 
+  await ensurePackageJson(rootPath, name);
+
   return configEntry;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-ssr",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Elm-first SSR library and framework for Cloudflare Workers (and Bun): file-based routes/islands, backend-neutral effect adapters (KV/D1/Redis/Postgres), background tasks (waitUntil/Queues), SQL-file migrations, CLI scaffold + build.",
   "license": "MIT",
   "author": "Michał Majchrzak <michmajchrzak@gmail.com>",