create-prisma-php-app 1.9.15 → 1.9.17

package/dist/prisma-client-php/index.js

@@ -1,15 +1,15 @@
 import*as fs from"fs";import{exec}from"child_process";import path from"path";import{fileURLToPath}from"url";import CryptoJS from"crypto-js";const __filename=fileURLToPath(import.meta.url),__dirname=path.dirname(__filename),getSecretKey=()=>{const r=fs.readFileSync(`${__dirname}/key.enc`,"utf8");if(r.length<400)throw new Error("File content is less than 400 characters.");return r.substring(247,289)},decryptData=(r,t)=>CryptoJS.AES.decrypt(r,t).toString(CryptoJS.enc.Utf8);
 const executePHP = (command) => {
-    exec(command, (error, stdout, stderr) => {
-        if (error) {
-            console.error(`Execution error: ${error}`);
-            return;
-        }
-        if (stderr) {
-            console.error(`Standard error: ${stderr}`);
-            return;
-        }
-        console.log(`Standard output...\n${stdout}`);
-    });
+  exec(command, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`Execution error: ${error}`);
+      return;
+    }
+    if (stderr) {
+      console.error(`Standard error: ${stderr}`);
+      return;
+    }
+    console.log(`Standard output...\n${stdout}`);
+  });
 };
 const main=async()=>{try{const e=process.cwd(),n=path.join(e,"prisma-php.json"),a=fs.readFileSync(n,{encoding:"utf8"}),c=JSON.parse(a),t=c.phpGenerateClassPath,i=`${__dirname}/index.php`,p=`${__dirname}/index.enc`,s=getSecretKey(),r=fs.readFileSync(p,{encoding:"utf8"}),d=decryptData(r,s);fs.writeFileSync(`${__dirname}/index.php`,d);const h=`${c.phpRootPathExe} ${i} ${t}`;executePHP(h)}catch(e){}};main().catch((e=>{}));

package/dist/settings/project-name.cjs

