create-prisma-php-app 4.3.7 → 4.3.9

package/dist/settings/bs-config.ts

@@ -1,4 +1,7 @@
-import { createProxyMiddleware } from "http-proxy-middleware";
+import {
+  createProxyMiddleware,
+  responseInterceptor,
+} from "http-proxy-middleware";
 import { writeFileSync, existsSync, mkdirSync } from "fs";
 import browserSync, { BrowserSyncInstance } from "browser-sync";
 import prismaPhpConfigJson from "../prisma-php.json";
@@ -121,10 +124,85 @@ bs.init(
         res.setHeader("Expires", "0");
         next();
       },
+
+      (req, _, next) => {
+        const time = new Date().toLocaleTimeString();
+        console.log(
+          `${chalk.gray(time)} ${chalk.cyan("[Proxy]")} ${chalk.bold(req.method)} ${req.url}`,
+        );
+        next();
+      },
+
       createProxyMiddleware({
         target: prismaPhpConfigJson.bsTarget,
         changeOrigin: true,
         pathRewrite: {},
+        selfHandleResponse: true,
+
+        on: {
+          proxyReq: (proxyReq, req, _res) => {
+            proxyReq.setHeader("Accept-Encoding", "");
+
+            const sendsJson =
+              req.headers["content-type"]?.includes("application/json");
+            const asksJson =
+              req.headers["accept"]?.includes("application/json");
+
+            if (!sendsJson && !asksJson) return;
+
+            const originalWrite = proxyReq.write;
+            proxyReq.write = function (data, ...args) {
+              if (data) {
+                try {
+                  const body = data.toString();
+                  const json = JSON.parse(body);
+                  console.log(
+                    chalk.blue("→ API Request:"),
+                    JSON.stringify(json, null, 2),
+                  );
+                } catch {
+                  if (data.toString().trim() !== "") {
+                    console.log(chalk.blue("→ API Request:"), data.toString());
+                  }
+                }
+              }
+              // @ts-ignore
+              return originalWrite.call(proxyReq, data, ...args);
+            };
+          },
+
+          proxyRes: responseInterceptor(
+            async (responseBuffer, proxyRes, _req, _res) => {
+              const contentType = proxyRes.headers["content-type"] || "";
+
+              if (!contentType.includes("application/json")) {
+                return responseBuffer;
+              }
+
+              try {
+                const body = responseBuffer.toString("utf8");
+                console.log(
+                  chalk.green("← API Response:"),
+                  JSON.stringify(JSON.parse(body), null, 2),
+                );
+                console.log(
+                  chalk.gray("----------------------------------------"),
+                );
+              } catch (e) {
+                console.log(
+                  chalk.red("← API Response (Parse Error):"),
+                  responseBuffer.toString(),
+                );
+              }
+
+              return responseBuffer;
+            },
+          ),
+
+          error: (err) => {
+            console.error(chalk.red("Proxy Error:"), err);
+          },
+        },
       }),
     ],
     notify: false,

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

@@ -175,7 +175,7 @@ class Auth
             if (empty($token->{Auth::PAYLOAD_NAME})) return null;
             if (isset($token->exp) && time() >= $token->exp) return null;
 
-            return $token;
+            return $token->{Auth::PAYLOAD_NAME};
         } catch (Exception) {
             return null;
         }
@@ -198,15 +198,20 @@ class Auth
      */
     public function refreshToken(string $jwt, ?string $tokenValidity = null): string
     {
-        $decodedToken = $this->verifyToken($jwt);
+        $decodedData = $this->verifyToken($jwt);
 
-        if (!$decodedToken) {
+        if (!$decodedData) {
             throw new InvalidArgumentException("Invalid token.");
         }
 
         $expirationTime = $this->calculateExpirationTime($tokenValidity ?? $this->defaultTokenValidity);
-        $decodedToken->exp = $expirationTime;
-        $newJwt = JWT::encode((array)$decodedToken, $this->secretKey, 'HS256');
+
+        $payload = [
+            self::PAYLOAD_NAME => $decodedData,
+            'exp' => $expirationTime,
+        ];
+
+        $newJwt = JWT::encode($payload, $this->secretKey, 'HS256');
 
         if (!headers_sent()) {
             $this->setCookies($newJwt, $expirationTime);

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

@@ -7,6 +7,7 @@ namespace Lib\Middleware;
 use Lib\Auth\Auth;
 use Lib\Auth\AuthConfig;
 use PP\Request;
+use Throwable;
 
 final class AuthMiddleware
 {
@@ -24,9 +25,18 @@ final class AuthMiddleware
             // Check if the user is authenticated and refresh the token if necessary
             if (AuthConfig::IS_TOKEN_AUTO_REFRESH) {
                 $auth = Auth::getInstance();
-                if (isset($_COOKIE[Auth::$cookieName])) {
-                    $jwt = $_COOKIE[Auth::$cookieName];
-                    $jwt = $auth->refreshToken($jwt);
+
+                $jwt = $_COOKIE[Auth::$cookieName] ?? Request::getBearerToken();
+
+                if ($jwt) {
+                    try {
+                        $newJwt = $auth->refreshToken($jwt);
+                        if (!isset($_COOKIE[Auth::$cookieName])) {
+                            header('Authorization: Bearer ' . $newJwt);
+                            header('X-Refreshed-Token: ' . $newJwt);
+                        }
+                    } catch (Throwable) {
+                    }
                 }
             }
 
@@ -89,29 +99,35 @@ final class AuthMiddleware
     protected static function isAuthorized(): bool
     {
         $auth = Auth::getInstance();
-        if (!isset($_COOKIE[Auth::$cookieName])) {
-            unset($_SESSION[Auth::PAYLOAD_SESSION_KEY]);
+        $jwt = $_COOKIE[Auth::$cookieName] ?? Request::getBearerToken();
+
+        if (!$jwt) {
+            if (isset($_SESSION[Auth::PAYLOAD_SESSION_KEY])) {
+                unset($_SESSION[Auth::PAYLOAD_SESSION_KEY]);
+            }
             return false;
         }
 
-        $jwt = $_COOKIE[Auth::$cookieName];
-
         if (AuthConfig::IS_TOKEN_AUTO_REFRESH) {
-            $jwt = $auth->refreshToken($jwt);
-            $verifyToken = $auth->verifyToken($jwt);
+            try {
+                $jwt = $auth->refreshToken($jwt);
+
+                if (!isset($_COOKIE[Auth::$cookieName]) && !headers_sent()) {
+                    header('Authorization: Bearer ' . $jwt);
+                    header('X-Refreshed-Token: ' . $jwt);
+                }
+            } catch (Throwable) {
+                return false;
+            }
         }
 
         $verifyToken = $auth->verifyToken($jwt);
+
         if ($verifyToken === false) {
             return false;
         }
 
-        // Access the PAYLOAD_NAME property using the -> operator instead of array syntax
-        if (isset($verifyToken->{Auth::PAYLOAD_NAME})) {
-            return true;
-        }
-
-        return false;
+        return isset($verifyToken->{Auth::PAYLOAD_NAME});
     }
 
     protected static function hasRequiredRole(string $requestPathname): string

package/package.json

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