create-prisma-php-app 4.0.0-alpha.2 → 4.0.0-alpha.21

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

@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\Middleware;
+
+final class CorsMiddleware
+{
+    /** Entry point */
+    public static function handle(?array $overrides = null): void
+    {
+        // Not a CORS request
+        $origin = $_SERVER['HTTP_ORIGIN'] ?? '';
+        if ($origin === '') {
+            return;
+        }
+
+        // Resolve config (env → overrides)
+        $cfg = self::buildConfig($overrides);
+
+        // Not allowed? Do nothing (browser will block)
+        if (!self::isAllowedOrigin($origin, $cfg['allowedOrigins'])) {
+            return;
+        }
+
+        // Compute which value to send for Access-Control-Allow-Origin
+        // If credentials are disabled and '*' is in list, we can send '*'
+        $sendWildcard = (!$cfg['allowCredentials'] && self::listHasWildcard($cfg['allowedOrigins']));
+        $allowOriginValue = $sendWildcard ? '*' : self::normalize($origin);
+
+        // Vary for caches
+        header('Vary: Origin, Access-Control-Request-Method, Access-Control-Request-Headers');
+
+        header('Access-Control-Allow-Origin: ' . $allowOriginValue);
+        if ($cfg['allowCredentials']) {
+            header('Access-Control-Allow-Credentials: true');
+        }
+
+        if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
+            // Preflight response
+            $requestedHeaders = $_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS'] ?? '';
+            $allowedHeaders = $cfg['allowedHeaders'] !== ''
+                ? $cfg['allowedHeaders']
+                : ($requestedHeaders ?: 'Content-Type, Authorization, X-Requested-With');
+
+            header('Access-Control-Allow-Methods: ' . $cfg['allowedMethods']);
+            header('Access-Control-Allow-Headers: ' . $allowedHeaders);
+            if ($cfg['maxAge'] > 0) {
+                header('Access-Control-Max-Age: ' . (string) $cfg['maxAge']);
+            }
+
+            // Optional: Private Network Access preflights (Chrome)
+            if (!empty($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_PRIVATE_NETWORK'])) {
+                header('Access-Control-Allow-Private-Network: true');
+            }
+
+            http_response_code(204);
+            header('Content-Length: 0');
+            exit;
+        }
+
+        // Simple/actual request
+        if ($cfg['exposeHeaders'] !== '') {
+            header('Access-Control-Expose-Headers: ' . $cfg['exposeHeaders']);
+        }
+    }
+
+    /** Read env + normalize + apply overrides */
+    private static function buildConfig(?array $overrides): array
+    {
+        $allowed = self::parseList($_ENV['CORS_ALLOWED_ORIGINS'] ?? '');
+        $cfg = [
+            'allowedOrigins'   => $allowed,
+            'allowCredentials' => filter_var($_ENV['CORS_ALLOW_CREDENTIALS'] ?? 'false', FILTER_VALIDATE_BOOLEAN),
+            'allowedMethods'   => $_ENV['CORS_ALLOWED_METHODS'] ?? 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+            'allowedHeaders'   => trim($_ENV['CORS_ALLOWED_HEADERS'] ?? ''),
+            'exposeHeaders'    => trim($_ENV['CORS_EXPOSE_HEADERS'] ?? ''),
+            'maxAge'           => (int)($_ENV['CORS_MAX_AGE'] ?? 86400),
+        ];
+
+        if (is_array($overrides)) {
+            foreach ($overrides as $k => $v) {
+                if (array_key_exists($k, $cfg)) {
+                    $cfg[$k] = $v;
+                }
+            }
+        }
+
+        // Normalize patterns
+        $cfg['allowedOrigins'] = array_map([self::class, 'normalize'], $cfg['allowedOrigins']);
+        return $cfg;
+    }
+
+    /** CSV or JSON array → array<string> */
+    private static function parseList(string $raw): array
+    {
+        $raw = trim($raw);
+        if ($raw === '') return [];
+
+        if ($raw[0] === '[') {
+            $arr = json_decode($raw, true);
+            if (is_array($arr)) {
+                return array_values(array_filter(array_map('strval', $arr), 'strlen'));
+            }
+        }
+        return array_values(array_filter(array_map('trim', explode(',', $raw)), 'strlen'));
+    }
+
+    private static function normalize(string $origin): string
+    {
+        return rtrim($origin, '/');
+    }
+
+    private static function isAllowedOrigin(string $origin, array $list): bool
+    {
+        $o = self::normalize($origin);
+
+        foreach ($list as $pattern) {
+            $p = self::normalize($pattern);
+
+            // literal "*"
+            if ($p === '*') return true;
+
+            // allow literal "null" for file:// or sandboxed if explicitly listed
+            if ($o === 'null' && strtolower($p) === 'null') return true;
+
+            // wildcard like https://*.example.com
+            if (strpos($p, '*') !== false) {
+                $regex = '/^' . str_replace('\*', '[^.]+', preg_quote($p, '/')) . '$/i';
+                if (preg_match($regex, $o)) return true;
+            } else {
+                if (strcasecmp($p, $o) === 0) return true;
+            }
+        }
+        return false;
+    }
+
+    private static function listHasWildcard(array $list): bool
+    {
+        foreach ($list as $p) {
+            if (trim($p) === '*') return true;
+        }
+        return false;
+    }
+}

