create-prisma-php-app 5.0.0-alpha.7 → 5.0.0

package/dist/tests/SocketsRegistrationTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests;
+
+use Lib\Websocket\SocketRegistry;
+use PHPUnit\Framework\TestCase;
+use Tests\Support\RequiresFeature;
+
+/**
+ * The app's real registration file loads cleanly and registers every socket
+ * the frontend connects to. A socket the browser names but the server never
+ * registered is a refused connection in production — catch it here instead.
+ */
+final class SocketsRegistrationTest extends TestCase
+{
+    use RequiresFeature;
+
+    protected function setUp(): void
+    {
+        $this->requireFeature('websocket');
+        SocketRegistryTest::resetRegistry();
+    }
+
+    protected function tearDown(): void
+    {
+        SocketRegistryTest::resetRegistry();
+    }
+
+    public function testTheRegistrationFileLoadsAndNamesItsSockets(): void
+    {
+        require DOCUMENT_PATH . '/src/Lib/Websocket/sockets.php';
+
+        $names = SocketRegistry::names();
+
+        self::assertContains('echo', $names);
+        self::assertContains('chat', $names);
+    }
+}

package/dist/tests/Support/FakeConnection.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+use Ratchet\ConnectionInterface;
+use GuzzleHttp\Psr7\Request as Psr7Request;
+
+/**
+ * A Ratchet connection stand-in that records what the server sends.
+ *
+ * The named-socket wire is frames and closes, so a test only needs to see
+ * both: `$sentFrames` collects every `send(...)` payload (decoded from JSON
+ * when possible) and `$closeCodes` collects every `close(...)` code. The
+ * `httpRequest` property mirrors how Ratchet exposes the handshake request.
+ */
+final class FakeConnection implements ConnectionInterface
+{
+    /** @var list<mixed> Decoded JSON frames (raw string when not JSON). */
+    public array $sentFrames = [];
+
+    /** @var list<string> Raw frames exactly as sent. */
+    public array $rawFrames = [];
+
+    /** @var list<int> */
+    public array $closeCodes = [];
+
+    public bool $isClosed = false;
+
+    public ?Psr7Request $httpRequest = null;
+
+    /**
+     * @param array<string, string> $headers Handshake headers (e.g. Origin, Cookie).
+     */
+    public function __construct(string $uri = '/__pulsepoint/ws', array $headers = [])
+    {
+        $this->httpRequest = new Psr7Request('GET', $uri, $headers);
+    }
+
+    public function send($data): ConnectionInterface
+    {
+        $this->rawFrames[] = (string) $data;
+
+        $decoded = json_decode((string) $data, true);
+        $this->sentFrames[] = json_last_error() === JSON_ERROR_NONE ? $decoded : (string) $data;
+
+        return $this;
+    }
+
+    public function close($code = 1000): void
+    {
+        $this->closeCodes[] = (int) $code;
+        $this->isClosed = true;
+    }
+
+    /** The last frame the server sent, decoded. */
+    public function lastFrame(): mixed
+    {
+        return $this->sentFrames === [] ? null : end($this->sentFrames);
+    }
+}

package/dist/tests/Support/Features.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+/**
+ * Feature flags for the test suite, read from `prisma-php.json`.
+ *
+ * `prisma-php.json` is the single source of truth for which optional Prisma
+ * PHP features are enabled in the current app (`websocket`, `mcp`,
+ * `swaggerDocs`, `prisma`, `tailwindcss`, `typescript`, `backendOnly`).
+ * Tests that exercise an optional feature's scaffold must guard on the flag —
+ * when the feature is off, its files do not exist and the test must skip,
+ * not fatal.
+ */
+final class Features
+{
+    /** @var array<string, mixed>|null */
+    private static ?array $config = null;
+
+    /** @return array<string, mixed> The parsed prisma-php.json. */
+    public static function config(): array
+    {
+        if (self::$config === null) {
+            $raw = @file_get_contents(DOCUMENT_PATH . '/prisma-php.json');
+            $decoded = is_string($raw) ? json_decode($raw, true) : null;
+            self::$config = is_array($decoded) ? $decoded : [];
+        }
+
+        return self::$config;
+    }
+
+    public static function enabled(string $feature): bool
+    {
+        return (self::config()[$feature] ?? false) === true;
+    }
+}

