create-prisma-php-app 1.19.500 → 1.20.0

package/dist/settings/request-methods.php

@@ -32,6 +32,7 @@ $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ||
 $domainName = $_SERVER['HTTP_HOST'];
 $scriptName = dirname($_SERVER['SCRIPT_NAME']) . '/';
 $baseUrl = $protocol . $domainName . rtrim($scriptName, '/') . '/src/app/';
+$referer = $_SERVER['HTTP_REFERER'] ?? 'Unknown';
 
 $params = [];
 

package/dist/src/Lib/AI/ChatGPTClient.php

@@ -14,14 +14,15 @@ class ChatGPTClient
     private $client;
     private $apiUrl;
     private $apiKey;
+    private $cache = [];
 
     /**
      * Constructor initializes the Guzzle HTTP client and sets up API configuration.
      */
-    public function __construct()
+    public function __construct(Client $client = null)
     {
-        // Initialize the Guzzle HTTP client
-        $this->client = new Client();
+        // Initialize the Guzzle HTTP client, allowing for dependency injection
+        $this->client = $client ?: new Client();
 
         // API URL for chat completions
         $this->apiUrl = 'https://api.openai.com/v1/chat/completions';
@@ -36,9 +37,8 @@ class ChatGPTClient
      * @param array $conversationHistory The conversation history array.
      * @return string The model name to be used.
      */
-    private function determineModel(array $conversationHistory)
+    protected function determineModel(array $conversationHistory): string
     {
-        // Example logic for model selection
         $messageCount = count($conversationHistory);
         $totalTokens = array_reduce($conversationHistory, function ($carry, $item) {
             return $carry + str_word_count($item['content'] ?? '');
@@ -53,6 +53,25 @@ class ChatGPTClient
         return 'gpt-3.5-turbo';
     }
 
+    /**
+     * Formats the conversation history to ensure it is valid.
+     *
+     * @param array $conversationHistory The conversation history array.
+     * @return array The formatted conversation history.
+     */
+    protected function formatConversationHistory(array $conversationHistory): array
+    {
+        $formattedHistory = [];
+        foreach ($conversationHistory as $message) {
+            if (is_array($message) && isset($message['role'], $message['content']) && Validator::string($message['content'])) {
+                $formattedHistory[] = $message;
+            } else {
+                $formattedHistory[] = ['role' => 'user', 'content' => (string) $message];
+            }
+        }
+        return $formattedHistory;
+    }
+
     /**
      * Sends a message to the OpenAI API and returns the AI's response.
      *
@@ -64,31 +83,29 @@ class ChatGPTClient
      */
     public function sendMessage(array $conversationHistory, string $userMessage): string
     {
-        try {
-            if (!Validator::string($userMessage)) {
-                throw new \InvalidArgumentException("Invalid user message: must be a string.");
-            }
+        if (!Validator::string($userMessage)) {
+            throw new \InvalidArgumentException("Invalid user message: must be a string.");
+        }
 
-            // Optional: Convert emojis or special patterns in the message
-            $userMessage = Validator::emojis($userMessage);
-
-            // Ensure conversationHistory is properly formatted
-            $formattedHistory = [];
-            foreach ((array) $conversationHistory as $key => $message) {
-                if (is_array($message) && isset($message['role'], $message['content']) && Validator::string($message['content'])) {
-                    $formattedHistory[] = $message;
-                } else {
-                    // If the message is a string, assume it's a user message without a role
-                    $formattedHistory[] = ['role' => 'user', 'content' => (string) $message];
-                }
-            }
+        // Optional: Convert emojis or special patterns in the message
+        $userMessage = Validator::emojis($userMessage);
 
-            // Add the new user message
-            $formattedHistory[] = ['role' => 'user', 'content' => $userMessage];
+        // Format the conversation history
+        $formattedHistory = $this->formatConversationHistory($conversationHistory);
 
-            // Determine the appropriate model to use
-            $model = $this->determineModel($formattedHistory);
+        // Add the new user message
+        $formattedHistory[] = ['role' => 'user', 'content' => $userMessage];
+
+        // Check cache first
+        $cacheKey = md5(serialize($formattedHistory));
+        if (isset($this->cache[$cacheKey])) {
+            return $this->cache[$cacheKey];
+        }
 
+        // Determine the appropriate model to use
+        $model = $this->determineModel($formattedHistory);
+
+        try {
             // Sending a POST request to the AI API
             $response = $this->client->request('POST', $this->apiUrl, [
                 'headers' => [
@@ -106,10 +123,18 @@ class ChatGPTClient
             $responseBody = $response->getBody();
             $responseContent = json_decode($responseBody, true);
 
-            // Return the content of the AI's response message
-            return $responseContent['choices'][0]['message']['content'];
+            // Check if response is in expected format
+            if (isset($responseContent['choices'][0]['message']['content'])) {
+                $aiMessage = $responseContent['choices'][0]['message']['content'];
+                // Cache the result
+                $this->cache[$cacheKey] = $aiMessage;
+                return $aiMessage;
+            }
+
+            throw new \RuntimeException('Unexpected API response format.');
         } catch (RequestException $e) {
-            throw new \RuntimeException("API request failed: " . $e->getMessage());
+            // Log error here if you have a logger
+            throw new \RuntimeException("API request failed: " . $e->getMessage(), 0, $e);
         }
     }
 
@@ -119,7 +144,7 @@ class ChatGPTClient
      * @param string $gptResponse The raw response from GPT.
      * @return string The formatted HTML.
      */
-    public function formatGPTResponseToHTML($gptResponse)
+    public function formatGPTResponseToHTML(string $gptResponse): string
     {
         try {
             // Decode all HTML entities including numeric ones
@@ -140,12 +165,10 @@ class ChatGPTClient
             }, $gptResponse);
 
             // Convert bold text (e.g., **text** or __text__ -> <strong>text</strong>)
-            $gptResponse = preg_replace('/\*\*(.*?)\*\*/s', '<strong>$1</strong>', $gptResponse);
-            $gptResponse = preg_replace('/__(.*?)__/s', '<strong>$1</strong>', $gptResponse);
+            $gptResponse = preg_replace('/(\*\*|__)(.*?)\1/', '<strong>$2</strong>', $gptResponse);
 
             // Convert italic text (e.g., *text* or _text_ -> <em>text</em>)
-            $gptResponse = preg_replace('/(?<!\*)\*(?!\*)(.*?)\*(?!\*)/s', '<em>$1</em>', $gptResponse);
-            $gptResponse = preg_replace('/(?<!_)_(?!_)(.*?)_(?!_)/s', '<em>$1</em>', $gptResponse);
+            $gptResponse = preg_replace('/(\*|_)(.*?)\1/', '<em>$2</em>', $gptResponse);
 
             // Convert strikethrough text (e.g., ~~text~~ -> <del>text</del>)
             $gptResponse = preg_replace('/~~(.*?)~~/s', '<del>$1</del>', $gptResponse);

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

@@ -16,16 +16,25 @@ class Auth
     public const ROLE_NAME = '';
     public const PAYLOAD = 'payload_2183A';
     public const COOKIE_NAME = 'pphp_aut_token_D36E5';
-    private const PPHPAUTH = 'pphpauth';
 
+    private static ?Auth $instance = null;
+    private const PPHPAUTH = 'pphpauth';
     private $secretKey;
     private $defaultTokenValidity = '1h'; // Default to 1 hour
 
-    public function __construct()
+    private function __construct()
     {
         $this->secretKey = $_ENV['AUTH_SECRET'];
     }
 
+    public static function getInstance(): Auth
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
     /**
      * Authenticates a user and generates a JWT (JSON Web Token) based on the specified user data
      * and token validity duration. The method first checks if the secret key is set, calculates
@@ -35,7 +44,7 @@ class Auth
      * @param mixed $data User data which can be a simple string or an instance of AuthRole.
      *                    If an instance of AuthRole is provided, its `value` property will be used as the role in the token.
      * @param string|null $tokenValidity Optional parameter specifying the duration the token is valid for (e.g., '10m', '1h').
-     *                                   If null, the default validity period set in the class property is used.
+     *                                   If null, the default validity period set in the class property is used, which is 1 hour.
      *                                   The format should be a number followed by a time unit ('s' for seconds, 'm' for minutes,
      *                                   'h' for hours, 'd' for days), and this is parsed to calculate the exact expiration time.
      *
@@ -91,7 +100,19 @@ class Auth
      */
     public function isAuthenticated(): bool
     {
-        return isset($_SESSION[self::PAYLOAD]);
+        if (!isset($_COOKIE[self::COOKIE_NAME])) {
+            unset($_SESSION[self::PAYLOAD]);
+            return false;
+        }
+
+        $jwt = $_COOKIE[self::COOKIE_NAME];
+
+        $verifyToken = $this->verifyToken($jwt);
+        if ($verifyToken === false) {
+            return false;
+        }
+
+        return true;
     }
 
     private function calculateExpirationTime(string $duration): int
@@ -136,7 +157,7 @@ class Auth
     {
         try {
             return JWT::decode($jwt, new Key($this->secretKey, 'HS256'));
-        } catch (\Exception $e) {
+        } catch (\Exception) {
             throw new \InvalidArgumentException("Invalid token.");
         }
     }
@@ -227,7 +248,8 @@ class Auth
     public function getPayload()
     {
         if (isset($_SESSION[self::PAYLOAD])) {
-            return $_SESSION[self::PAYLOAD][self::PAYLOAD_NAME];
+            $value = $_SESSION[self::PAYLOAD][self::PAYLOAD_NAME];
+            return is_array($value) ? new \ArrayObject($value, \ArrayObject::ARRAY_AS_PROPS) : $value;
         }
 
         return null;
@@ -278,7 +300,7 @@ class Auth
      * @param mixed ...$providers An array of provider objects such as GoogleProvider or GithubProvider.
      * 
      * Example:
-     *   $auth = new Auth();
+     *   $auth = Auth::getInstance();
      *   $auth->authProviders(new GoogleProvider('client_id', 'client_secret', 'redirect_uri'));
      */
     public function authProviders(...$providers)
@@ -461,8 +483,7 @@ class GoogleProvider
         public string $clientSecret,
         public string $redirectUri,
         public string $maxAge = '30d'
-    ) {
-    }
+    ) {}
 }
 
 class GithubProvider
@@ -471,6 +492,5 @@ class GithubProvider
         public string $clientId,
         public string $clientSecret,
         public string $maxAge = '30d'
-    ) {
-    }
+    ) {}
 }

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

@@ -13,26 +13,17 @@ enum AuthRole: string
     }
 }
 
