@noego/app 0.0.6 → 0.0.7

package/.claude/settings.local.json

@@ -3,7 +3,8 @@
     "allow": [
       "Bash(cat:*)",
       "Bash(curl:*)",
-      "Bash(noego dev)"
+      "Bash(noego dev)",
+      "WebSearch"
     ],
     "deny": [],
     "ask": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -14,6 +14,10 @@
     "./client": {
       "import": "./src/client.js",
       "types": "./types/client.d.ts"
+    },
+    "./config": {
+      "import": "./src/runtime/config.js",
+      "types": "./types/config.d.ts"
     }
   },
   "scripts": {

package/src/commands/dev.js

@@ -296,34 +296,39 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   const chokidar = requireFromRoot('chokidar');
   const picomatch = (await import('picomatch')).default;
   
-  const resolvePattern = (pattern) => {
-    if (path.isAbsolute(pattern)) return pattern;
-    return path.resolve(root, pattern);
+  // Keep patterns relative for chokidar to work properly with globs
+  // Absolute patterns with globs don't work well, especially in chokidar v4
+  const normalizePattern = (pattern) => {
+    // If pattern is absolute, make it relative to root
+    if (path.isAbsolute(pattern)) {
+      return path.relative(root, pattern);
+    }
+    return pattern;
   };
-  
+
   // Collect watch patterns
   const backendPatterns = [];
   const frontendPatterns = [];
   const sharedPatterns = [];
-  
+
   // App watch patterns (restart both)
   if (yamlConfig.app?.watch) {
     for (const pattern of yamlConfig.app.watch) {
-      sharedPatterns.push(resolvePattern(pattern));
+      sharedPatterns.push(normalizePattern(pattern));
     }
   }
-  
+
   // Server watch patterns (restart backend only)
   if (yamlConfig.server?.watch) {
     for (const pattern of yamlConfig.server.watch) {
-      backendPatterns.push(resolvePattern(pattern));
+      backendPatterns.push(normalizePattern(pattern));
     }
   }
-  
+
   // Client watch patterns (restart frontend only)
   if (yamlConfig.client?.watch) {
     for (const pattern of yamlConfig.client.watch) {
-      frontendPatterns.push(resolvePattern(pattern));
+      frontendPatterns.push(normalizePattern(pattern));
     }
   }
   
@@ -426,25 +431,27 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   const handleFileChange = async (reason, file) => {
     if (pending) return;
     pending = true;
-    
-    const absPath = path.isAbsolute(file) ? file : path.resolve(root, file);
-    
+
+    // With cwd set, chokidar reports relative paths
+    // Our patterns are now relative, so match against the relative path
+    const relativePath = path.isAbsolute(file) ? path.relative(root, file) : file;
+
     // Determine which service(s) to restart
     let restartBackend = false;
     let restartFrontend = false;
-    
-    if (sharedMatcher && sharedMatcher(absPath)) {
+
+    if (sharedMatcher && sharedMatcher(relativePath)) {
       // Shared file changed - restart both
-      logger.info(`Shared file changed (${reason}): ${file}`);
+      logger.info(`Shared file changed (${reason}): ${relativePath}`);
       restartBackend = true;
       restartFrontend = true;
-    } else if (backendMatcher && backendMatcher(absPath)) {
+    } else if (backendMatcher && backendMatcher(relativePath)) {
       // Backend file changed
-      logger.info(`Backend file changed (${reason}): ${file}`);
+      logger.info(`Backend file changed (${reason}): ${relativePath}`);
       restartBackend = true;
-    } else if (frontendMatcher && frontendMatcher(absPath)) {
+    } else if (frontendMatcher && frontendMatcher(relativePath)) {
       // Frontend file changed
-      logger.info(`Frontend file changed (${reason}): ${file}`);
+      logger.info(`Frontend file changed (${reason}): ${relativePath}`);
       restartFrontend = true;
     }
     
@@ -462,15 +469,34 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   };
   
   // Create watcher
+  // Use cwd with relative patterns for proper glob support
   const watcher = chokidar.watch(allPatterns, {
-    ignoreInitial: true,
-    cwd: root
+    cwd: root,
+    ignoreInitial: true
   });
-  
+
+  // Debug: Log what patterns we're actually watching
+  logger.info('Watch patterns:', allPatterns);
+
   watcher
-    .on('add', (p) => handleFileChange('add', p))
-    .on('change', (p) => handleFileChange('change', p))
-    .on('unlink', (p) => handleFileChange('unlink', p));
+    .on('add', (p) => {
+      logger.debug(`File add event: ${p}`);
+      handleFileChange('add', p);
+    })
+    .on('change', (p) => {
+      logger.debug(`File change event: ${p}`);
+      handleFileChange('change', p);
+    })
+    .on('unlink', (p) => {
+      logger.debug(`File unlink event: ${p}`);
+      handleFileChange('unlink', p);
+    })
+    .on('ready', () => {
+      logger.info('File watcher is ready');
+    })
+    .on('error', (error) => {
+      logger.error('Watcher error:', error);
+    });
   
   // Start initial processes
   startBackend();
@@ -518,48 +544,47 @@ async function createWatcher(context, yamlConfig, configFilePath) {
   const chokidar = requireFromRoot('chokidar');
   
   const patterns = new Set();
-  
-  const resolvePattern = (pattern) => {
-    if (path.isAbsolute(pattern)) return pattern;
-    return path.resolve(root, pattern);
+
+  // Keep patterns relative for chokidar to work properly with globs
+  const normalizePattern = (pattern) => {
+    // If pattern is absolute, make it relative to root
+    if (path.isAbsolute(pattern)) {
+      return path.relative(root, pattern);
+    }
+    return pattern;
   };
-  
-  // User-supplied watch paths
-  if (yamlConfig.dev?.watchPaths) {
-    for (const pattern of yamlConfig.dev.watchPaths) {
-      patterns.add(resolvePattern(pattern));
+
+  // App watch patterns
+  if (yamlConfig.app?.watch) {
+    for (const pattern of yamlConfig.app.watch) {
+      patterns.add(normalizePattern(pattern));
     }
   }
-  
-  // Default watch patterns from config
-  if (yamlConfig.server?.controllers) {
-    patterns.add(resolvePattern(`${yamlConfig.server.controllers}/**/*.{ts,js}`));
-  }
-  if (yamlConfig.server?.middleware) {
-    patterns.add(resolvePattern(`${yamlConfig.server.middleware}/**/*.{ts,js}`));
-  }
-  if (yamlConfig.server?.openapi) {
-    patterns.add(resolvePattern(yamlConfig.server.openapi));
-    const openapiDir = path.dirname(resolvePattern(yamlConfig.server.openapi));
-    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
-  }
-  if (yamlConfig.client?.openapi) {
-    patterns.add(resolvePattern(yamlConfig.client.openapi));
-    const openapiDir = path.dirname(resolvePattern(yamlConfig.client.openapi));
-    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
+
+  // Server watch patterns
+  if (yamlConfig.server?.watch) {
+    for (const pattern of yamlConfig.server.watch) {
+      patterns.add(normalizePattern(pattern));
+    }
   }
-  if (yamlConfig.assets) {
-    for (const asset of yamlConfig.assets) {
-      if (asset.includes('*.sql')) {
-        patterns.add(resolvePattern(asset));
-      }
+
+  // Client watch patterns
+  if (yamlConfig.client?.watch) {
+    for (const pattern of yamlConfig.client.watch) {
+      patterns.add(normalizePattern(pattern));
     }
   }
-  
+
+  if (patterns.size === 0) {
+    logger.warn('No watch patterns configured. Watching disabled.');
+    return null;
+  }
+
   logger.info('Watching for changes to restart server...');
+  // Use cwd with relative patterns for proper glob support
   const watcher = chokidar.watch(Array.from(patterns), {
-    ignoreInitial: true,
-    cwd: root
+    cwd: root,
+    ignoreInitial: true
   });
   return watcher;
 }
@@ -604,19 +629,23 @@ async function runWithRestart(context, tsxExecutable, tsxArgs, env, watcher, log
     start();
     pending = false;
   };
-  
-  watcher
-    .on('add', (p) => scheduleRestart('add', p))
-    .on('change', (p) => scheduleRestart('change', p))
-    .on('unlink', (p) => scheduleRestart('unlink', p));
-  
+
+  if (watcher) {
+    watcher
+      .on('add', (p) => scheduleRestart('add', p))
+      .on('change', (p) => scheduleRestart('change', p))
+      .on('unlink', (p) => scheduleRestart('unlink', p));
+  }
+
   // Start initial server
   start();
-  
+
   // Keep process alive until SIGINT/SIGTERM
   const shutdown = async () => {
     await stop();
-    await watcher.close();
+    if (watcher) {
+      await watcher.close();
+    }
     process.exit(0);
   };
   process.on('SIGINT', shutdown);

package/src/commands/serve.js

@@ -74,39 +74,52 @@ async function createWatcher(context) {
     patterns.add(value);
   };
 
-  const resolveGlob = (entry) => {
+  // Keep patterns relative for chokidar to work properly with globs
+  const normalizePattern = (entry) => {
     if (!entry) return null;
     if (typeof entry === 'string') {
-      return path.isAbsolute(entry) ? entry : path.join(config.rootDir, entry);
+      // If pattern is absolute, make it relative to rootDir
+      if (path.isAbsolute(entry)) {
+        return path.relative(config.rootDir, entry);
+      }
+      return entry;
     }
+    // Handle object-style patterns
     if (entry.isAbsolute) {
-      return entry.pattern;
+      return path.relative(config.rootDir, entry.pattern);
     }
     if (entry.cwd) {
-      return path.join(entry.cwd, entry.pattern);
+      const absolute = path.join(entry.cwd, entry.pattern);
+      return path.relative(config.rootDir, absolute);
     }
     return entry.pattern;
   };
 
-  // User-supplied patterns
-  for (const entry of config.dev.watchPaths) {
-    const pattern = resolveGlob(entry);
-    if (pattern) addPattern(pattern);
+  // App watch patterns - restart server
+  if (config.app?.watch) {
+    for (const entry of config.app.watch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
   }
 
-  // Server-side defaults
-  addPattern(path.join(config.server.controllersDir, '**/*.{ts,js}'));
-  addPattern(path.join(config.server.middlewareDir, '**/*.{ts,js}'));
-  addPattern(config.server.openapiFile);
-  addPattern(path.join(path.dirname(config.server.openapiFile), 'openapi/**/*.yaml'));
-  for (const entry of config.server.sqlGlobs) {
-    const pattern = resolveGlob(entry);
-    if (pattern) addPattern(pattern);
+  // Server watch patterns - restart server
+  if (config.server?.watch) {
+    for (const entry of config.server.watch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
   }
 
-  // UI OpenAPI changes should restart (routes/manifest)
-  addPattern(config.ui.openapiFile);
-  addPattern(path.join(path.dirname(config.ui.openapiFile), 'openapi/**/*.yaml'));
+  // Client watch patterns - restart server (in non-split mode)
+  // Check both ui.watch (from buildConfig) and client.watch (from spread)
+  const clientWatch = config.ui?.watch || config.client?.watch;
+  if (clientWatch) {
+    for (const entry of clientWatch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
+  }
 
   // Ignore Svelte/client files to let Vite HMR handle them
   const uiIgnores = [
@@ -114,11 +127,17 @@ async function createWatcher(context) {
     path.join(config.ui.rootDir, '**/*.{ts,tsx,css,scss,html}')
   ];
 
+  if (patterns.size === 0) {
+    logger.warn('No watch patterns configured. Watching disabled.');
+    return null;
+  }
+
   logger.info('Watching for changes to restart server...');
+  // Use cwd with relative patterns for proper glob support
   const watcher = chokidar.watch(Array.from(patterns), {
+    cwd: config.rootDir,
     ignoreInitial: true,
-    ignored: uiIgnores,
-    cwd: config.rootDir
+    ignored: uiIgnores
   });
   return watcher;
 }
@@ -166,10 +185,12 @@ async function runWithRestart(context, runner, watcher, frontendProc) {
     pending = false;
   };
 
-  watcher
-    .on('add', (p) => scheduleRestart('add', p))
-    .on('change', (p) => scheduleRestart('change', p))
-    .on('unlink', (p) => scheduleRestart('unlink', p));
+  if (watcher) {
+    watcher
+      .on('add', (p) => scheduleRestart('add', p))
+      .on('change', (p) => scheduleRestart('change', p))
+      .on('unlink', (p) => scheduleRestart('unlink', p));
+  }
 
   // Start initial server
   start();
@@ -177,7 +198,9 @@ async function runWithRestart(context, runner, watcher, frontendProc) {
   // Keep process alive until SIGINT/SIGTERM
   const shutdown = async () => {
     await stop();
-    await watcher.close();
+    if (watcher) {
+      await watcher.close();
+    }
     if (frontendProc) {
       try { frontendProc.kill('SIGTERM'); } catch {}
     }

package/src/config.js

@@ -73,7 +73,8 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
       controllersDir: config.server.controllers_abs,
       middlewareDir: config.server.middleware_abs,
       openapiFile: config.server.openapi_abs,
-      sqlGlobs: serverSqlGlobs
+      sqlGlobs: serverSqlGlobs,
+      watch: config.server.watch  // Preserve watch property
     } : null,
     ui: config.client ? {
       rootDir: uiRootDir,
@@ -85,7 +86,8 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
       options: {}, // This seems to be deprecated
       openapiFile: config.client.openapi_abs,
       assets: assetSpecs,
-      clientExclude: clientExcludeSpecs
+      clientExclude: clientExcludeSpecs,
+      watch: config.client.watch  // Preserve watch property
     } : null,
     assets: assetSpecs,
     vite: {

package/src/runtime/config.js

@@ -0,0 +1,82 @@
+import path from 'node:path';
+import { loadConfig, findConfigFile, loadConfigFromEnv } from './config-loader.js';
+import {setContext} from "../client";
+
+
+
+
+/**
+ * Loads and applies the resolved project configuration to the application's runtime context.
+ * 
+ * @param {(config:any) => any} getAppFunction - A function that returns the application instance (e.g., Express app).
+ * @returns {Promise<object>} - The fully resolved and normalized configuration object.
+ */
+export async function buildConfig(getAppFunction) {
+  // Retrieve the application instance from the provided function.
+  /** @type {any} */
+  const app = getAppFunction();
+  // Load and resolve the configuration via getConfig (auto-detects config file or env).
+  const { config } = await getConfig();
+  // Attach the loaded config to the runtime context for downstream usage.
+  setContext(app, config);
+  // Return the config for consumers (generates env and internal path invariants).
+  return {config,app};
+}
+
+/**
+ * Automatically load configuration from environment variable or config file.
+ * 
+ * This function:
+ * 1. First checks NOEGO_CONFIGURATION env var (uses loadConfigFromEnv if present)
+ * 2. Otherwise searches for config file starting from rootDir (or process.cwd())
+ *    and walks up directories until a config file is found
+ * 3. Sets all environment variables automatically
+ * 4. Returns the fully resolved config object
+ * 
+ * @param {string} [rootDir] - Optional starting directory for config file search. Defaults to process.cwd()
+ * @returns {Promise<{root: string, config: object, configFilePath: string|null}>}
+ */
+export async function getConfig(rootDir) {
+  // First priority: check NOEGO_CONFIGURATION env var
+  if (process.env.NOEGO_CONFIGURATION) {
+    return loadConfigFromEnv();
+  }
+
+  // Second priority: find and load config file
+  const startDir = rootDir ? path.resolve(rootDir) : process.cwd();
+
+  
+  // Walk up directories to find config file
+  let currentDir = startDir;
+  let lastDir = '';
+  
+  while (currentDir !== lastDir) {
+    try {
+      const configFilePath = await findConfigFile(currentDir);
+      // Found config file, load it
+      // Pass rootDir if provided, otherwise let loadConfig determine root from config file
+      return await loadConfig(configFilePath, rootDir);
+    } catch (error) {
+      // Config file not found in this directory, try parent
+      lastDir = currentDir;
+      currentDir = path.dirname(currentDir);
+      
+      // Stop if we've reached filesystem root
+      if (currentDir === lastDir) {
+        throw new Error(
+          `No configuration file found starting from ${startDir}.\n` +
+          `Please create hammer.config.yml (or a similar named file) in your project root.`
+        );
+      }
+    }
+  }
+
+  
+  
+  // Should never reach here, but just in case
+  throw new Error(
+    `No configuration file found starting from ${startDir}.\n` +
+    `Please create hammer.config.yml (or a similar named file) in your project root.`
+  );
+}
+

package/types/config.d.ts

@@ -0,0 +1,23 @@
+import type { Express } from 'express';
+
+/**
+ * Result returned by buildConfig
+ */
+export interface BuildConfigResult {
+  config: Record<string, unknown>;
+  app: Express;
+}
+
+/**
+ * Loads and applies the resolved project configuration to the application's runtime context.
+ * 
+ * This function:
+ * 1. Retrieves the application instance from the provided function
+ * 2. Loads configuration via getConfig (auto-detects config file or env)
+ * 3. Attaches the loaded config to the runtime context via setContext
+ * 4. Returns both the config object and app instance for consumers
+ * 
+ * @param getAppFunction - A function that returns the application instance (e.g., Express app)
+ * @returns Promise resolving to an object containing both the config and app
+ */
+export function buildConfig(getAppFunction: (config:any) => Express): Promise<BuildConfigResult>;