package/dist/tests/Support/RequiresFeature.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Support;
+
+/**
+ * Skip guard for tests of optional Prisma PHP features.
+ *
+ * Call `$this->requireFeature('websocket')` as the FIRST line of `setUp()`,
+ * before touching any class from the feature's scaffold — a disabled
+ * feature's files are not generated, so reaching them would fatal instead
+ * of failing cleanly. A skipped test reports why and how to enable it.
+ */
+trait RequiresFeature
+{
+    protected function requireFeature(string $feature): void
+    {
+        if (!Features::enabled($feature)) {
+            self::markTestSkipped(
+                "The `$feature` feature is disabled in prisma-php.json; "
+                    . "enable it and run `npx pp update project -y` to use this suite."
+            );
+        }
+    }
+}

package/dist/tests/bootstrap.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Shared PHPUnit setup for the app-level test suite.
+ *
+ * Mirrors what the runtime gives app code — the composer autoloader and the
+ * path constants from `settings/paths.php` — without booting the framework:
+ * `bootstrap.php` (route resolution, CSRF cookie, rendering) is NOT loaded
+ * here, so tests exercise app classes directly.
+ *
+ * The real `.env` is deliberately NOT loaded. Tests run against deterministic
+ * environment defaults so the suite behaves the same on any machine and can
+ * never depend on (or leak) real secrets. Each default is only applied when
+ * the variable is not already set, so CI can still override.
+ */
+
+require_once dirname(__DIR__) . '/vendor/autoload.php';
+require_once dirname(__DIR__) . '/settings/paths.php';
+
+// Keep the app in its non-production code paths during tests (dev origin
+// relaxations, readable error messages).
+if (getenv('APP_ENV') === false) {
+    putenv('APP_ENV=development');
+    $_ENV['APP_ENV'] = 'development';
+}
+
+// Deterministic secrets so Auth and Csrf construct without a real .env.
+// HS256 requires at least 32 bytes of key material.
+if (getenv('AUTH_SECRET') === false) {
+    putenv('AUTH_SECRET=test-secret-not-for-production-32bytes');
+    $_ENV['AUTH_SECRET'] = 'test-secret-not-for-production-32bytes';
+}
+
+if (getenv('FUNCTION_CALL_SECRET') === false) {
+    putenv('FUNCTION_CALL_SECRET=test-function-call-secret');
+    $_ENV['FUNCTION_CALL_SECRET'] = 'test-function-call-secret';
+}
+
+// Auth::signIn writes the session payload; give CLI tests a session store.
+if (!isset($_SESSION)) {
+    $_SESSION = [];
+}

package/dist/ts/main.ts

@@ -1,6 +1,24 @@
-import "/js/pp-reactive-v2.js";
+import "/js/pp-reactive-v2.min.js";
 
 // The following global names have already been declared elsewhere in the project:
 // - pp: Used for the Reactive Core functionality.
-// - store: Handles local storage synchronization with the server.
-// - searchParams: Manages URL manipulation and query parameters.
+
+// Imports goes here --Start
+
+// Uncomment the following line if you need to use the createGlobalSingleton function in this file.
+// import { createGlobalSingleton } from "./global-functions.js";
+// import { myCustomFunction } from "./money.js";
+
+// createGlobalSingleton("myCustomFunction", myCustomFunction);
+
+// Imports goes here --End
+
+const pp = (globalThis as any).pp;
+
+if (document.readyState !== "loading") {
+  pp?.mount?.();
+} else {
+  document.addEventListener("DOMContentLoaded", () => pp?.mount?.(), {
+    once: true,
+  });
+}

package/dist/ts/tailwind-merge.ts

