create-prisma-php-app 4.3.6 → 4.3.8

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";
@@ -13,11 +16,12 @@ import {
 } from "./class-imports";
 import { checkComponentImports } from "./component-import-checker";
 import { DebouncedWorker, createSrcWatcher, DEFAULT_AWF } from "./utils.js";
+import chalk from "chalk";
 
 const { __dirname } = getFileMeta();
 const bs: BrowserSyncInstance = browserSync.create();
 
-const PUBLIC_IGNORE_DIRS = [''];
+const PUBLIC_IGNORE_DIRS = [""];
 
 const pipeline = new DebouncedWorker(
   async () => {
@@ -46,18 +50,18 @@ const pipeline = new DebouncedWorker(
     }
   },
   350,
-  "bs-pipeline"
+  "bs-pipeline",
 );
 
 const publicPipeline = new DebouncedWorker(
   async () => {
-    console.log("→ Public directory changed, reloading browser...");
+    console.log(chalk.cyan("→ Public directory changed, reloading browser..."));
     if (bs.active) {
       bs.reload();
     }
   },
   350,
-  "bs-public-pipeline"
+  "bs-public-pipeline",
 );
 
 createSrcWatcher(join(SRC_DIR, "**", "*"), {
@@ -90,16 +94,17 @@ createSrcWatcher(join(PUBLIC_DIR, "**", "*"), {
 
 const viteFlagFile = join(__dirname, "..", ".pp", ".vite-build-complete");
 mkdirSync(dirname(viteFlagFile), { recursive: true });
-writeFileSync(viteFlagFile, "");
 
 if (!existsSync(viteFlagFile)) {
   writeFileSync(viteFlagFile, "0");
+} else {
+  writeFileSync(viteFlagFile, "");
 }
 
 createSrcWatcher(viteFlagFile, {
   onEvent: (ev) => {
     if (ev === "change" && bs.active) {
-      console.log("→ Vite build complete, reloading browser...");
+      console.log(chalk.green("→ Vite build complete, reloading browser..."));
       bs.reload();
     }
   },
@@ -119,36 +124,138 @@ 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,
     open: false,
     ghostMode: false,
     codeSync: true,
+    logLevel: "silent",
   },
   (err, bsInstance) => {
     if (err) {
-      console.error("BrowserSync failed to start:", err);
+      console.error(chalk.red("BrowserSync failed to start:"), err);
       return;
     }
 
     const urls = bsInstance.getOption("urls");
+    const localUrl = urls.get("local");
+    const externalUrl = urls.get("external");
+    const uiUrl = urls.get("ui");
+    const uiExtUrl = urls.get("ui-external");
+
+    console.log("");
+    console.log(chalk.green.bold("✔ Ports Configured:"));
+    console.log(
+      `  ${chalk.blue.bold("Frontend (BrowserSync):")} ${chalk.magenta(localUrl)}`,
+    );
+    console.log(
+      `  ${chalk.yellow.bold("Backend (PHP Target):")}   ${chalk.magenta(
+        prismaPhpConfigJson.bsTarget || "http://localhost:80",
+      )}`,
+    );
+    console.log(chalk.gray(" ------------------------------------"));
+
+    if (externalUrl) {
+      console.log(
+        `    ${chalk.bold("External:")} ${chalk.magenta(externalUrl)}`,
+      );
+    }
+
+    if (uiUrl) {
+      console.log(`          ${chalk.bold("UI:")} ${chalk.magenta(uiUrl)}`);
+    }
+
     const out = {
-      local: urls.get("local"),
-      external: urls.get("external"),
-      ui: urls.get("ui"),
-      uiExternal: urls.get("ui-external"),
+      local: localUrl,
+      external: externalUrl,
+      ui: uiUrl,
+      uiExternal: uiExtUrl,
     };
 
     writeFileSync(
       join(__dirname, "bs-config.json"),
-      JSON.stringify(out, null, 2)
+      JSON.stringify(out, null, 2),
     );
-    console.log("\n\x1b[90mPress Ctrl+C to stop.\x1b[0m\n");
-  }
+    console.log(`\n${chalk.gray("Press Ctrl+C to stop.")}\n`);
+  },
 );

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/package.json

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