feat: add recursive scanning and kebab-case route derivation

- discover() accepts recursive flag for subdirectory scanning
- Subdirectory names become kebab-cased URL path segments
- Class names converted to kebab-case via CaseConverter
- #[RestController] name with '/' is rejected (skipped)
- Explicit attribute name is always flat (ignores directory nesting)
- Non-recursive remains the default

Author: Ibrahim BinAlshikh

WebFiori/Framework/Router/ServiceRouter.php

@@ -18,6 +18,7 @@
 use WebFiori\Http\RequestProcessor;
 use WebFiori\Http\WebService;
 use WebFiori\Http\WebServicesManager;
+use WebFiori\Json\CaseConverter;
 
 /**
  * Discovers and registers API routes from a namespace.
@@ -42,12 +43,13 @@ class ServiceRouter {
      * @param string $basePath URL prefix (e.g. '/apis').
      * @param array $routeOptions Shared route options applied to all routes.
      * @param string|null $directory Directory to scan. If null, derived from namespace relative to ROOT_PATH.
+     * @param bool $recursive If true, scan subdirectories. Subdirectory names become URL path segments.
      *
      * @return int Number of routes registered.
      */
-    public static function discover(string $namespace, string $basePath, array $routeOptions = [], ?string $directory = null): int {
+    public static function discover(string $namespace, string $basePath, array $routeOptions = [], ?string $directory = null, bool $recursive = false): int {
         $dir = $directory ?? self::namespaceToPath($namespace);
-        $map = self::scanNamespace($namespace, $dir);
+        $map = self::scanNamespace($namespace, $dir, '', $recursive);
         $count = 0;
         $basePath = rtrim($basePath, '/');
 
@@ -173,10 +175,12 @@ public static function handle(string $controllerName, string $namespace, ?string
      *
      * @param string $namespace The namespace to scan.
      * @param string $dir The directory to scan.
+     * @param string $pathPrefix Relative path prefix for recursive scanning (kebab-cased).
+     * @param bool $recursive Whether to scan subdirectories.
      *
      * @return array Map of name => ['class' => FQCN, 'type' => 'service'|'manager']
      */
-    private static function scanNamespace(string $namespace, string $dir): array {
+    private static function scanNamespace(string $namespace, string $dir, string $pathPrefix = '', bool $recursive = false): array {
         $map = [];
 
         if (!is_dir($dir)) {
@@ -208,15 +212,25 @@ private static function scanNamespace(string $namespace, string $dir): array {
 
             if (!empty($attrs)) {
                 $attr = $attrs[0]->newInstance();
-                $name = !empty($attr->name) ? $attr->name : self::deriveNameFromClass($className);
+
+                if (!empty($attr->name)) {
+                    if (str_contains($attr->name, '/')) {
+                        continue; // Invalid: name must not contain slashes
+                    }
+
+                    $name = $attr->name;
+                } else {
+                    $name = $pathPrefix . self::deriveNameFromClass($className);
+                }
+
                 $map[$name] = ['class' => $fqcn, 'type' => 'service'];
 
                 continue;
             }
 
             // Priority 2: WebServicesManager subclass
             if ($ref->isSubclassOf(WebServicesManager::class)) {
-                $name = self::deriveNameFromClass($className);
+                $name = $pathPrefix . self::deriveNameFromClass($className);
                 $map[$name] = ['class' => $fqcn, 'type' => 'manager'];
 
                 continue;
@@ -225,14 +239,30 @@ private static function scanNamespace(string $namespace, string $dir): array {
             // Priority 3: WebService subclass without attribute
             if ($ref->isSubclassOf(WebService::class)) {
                 $instance = new $fqcn();
-                $name = $instance->getName();
+                $svcName = $instance->getName();
 
-                if (!empty($name)) {
+                if (!empty($svcName)) {
+                    $name = $pathPrefix . $svcName;
                     $map[$name] = ['class' => $fqcn, 'type' => 'service'];
                 }
             }
         }
 
+        // Recursive: scan subdirectories
+        if ($recursive) {
+            $subdirs = glob($dir . DIRECTORY_SEPARATOR . '*', GLOB_ONLYDIR);
+
+            if ($subdirs !== false) {
+                foreach ($subdirs as $subdir) {
+                    $subDirName = basename($subdir);
+                    $subNamespace = $namespace . '\\' . $subDirName;
+                    $subPrefix = $pathPrefix . CaseConverter::toKebabCase($subDirName, 'lower') . '/';
+                    $subMap = self::scanNamespace($subNamespace, $subdir, $subPrefix, true);
+                    $map = array_merge($map, $subMap);
+                }
+            }
+        }
+
         return $map;
     }
 
@@ -244,13 +274,17 @@ private static function namespaceToPath(string $namespace): string {
     }
 
     /**
-     * Derive route name from class name.
-     * OrderService → orders, ProductManager → product
+     * Derive route name from class name using kebab-case.
+     * OrderService → order, UserProfileService → user-profile
      */
     private static function deriveNameFromClass(string $className): string {
         $name = preg_replace('/(Service|Manager|Controller)$/', '', $className);
 
-        return strtolower($name);
+        if (empty($name)) {
+            $name = $className;
+        }
+
+        return CaseConverter::toKebabCase($name, 'lower');
     }
 
     /**

tests/ServiceRouterFixtures/UserAuth/LoginService.php

@@ -0,0 +1,15 @@
+<?php
+namespace WebFiori\Tests\ServiceRouterFixtures\UserAuth;
+
+use WebFiori\Http\Annotations\RestController;
+use WebFiori\Http\WebService;
+
+#[RestController]
+class LoginService extends WebService {
+    public function __construct() {
+        parent::__construct('login');
+    }
+
+    public function processRequest() {
+    }
+}

tests/WebFiori/Framework/Tests/Router/ServiceRouterTest.php

@@ -130,6 +130,37 @@ public function testResetClearsDiscovered() {
         $this->assertEmpty(ServiceRouter::getDiscovered());
     }
 
+    /** @test */
+    public function testDiscoverRecursiveFindsNestedServices() {
+        ServiceRouter::discover($this->namespace, '/apis', [], $this->fixturesDir, true);
+        $discovered = ServiceRouter::getDiscovered();
+
+        // LoginService in UserAuth/ subdirectory
+        $this->assertArrayHasKey('user-auth/login', $discovered);
+        $this->assertEquals('/apis/user-auth/login', $discovered['user-auth/login']['path']);
+    }
+
+    /** @test */
+    public function testDiscoverNonRecursiveSkipsSubdirectories() {
+        ServiceRouter::discover($this->namespace, '/apis', [], $this->fixturesDir, false);
+        $discovered = ServiceRouter::getDiscovered();
+
+        $this->assertArrayNotHasKey('user-auth/login', $discovered);
+    }
+
+    /** @test */
+    public function testDiscoverSkipsAttributeNameWithSlash() {
+        // OrderService has #[RestController('orders')] — valid
+        // If we had one with slash it would be skipped
+        ServiceRouter::discover($this->namespace, '/apis', [], $this->fixturesDir);
+        $discovered = ServiceRouter::getDiscovered();
+
+        // All discovered names should not contain slashes (non-recursive)
+        foreach ($discovered as $name => $entry) {
+            $this->assertStringNotContainsString('/', $name);
+        }
+    }
+
     /** @test */
     public function testDynamicRegistersRoute() {
         $routesBefore = Router::routesCount();