@noego/app 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -43,6 +43,7 @@
   "peerDependencies": {
     "@noego/dinner": "*",
     "@noego/forge": "*",
+    "@noego/ioc": "*",
     "express": "*"
   },
   "devDependencies": {

package/src/client.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import { getContainer } from './container.js';
 
 // Runtime context - set by the runtime before calling server.main
 let runtimeContext = null;
@@ -44,9 +45,21 @@ export async function boot(assets, options = {}) {
     server: app,
     ajv_formats: true,
     assets: assets,
-    controller_builder: options.controller_builder || (async (Controller) => {
-      // Default: try to instantiate with new
-      return new Controller();
+    // Default context_builder creates a scoped container per request
+    context_builder: options.context_builder || ((req, res) => {
+      const globalContainer = getContainer();
+      const scopedContainer = globalContainer.extend();
+      // Attach scoped container to request for middleware/decorators to access
+      req.container = scopedContainer;
+      return { container: scopedContainer };
+    }),
+    // Default controller_builder uses the scoped container from context
+    controller_builder: options.controller_builder || (async (Controller, context) => {
+      if (context?.container) {
+        return context.container.get(Controller);
+      }
+      // Fallback: use global container if no scoped container in context
+      return getContainer().get(Controller);
     }),
     controller_args_provider: options.controller_args_provider || (async (req, res) => ({ req, res })),
   });

package/src/commands/dev.js

@@ -525,6 +525,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
 
   // Crash restart tracking
   const MAX_CRASH_RESTARTS = 3;
+  const PORT_RECOVERY_TIMEOUT = 30000; // 30 seconds to wait for port to become free
   const CRASH_RESTART_DELAY = 2000; // 2 seconds between crash restarts
   const STABILITY_THRESHOLD = 30000; // Reset crash counter if running 30+ seconds
   let backendCrashRestarts = 0;
@@ -541,8 +542,10 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
     if (retryAfterRecovery) {
       backendPortRetries++;
       if (backendPortRetries > MAX_PORT_RECOVERY_RETRIES) {
-        logger.error(`[BACKEND] Exceeded max port recovery retries (${MAX_PORT_RECOVERY_RETRIES}). Shutting down...`);
-        shutdown('backend-port-recovery-exceeded', 1, 'backend-port-recovery');
+        logger.error(`[BACKEND] Exceeded max port recovery retries (${MAX_PORT_RECOVERY_RETRIES}).`);
+        logger.info(`[BACKEND] Service is down. Waiting for file change to retry...`);
+        backendProc = null;
+        // Don't shutdown - keep file watcher running so a file change can trigger a fresh restart
         return;
       }
       logger.warn(`[BACKEND] Port recovery retry ${backendPortRetries}/${MAX_PORT_RECOVERY_RETRIES}...`);
@@ -617,7 +620,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
 
           // Wait for port to be free before restarting (fixes race condition)
           backendProc = null;
-          waitForPortFree(backendPort, 10000, 100).subscribe({
+          waitForPortFree(backendPort, PORT_RECOVERY_TIMEOUT, 100).subscribe({
             next: () => {
               if (!isShuttingDown) {
                 logger.info(`[BACKEND] Port ${backendPort} is free, restarting...`);
@@ -632,12 +635,12 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
                 logger.warn(`[BACKEND] Port conflict detected - attempting port recovery...`);
                 const recovered = recoverFromPortInUse(backendPort, logger);
                 if (recovered && !isShuttingDown) {
-                  // Wait a moment for OS to fully release the port
+                  // Wait for OS to fully release the port before retrying
                   setTimeout(() => {
                     if (!isShuttingDown) {
                       startBackend(true); // Mark as recovery retry
                     }
-                  }, 500);
+                  }, CRASH_RESTART_DELAY);
                   return;
                 }
               }
@@ -649,8 +652,10 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
             }
           });
         } else {
-          logger.error(`[BACKEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}). Shutting down...`);
-          shutdown('backend-exceeded-restarts', 1, 'backend-crash');
+          logger.error(`[BACKEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}).`);
+          logger.info(`[BACKEND] Service is down. Waiting for file change to retry...`);
+          backendProc = null;
+          // Don't shutdown - keep file watcher running so a file change can trigger a fresh restart
         }
       }
     });
@@ -667,7 +672,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
             if (!isShuttingDown) {
               startBackend(true);
             }
-          }, 500);
+          }, CRASH_RESTART_DELAY);
         }
       }
     });
