@triophore/falconjs 1.0.0 → 1.0.4

package/FalconAuthPlugin.js

@@ -63,7 +63,9 @@ class FalconAuth {
       socketio: Joi.object({
         enabled: Joi.boolean().default(true),
         timeout: Joi.number().default(5000)
-      }).default({ enabled: true, timeout: 5000 })
+      }).default({ enabled: true, timeout: 5000 }),
+
+      default: Joi.string().optional()
     });
 
     const { error, value } = schema.validate(options);
@@ -95,10 +97,15 @@ class FalconAuth {
       await this.registerJWKS(server);
     }
 
-    // Set default strategy if only one is configured
-    const strategies = Object.keys(this.options).filter(k => k !== 'socketio');
-    if (strategies.length === 1) {
-      server.auth.default(strategies[0]);
+    // Set default strategy
+    if (this.options.default) {
+      server.auth.default(this.options.default);
+    } else {
+      // Auto-set default strategy if only one is configured (and no default specified)
+      const strategies = Object.keys(this.options).filter(k => k !== 'socketio' && k !== 'default');
+      if (strategies.length === 1) {
+        server.auth.default(strategies[0]);
+      }
     }
   }
 
@@ -279,15 +286,15 @@ class FalconAuth {
 
   extractSocketToken(socket) {
     const { token, auth, authorization } = socket.handshake.auth || {};
-    
+
     if (token) return token;
     if (auth) return auth;
-    
+
     const authHeader = socket.handshake.headers.authorization;
     if (authHeader?.startsWith('Bearer ')) {
       return authHeader.substring(7);
     }
-    
+
     return socket.handshake.query.token;
   }
 
@@ -297,14 +304,14 @@ class FalconAuth {
       try {
         const cacheKey = `auth:custom:${this.hashToken(token)}`;
         let user = await this.getFromCache(cacheKey);
-        
+
         if (!user) {
           user = await this.options.custom.validate(token, null, this.context);
           if (user) {
             await this.setCache(cacheKey, user, 300);
           }
         }
-        
+
         if (user) return user;
       } catch (error) {
         this.logger.debug('Custom socket auth failed:', error.message);
@@ -318,21 +325,21 @@ class FalconAuth {
         const decoded = jwt.verify(token, this.options.jwt.secret, {
           algorithms: this.options.jwt.algorithms
         });
-        
+
         const cacheKey = `auth:jwt:${decoded.sub || decoded.id}`;
         let user = null;
-        
+
         if (this.options.jwt.cache.enabled) {
           user = await this.getFromCache(cacheKey);
         }
-        
+
         if (!user) {
           user = await this.options.jwt.validate(decoded, null, this.context);
           if (user && this.options.jwt.cache.enabled) {
             await this.setCache(cacheKey, user, this.options.jwt.cache.ttl);
           }
         }
-        
+
         if (user) return user;
       } catch (error) {
         this.logger.debug('JWT socket auth failed:', error.message);
@@ -348,21 +355,21 @@ class FalconAuth {
             issuer: this.options.jwks.issuer,
             audience: this.options.jwks.audience
           });
-          
+
           const cacheKey = `auth:jwks:${payload.sub}`;
           let user = null;
-          
+
           if (this.options.jwks.cache.enabled) {
             user = await this.getFromCache(cacheKey);
           }
-          
+
           if (!user) {
             user = await this.options.jwks.validate(payload, null, this.context);
             if (user && this.options.jwks.cache.enabled) {
               await this.setCache(cacheKey, user, this.options.jwks.cache.ttl);
             }
           }
-          
+
           if (user) return user;
         }
       } catch (error) {
@@ -378,12 +385,12 @@ class FalconAuth {
     if (customExtractor) {
       return customExtractor(request);
     }
-    
+
     const authHeader = request.headers.authorization;
     if (authHeader?.startsWith('Bearer ')) {
       return authHeader.substring(7);
     }
-    
+
     return request.query.token || request.payload?.token;
   }
 
@@ -394,7 +401,7 @@ class FalconAuth {
 
   async getFromCache(key) {
     if (!this.redis) return null;
-    
+
     try {
       const cached = await this.redis.get(key);
       return cached ? JSON.parse(cached) : null;
@@ -406,7 +413,7 @@ class FalconAuth {
 
   async setCache(key, value, ttl) {
     if (!this.redis) return;
-    
+
     try {
       await this.redis.setEx(key, ttl, JSON.stringify(value));
     } catch (error) {
@@ -461,10 +468,10 @@ const plugin = {
   register: async function (server, options) {
     // Get context from server app (passed from Falcon.js)
     const context = server.app.falconContext || {};
-    
+
     const falconAuth = new FalconAuth(options, context);
     await falconAuth.registerHapi(server);
-    
+
     // Expose auth instance for Socket.IO use
     server.app.falconAuth = falconAuth;
   }

package/falcon.js

@@ -469,49 +469,74 @@ class Falcon {
    * @param {string[]} files - Array to collect file paths (used for recursion)
    * @returns {Promise<string[]>} Array of JavaScript file paths
    */
-  async #findJsFilesRecursively(dir, files = []) {
-    const items = await fs.promises.readdir(dir, { withFileTypes: true });
+  async #findJsFilesRecursively(dir) {
+    let files = [];
+    try {
+      const items = await fs.promises.readdir(dir, { withFileTypes: true });
 
-    for (const item of items) {
-      const fullPath = path.join(dir, item.name);
+      for (const item of items) {
+        const fullPath = path.join(dir, item.name);
 
-      if (item.isDirectory() && !item.name.startsWith('.')) {
-        await this.#findJsFilesRecursively(fullPath, files);
-      }
-      else if (item.isFile() && item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
-        files.push(fullPath);
+        if (item.isDirectory() && !item.name.startsWith('.')) {
+          // Recursively find files and concat
+          const nestedFiles = await this.#findJsFilesRecursively(fullPath);
+          files = files.concat(nestedFiles);
+        }
+        else if (item.isFile() && item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
+          files.push(fullPath);
+        }
       }
+    } catch (err) {
+      this.CONTEXT["logger"].error(`Error scanning directory ${dir}:`, err.message);
     }
 
     return files;
   }
 
   /**
-   * Builds a clean route path from file system path.
-   * Converts folder structure to REST-style paths with parameter support.
+   * Parses route file path to extract method and route path.
+   * Validates against [METHOD]#filename.js pattern.
    * 
    * @private
    * @param {string} relativePath - Relative path from routes directory
-   * @returns {string} Clean route path
+   * @returns {Object|null} Object { method, path } or null if invalid
    */
-  #buildRoutePath(relativePath) {
-    let routePath = '/' + path.dirname(relativePath)
-      .replace(/\\/g, '/')
-      .replace(/\/index$/gi, '')
-      .replace(/\/_/g, '/:')
-      .replace(/_/g, '-')
-      .replace(/(^|\/)\[([^\]]+)\]/g, '$1:$2');
-
-    const baseName = path.basename(relativePath, '.js');
-    if (baseName !== 'index') {
-      let segment = baseName
-        .replace(/^_/, ':')
-        .replace(/_/g, '-')
-        .replace(/^\[([^\]]+)\]$/, ':$1');
-      routePath = path.posix.join(routePath, segment);
+  #parseRouteFile(relativePath) {
+    const filename = path.basename(relativePath);
+
+    // Check for [METHOD]# pattern
+    // Allows any methods characters, will be validated by Hapi or logic if needed, but user said ANY is valid
+    const match = filename.match(/^\[([A-Z]+)\]#(.*)\.js$/i);
+    if (!match) {
+      return null;
     }
 
-    return routePath.replace(/\/+$/, '') || '/';
+    const method = match[1].toUpperCase();
+    const rawName = match[2];
+
+    let dirname = path.dirname(relativePath);
+    if (dirname === '.') dirname = '';
+
+    // Convert dirname params [param] -> {param}
+    let routePath = '/' + dirname
+      .split('/')
+      .map(segment => segment.replace(/^\[(.+)\]$/, '{$1}'))
+      .join('/');
+
+    // Clean up path
+    routePath = routePath.replace(/\/+/g, '/');
+
+    // Append filename (unless index)
+    if (rawName !== 'index') {
+      routePath = path.posix.join(routePath, rawName);
+    }
+
+    // Ensure no trailing slash (unless root)
+    if (routePath !== '/') {
+      routePath = routePath.replace(/\/$/, '');
+    }
+
+    return { method, path: routePath };
   }
 
   /**
@@ -526,12 +551,15 @@ class Falcon {
   #findBestValidatorName(baseName, relativePath, validators) {
     const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 
+    // Adjust baseName for validator search since we stripped [METHOD]#
+    const realBaseName = baseName.replace(/^\[[A-Z]+\]#/, '');
+
     const candidates = [
-      baseName,
-      baseName + 'Payload',
-      path.dirname(relativePath).split(path.sep).pop() + baseName,
-      capitalize(baseName),
-      baseName.replace(/Handler$/i, ''),
+      realBaseName,
+      realBaseName + 'Payload',
+      path.dirname(relativePath).split(path.sep).pop() + realBaseName,
+      capitalize(realBaseName),
+      realBaseName.replace(/Handler$/i, ''),
     ];
     for (const c of candidates) {
       if (validators[c]) return c;
@@ -585,8 +613,8 @@ class Falcon {
   }
 
   /**
-   * Loads routes recursively from the routes directory with automatic validation and Swagger documentation.
-   * Supports nested folder structures and automatic validator matching.
+   * Loads routes recursively from the routes directory using dynamic file naming conventions.
+   * Pattern: [METHOD]#filename.js
    * 
    * @private
    * @async
@@ -619,45 +647,73 @@ class Falcon {
     // Register Swagger first (needs to be before routes)
     await this.#registerSwagger();
 
-    this.CONTEXT["logger"].info("Loading routes with validation + Swagger docs...");
+    this.CONTEXT["logger"].info("Loading routes with dynamic naming convention...");
 
     const routeFiles = await this.#findJsFilesRecursively(routesDir);
 
     for (const filePath of routeFiles) {
       const relativePath = path.relative(routesDir, filePath);
-      const baseName = path.basename(filePath, '.js');
-      let routePath = this.#buildRoutePath(relativePath);
-      this.CONTEXT["logger"].info("Route Name : " + routePath);
+
+      const parsed = this.#parseRouteFile(relativePath);
+      if (!parsed) {
+        // Discard if not matching pattern
+        continue;
+      }
+
+      const { method, path: routePath } = parsed;
+      this.CONTEXT["logger"].info(`Route found: [${method}] ${routePath} (${relativePath})`);
 
       try {
         const routeModule = require(filePath);
-        const register = typeof routeModule === 'function' ? routeModule : routeModule.route?.bind(routeModule);
 
-        if (typeof register !== 'function') continue;
+        // 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)
 
-        // Find validator + extract schema
-        const validatorName = this.#findBestValidatorName(baseName, relativePath, validators);
-        const validator = validatorName ? validators[validatorName] : null;
+        let handler, options = {};
+
+        if (typeof routeModule === 'function') {
+          // Assume it's a handler(request, h)
+          handler = routeModule;
+        } 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`);
+          continue;
+        }
 
         // Auto-generate tag from folder
         const tag = path.dirname(relativePath).split(path.sep)[0] || 'api';
 
-        const wrappedRoute = async (server, ctx) => {
-          // Add auto-generated route info to context
-          ctx.route = {
-            path: routePath,
-            tag: tag,
-            validator: validator,
-            validatorName: validatorName
-          };
-
-          await register(ctx); // Only pass context, server is already in ctx.server
-        };
+        // Find validator attempt
+        const baseName = path.basename(filePath, '.js');
+        const validatorName = this.#findBestValidatorName(baseName, relativePath, validators);
+        if (validatorName && validators[validatorName]) {
+          // Merge into options.validate if not present
+          options.validate = options.validate || {};
+          if (!options.validate.payload && !options.validate.query && !options.validate.params) {
+            // Heuristic: default to payload for POST/PUT/PATCH, query for others?
+            // Or just user provided. For now let's leave flexible or auto-attach if user wants.
+            // The old logic attached it to ctx.route.validator.
+          }
+        }
 
-        await wrappedRoute(this.httpServer, this.CONTEXT);
+        // Register the route
+        this.httpServer.route({
+          method: method,
+          path: routePath,
+          handler: handler,
+          options: {
+            tags: [tag],
+            ...options
+          }
+        });
 
-        const valMark = validator ? 'Validated + Documented' : 'Documented';
-        this.CONTEXT["logger"].info(`${valMark} ${routePath} ← ${relativePath}`);
       } catch (err) {
         this.CONTEXT["logger"].error(`Route failed: ${filePath}`, err.message);
       }

package/package.json

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

package/test_new_logic.js

@@ -0,0 +1,63 @@
+const path = require('path');
+
+function parseRoute(relativePath) {
+    const filename = path.basename(relativePath);
+
+    // 1. Check for [METHOD]# pattern
+    const match = filename.match(/^\[([A-Z]+)\]#(.*)\.js$/i);
+    if (!match) {
+        return null; // Ignore file
+    }
+
+    const method = match[1].toUpperCase();
+    const rawName = match[2]; // filename without [METHOD]# and .js
+
+    // 2. Build Path
+    let dirname = path.dirname(relativePath);
+    if (dirname === '.') dirname = '';
+
+    // Convert dirname params [param] -> {param}
+    let routePath = '/' + dirname
+        .split('/')
+        .map(segment => segment.replace(/^\[(.+)\]$/, '{$1}')) // [id] -> {id}
+        .join('/');
+
+    // Clean up path
+    routePath = routePath.replace(/\/+/g, '/');
+
+    // Append filename (unless index)
+    if (rawName !== 'index') {
+        routePath = path.posix.join(routePath, rawName);
+    }
+
+    // Ensure no trailing slash (unless root)
+    if (routePath !== '/') {
+        routePath = routePath.replace(/\/$/, '');
+    }
+
+    return {
+        method,
+        path: routePath
+    };
+}
+
+const tests = [
+    'files.js', // Should be ignored
+    '[GET]#file.js', // -> /file, GET
+    '[POST]#index.js', // -> /, POST
+    'folder_name/[GET]#file.js', // -> /folder_name/file, GET
+    'folder_name/[param]/[PUT]#file.js', // -> /folder_name/{param}/file, PUT
+    'users/[id]/[GET]#details.js', // -> /users/{id}/details, GET
+    'users/[id]/[GET]#index.js', // -> /users/{id}, GET
+    'api/v1/[DELETE]#user.js' // -> /api/v1/user, DELETE
+];
+
+console.log('--- Testing Route Parsing ---');
+tests.forEach(t => {
+    const result = parseRoute(t);
+    if (result) {
+        console.log(`${t} -> ${result.method} ${result.path}`);
+    } else {
+        console.log(`${t} -> IGNORED`);
+    }
+});

package/test_recursive_routes/auth/login.js

@@ -0,0 +1 @@
+module.exports = {}

package/test_recursive_routes/index.js

@@ -0,0 +1 @@
+module.exports = {}