@@ -9,6 +9,7 @@ const newProjectName = path.basename(path.join(__dirname, ".."));
 
 // Function to update the project name and paths in the JSON config
 function updateProjectNameInConfig(filePath, newProjectName) {
+  const filePathDir = path.dirname(filePath);
   fs.readFile(filePath, "utf8", (err, data) => {
     if (err) {
       console.error("Error reading the JSON file:", err);
@@ -17,29 +18,16 @@ function updateProjectNameInConfig(filePath, newProjectName) {
 
     let config = JSON.parse(data);
 
-    // Extract the old project name from the projectRootPath
-    const oldProjectNameMatch = /[^\\]*$/.exec(config.projectRootPath);
-    if (!oldProjectNameMatch) {
-      console.error(
-        "Could not extract the old project name from projectRootPath."
-      );
-      return;
-    }
-    const oldProjectName = oldProjectNameMatch[0];
-
     // Update the projectName
     config.projectName = newProjectName;
 
-    // Update paths containing the old project name
-    config.projectRootPath = config.projectRootPath.replace(
-      new RegExp(oldProjectName + "$"),
-      newProjectName
-    );
-    config.bsTarget = config.bsTarget.replace(oldProjectName, newProjectName);
-    config.bsPathRewrite["^/"] = config.bsPathRewrite["^/"].replace(
-      oldProjectName,
-      newProjectName
-    );
+    // Update other paths
+    config.projectRootPath = filePathDir;
+
+    const targetPath = getTargetPath(filePathDir, config.phpEnvironment);
+
+    config.bsTarget = `http://localhost${targetPath}`;
+    config.bsPathRewrite["^/"] = targetPath;
 
     // Save the updated config back to the JSON file
     fs.writeFile(filePath, JSON.stringify(config, null, 2), "utf8", (err) => {
@@ -47,10 +35,49 @@ function updateProjectNameInConfig(filePath, newProjectName) {
         console.error("Error writing the updated JSON file:", err);
         return;
       }
-      console.log("The project name and paths have been updated successfully.");
+      console.log(
+        "The project name, PHP path, and other paths have been updated successfully."
+      );
     });
   });
 }
 
+// Function to determine the target path for browser-sync
+function getTargetPath(fullPath, environment) {
+  const normalizedPath = path.normalize(fullPath);
+  const webDirectories = {
+    XAMPP: path.join("htdocs"),
+    WAMP: path.join("www"),
+    MAMP: path.join("htdocs"),
+    LAMP: path.join("var", "www", "html"),
+    LEMP: path.join("usr", "share", "nginx", "html"),
+    AMPPS: path.join("www"),
+    UniformServer: path.join("www"),
+    EasyPHP: path.join("data", "localweb"),
+  };
+
+  const webDir = webDirectories[environment.toUpperCase()];
+  if (!webDir) {
+    throw new Error(`Unsupported environment: ${environment}`);
+  }
+
+  const indexOfWebDir = normalizedPath
+    .toLowerCase()
+    .indexOf(path.normalize(webDir).toLowerCase());
+  if (indexOfWebDir === -1) {
+    throw new Error(`Web directory not found in path: ${webDir}`);
+  }
+
+  const startIndex = indexOfWebDir + webDir.length;
+  const subPath = normalizedPath.slice(startIndex);
+  const safeSeparatorRegex = new RegExp(
+    path.sep.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"),
+    "g"
+  );
+  const finalPath = subPath.replace(safeSeparatorRegex, "/") + "/";
+
+  return finalPath;
+}
+
 // Run the function with your config file path and the new project name
 updateProjectNameInConfig(configFilePath, newProjectName);

package/dist/settings/request-methods.php

@@ -0,0 +1,16 @@
+<?php
+
+$requestMethod = $_SERVER['REQUEST_METHOD'];
+$isGet = $requestMethod === 'GET';
+$isPost = $requestMethod === 'POST';
+$isPut = $requestMethod === 'PUT';
+$isDelete = $requestMethod === 'DELETE';
+$isPatch = $requestMethod === 'PATCH';
+$isHead = $requestMethod === 'HEAD';
+$isOptions = $requestMethod === 'OPTIONS';
+$contentType = $_SERVER['CONTENT_TYPE'] ?? '';
+$requestedWith = $_SERVER['HTTP_X_REQUESTED_WITH'] ?? '';
+$protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' || $_SERVER['SERVER_PORT'] == 443) ? "https://" : "http://";
+$domainName = $_SERVER['HTTP_HOST'];
+$scriptName = dirname($_SERVER['SCRIPT_NAME']) . '/';
+$baseUrl = $protocol . $domainName . rtrim($scriptName, '/') . '/src/app/';

package/dist/settings/route-request.php

@@ -0,0 +1,31 @@
+<?php
+
+header('Content-Type: application/json');
+
+if ($isOptions == 'OPTIONS') {
+    header('HTTP/1.1 200 OK');
+    exit;
+}
+
+// Determine the request method
+$allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+if (!in_array($requestMethod, $allowedMethods)) {
+    echo "Method not allowed\n";
+    header("HTTP/1.1 405 Method Not Allowed");
+    exit;
+}
+
+$params = [];
+
+if (stripos($contentType, 'application/json') !== false) {
+    $jsonInput = file_get_contents('php://input');
+    if (!empty($jsonInput)) {
+        $data = json_decode($jsonInput, true);
+        if (json_last_error() === JSON_ERROR_NONE) {
+            $params = $data;
+        } else {
+            echo json_encode(['error' => 'Error: Invalid JSON body!']);
+            exit;
+        }
+    }
+}

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

@@ -0,0 +1,163 @@
+<?php
+
+namespace Lib\Auth;
+
+use Firebase\JWT\JWT;
+use Firebase\JWT\Key;
+use DateInterval;
+use DateTime;
+use Psr\Log\LoggerInterface;
+
+class Auth
+{
+    public const PAYLOAD_NAME = 'role';
+    public const PAYLOAD = 'payload';
+    public const COOKIE_NAME = 'auth_token';
+
+    private $secretKey;
+    private $defaultTokenValidity = '1h'; // Default to 1 hour
+    private $logger;
+
+    public function __construct(LoggerInterface $logger = null)
+    {
+        $this->secretKey = $_ENV['AUTH_SECRET'];
+        $this->logger = $logger;
+    }
+
+    public function authenticate($role, string $tokenValidity = null): string
+    {
+        if (!$this->secretKey) {
+            throw new \InvalidArgumentException("Secret key is required for authentication.");
+        }
+
+        $expirationTime = $this->calculateExpirationTime($tokenValidity ?? $this->defaultTokenValidity);
+
+        if ($role instanceof AuthRole) {
+            $role = $role->value;
+        }
+
+        $payload = [
+            self::PAYLOAD_NAME => $role,
+            'exp' => $expirationTime,
+        ];
+
+        // Set the payload in the session
+        $_SESSION[self::PAYLOAD] = $payload;
+
+        // Encode the JWT
+        $jwt = JWT::encode($payload, $this->secretKey, 'HS256');
+
+        if (!headers_sent()) {
+            $this->setCookies($jwt, $expirationTime);
+        }
+
+        return $jwt;
+    }
+
+    private function calculateExpirationTime(string $duration): int
+    {
+        $now = new DateTime();
+        $interval = $this->convertDurationToInterval($duration);
+        $futureDate = $now->add($interval);
+        return $futureDate->getTimestamp();
+    }
+
+    private function convertDurationToInterval(string $duration): DateInterval
+    {
+        if (preg_match('/^(\d+)(s|m|h|d)$/', $duration, $matches)) {
+            $value = (int)$matches[1];
+            $unit = $matches[2];
+
+            switch ($unit) {
+                case 's':
+                    return new DateInterval("PT{$value}S");
+                case 'm':
+                    return new DateInterval("PT{$value}M");
+                case 'h':
+                    return new DateInterval("PT{$value}H");
+                case 'd':
+                    return new DateInterval("P{$value}D");
+                default:
+                    throw new \InvalidArgumentException("Invalid duration format: {$duration}");
+            }
+        }
+
+        throw new \InvalidArgumentException("Invalid duration format: {$duration}");
+    }
+
+    public function verifyToken(string $jwt)
+    {
+        try {
+            return JWT::decode($jwt, new Key($this->secretKey, 'HS256'));
+        } catch (\Firebase\JWT\ExpiredException $e) {
+            if ($this->logger) {
+                $this->logger->error("JWT expired: " . $e->getMessage());
+            }
+            return false;
+        } catch (\Exception $e) {
+            if ($this->logger) {
+                $this->logger->error("JWT verification failed: " . $e->getMessage());
+            }
+            return false;
+        }
+    }
+
+    public function refreshToken(string $jwt, string $tokenValidity = null): string
+    {
+        $decodedToken = $this->verifyToken($jwt);
+
+        if (!$decodedToken) {
+            throw new \InvalidArgumentException("Invalid token.");
+        }
+
+        $expirationTime = $this->calculateExpirationTime($tokenValidity ?? $this->defaultTokenValidity);
+
+        $decodedToken->exp = $expirationTime;
+        $newJwt = JWT::encode((array)$decodedToken, $this->secretKey, 'HS256');
+
+        if (!headers_sent()) {
+            $this->setCookies($newJwt, $expirationTime);
+        }
+
+        return $newJwt;
+    }
+
+    protected function setCookies(string $jwt, int $expirationTime)
+    {
+        if (!headers_sent()) {
+            setcookie(self::COOKIE_NAME, $jwt, [
+                'expires' => $expirationTime,
+                'path' => '/',
+                'domain' => '', // Specify your domain
+                'secure' => true,
+                'httponly' => true,
+                'samesite' => 'Lax', // or 'Strict' depending on your requirements
+            ]);
+        }
+    }
+
+    public function logout(string $redirect = null)
+    {
+        if (isset($_COOKIE[self::COOKIE_NAME])) {
+            unset($_COOKIE[self::COOKIE_NAME]);
+            setcookie(self::COOKIE_NAME, '', time() - 3600, '/');
+        }
+
+        if (isset($_SESSION[self::PAYLOAD])) {
+            unset($_SESSION[self::PAYLOAD]);
+        }
+
+        if ($redirect) {
+            redirect($redirect);
+        }
+    }
+
+    public function getPayload()
+    {
+        if (isset($_SESSION[self::PAYLOAD])) {
+            return $_SESSION[self::PAYLOAD][self::PAYLOAD_NAME];
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,59 @@
+<?php
+
+namespace Lib\Auth;
+
+enum AuthRole: string
+{
+    case Admin = 'Admin';
+    case User = 'User';
+
+    public function equals($role)
+    {
+        return $this->value === $role;
+    }
+}
+
+class AuthConfig
+{
+    public const ROLE_IDENTIFIER = 'role';
+    public const IS_ROLE_BASE = true;
+    public const IS_TOKEN_AUTO_REFRESH = true;
+
+    // An array listing the public routes that do not require authentication.
+    // Example: public static $publicRoutes = ['/'];
+    public static $publicRoutes = ['/'];
+
+    // 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 = ['profile', 'dashboard/settings'];
+    public static $privateRoutes = [];
+
+    // An associative array mapping specific routes to required user roles for access control.
+    // Each route is a key with an array of roles that are allowed access.
+    // Format:
+    // 'route_path' => [self::ROLE_IDENTIFIER => [AuthRole::Role1, AuthRole::Role2, ...]],
+    // Example:
+    // public static $roleBasedRoutes = [
+    //     'dashboard' => [self::ROLE_IDENTIFIER => [AuthRole::Admin, AuthRole::User]],
+    //     'dashboard/users' => [self::ROLE_IDENTIFIER => [AuthRole::Admin]],
+    //     'sales' => [self::ROLE_IDENTIFIER => [AuthRole::Admin, AuthRole::User]]
+    // ];
+    public static $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.
+     */
+    public static function checkAuthRole($userRole, $roles)
+    {
+        foreach ($roles as $role) {
+            if ($userRole === $role->value) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,91 @@
+<?php
+
+namespace Lib\Middleware;
+
+use Lib\Auth\Auth;
+use Lib\Auth\AuthConfig;
+
+class AuthMiddleware
+{
+    public static function handle($requestUri)
+    {
+        $requestUri = trim($requestUri);
+        if (!self::matches($requestUri)) {
+            return;
+        }
+
+        // Check if the user is authorized to access the route or redirect to login
+        if (!self::isAuthorized()) {
+            redirect('/auth/login');
+            exit;
+        }
+
+        // Check if the user has the required role to access the route or redirect to denied
+        if (AuthConfig::IS_ROLE_BASE && !self::hasRequiredRole($requestUri)) {
+            redirect('/denied');
+            exit;
+        }
+    }
+
+    protected static function matches($requestUri)
+    {
+        foreach (AuthConfig::$privateRoutes ?? [] as $pattern) {
+            if (self::getUriRegex($pattern, $requestUri)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected static function isAuthorized(): bool
+    {
+        $auth = new Auth();
+        $cookieName = Auth::COOKIE_NAME;
+        if (!isset($_COOKIE[$cookieName])) {
+            unset($_SESSION[Auth::PAYLOAD]);
+            return false;
+        }
+
+        $jwt = $_COOKIE[$cookieName];
+
+        if (AuthConfig::IS_TOKEN_AUTO_REFRESH) {
+            $jwt = $auth->refreshToken($jwt);
+            $verifyToken = $auth->verifyToken($jwt);
+        }
+
+        $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;
+    }
+
+    protected static function hasRequiredRole($requestUri): bool
+    {
+        $auth = new Auth();
+        $roleBasedRoutes = AuthConfig::$roleBasedRoutes ?? [];
+        foreach ($roleBasedRoutes as $pattern => $data) {
+            if (self::getUriRegex($pattern, $requestUri)) {
+                $userRole = $auth->getPayload()['userRole'] ?? null;
+                if ($userRole !== null && AuthConfig::checkAuthRole($userRole, $data[AuthConfig::ROLE_IDENTIFIER])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static function getUriRegex($pattern, $requestUri)
+    {
+        $pattern = strtolower($pattern);
+        $requestUri = strtolower(trim($requestUri));
+        $regex = "#^/?" . preg_quote($pattern, '#') . "$#";
+        return preg_match($regex, $requestUri);
+    }
+}

package/dist/src/Lib/StateManager.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Lib;
+
+/**
+ * Manages the application state.
+ */
+class StateManager
+{
+    private $state;
+    private $listeners;
+
+    /**
+     * Constructs a new StateManager instance.
+     *
+     * @param array $initialState The initial state of the application.
+     */
+    public function __construct($initialState = [])
+    {
+        $this->state = $initialState;
+        $this->listeners = [];
+        $this->loadState();
+    }
+
+    /**
+     * Retrieves the current state of the application.
+     *
+     * @param string|null $key The key of the state value to retrieve. If null, returns the entire state.
+     * @return mixed|null The state value corresponding to the given key, or null if the key is not found.
+     */
+    public function getState($key = null)
+    {
+        if ($key === null) {
+            return $this->state;
+        }
+
+        return $this->state[$key] ?? null;
+    }
+
+    /**
+     * Updates the application state with the given update.
+     *
+     * @param array $update The state update to apply.
+     * @param bool $saveToStorage Whether to save the updated state to storage.
+     */
+    public function setState($update, $saveToStorage = false)
+    {
+        $this->state = array_merge($this->state, $update);
+        foreach ($this->listeners as $listener) {
+            call_user_func($listener, $this->state);
+        }
+        if ($saveToStorage) {
+            $this->saveState();
+        }
+    }
+
+    /**
+     * Subscribes a listener to state changes.
+     *
+     * @param callable $listener The listener function to subscribe.
+     * @return callable A function that can be called to unsubscribe the listener.
+     */
+    public function subscribe($listener)
+    {
+        $this->listeners[] = $listener;
+        call_user_func($listener, $this->state);
+        return function () use ($listener) {
+            $this->listeners = array_filter($this->listeners, function ($l) use ($listener) {
+                return $l !== $listener;
+            });
+        };
+    }
+
+    /**
+     * Saves the current state to storage.
+     */
+    private function saveState()
+    {
+        $_SESSION['appState'] = json_encode($this->state);
+    }
+
+    /**
+     * Loads the state from storage, if available.
+     */
+    private function loadState()
+    {
+        if (isset($_SESSION['appState'])) {
+            $this->state = json_decode($_SESSION['appState'], true);
+            foreach ($this->listeners as $listener) {
+                call_user_func($listener, $this->state);
+            }
+        }
+    }
+
+    /**
+     * Resets the application state.
+     *
+     * @param bool $clearFromStorage Whether to clear the state from storage.
+     */
+    public function resetState($clearFromStorage = false)
+    {
+        $this->state = [];
+        foreach ($this->listeners as $listener) {
+            call_user_func($listener, $this->state);
+        }
+        if ($clearFromStorage) {
+            unset($_SESSION['appState']);
+        }
+    }
+}

package/dist/src/app/index.php

@@ -5,9 +5,12 @@
             <span class="sr-only">Prisma PHP</span>
         </a>
         <nav class="ml-auto flex gap-4 sm:gap-6">
-            <a class="text-sm font-medium hover:underline underline-offset-4" href="#">
+            <a class="text-sm font-medium hover:underline underline-offset-4" href="https://prismaphp.tsnc.tech/features" target="_blank">
                 Features
             </a>
+            <a class="text-sm font-medium hover:underline underline-offset-4" href="https://prismaphp.tsnc.tech/newsletter" target="_blank">
+                Join the Newsletter
+            </a>
             <a class="text-sm font-medium hover:underline underline-offset-4" href="https://prismaphp.tsnc.tech/docs?doc=get-started" target="_blank">
                 Documentation
             </a>
@@ -26,7 +29,7 @@
                     <p class="mx-auto max-w-[700px] text-gray-500 md:text-xl dark:text-gray-400">
                         The Next Generation ORM for PHP
                     </p>
-                    <a class="inline-flex h-10 items-center justify-center rounded-md bg-gray-900 px-8 text-sm font-medium text-gray-50 shadow transition-colors hover:bg-gray-900/90 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-gray-950 disabled:pointer-events-none disabled:opacity-50 dark:bg-gray-50 dark:text-gray-900 dark:hover:bg-gray-50/90 dark:focus-visible:ring-gray-300" href="#">
+                    <a class="inline-flex h-10 items-center justify-center rounded-md bg-gray-900 px-8 text-sm font-medium text-gray-50 shadow transition-colors hover:bg-gray-900/90 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-gray-950 disabled:pointer-events-none disabled:opacity-50 dark:bg-gray-50 dark:text-gray-900 dark:hover:bg-gray-50/90 dark:focus-visible:ring-gray-300" href="https://prismaphp.tsnc.tech/docs?doc=get-started">
                         Get Started
                     </a>
                 </div>

package/package.json

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