package/dist/src/Lib/PHPMailer/Mailer.php

@@ -0,0 +1,169 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\PHPMailer;
+
+use PHPMailer\PHPMailer\PHPMailer;
+use PHPMailer\PHPMailer\Exception;
+use Lib\Validator;
+
+class Mailer
+{
+    private PHPMailer $mail;
+
+    public function __construct()
+    {
+        $this->mail = new PHPMailer(true);
+        $this->mail->CharSet = 'UTF-8';
+        $this->setup();
+    }
+
+    private function setup(): void
+    {
+        $this->mail->isSMTP();
+        $this->mail->SMTPDebug = 0;
+        $this->mail->Host = $_ENV['SMTP_HOST'];
+        $this->mail->SMTPAuth = true;
+        $this->mail->Username = $_ENV['SMTP_USERNAME'];
+        $this->mail->Password = $_ENV['SMTP_PASSWORD'];
+        $this->mail->SMTPSecure = $_ENV['SMTP_ENCRYPTION'];
+        $this->mail->Port = (int) $_ENV['SMTP_PORT'];
+        $this->mail->setFrom($_ENV['MAIL_FROM'], $_ENV['MAIL_FROM_NAME']);
+    }
+
+    /**
+     * Send an email.
+     *
+     * @param string $to The recipient's email address.
+     * @param string $subject The subject of the email.
+     * @param string $body The HTML body of the email.
+     * @param array $options (optional) Additional email options like name, altBody, CC, BCC, and attachments.
+     *                       - attachments: A string or an array of file paths, or an array of associative arrays with keys 'path' and 'name'.
+     *
+     * @return bool Returns true if the email is sent successfully, false otherwise.
+     *
+     * @throws Exception Throws an exception if the email could not be sent.
+     */
+    public function send(string $to, string $subject, string $body, array $options = []): bool
+    {
+        try {
+            // Validate and sanitize inputs
+            $to = Validator::email($to);
+            if (!$to) {
+                throw new Exception('Invalid email address for the main recipient');
+            }
+
+            $subject = Validator::string($subject);
+            $body = Validator::html($body);
+            $altBody = $this->convertToPlainText($body);
+
+            $name = $options['name'] ?? '';
+            $addCC = $options['addCC'] ?? [];
+            $addBCC = $options['addBCC'] ?? [];
+            $attachments = $options['attachments'] ?? [];
+
+            $name = Validator::string($name);
+
+            // Handle CC recipients
+            $this->handleRecipients($addCC, 'CC');
+            // Handle BCC recipients
+            $this->handleRecipients($addBCC, 'BCC');
+            // Handle file attachments if provided
+            if (!empty($attachments)) {
+                $this->handleAttachments($attachments);
+            }
+
+            // Set the main recipient and other email properties
+            $this->mail->addAddress($to, $name);
+            $this->mail->isHTML(true);
+            $this->mail->Subject = $subject;
+            $this->mail->Body = $body;
+            $this->mail->AltBody = $altBody;
+
+            // Send the email
+            return $this->mail->send();
+        } catch (Exception $e) {
+            throw new Exception($e->getMessage());
+        }
+    }
+
+    /**
+     * Handle adding CC or BCC recipients.
+     *
+     * @param string|array $recipients Email addresses to add.
+     * @param string $type Type of recipient ('CC' or 'BCC').
+     *
+     * @throws Exception Throws an exception if any email address is invalid.
+     */
+    private function handleRecipients(string|array $recipients, string $type): void
+    {
+        if (!empty($recipients)) {
+            $method = $type === 'CC' ? 'addCC' : 'addBCC';
+
+            if (is_array($recipients)) {
+                foreach ($recipients as $recipient) {
+                    $recipient = Validator::email($recipient);
+                    if ($recipient) {
+                        $this->mail->{$method}($recipient);
+                    } else {
+                        throw new Exception("Invalid email address in $type");
+                    }
+                }
+            } else {
+                $recipient = Validator::email($recipients);
+                if ($recipient) {
+                    $this->mail->{$method}($recipient);
+                } else {
+                    throw new Exception("Invalid email address in $type");
+                }
+            }
+        }
+    }
+
+    /**
+     * Handle adding file attachments.
+     *
+     * @param string|array $attachments File path(s) to attach.
+     *                                  You can pass a string for a single file or an array of file paths.
+     *                                  Alternatively, each attachment can be an array with keys 'path' and 'name' for custom naming.
+     *
+     * @throws Exception Throws an exception if any attachment file is not found.
+     */
+    private function handleAttachments(string|array $attachments): void
+    {
+        if (is_array($attachments)) {
+            foreach ($attachments as $attachment) {
+                if (is_array($attachment)) {
+                    $file = $attachment['path'] ?? null;
+                    $name = $attachment['name'] ?? '';
+                    if (!$file || !file_exists($file)) {
+                        throw new Exception("Attachment file does not exist: " . ($file ?? 'unknown'));
+                    }
+                    $this->mail->addAttachment($file, $name);
+                } else {
+                    if (!file_exists($attachment)) {
+                        throw new Exception("Attachment file does not exist: $attachment");
+                    }
+                    $this->mail->addAttachment($attachment);
+                }
+            }
+        } else {
+            if (!file_exists($attachments)) {
+                throw new Exception("Attachment file does not exist: $attachments");
+            }
+            $this->mail->addAttachment($attachments);
+        }
+    }
+
+    /**
+     * Convert HTML content to plain text.
+     *
+     * @param string $html The HTML content to convert.
+     * @return string The plain text content.
+     */
+    private function convertToPlainText(string $html): string
+    {
+        return strip_tags(str_replace(['<br>', '<br/>', '<br />', '</p>'], "\n", $html));
+    }
+}

