create-prisma-php-app 1.26.5 → 1.26.7

package/dist/bootstrap.php

@@ -35,7 +35,7 @@ function determineContentToInclude()
      * ======================================
      */
     $requestUri = $_SERVER['REQUEST_URI'];
-    $requestUri = empty($_SERVER['SCRIPT_URL']) ? uriExtractor($requestUri) : $requestUri;
+    $requestUri = empty($_SERVER['SCRIPT_URL']) ? trim(uriExtractor($requestUri)) : trim($requestUri);
     /** 
      * ============ URI Path Handling ============ 
      * The $uri variable now contains the URI path without query parameters and without the leading slash. 
@@ -46,7 +46,7 @@ function determineContentToInclude()
      */
     $scriptUrl = explode('?', $requestUri, 2)[0];
     $pathname = $_SERVER['SCRIPT_URL'] ?? $scriptUrl;
-    $pathname = ltrim($pathname, '/');
+    $pathname = trim($pathname, '/');
     $baseDir = APP_PATH;
     $includePath = '';
     $layoutsToInclude = [];

package/dist/src/Lib/Auth/Auth.php

@@ -181,7 +181,7 @@ class Auth
 
             $token = JWT::decode($jwt, new Key($this->secretKey, 'HS256'));
 
-            if (empty($token->role)) {
+            if (empty($token->{Auth::PAYLOAD_NAME})) {
                 return null;
             }
 

package/dist/src/Lib/Auth/AuthConfig.php

@@ -20,14 +20,35 @@ final class AuthConfig
     public const ROLE_IDENTIFIER = 'role';
     public const IS_ROLE_BASE = false;
     public const IS_TOKEN_AUTO_REFRESH = false;
+    public const IS_ALL_ROUTES_PRIVATE = false;
 
     /**
+     * This is the (default) option for authentication. If IS_ALL_ROUTES_PRIVATE is set to false, 
      * An array of private routes that are accessible to all authenticated users
      * without specific role-based access control. Routes should be listed as string paths.
      * Example: public static $privateRoutes = ['/']; // This makes the home page private
      * Example: public static $privateRoutes = ['/profile', '/dashboard/settings']; // These routes are private
      */
-    public static $privateRoutes = [];
+    public static array $privateRoutes = [];
+
+    /**
+     * This is the (default) option for authentication. If IS_ALL_ROUTES_PRIVATE is set to true,
+     * An array of public routes that are accessible to all users, authenticated or not.
+     */
+    public const DEFAULT_SIGNIN_REDIRECT = '/dashboard'; // Default redirect route after sign in
+    public const API_AUTH_PREFIX = '/api/auth'; // Prefix for third-party API authentication routes (github, google, etc.)
+
+    /**
+     * An array of public routes that are accessible to all users, authenticated or not.
+     * Routes should be listed as string paths.
+     * Example: public static $publicRoutes = ['/']; // This makes the home page public
+     * Example: public static $publicRoutes = ['/about', '/contact']; // These routes are public
+     */
+    public static array $publicRoutes = ['/'];
+    public static array $authRoutes = [
+        '/signin',
+        '/signup',
+    ];
 
     /**
      * An associative array mapping specific routes to required user roles for access control.
@@ -41,17 +62,21 @@ final class AuthConfig
      *     'sales' => [self::ROLE_IDENTIFIER => [AuthRole::Admin, AuthRole::User]]
      * ];
      */
-    public static $roleBasedRoutes = [];
+    public static array $roleBasedRoutes = [];
 
     /**
      * Checks if the given user role is authorized to access a set of roles.
      * 
-     * @param string $userRole The role of the user attempting to access the route.
-     * @param array $roles An array of AuthRole instances specifying allowed roles.
-     * @return bool Returns true if the user role is in the allowed roles, false otherwise.
+     * @param \ArrayObject|string $userRole The user's role to check.
+     * @param array<AuthRole> $roles An array of AuthRole instances specifying allowed roles.
+     * @return bool Returns true if the user's role matches any of the allowed roles, false otherwise.
      */
-    public static function checkAuthRole($userRole, $roles)
+    public static function checkAuthRole(\ArrayObject|string $userRole, array $roles): bool
     {
+        if ($userRole instanceof \ArrayObject) {
+            $userRole = $userRole[Auth::ROLE_NAME] ?? '';
+        }
+
         foreach ($roles as $role) {
             if ($userRole === $role->value) {
                 return true;

package/dist/src/Lib/Middleware/AuthMiddleware.php

@@ -12,26 +12,62 @@ final class AuthMiddleware
 {
     public static function handle($requestPathname)
     {
-        $requestPathname = trim($requestPathname);
-        if (!self::matches($requestPathname)) {
-            return;
-        }
+        if (AuthConfig::IS_ALL_ROUTES_PRIVATE) {
+            $isLogin = Auth::getInstance()->isAuthenticated();
+            $isApiAuthRoute = stripos($requestPathname, AuthConfig::API_AUTH_PREFIX) === 0;
+            $isPublicRoute = self::matches($requestPathname, AuthConfig::$publicRoutes);
+            $isAuthRoute = self::matches($requestPathname, AuthConfig::$authRoutes);
+
+            // Skip the middleware if the route is api auth route
+            if ($isApiAuthRoute) {
+                return;
+            }
+
+            // Redirect to the default sign in route if the user is already authenticated
+            if ($isAuthRoute) {
+                if ($isLogin) {
+                    Request::redirect(AuthConfig::DEFAULT_SIGNIN_REDIRECT);
+                }
+                return;
+            }
+
+            // Redirect to the default home route if the user is already authenticated
+            if (!$isLogin && !$isPublicRoute) {
+                Request::redirect("/signin");
+            }
+        } else {
+            // Skip the middleware if the route is public
+            if (!self::matches($requestPathname, AuthConfig::$privateRoutes)) {
+                return;
+            }
 
-        // Check if the user is authorized to access the route or redirect to login
-        if (!self::isAuthorized()) {
-            Request::redirect('/auth/login');
+            // Check if the user is authorized to access the route or redirect to login
+            if (!self::isAuthorized()) {
+                Request::redirect('/signin');
+            }
         }
 
         // Check if the user has the required role to access the route or redirect to denied
-        if (AuthConfig::IS_ROLE_BASE && !self::hasRequiredRole($requestPathname)) {
-            Request::redirect('/denied');
+        if (AuthConfig::IS_ROLE_BASE) {
+            $matchValue = self::hasRequiredRole($requestPathname);
+            if ($matchValue === "Route not in array") {
+                // echo "No validation needed for this route.";
+            } elseif ($matchValue === "Match") {
+                // echo "You are authorized to access this route";
+            } elseif ($matchValue === "Role mismatch") {
+                // echo "You are not authorized to access this route";
+                Request::redirect('/denied');
+            } else {
+                // echo "Unexpected error encountered";
+            }
         }
     }
 
-    protected static function matches($requestPathname)
+    protected static function matches(string $requestPathname, array $routes): bool
     {
-        foreach (AuthConfig::$privateRoutes ?? [] as $pattern) {
-            if (self::getUriRegex($pattern, $requestPathname)) {
+        foreach ($routes ?? [] as $pattern) {
+            $getUriRegexValue = self::getUriRegex($pattern, $requestPathname);
+            if ($getUriRegexValue) {
                 return true;
             }
         }
@@ -67,34 +103,44 @@ final class AuthMiddleware
         return false;
     }
 
-    protected static function hasRequiredRole($requestPathname): bool
+    protected static function hasRequiredRole(string $requestPathname): string
     {
         $auth = Auth::getInstance();
         $roleBasedRoutes = AuthConfig::$roleBasedRoutes ?? [];
+
+        // Normalize the request path for matching
+        $requestPathnameValue = trim($requestPathname, '/');
+
         foreach ($roleBasedRoutes as $pattern => $data) {
-            if (self::getUriRegex($pattern, $requestPathname)) {
+            $patternValue = trim($pattern, '/');
+            if ($patternValue === $requestPathnameValue) {
+                // Route is found in array, check permissions
                 $userRole = Auth::ROLE_NAME ? $auth->getPayload()[Auth::ROLE_NAME] : $auth->getPayload();
-                if ($userRole !== null && AuthConfig::checkAuthRole($userRole, $data[AuthConfig::ROLE_IDENTIFIER])) {
-                    return true;
-                }
+                return ($userRole !== null && AuthConfig::checkAuthRole($userRole, $data[AuthConfig::ROLE_IDENTIFIER]))
+                    ? "Match"
+                    : "Role mismatch";
             }
         }
-        return false;
+
+        // Route not found in role-based routes array
+        return "Route not in array";
     }
 
-    private static function getUriRegex($pattern, $requestPathname)
+    private static function getUriRegex(string $pattern, string $requestPathname): int|bool
     {
-        $pattern = strtolower($pattern);
-        $requestPathname = strtolower(trim($requestPathname));
+        // Normalize both the pattern and the request path
+        $pattern = strtolower(trim($pattern, '/'));
+        $requestPathname = strtolower(trim($requestPathname, '/'));
 
         // Handle the case where the requestPathname is empty, which means home or "/"
-        if (empty($requestPathname) || $requestPathname === '/') {
+        if (empty($requestPathname)) {
             $requestPathname = '/';
         } else {
-            $requestPathname = "/" . $requestPathname;
+            $requestPathname = "/$requestPathname";
         }
 
-        $regex = "#^/?" . preg_quote($pattern, '#') . "(/.*)?$#";
+        // Construct the regex pattern
+        $regex = "#^/?" . preg_quote("/$pattern", '#') . "(/.*)?$#";
         return preg_match($regex, $requestPathname);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "1.26.5",
+  "version": "1.26.7",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",