@triophore/falconjs 1.0.4 → 1.0.5

package/falcon.js

@@ -666,24 +666,43 @@ class Falcon {
       try {
         const routeModule = require(filePath);
 
-        // Flexible export: can be a handler function, or an object with handler/options
-        // OR legacy support: function that takes context (but we need to manually register)
+        let handler, options = {}, finalMethod = method, finalPath = routePath;
 
-        let handler, options = {};
+        // NEW PATTERN: module.exports.route = async function(context) { return { ... } }
+        if (routeModule.route && typeof routeModule.route === 'function') {
+          const routeConfig = await routeModule.route(this.CONTEXT);
 
-        if (typeof routeModule === 'function') {
-          // Assume it's a handler(request, h)
+          if (!routeConfig) {
+            this.CONTEXT["logger"].warn(`Skipping ${relativePath}: route() returned null/undefined`);
+            continue;
+          }
+
+          // Extract handler and options from returned config
+          handler = routeConfig.handler;
+          options = routeConfig.options || {};
+
+          // Allow optional method/path override from return value
+          if (routeConfig.method) {
+            finalMethod = routeConfig.method;
+            this.CONTEXT["logger"].debug(`Method overridden to ${finalMethod} for ${relativePath}`);
+          }
+          if (routeConfig.path) {
+            finalPath = routeConfig.path;
+            this.CONTEXT["logger"].debug(`Path overridden to ${finalPath} for ${relativePath}`);
+          }
+        }
+        // LEGACY PATTERN: Direct handler function export
+        else if (typeof routeModule === 'function') {
           handler = routeModule;
-        } else if (typeof routeModule === 'object') {
+        }
+        // LEGACY PATTERN: Object with handler/options
+        else if (typeof routeModule === 'object') {
           if (routeModule.handler) handler = routeModule.handler;
           if (routeModule.options) options = routeModule.options;
-
-          // If user exported .route function (legacy), we can't really use it easily with new params 
-          // unless we assume they migrated. We'll stick to handler/options pattern for new files.
         }
 
         if (!handler) {
-          this.CONTEXT["logger"].warn(`Skipping ${relativePath}: No handler exported`);
+          this.CONTEXT["logger"].warn(`Skipping ${relativePath}: No handler found`);
           continue;
         }
 
@@ -705,8 +724,8 @@ class Falcon {
 
         // Register the route
         this.httpServer.route({
-          method: method,
-          path: routePath,
+          method: finalMethod,
+          path: finalPath,
           handler: handler,
           options: {
             tags: [tag],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triophore/falconjs",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "simple server framework for nodejs",
   "main": "index.js",
   "scripts": {