-class AuthConfig
+final class AuthConfig
 {
     public const ROLE_IDENTIFIER = 'role';
     public const IS_ROLE_BASE = false;
     public const IS_TOKEN_AUTO_REFRESH = false;
 
-    /**
-     * An array listing the public routes that do not require authentication.
-     * Routes should be listed as string paths.
-     * By default, all routes are public.
-     * Example: public static $publicRoutes = ['/']; // This means the home page and others are public and do not require authentication.
-     * NOTE: This $publicRoutes = ['/']; is the default setting and does not need to be modified.
-     */
-    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 = ['/']; // This makes the home page private
-     * Example: public static $privateRoutes = ['profile', 'dashboard/settings']; // These routes are private
+     * Example: public static $privateRoutes = ['/profile', '/dashboard/settings']; // These routes are private
      */
     public static $privateRoutes = [];
 

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

@@ -5,7 +5,7 @@ namespace Lib\Middleware;
 use Lib\Auth\Auth;
 use Lib\Auth\AuthConfig;
 
-class AuthMiddleware
+final class AuthMiddleware
 {
     public static function handle($requestUri)
     {
@@ -17,13 +17,11 @@ class AuthMiddleware
         // 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;
         }
     }
 
@@ -39,7 +37,7 @@ class AuthMiddleware
 
     protected static function isAuthorized(): bool
     {
-        $auth = new Auth();
+        $auth = Auth::getInstance();
         $cookieName = Auth::COOKIE_NAME;
         if (!isset($_COOKIE[$cookieName])) {
             unset($_SESSION[Auth::PAYLOAD]);
@@ -68,7 +66,7 @@ class AuthMiddleware
 
     protected static function hasRequiredRole($requestUri): bool
     {
-        $auth = new Auth();
+        $auth = Auth::getInstance();
         $roleBasedRoutes = AuthConfig::$roleBasedRoutes ?? [];
         foreach ($roleBasedRoutes as $pattern => $data) {
             if (self::getUriRegex($pattern, $requestUri)) {

package/dist/src/Lib/Prisma/Classes/Utility.php

@@ -11,7 +11,7 @@ enum ArrayType: string
     case Value = 'value';
 }
 
-abstract class Utility
+final class Utility
 {
     public static function checkFieldsExistWithReferences(
         array $select,

package/dist/src/Lib/StateManager.php

@@ -7,14 +7,12 @@ namespace Lib;
  */
 class StateManager
 {
+    private static ?StateManager $instance = null;
     private const APP_STATE = 'app_state_F989A';
     private array $state = [];
     private array $listeners = [];
 
-    /**
-     * Initializes a new instance of the StateManager class.
-     */
-    public function __construct()
+    private function __construct()
     {
         global $isWire;
 
@@ -25,6 +23,14 @@ class StateManager
         }
     }
 
+    public static function getInstance(): StateManager
+    {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
     /**
      * Gets the state value for the specified key.
      *
@@ -71,7 +77,7 @@ class StateManager
     {
         $this->listeners[] = $listener;
         $listener($this->state);
-        return fn () => $this->listeners = array_filter($this->listeners, fn ($l) => $l !== $listener);
+        return fn() => $this->listeners = array_filter($this->listeners, fn($l) => $l !== $listener);
     }
 
     /**

package/dist/src/Lib/Validator.php

@@ -5,7 +5,7 @@ namespace Lib;
 use HTMLPurifier;
 use HTMLPurifier_Config;
 
-class Validator
+final class Validator
 {
     // String Validation
 
@@ -351,4 +351,226 @@ class Validator
 
         return strtr($content, $emojiMap);
     }
+
+    /**
+     * Validate a value against a set of rules.
+     *
+     * @param mixed $value The value to validate.
+     * @param string $rules A pipe-separated string of rules (e.g., 'required|min:2|max:50').
+     * @param mixed $confirmationValue The value to confirm against, if applicable.
+     * @return bool|string|null True if validation passes, string with error message if fails, or null for optional field.
+     */
+    public static function withRules($value, string $rules, $confirmationValue = null)
+    {
+        $rulesArray = explode('|', $rules);
+        foreach ($rulesArray as $rule) {
+            // Handle parameters in rules, e.g., 'min:10'
+            if (strpos($rule, ':') !== false) {
+                [$ruleName, $parameter] = explode(':', $rule);
+                $result = self::applyRule($ruleName, $parameter, $value, $confirmationValue);
+            } else {
+                $result = self::applyRule($rule, null, $value, $confirmationValue);
+            }
+
+            // If a validation rule fails, return the error message
+            if ($result !== true) {
+                return $result;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Apply an individual rule to a value.
+     *
+     * @param string $rule The rule to apply.
+     * @param mixed $parameter The parameter for the rule, if applicable.
+     * @param mixed $value The value to validate.
+     * @return bool|string True if the rule passes, or a string with an error message if it fails.
+     */
+    private static function applyRule(string $rule, $parameter, $value, $confirmationValue = null)
+    {
+        switch ($rule) {
+            case 'required':
+                if (empty($value) && $value !== '0') {
+                    return "This field is required.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'min':
+                if (strlen($value) < (int)$parameter) {
+                    return "This field must be at least $parameter characters long.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'max':
+                if (strlen($value) > (int)$parameter) {
+                    return "This field must not exceed $parameter characters.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'startsWith':
+                if (strpos($value, $parameter) !== 0) {
+                    return "This field must start with $parameter.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'endsWith':
+                if (substr($value, -strlen($parameter)) !== $parameter) {
+                    return "This field must end with $parameter.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'confirmed':
+                if ($confirmationValue !== $value) {
+                    return "The $rule confirmation does not match.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'email':
+                return self::email($value) ? true : "This field must be a valid email address.";
+            case 'url':
+                return self::url($value) ? true : "This field must be a valid URL.";
+            case 'ip':
+                return self::ip($value) ? true : "This field must be a valid IP address.";
+            case 'uuid':
+                return self::uuid($value) ? true : "This field must be a valid UUID.";
+            case 'cuid':
+                return self::cuid($value) ? true : "This field must be a valid CUID.";
+            case 'int':
+                return self::int($value) !== null ? true : "This field must be an integer.";
+            case 'float':
+                return self::float($value) !== null ? true : "This field must be a float.";
+            case 'boolean':
+                return self::boolean($value) !== null ? true : "This field must be a boolean.";
+            case 'in':
+                if (!in_array($value, explode(',', $parameter), true)) {
+                    return "The selected value is invalid.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'notIn':
+                if (in_array($value, explode(',', $parameter), true)) {
+                    return "The selected value is invalid.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'size':
+                if (strlen($value) !== (int)$parameter) {
+                    return "This field must be exactly $parameter characters long.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'between':
+                [$min, $max] = explode(',', $parameter);
+                if (strlen($value) < (int)$min || strlen($value) > (int)$max) {
+                    return "This field must be between $min and $max characters long.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'date':
+                return self::date($value, $parameter ?: 'Y-m-d') ? true : "This field must be a valid date.";
+            case 'dateFormat':
+                if (!\DateTime::createFromFormat($parameter, $value)) {
+                    return "This field must match the format $parameter.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'before':
+                if (strtotime($value) >= strtotime($parameter)) {
+                    return "This field must be a date before $parameter.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'after':
+                if (strtotime($value) <= strtotime($parameter)) {
+                    return "This field must be a date after $parameter.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'json':
+                return self::json($value) ? true : "This field must be a valid JSON string.";
+                break;
+            case 'timezone':
+                if (!in_array($value, timezone_identifiers_list())) {
+                    return "This field must be a valid timezone.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'regex':
+                if (!preg_match($parameter, $value)) {
+                    return "This field format is invalid.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'digits':
+                if (!ctype_digit($value) || strlen($value) != $parameter) {
+                    return "This field must be $parameter digits.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'digitsBetween':
+                [$min, $max] = explode(',', $parameter);
+                if (!ctype_digit($value) || strlen($value) < (int)$min || strlen($value) > (int)$max) {
+                    return "This field must be between $min and $max digits.";
+                } else {
+                    return true;
+                }
+                break;
+            case 'mimes':
+                $mimeTypes = explode(',', $parameter);
+                if (!self::isMimeTypeAllowed($value, $mimeTypes)) {
+                    return "The file must be of type: " . implode(', ', $mimeTypes) . ".";
+                } else {
+                    return true;
+                }
+                break;
+            case 'file':
+                if (!is_uploaded_file($value)) {
+                    return "This field must be a valid file.";
+                } else {
+                    return true;
+                }
+                break;
+                // Add additional rules as needed...
+            default:
+                return true;
+        }
+    }
+
+    private static function isMimeTypeAllowed($file, array $allowedMimeTypes)
+    {
+        // Check if the file is a valid uploaded file
+        if (!is_uploaded_file($file)) {
+            return false;
+        }
+
+        // Get the MIME type of the file using PHP's finfo_file function
+        $finfo = finfo_open(FILEINFO_MIME_TYPE);
+        $mimeType = finfo_file($finfo, $file);
+        finfo_close($finfo);
+
+        // Check if the MIME type is in the list of allowed MIME types
+        if (in_array($mimeType, $allowedMimeTypes, true)) {
+            return true;
+        }
+
+        return false;
+    }
 }

package/package.json

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