@@ -0,0 +1,13 @@
+import { twMerge } from "tailwind-merge";
+
+export type MergeableClassName = string | false | null | undefined;
+
+export function mergeTailwindClasses(
+  ...classNames: MergeableClassName[]
+): string {
+  return twMerge(
+    classNames
+      .filter((className): className is string => Boolean(className))
+      .join(" "),
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma-php-app",
-  "version": "5.0.0-alpha.7",
+  "version": "5.0.0",
   "description": "Prisma-PHP: A Revolutionary Library Bridging PHP with Prisma ORM",
   "main": "dist/index.js",
   "type": "module",
@@ -32,15 +32,15 @@
   "author": "Jefferson Abraham Omier <thesteelninjacode@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.6.2",
+    "chalk": "^6.0.0",
     "crypto-js": "^4.2.0",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@types/crypto-js": "^4.2.2",
-    "@types/node": "^25.0.3",
+    "@types/node": "^26.4.0",
     "@types/prompts": "^2.4.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^7.0.2"
   }
 }

package/dist/README.md

@@ -1,213 +0,0 @@
-# Prisma PHP
-
-Prisma PHP is a modern full-stack PHP framework that combines native PHP, PulsePoint reactivity, PHPX components, and a Prisma-inspired ORM into one cohesive developer experience.
-
-Build reactive interfaces with a server-first mental model, structured routing, type-safe data access, and a project layout designed for real applications.
-
-## Getting Started
-
-Create a new Prisma PHP project:
-
-```bash
-npx create-prisma-php-app@latest my-app
-```
-
-Start the development server:
-
-```bash
-npm run dev
-```
-
-Open the local app in your browser after the dev server starts.
-
-## Prerequisites
-
-Before creating a Prisma PHP project, make sure you have:
-
-- Node.js 22.x or higher
-- PHP 8.2 or higher
-- Composer 2.x or higher
-- XAMPP or another local PHP environment
-
-If you are using XAMPP on Windows, enabling `extension=zip` in `php.ini` is recommended so Composer dependencies install correctly.
-
-## What Prisma PHP Includes
-
-Prisma PHP brings together the core pieces needed to build full-stack PHP apps:
-
-- **Native PHP + modern reactivity** with PulsePoint
-- **PHPX component system** for reusable UI composition
-- **Prisma PHP ORM** for schema-first, type-safe database access
-- **Built-in authentication patterns** for sessions, route protection, RBAC, credentials auth, and provider login
-- **File-based routing** with clear route file conventions
-- **CLI scaffolding** for new apps, starter kits, and optional features
-- **Flexible deployment options** for local development and production workflows
-
-## Common Create Commands
-
-Create a default full-stack app:
-
-```bash
-npx create-prisma-php-app@latest my-app
-```
-
-Create a project with common options:
-
-```bash
-npx create-prisma-php-app@latest my-app --tailwindcss --typescript
-```
-
-Use a starter kit:
-
-```bash
-npx create-prisma-php-app my-app --starter-kit=fullstack
-```
-
-Other documented flags may include capabilities such as WebSocket support, MCP support, backend-only mode, Swagger docs, and Prisma integration depending on the installed version.
-
-## Documentation
-
-Prisma PHP ships with local documentation for the installed project version.
-
-The installed docs live here:
-
-```txt
-node_modules/prisma-php/dist/docs
-```
-
-Treat these installed docs as the primary documentation source for the current project version.
-
-You can also explore the public docs site:
-
-```txt
-https://prismaphp.tsnc.tech/
-```
-
-## AI Quick Start
-
-If you are using AI-assisted development in a Prisma PHP project:
-
-1. Read `./prisma-php.json` first.
-2. Read the installed docs in `node_modules/prisma-php/dist/docs`.
-3. Read `AGENTS.md` for task-routing rules, framework constraints, and code-generation guidance.
-4. Inspect `vendor/tsnc/prisma-php/src` only when the docs do not answer the task.
-
-### Default interactive UI rule
-
-In Prisma PHP, AI should treat **PulsePoint as the default frontend interactivity model**.
-
-For normal full-stack page work:
-
-- render the page with `index.php`
-- manage browser-side state and UI behavior with **PulsePoint**
-- call PHP from the frontend with **`pp.fetchFunction(...)`**
-- expose callable PHP functions with **`#[Exposed]`**
-- validate incoming data on the PHP side with **`PP\Validator`**
-
-Do **not** default to PHP-only refresh cycles, handcrafted `fetch('/api/...')` patterns, or extra `route.php` handlers for normal interactive page behavior when PulsePoint plus `pp.fetchFunction(...)` already fits the task.
-
-Only prefer a more PHP-only interaction style when the **user explicitly asks for PHP-only behavior**, or when the task is clearly non-reactive.
-
-## Project Capability Manifest
-
-Prisma PHP uses `prisma-php.json` at the repository root as the source of truth for enabled framework features and local environment configuration.
-
-Use it to verify capabilities such as:
-
-- Tailwind CSS support
-- backend-only mode
-- Prisma ORM support
-- Swagger docs
-- WebSocket support
-- MCP support
-- TypeScript support
-- local development paths and BrowserSync settings
-
-Do not assume a feature is enabled unless `prisma-php.json` confirms it.
-
-## Documentation Map
-
-Use these docs as the main entry points for common work:
-
-- `index.md` for the general documentation entry point
-- `project-structure.md` for project structure, route placement, and file conventions
-- `layouts-and-pages.md` for pages, layouts, nested routes, and dynamic routes
-- `components.md` for PHPX components, props, children, fragments, icons, buttons, and composition
-- `fetching-data.md` for `pp.fetchFunction(...)`, `#[Exposed]`, and interactive backend flows
-- `prisma-php-orm.md` for Prisma ORM, `schema.prisma`, migrations, and generated PHP classes
-- `authentication.md` for auth strategy, sessions, RBAC, credentials auth, and provider flows
-- `file-manager.md` for uploads, `multipart/form-data`, `$_FILES`, and `PP\FileManager\UploadFile`
-- `route-handlers.md` for `route.php`, JSON responses, and direct server handlers
-- `error-handling.md` for expected errors, `error.php`, `not-found.php`, and validation failures
-- `caching.md` for cache behavior and `CacheHandler`
-- `metadata-and-og-images.md` for metadata, title, description, icons, and head behavior
-- `pulsepoint.md` for PulsePoint runtime usage and reactivity patterns
-- `upgrading.md` for feature enablement and project update workflows
-
-## Recommended Development Approach
-
-When working in Prisma PHP:
-
-- prefer the installed Prisma PHP docs over assumptions from other frameworks
-- use `AGENTS.md` as the strict AI operating guide
-- inspect nearby project files before generating new framework-specific code
-- inspect framework internals only when the installed docs are not enough
-
-## Route and File Conventions
-
-Prisma PHP uses file-based routing with special route files such as:
-
-- `index.php` for rendered UI routes
-- `layout.php` for shared UI wrappers
-- `route.php` for direct handlers such as JSON or API-style endpoints
-- `loading.php` for loading UI
-- `not-found.php` for route-level not-found UI
-- `error.php` for route-level or app-level error UI
-
-For task-specific route decision rules and framework generation rules, read `AGENTS.md`.
-
-## PulsePoint and Frontend Reactivity
-
-Prisma PHP uses PulsePoint for browser-side reactivity, and AI should assume this is the **default choice** for interactive UI behavior in full-stack routes.
-
-When working with runtime features such as:
-
-- `pp.state`
-- `pp.effect`
-- `pp.ref`
-- `pp-for`
-- `pp-spread`
-- `pp-ref`
-
-read the installed Prisma PHP docs for the current version first, then consult:
-
-```txt
-https://pulsepoint.tsnc.tech/llms
-```
-
-## Project Structure
-
-A generated Prisma PHP project typically includes folders like these:
-
-```text
-prisma-php-project/
-├── prisma/            # schema, migrations, seed files
-├── public/            # public entry point and assets
-├── settings/          # project configuration
-├── src/               # application source code
-├── package.json       # frontend/dev scripts
-├── composer.json      # PHP dependencies
-└── prisma-php.json    # Prisma PHP project capability manifest
-```
-
-## Updating Existing Projects
-
-When enabling features or syncing framework-managed project files:
-
-1. Update `prisma-php.json` first.
-2. Read `upgrading.md` in the installed docs.
-3. Run the documented project update workflow for the current version.
-
-## Learn More
-
-Start with the installed docs for the current project version, use the topic-specific markdown guides for focused work, and rely on `AGENTS.md` when strict AI generation rules are needed.