create-prisma-php-app 4.0.0-alpha.5 → 4.0.0-alpha.51

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/PartialRenderer.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib;
+
+use DOMDocument;
+use DOMXPath;
+use DOMElement;
+
+final class PartialRenderer
+{
+    /** @return array<string,string> selector => outerHTML */
+    public static function extract(string $html, array $selectors): array
+    {
+        $doc = new DOMDocument('1.0', 'UTF-8');
+        libxml_use_internal_errors(true);
+        $doc->loadHTML($html, LIBXML_NOERROR | LIBXML_NOWARNING | LIBXML_HTML_NOIMPLIED);
+        libxml_clear_errors();
+
+        $xpath   = new DOMXPath($doc);
+        $payload = [];
+
+        foreach ($selectors as $rawSel) {
+            $sel = preg_replace('/[^-_\w]/', '', (string)$rawSel);
+
+            /** @var DOMElement|null $node */
+            $node = $xpath->query("//*[@pp-sync='{$sel}']")->item(0);
+
+            if (!$node && $sel !== '') {
+                $node = $xpath->query("//*[@id='{$sel}' or contains(concat(' ',normalize-space(@class),' '),' {$sel} ')]")->item(0);
+            }
+
+            if ($node) {
+                $payload[$sel] = $doc->saveHTML($node);
+            }
+        }
+        return $payload;
+    }
+}

package/dist/src/Lib/PrismaPHPSettings.php

@@ -0,0 +1,181 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Lib;
+
+use Exception;
+
+class BSPathRewrite
+{
+    public string $pattern;
+    public string $replacement;
+
+    public function __construct(array $data)
+    {
+        $this->pattern = $data['pattern'] ?? '';
+        $this->replacement = $data['replacement'] ?? '';
+    }
+}
+
+class PrismaSettings
+{
+    public string $projectName;
+    public string $projectRootPath;
+    public string $phpEnvironment;
+    public string $phpRootPathExe;
+    public string $phpGenerateClassPath;
+    public string $bsTarget;
+    public BSPathRewrite $bsPathRewrite;
+    public bool $backendOnly;
+    public bool $swaggerDocs;
+    public bool $tailwindcss;
+    public bool $websocket;
+    public bool $prisma;
+    public bool $docker;
+    public string $version;
+    public array $excludeFiles;
+
+    public function __construct(array $data)
+    {
+        $this->projectName = $data['projectName'] ?? '';
+        $this->projectRootPath = $data['projectRootPath'] ?? '';
+        $this->phpEnvironment = $data['phpEnvironment'] ?? '';
+        $this->phpRootPathExe = $data['phpRootPathExe'] ?? '';
+        $this->bsTarget = $data['bsTarget'] ?? '';
+        $this->bsPathRewrite = new BSPathRewrite($data['bsPathRewrite'] ?? []);
+        $this->backendOnly = $data['backendOnly'] ?? false;
+        $this->swaggerDocs = $data['swaggerDocs'] ?? false;
+        $this->tailwindcss = $data['tailwindcss'] ?? false;
+        $this->websocket = $data['websocket'] ?? false;
+        $this->prisma = $data['prisma'] ?? false;
+        $this->docker = $data['docker'] ?? false;
+        $this->version = $data['version'] ?? '';
+        $this->excludeFiles = $data['excludeFiles'] ?? [];
+    }
+}
+
+class PrismaPHPSettings
+{
+    /**
+     * The settings from the prisma-php.json file.
+     * 
+     * @var PrismaSettings
+     */
+    public static PrismaSettings $option;
+
+    /**
+     * The list of route files from the files-list.json file.
+     * 
+     * @var array
+     */
+    public static array $routeFiles = [];
+
+    /**
+     * The list of class log files.
+     * 
+     * @var array
+     */
+    public static array $classLogFiles = [];
+
+    /**
+     * The list of include files.
+     *
+     * @var array
+     */
+    public static array $includeFiles = [];
+
+    /**
+     * The local storage key for the app state.
+     *
+     * @var string
+     */
+    public static string $localStoreKey;
+
+    public static function init(): void
+    {
+        self::$option = self::getPrismaSettings();
+        self::$routeFiles = self::getRoutesFileList();
+        self::$classLogFiles = self::getClassesLogFiles();
+        self::$includeFiles = self::getIncludeFiles();
+        self::$localStoreKey = self::getLocalStorageKey();
+    }
+
+    /**
+     * Get Prisma settings from the JSON file.
+     *
+     * @return PrismaSettings
+     * @throws Exception if the JSON file cannot be decoded.
+     */
+    private static function getPrismaSettings(): PrismaSettings
+    {
+        $prismaPHPSettingsJson = DOCUMENT_PATH . '/prisma-php.json';
+
+        if (!file_exists($prismaPHPSettingsJson)) {
+            throw new Exception("Settings file not found: $prismaPHPSettingsJson");
+        }
+
+        $jsonContent = file_get_contents($prismaPHPSettingsJson);
+        $decodedJson = json_decode($jsonContent, true);
+
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            throw new Exception("Failed to decode JSON: " . json_last_error_msg());
+        }
+
+        return new PrismaSettings($decodedJson);
+    }
+
+    private static function getRoutesFileList(): array
+    {
+        $jsonFileName = SETTINGS_PATH . '/files-list.json';
+        if (!file_exists($jsonFileName)) {
+            return [];
+        }
+
+        $jsonContent = file_get_contents($jsonFileName);
+        if ($jsonContent === false || empty(trim($jsonContent))) {
+            return [];
+        }
+
+        $routeFiles = json_decode($jsonContent, true);
+        return is_array($routeFiles) ? $routeFiles : [];
+    }
+
+    private static function getClassesLogFiles(): array
+    {
+        $jsonFileName = SETTINGS_PATH . '/class-imports.json';
+        if (!file_exists($jsonFileName)) {
+            return [];
+        }
+
+        $jsonContent = file_get_contents($jsonFileName);
+        if ($jsonContent === false || empty(trim($jsonContent))) {
+            return [];
+        }
+
+        $classLogFiles = json_decode($jsonContent, true);
+        return is_array($classLogFiles) ? $classLogFiles : [];
+    }
+
+    private static function getIncludeFiles(): array
+    {
+        $jsonFileName = SETTINGS_PATH . "/request-data.json";
+        if (!file_exists($jsonFileName)) {
+            return [];
+        }
+
+        $jsonContent = file_get_contents($jsonFileName);
+        if ($jsonContent === false || empty(trim($jsonContent))) {
+            return [];
+        }
+
+        $includeFiles = json_decode($jsonContent, true);
+        return is_array($includeFiles) ? $includeFiles : [];
+    }
+
+    private static function getLocalStorageKey(): string
+    {
+        $localStorageKey = $_ENV['LOCALSTORE_KEY'] ?? 'pphp_local_store_59e13';
+        return strtolower(preg_replace('/\s+/', '_', trim($localStorageKey)));
+    }
+}