tina4-nodejs 3.11.2 → 3.11.5

package/package.json

@@ -3,7 +3,7 @@
 
 
 
-  "version": "3.11.2",
+  "version": "3.11.5",
 
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript — 54 built-in features, zero dependencies",

package/packages/cli/src/commands/generate.ts

@@ -88,13 +88,19 @@ export function parseFields(fieldsStr: string): Array<[string, string]> {
 }
 
 export function parseCliArgs(args: string[]): { flags: Record<string, string | boolean>; positional: string[] } {
+  // Boolean-only flags that never take a value argument
+  const booleanFlags = new Set(["no-browser", "no-reload", "production", "managed", "all", "clear"]);
+
   const flags: Record<string, string | boolean> = {};
   const positional: string[] = [];
   let i = 0;
   while (i < args.length) {
     if (args[i].startsWith("--")) {
       const key = args[i].slice(2);
-      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+      if (booleanFlags.has(key)) {
+        flags[key] = true;
+        i += 1;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
         flags[key] = args[i + 1];
         i += 2;
       } else {

package/packages/cli/src/commands/serve.ts

@@ -37,48 +37,13 @@ export async function serveProject(options: ServeOptions): Promise<void> {
     staticDir,
   });
 
-  // Watch for file changes.
-  //
-  // Templates and static assets are re-read from disk every request in dev mode,
-  // so we only need to touch the router when a .ts/.js route file actually
-  // changes. Clearing the router on every edit (including templates) leaves a
-  // brief window where the router is empty — any request hitting that window
-  // gets a 404 whose response path bypasses the dev toolbar injection, so the
-  // toolbar appears to "vanish" after a hot reload. Route-file-only clearing
-  // matches the behaviour of Python's DevReload and the fix made in PHP v3.10.87.
-  const noReload = ["true", "1", "yes"].includes((process.env.TINA4_NO_RELOAD ?? "").toLowerCase());
-  const watchDirs = [routesDir, ormDir, modelsDir, templatesDir].filter((d) => existsSync(d));
-  let watcher: { close: () => void } | null = null;
-  if (!noReload) {
-    watcher = watchForChanges(watchDirs, async ({ code }) => {
-      if (!code) {
-        // Template/CSS/JS asset change — nothing to do in the server. The
-        // browser will re-fetch on its own reload cycle and the request will
-        // be served against the existing route set with the toolbar intact.
-        return;
-      }
-      try {
-        // Re-discover routes. discoverRoutes() cache-busts imports via ?t=<timestamp>,
-        // so the new modules are loaded fresh. Build the new list first, then
-        // replace the router's state in one back-to-back block to minimise the
-        // window where the router is empty.
-        const { discoverRoutes } = await import("../../../core/src/index.js");
-        const routes = await discoverRoutes(routesDir);
-        server.router.clear();
-        for (const route of routes) {
-          server.router.addRoute(route);
-        }
-        console.log(`  Reloaded ${routes.length} route(s)`);
-      } catch (err) {
-        console.error("  Error reloading routes:", err);
-      }
-    });
-  }
+  // File watching is handled by the Rust CLI (tina4 serve). The framework
+  // only needs POST /__dev/api/reload to update the mtime counter for browser polling.
+  // No internal file watcher.
 
   // Graceful shutdown
   const shutdown = () => {
     console.log("\n  Shutting down...");
-    watcher?.close();
     server.close();
     process.exit(0);
   };

package/packages/core/src/devAdmin.ts

@@ -437,6 +437,9 @@ export class DevAdmin {
       // Dashboard
       { method: "GET", pattern: "/__dev", handler: handleDashboard },
       { method: "GET", pattern: "/__dev/", handler: handleDashboard },
+      // Reload — called by Rust CLI on file changes
+      { method: "GET", pattern: "/__dev/api/mtime", handler: handleMtime },
+      { method: "POST", pattern: "/__dev/api/reload", handler: handleReload },
       // Status & system
       { method: "GET", pattern: "/__dev/api/status", handler: handleStatus(router) },
       { method: "GET", pattern: "/__dev/api/system", handler: handleSystem },
@@ -526,6 +529,23 @@ const handleDashboard: RouteHandler = (_req, res) => {
   res.raw.end(spa);
 };
 
+// Reload mtime counter — updated by POST /__dev/api/reload from Rust CLI
+let _reloadMtime = 0;
+let _reloadFile = "";
+
+const handleMtime: RouteHandler = async (_req, res) => {
+  res.json({ mtime: _reloadMtime, file: _reloadFile });
+};
+
+const handleReload: RouteHandler = async (req, res) => {
+  _reloadMtime = Math.floor(Date.now() / 1000);
+  const body = req.body as Record<string, unknown> | undefined;
+  _reloadFile = (body?.file as string) || "";
+  const reloadType = (body?.type as string) || "reload";
+  console.log(`  External reload trigger: ${reloadType}${_reloadFile ? ` (${_reloadFile})` : ""}`);
+  res.json({ ok: true, type: reloadType });
+};
+
 function handleStatus(router: Router): RouteHandler {
   return async (_req, res) => {
     const mem = process.memoryUsage();