create-prisma-php-app 1.20.0 → 1.20.2

package/dist/bootstrap.php

@@ -456,29 +456,62 @@ function convertToArrayObject($data)
 function wireCallback()
 {
     try {
-        // Read input data
-        $input = file_get_contents('php://input');
-        $data = json_decode($input, true);
-
         // Initialize response
         $response = [
             'success' => false,
             'error' => 'Callback not provided',
-            'data' => $data
+            'data' => null
         ];
 
         $callbackResponse = null;
+        $data = [];
+
+        // Check if the request includes one or more files
+        $hasFile = isset($_FILES['file']) && !empty($_FILES['file']['name'][0]);
+
+        // Process form data
+        if ($hasFile) {
+            // Handle file upload, including multiple files
+            $data = $_POST; // Form data will be available in $_POST
+
+            if (is_array($_FILES['file']['name'])) {
+                // Multiple files uploaded
+                $files = [];
+                foreach ($_FILES['file']['name'] as $index => $name) {
+                    $files[] = [
+                        'name' => $name,
+                        'type' => $_FILES['file']['type'][$index],
+                        'tmp_name' => $_FILES['file']['tmp_name'][$index],
+                        'error' => $_FILES['file']['error'][$index],
+                        'size' => $_FILES['file']['size'][$index],
+                    ];
+                }
+                $data['files'] = $files;
+            } else {
+                // Single file uploaded
+                $data['file'] = $_FILES['file']; // Attach single file information to data
+            }
+        } else {
+            // Handle non-file form data (likely JSON)
+            $input = file_get_contents('php://input');
+            $data = json_decode($input, true);
+
+            if (json_last_error() !== JSON_ERROR_NONE) {
+                // Fallback to handle form data in POST (non-JSON)
+                $data = $_POST;
+            }
+        }
 
         // Validate and call the dynamic function
         if (isset($data['callback'])) {
             // Sanitize and create a dynamic function name
-            $callbackName = preg_replace('/[^a-zA-Z0-9_]/', '', $data['callback']); // Sanitize
+            $callbackName = preg_replace('/[^a-zA-Z0-9_]/', '', $data['callback']); // Sanitize the callback name
 
             // Check if the dynamic function is defined and callable
             if (function_exists($callbackName) && is_callable($callbackName)) {
                 $dataObject = convertToArrayObject($data);
 
-                // Call the anonymous function dynamically
+                // Call the function dynamically
                 $callbackResponse = call_user_func($callbackName, $dataObject);
 
                 // Handle different types of responses
@@ -499,6 +532,8 @@ function wireCallback()
                 // Invalid callback provided
                 $response['error'] = 'Invalid callback';
             }
+        } else {
+            $response['error'] = 'No callback provided';
         }
 
         // Output the JSON response only if the callbackResponse is not null
@@ -506,7 +541,7 @@ function wireCallback()
             echo json_encode($response);
         }
     } catch (Throwable $e) {
-        // Handle any exceptions and prepare error response
+        // Handle any exceptions and prepare an error response
         $response = [
             'success' => false,
             'error' => 'Exception occurred',

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/';
+$documentUrl = $protocol . $domainName . rtrim($scriptName, '/') . '/';
 $referer = $_SERVER['HTTP_REFERER'] ?? 'Unknown';
 
 $params = [];

package/dist/src/Lib/FileManager/UploadFile.php

@@ -0,0 +1,361 @@
+<?php
+
+namespace Lib\FileManager;
+
+class UploadFile
+{
+    protected string $destination;
+    protected array $messages = [];
+    protected array $errorCode = [];
+    protected int $maxSize = 51200; // 50KB default
+    protected array $permittedTypes = [
+        'image/jpeg',
+        'image/pjpeg',
+        'image/gif',
+        'image/png',
+        'image/webp'
+    ];
+    protected string $newName = '';
+    protected bool $typeCheckingOn = true;
+    protected array $notTrusted = ['bin', 'cgi', 'exe', 'js', 'pl', 'php', 'py', 'sh'];
+    protected string $suffix = '.upload';
+    protected bool $renameDuplicates;
+
+    /**
+     * Constructor for the UploadFile class.
+     *
+     * @param string $uploadFolder The folder to which uploaded files will be moved.
+     * @throws \Exception If the upload folder is not a valid, writable folder.
+     */
+    public function __construct(string $uploadFolder)
+    {
+        if (!is_dir($uploadFolder) || !is_writable($uploadFolder)) {
+            throw new \Exception("$uploadFolder must be a valid, writable folder.");
+        }
+        // Ensure the folder ends with a '/'
+        $this->destination = rtrim($uploadFolder, '/') . '/';
+    }
+
+    /**
+     * Sets the maximum size for uploaded files.
+     *
+     * @param int $bytes The maximum size in bytes.
+     * @return void
+     */
+    public function setMaxSize(int $bytes): void
+    {
+        $serverMax = self::convertToBytes(ini_get('upload_max_filesize'));
+        if ($bytes > $serverMax) {
+            throw new \Exception('Maximum size cannot exceed server limit for individual files: ' . self::convertFromBytes($serverMax));
+        }
+        if ($bytes > 0) {
+            $this->maxSize = $bytes;
+        }
+    }
+
+    /**
+     * Converts a string value representing a file size to bytes.
+     *
+     * @param string $val The string value representing the file size.
+     * @return int The file size in bytes.
+     */
+    public static function convertToBytes(string $val): int
+    {
+        $val = trim($val);
+        $last = strtolower($val[strlen($val) - 1]);
+        $multiplier = match ($last) {
+            'g' => 1024 * 1024 * 1024,
+            'm' => 1024 * 1024,
+            'k' => 1024,
+            default => 1,
+        };
+        return (int) $val * $multiplier;
+    }
+
+    /**
+     * Converts the given number of bytes to a human-readable string representation.
+     *
+     * @param int $bytes The number of bytes to convert.
+     * @return string The human-readable string representation of the converted bytes.
+     */
+    public static function convertFromBytes(int $bytes): string
+    {
+        return $bytes >= 1024 * 1024
+            ? number_format($bytes / (1024 * 1024), 1) . ' MB'
+            : number_format($bytes / 1024, 1) . ' KB';
+    }
+
+    /**
+     * Disable type checking and set the allowed file types.
+     *
+     * @param string|null $suffix The file suffix to allow. If null, the current suffix will be used.
+     * @return void
+     */
+    public function allowAllTypes(?string $suffix = null): void
+    {
+        $this->typeCheckingOn = false;
+        $this->suffix = $suffix ? (strpos($suffix, '.') === 0 ? $suffix : ".$suffix") : $this->suffix;
+    }
+
+    /**
+     * Uploads file(s) to the server.
+     *
+     * @param bool $renameDuplicates (optional) Whether to rename duplicate files. Default is true.
+     * @return void
+     */
+    public function upload(bool $renameDuplicates = true): void
+    {
+        $this->renameDuplicates = $renameDuplicates;
+        if (empty($_FILES) || !is_array(current($_FILES))) {
+            // No file was uploaded or the structure is invalid, handle this as an error
+            $this->messages[] = "No files were uploaded.";
+            $this->errorCode[] = UPLOAD_ERR_NO_FILE;
+            return;
+        }
+
+        $uploaded = current($_FILES);
+
+        // Handle single and multiple file uploads using a unified approach
+        $files = is_array($uploaded['name']) ? $this->rearrangeFilesArray($uploaded) : [$uploaded];
+
+        foreach ($files as $file) {
+            if ($this->checkFile($file)) {
+                $this->moveFile($file);
+            }
+        }
+    }
+
+    /**
+     * Updates an existing file by deleting the old file and uploading the new one, using the old file's name.
+     *
+     * @param array $file The new file information from $_FILES.
+     * @param string $oldFilename The name of the file to be replaced.
+     * @return bool True if the update was successful, false otherwise.
+     */
+    public function update(array $file, string $oldFilename): bool
+    {
+        // First, delete the old file
+        if (!$this->delete($oldFilename)) {
+            $this->messages[] = "Failed to delete the old file $oldFilename. Update aborted.";
+            $this->errorCode[] = UPLOAD_ERR_CANT_WRITE; // Error code for failure to update
+            return false;
+        }
+
+        // Now proceed to upload the new file with the old filename
+        if ($this->checkFile($file)) {
+            // Set the new file name to match the old file's name
+            $this->newName = $oldFilename;
+            $this->moveFile($file);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Renames a file in the destination folder.
+     *
+     * @param string $oldName The current name of the file.
+     * @param string $newName The new name for the file.
+     * @return bool True if the rename was successful, false otherwise.
+     */
+    public function rename(string $oldName, string $newName): bool
+    {
+        $oldPath = $this->destination . $oldName;
+
+        // Extract the file extension from the old file
+        $extension = pathinfo($oldName, PATHINFO_EXTENSION);
+
+        // Add the extension to the new name
+        $newNameWithExtension = str_replace(' ', '_', $newName) . '.' . $extension;
+        $newPath = $this->destination . $newNameWithExtension;
+
+        // Check if the file exists
+        if (!file_exists($oldPath)) {
+            $this->messages[] = "File $oldName does not exist.";
+            $this->errorCode[] = UPLOAD_ERR_NO_FILE; // Error code for file not found
+            return false;
+        }
+
+        // Validate that the new name doesn't already exist
+        if (file_exists($newPath)) {
+            $this->messages[] = "A file with the name $newNameWithExtension already exists.";
+            $this->errorCode[] = UPLOAD_ERR_CANT_WRITE; // Error code for name conflict
+            return false;
+        }
+
+        // Attempt to rename the file
+        if (rename($oldPath, $newPath)) {
+            $this->messages[] = "File $oldName renamed successfully to $newNameWithExtension";
+            $this->errorCode[] = 0; // Success code
+            return true;
+        } else {
+            $this->messages[] = "Failed to rename $oldName to $newNameWithExtension";
+            $this->errorCode[] = UPLOAD_ERR_CANT_WRITE; // Error code for rename failure
+            return false;
+        }
+    }
+
+    /**
+     * Deletes a file from the destination folder.
+     *
+     * @param string $filename The name of the file to delete.
+     * @return bool True if the file was deleted, false otherwise.
+     */
+    public function delete(string $filename): bool
+    {
+        $filePath = $this->destination . $filename;
+
+        if (!file_exists($filePath)) {
+            $this->messages[] = "File $filename does not exist.";
+            $this->errorCode[] = UPLOAD_ERR_NO_FILE; // Error code for file not found
+            return false;
+        }
+
+        if (unlink($filePath)) {
+            $this->messages[] = "File $filename deleted successfully.";
+            $this->errorCode[] = 0; // Success code
+            return true;
+        } else {
+            $this->messages[] = "Failed to delete $filename.";
+            $this->errorCode[] = UPLOAD_ERR_CANT_WRITE; // Error code for failure to delete
+            return false;
+        }
+    }
+
+    /**
+     * Retrieves the messages associated with the file upload.
+     *
+     * @return array The array of messages.
+     */
+    public function getMessages(): array
+    {
+        return $this->messages;
+    }
+
+    /**
+     * Retrieves the error codes associated with the file upload.
+     *
+     * @return array The array of error codes.
+     */
+    public function getErrorCode(): array
+    {
+        return $this->errorCode;
+    }
+
+    protected function checkFile(array $file): bool
+    {
+        if ($file['error'] !== UPLOAD_ERR_OK) {
+            $this->getErrorMessage($file);
+            return false;
+        }
+        if (!$this->checkSize($file) || ($this->typeCheckingOn && !$this->checkType($file))) {
+            return false;
+        }
+        $this->checkName($file);
+        return true;
+    }
+
+    protected function getErrorMessage(array $file): void
+    {
+        $errorMessages = [
+            UPLOAD_ERR_INI_SIZE => $file['name'] . ' exceeds the maximum size: ' . self::convertFromBytes($this->maxSize),
+            UPLOAD_ERR_FORM_SIZE => $file['name'] . ' exceeds the form limit.',
+            UPLOAD_ERR_PARTIAL => $file['name'] . ' was only partially uploaded.',
+            UPLOAD_ERR_NO_FILE => 'No file submitted.',
+        ];
+
+        $this->errorCode = $file['error'];
+        $this->messages[] = $errorMessages[$file['error']] ?? 'Problem uploading ' . $file['name'];
+    }
+
+    protected function checkSize(array $file): bool
+    {
+        if ($file['size'] == 0) {
+            $this->messages[] = $file['name'] . ' is empty.';
+            $this->errorCode[] = UPLOAD_ERR_NO_FILE; // Log an error code for empty files
+            return false;
+        }
+        if ($file['size'] > $this->maxSize) {
+            $this->messages[] = $file['name'] . ' exceeds the maximum size: ' . self::convertFromBytes($this->maxSize);
+            $this->errorCode[] = UPLOAD_ERR_INI_SIZE; // Log an error code for exceeding size
+            return false;
+        }
+        return true;
+    }
+
+    protected function checkType(array $file): bool
+    {
+        if (!in_array($file['type'], $this->permittedTypes)) {
+            $this->messages[] = $file['name'] . ' is not a permitted type.';
+            $this->errorCode[] = UPLOAD_ERR_EXTENSION; // Log an error code for invalid file type
+            return false;
+        }
+        return true;
+    }
+
+    protected function checkName(array $file): void
+    {
+        $name = str_replace(' ', '_', $file['name']);
+        $nameParts = pathinfo($name);
+        $extension = $nameParts['extension'] ?? '';
+
+        // Handle trusted vs untrusted extensions
+        if (!$this->typeCheckingOn && (in_array($extension, $this->notTrusted) || empty($extension))) {
+            $this->newName = $name . $this->suffix;
+        }
+
+        // Rename duplicates if necessary
+        if ($this->renameDuplicates) {
+            $existingFiles = scandir($this->destination);
+            $originalName = $name;
+            $i = 1;
+
+            while (in_array($name, $existingFiles)) {
+                $name = "{$nameParts['filename']}_$i." . ($extension ?: ''); // Maintain the extension if available
+                $i++;
+            }
+
+            $this->newName = $name;
+        } else {
+            $this->newName = $name;
+        }
+    }
+
+    protected function moveFile(array $file): void
+    {
+        // Ensure the newName is set or fallback to the original file name
+        $filename = $this->newName ?: $file['name'];
+        $destination = $this->destination . $filename;
+        $success = move_uploaded_file($file['tmp_name'], $destination);
+
+        if ($success) {
+            $message = "{$file['name']} uploaded successfully.";
+            if ($this->newName && $this->newName !== $file['name']) {
+                $message .= " Renamed to {$this->newName}";
+            }
+        } else {
+            $message = "Failed to upload {$file['name']}.";
+        }
+
+        $this->messages[] = $message;
+        // Add a success/error code for file move
+        $this->errorCode[] = $success ? 0 : UPLOAD_ERR_CANT_WRITE; // 0 for success, error code for failure
+    }
+
+    // Utility function to restructure the $_FILES array for multiple uploads
+    protected function rearrangeFilesArray(array $files): array
+    {
+        $rearranged = [];
+        foreach ($files['name'] as $key => $name) {
+            $rearranged[] = [
+                'name' => $files['name'][$key],
+                'type' => $files['type'][$key],
+                'tmp_name' => $files['tmp_name'][$key],
+                'error' => $files['error'][$key],
+                'size' => $files['size'][$key],
+            ];
+        }
+        return $rearranged;
+    }
+}

package/dist/src/Lib/StateManager.php

@@ -104,10 +104,23 @@ class StateManager
 
     /**
      * Resets the application state to an empty array.
+     *
+     * @param string|null $key The key of the state value to reset.
      */
-    public function resetState(): void
+    public function resetState(string $key = null): void
     {
-        $this->state = [];
+        if ($key !== null) {
+            if (array_key_exists($key, $this->state)) {
+                $this->state[$key] = null;
+
+                if (array_key_exists($key, $GLOBALS)) {
+                    $GLOBALS[$key] = null;
+                }
+            }
+        } else {
+            $this->state = [];
+        }
+
         $this->notifyListeners();
         $this->saveState();
     }

package/dist/src/Lib/Validator.php

@@ -533,6 +533,14 @@ final class Validator
                     return true;
                 }
                 break;
+            case 'extensions':
+                $extensions = explode(',', $parameter);
+                if (!self::isExtensionAllowed($value, $extensions)) {
+                    return "The file must have one of the following extensions: " . implode(', ', $extensions) . ".";
+                } else {
+                    return true;
+                }
+                break;
             case 'mimes':
                 $mimeTypes = explode(',', $parameter);
                 if (!self::isMimeTypeAllowed($value, $mimeTypes)) {
@@ -554,6 +562,29 @@ final class Validator
         }
     }
 
+    /**
+     * Check if a file's extension is in the list of allowed extensions.
+     *
+     * @param string $file The path or filename of the file.
+     * @param array $allowedExtensions The list of allowed extensions.
+     * @return bool True if the extension is allowed, false otherwise.
+     */
+    private static function isExtensionAllowed($file, array $allowedExtensions): bool
+    {
+        // Extract the file extension
+        $fileExtension = pathinfo($file, PATHINFO_EXTENSION);
+
+        // Check if the extension is in the allowed list
+        return in_array(strtolower($fileExtension), array_map('strtolower', $allowedExtensions), true);
+    }
+
+    /**
+     * Check if a file's MIME type is in the list of allowed MIME types.
+     *
+     * @param string $file The path or filename of the file.
+     * @param array $allowedMimeTypes The list of allowed MIME types.
+     * @return bool True if the MIME type is allowed, false otherwise.
+     */
     private static function isMimeTypeAllowed($file, array $allowedMimeTypes)
     {
         // Check if the file is a valid uploaded file