package/dist/src/Lib/PHPX/Exceptions/ComponentValidationException.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Lib\PHPX\Exceptions;
+
+use RuntimeException;
+
+class ComponentValidationException extends RuntimeException
+{
+    private string $propName;
+    private string $componentName;
+    private array $availableProps;
+
+    public function __construct(
+        string $propName,
+        string $componentName,
+        array $availableProps,
+        string $context = ''
+    ) {
+        $this->propName = $propName;
+        $this->componentName = $componentName;
+        $this->availableProps = $availableProps;
+
+        $availableList = implode(', ', $availableProps);
+
+        $message = "Invalid prop '{$propName}' for component '{$componentName}'.\n";
+        $message .= "Available props: {$availableList}";
+
+        if ($context) {
+            $message .= "\n{$context}";
+        }
+
+        parent::__construct($message);
+    }
+
+    public function getPropName(): string
+    {
+        return $this->propName;
+    }
+
+    public function getComponentName(): string
+    {
+        return $this->componentName;
+    }
+
+    public function getAvailableProps(): array
+    {
+        return $this->availableProps;
+    }
+}

package/dist/src/Lib/PHPX/Fragment.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\PHPX;
+
+use Lib\PHPX\PHPX;
+
+class Fragment extends PHPX
+{
+    /** @property ?string $as = div|span|section|article|nav|header|footer|main|aside */
+    public ?string $as = null;
+    public ?string $class = '';
+
+    public function __construct(array $props = [])
+    {
+        parent::__construct($props);
+    }
+
+    public function render(): string
+    {
+        if ($this->as !== null) {
+            $attributes = $this->getAttributes();
+            $class = $this->getMergeClasses($this->class);
+            $classAttr = $class ? "class=\"{$class}\"" : '';
+
+            return "<{$this->as} {$classAttr} {$attributes}>{$this->children}</{$this->as}>";
+        }
+
+        return $this->children;
+    }
+}

package/dist/src/Lib/PHPX/IPHPX.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib\PHPX;
+
+interface IPHPX
+{
+    /**
+     * Constructor to initialize the component with the given properties.
+     * 
+     * @param array<string, mixed> $props Optional properties to customize the component.
+     */
+    public function __construct(array $props = []);
+
+    /**
+     * Renders the component with the given properties and children.
+     * 
+     * @return string The rendered HTML content.
+     */
+    public function render(): string;
+}