@@ -677,8 +682,10 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
     if (retryAfterRecovery) {
       frontendPortRetries++;
       if (frontendPortRetries > MAX_PORT_RECOVERY_RETRIES) {
-        logger.error(`[FRONTEND] Exceeded max port recovery retries (${MAX_PORT_RECOVERY_RETRIES}). Shutting down...`);
-        shutdown('frontend-port-recovery-exceeded', 1, 'frontend-port-recovery');
+        logger.error(`[FRONTEND] Exceeded max port recovery retries (${MAX_PORT_RECOVERY_RETRIES}).`);
+        logger.info(`[FRONTEND] Service is down. Waiting for file change to retry...`);
+        frontendProc = null;
+        // Don't shutdown - keep file watcher running so a file change can trigger a fresh restart
         return;
       }
       logger.warn(`[FRONTEND] Port recovery retry ${frontendPortRetries}/${MAX_PORT_RECOVERY_RETRIES}...`);
@@ -753,7 +760,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
 
           // Wait for port to be free before restarting (fixes race condition)
           frontendProc = null;
-          waitForPortFree(frontendPort, 10000, 100).subscribe({
+          waitForPortFree(frontendPort, PORT_RECOVERY_TIMEOUT, 100).subscribe({
             next: () => {
               if (!isShuttingDown) {
                 logger.info(`[FRONTEND] Port ${frontendPort} is free, restarting...`);
@@ -768,12 +775,12 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
                 logger.warn(`[FRONTEND] Port conflict detected - attempting port recovery...`);
                 const recovered = recoverFromPortInUse(frontendPort, logger);
                 if (recovered && !isShuttingDown) {
-                  // Wait a moment for OS to fully release the port
+                  // Wait for OS to fully release the port before retrying
                   setTimeout(() => {
                     if (!isShuttingDown) {
                       startFrontend(true); // Mark as recovery retry
                     }
-                  }, 500);
+                  }, CRASH_RESTART_DELAY);
                   return;
                 }
               }
@@ -785,8 +792,10 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
             }
           });
         } else {
-          logger.error(`[FRONTEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}). Shutting down...`);
-          shutdown('frontend-exceeded-restarts', 1, 'frontend-crash');
+          logger.error(`[FRONTEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}).`);
+          logger.info(`[FRONTEND] Service is down. Waiting for file change to retry...`);
+          frontendProc = null;
+          // Don't shutdown - keep file watcher running so a file change can trigger a fresh restart
         }
       }
     });
@@ -803,7 +812,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
             if (!isShuttingDown) {
               startFrontend(true);
             }
-          }, 500);
+          }, CRASH_RESTART_DELAY);
         }
       }
     });
@@ -1019,6 +1028,9 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
           // Then start the new backend
           of(undefined).pipe(
             tap(() => {
+              // Reset crash counters - file change gives a fresh start
+              backendCrashRestarts = 0;
+              backendPortRetries = 0;
               startBackend();
               logger.info(`✅ Backend restart complete\n`);
             })
@@ -1055,6 +1067,9 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
           // Then start the new frontend
           of(undefined).pipe(
             tap(() => {
+              // Reset crash counters - file change gives a fresh start
+              frontendCrashRestarts = 0;
+              frontendPortRetries = 0;
               startFrontend();
               logger.info(`✅ Frontend restart complete\n`);
             })

package/src/container.js

@@ -0,0 +1,35 @@
+/**
+ * Global IoC container management for @noego/app
+ *
+ * Uses Symbol.for() to ensure a true singleton across module boundaries,
+ * even if multiple versions of the package are loaded.
+ */
+
+const CONTAINER_KEY = Symbol.for('@noego/app.container');
+
+// Lazy-loaded container factory
+let _createContainer = null;
+
+/**
+ * Get the global IoC container instance.
+ * Creates it on first access using @noego/ioc.
+ *
+ * @returns {import('@noego/ioc').Container} The global container instance
+ */
+export function getContainer() {
+  if (!globalThis[CONTAINER_KEY]) {
+    // Dynamically require @noego/ioc to avoid bundling issues
+    // and to use the version from the user's project
+    const { createContainer } = require('@noego/ioc');
+    globalThis[CONTAINER_KEY] = createContainer();
+  }
+  return globalThis[CONTAINER_KEY];
+}
+
+/**
+ * Reset the global container (primarily for testing).
+ * This clears the singleton and allows a fresh container to be created.
+ */
+export function resetContainer() {
+  delete globalThis[CONTAINER_KEY];
+}

package/src/index.js

@@ -5,3 +5,4 @@
 
 export { runCombinedServices } from './runtime/runtime.js';
 export { boot, client } from './client.js';
+export { getContainer, resetContainer } from './container.js';