Merge pull request #34 from fastapi-startkit/chore/remove-laravel-references

chore: remove all Laravel references from docs

Author: tmgbedu

docs/broadcasting.md

@@ -42,6 +42,76 @@ app = Application(
 )
 ```
 
+### Passing a config object
+
+If your app uses `BroadcastingConfig` to read env-vars explicitly, pass it as a tuple alongside the provider (the same pattern used for `DatabaseProvider`, `FastAPIProvider`, etc.):
+
+```python
+from fastapi_startkit.broadcasting import ReverbProvider
+from fastapi_startkit.broadcasting.config import BroadcastingConfig
+
+app = Application(
+    base_path=...,
+    providers=[
+        # ... other providers
+        (ReverbProvider, BroadcastingConfig),
+    ]
+)
+```
+
+---
+
+## Mounted Pattern
+
+By default `ReverbProvider` registers the Reverb WebSocket server as a standalone ASGI app. When you need the WebSocket endpoint to live **under a sub-path of your existing FastAPI app** (e.g. `/reverb`) — useful when a single-origin constraint applies, or you want to avoid a separate port — mount it from inside your `AppProvider.boot()` method:
+
+```python
+# providers/app_provider.py
+from fastapi_startkit.providers import Provider
+
+class AppProvider(Provider):
+    def boot(self) -> None:
+        from routes.web import router
+        self.app.fastapi.include_router(router.router)
+
+        # Mount Reverb under /reverb — same origin as the FastAPI app
+        reverb_server = self.app.make('reverb.server')
+        self.app.fastapi.mount('/reverb', reverb_server.as_starlette_app('local'))
+```
+
+> [!IMPORTANT]
+> **Order matters.** Call `include_router` **before** `mount`. FastAPI resolves routes in registration order; mounting before the router causes the `/reverb` prefix to shadow any API routes whose paths start with `/r`.
+
+With the mounted pattern the Reverb WebSocket is reachable at:
+
+```
+ws://<host>:<port>/reverb/app/<REVERB_APP_KEY>
+```
+
+The corresponding `pusher-js` config uses `wsPath` to point the client at the mount point:
+
+```js
+import Pusher from "pusher-js";
+
+const pusher = new Pusher("local", {
+    wsHost: window.location.hostname,
+    wsPort: Number(window.location.port) || 80,
+    forceTLS: false,
+    enabledTransports: ["ws"],
+    cluster: "mt1",
+    wsPath: "/reverb",   // <-- tells pusher-js to prefix all WS paths
+});
+```
+
+### When to use the mounted pattern vs the standalone default
+
+| Scenario | Recommendation |
+|---|---|
+| Single-port deployment (e.g. `dist/` build on `:4545`) | **Mounted** — no second port to manage |
+| Separate WebSocket service / different host | Standalone (default) |
+| Reverse-proxy that routes `/reverb` to FastAPI | **Mounted** |
+| Simplest possible setup, two ports are fine | Standalone (default) |
+
 ---
 
 ## Configuration
@@ -217,6 +287,8 @@ Install `pusher-js` in your frontend project:
 npm install pusher-js
 ```
 
+### Standalone (separate port)
+
 Connect to the Reverb server — point `wsHost` and `wsPort` at your FastAPI app:
 
 ```js
@@ -237,5 +309,99 @@ channel.bind("OrderShipped", (data) => {
 });
 ```
 
+### Mounted (same port, sub-path)
+
+When using the [mounted pattern](#mounted-pattern), add `wsPath` to tell `pusher-js` the mount point:
+
+```js
+import Pusher from "pusher-js";
+
+const { hostname, port } = window.location;
+
+const pusher = new Pusher("local", {
+    wsHost: hostname,
+    wsPort: port ? Number(port) : 80,
+    forceTLS: false,
+    enabledTransports: ["ws"],
+    cluster: "mt1",
+    wsPath: "/reverb",
+});
+
+const channel = pusher.subscribe("orders.1");
+
+channel.bind("OrderShipped", (data) => {
+    console.log("Order shipped:", data);
+});
+```
+
 > [!TIP]
 > The first argument to `new Pusher(...)` is the `REVERB_APP_KEY`. It must match the value configured in your `.env` file.
+
+### React hook
+
+A lightweight custom hook that wraps `pusher-js` and returns an accumulated messages array:
+
+```ts
+// hooks/useBroadcastChannel.ts
+import { useEffect, useRef, useState } from 'react'
+import Pusher, { type Channel } from 'pusher-js'
+
+export interface BroadcastMessage {
+    event: string
+    data: Record<string, unknown>
+    receivedAt: number
+}
+
+export function useBroadcastChannel(channelName: string): BroadcastMessage[] {
+    const [messages, setMessages] = useState<BroadcastMessage[]>([])
+    const pusherRef = useRef<Pusher | null>(null)
+    const channelRef = useRef<Channel | null>(null)
+
+    useEffect(() => {
+        const { hostname, port } = window.location
+
+        const pusher = new Pusher('local', {
+            wsHost: hostname,
+            wsPort: port ? Number(port) : 80,
+            forceTLS: false,
+            enabledTransports: ['ws'],
+            cluster: 'mt1',
+            wsPath: '/reverb',
+        })
+
+        pusherRef.current = pusher
+        const channel = pusher.subscribe(channelName)
+        channelRef.current = channel
+
+        channel.bind_global((eventName: string, data: Record<string, unknown>) => {
+            if (eventName.startsWith('pusher:')) return
+            setMessages(prev => [...prev, { event: eventName, data, receivedAt: Date.now() }])
+        })
+
+        return () => {
+            channel.unbind_all()
+            pusher.unsubscribe(channelName)
+            pusher.disconnect()
+        }
+    }, [channelName])
+
+    return messages
+}
+```
+
+Usage:
+
+```tsx
+import { useBroadcastChannel } from '@/hooks/useBroadcastChannel'
+
+export function OrderList() {
+    const messages = useBroadcastChannel('orders')
+    return (
+        <ul>
+            {messages.map((msg, i) => (
+                <li key={i}>{JSON.stringify(msg.data)}</li>
+            ))}
+        </ul>
+    )
+}
+```

docs/console.md

@@ -7,7 +7,7 @@ keywords: cli, console, commands, automation, cleo
 
 # Console Commands
 
-Fastapi Startkit uses [Cleo](https://cleo.readthedocs.io/en/latest/) to provide a powerful command-line interface, inspired by Laravel's Artisan.
+Fastapi Startkit uses [Cleo](https://cleo.readthedocs.io/en/latest/) to provide a powerful command-line interface, with an Artisan-style design.
 
 ## Creating a Command
 

docs/database/index.md

@@ -7,7 +7,7 @@ keywords: database, orm, fastapi, python
 
 # Database
 
-Fastapi Startkit ships with a built-in ORM layer powered by **MasoniteORM**, adapted for async Python. It gives you expressive model definitions, an async query builder, migrations, and seeders — all with a Laravel-inspired feel.
+Fastapi Startkit ships with a built-in ORM layer powered by **MasoniteORM**, adapted for async Python. It gives you expressive model definitions, an async query builder, migrations, and seeders — all with an expressive, Pythonic feel.
 
 ## Installation
 
@@ -95,7 +95,7 @@ class DatabaseConfig:
         "mysql": DatabaseConnection(
             driver="mysql",
             host=env("DB_HOST", "127.0.0.1"),
-            database=env("DB_DATABASE", "laravel"),
+            database=env("DB_DATABASE", "app"),
             username=env("DB_USERNAME", "root"),
             password=env("DB_PASSWORD", ""),
             port=env("DB_PORT", "3306"),

docs/database/seeds.md

@@ -66,17 +66,17 @@ class PostSeeder(Seeder):
             return
 
         # Create tags
-        tag_laravel  = await Tag.first_or_create({"name": "laravel"})
+        tag_python   = await Tag.first_or_create({"name": "python"})
         tag_fastapi  = await Tag.first_or_create({"name": "fastapi"})
         tag_database = await Tag.first_or_create({"name": "database"})
 
         # Create first post and attach tags
         post1 = await Post.create(
             user_id=user.id,
-            title="Laravel and Databases",
-            content="This is a post about Laravel and its database capabilities."
+            title="Python and Databases",
+            content="This is a post about Python and its database capabilities."
         )
-        await PostTag.first_or_create({"post_id": post1.id, "tag_id": tag_laravel.id})
+        await PostTag.first_or_create({"post_id": post1.id, "tag_id": tag_python.id})
         await PostTag.first_or_create({"post_id": post1.id, "tag_id": tag_database.id})
 
         # Create second post and attach tags

docs/fastapi.md

@@ -71,7 +71,7 @@ class MyFastAPIProvider(Provider):
 
 ## Routing
 
-Fastapi Startkit supports the standard FastAPI routing approach as well as a `Router` wrapper that adds a more expressive, Laravel-inspired API on top.
+Fastapi Startkit supports the standard FastAPI routing approach as well as a `Router` wrapper that adds a more expressive, MVC-style API on top.
 
 ### Standard FastAPI Routing
 
@@ -108,7 +108,7 @@ class MyFastAPIProvider(Provider):
 
 ### Startkit Router
 
-Fastapi Startkit also ships a `Router` wrapper that lets you register routes imperatively — passing the path and endpoint as arguments instead of using decorators. This style is closer to how Laravel and other MVC frameworks handle routing.
+Fastapi Startkit also ships a `Router` wrapper that lets you register routes imperatively — passing the path and endpoint as arguments instead of using decorators. This style is closer to how MVC frameworks handle routing.
 
 #### Defining Routes
 

docs/getting-started.md

@@ -13,7 +13,7 @@ jsonLd:
     "name": "Fastapi Startkit Team"
 ---
 
-Fastapi Startkit is a modular, provider-driven, Laravel-inspired framework for building robust FastAPI applications with minimal boilerplate. That said, **it doesn't enforce you to use FastAPI at all** — You can build entirely headless CLI utilities, cron scripts, or background task workers and still get access to the full suite of infrastructure components such as logging, database, configuration, and dependency injection.
+Fastapi Startkit is a modular, provider-driven framework for building robust FastAPI applications with minimal boilerplate. That said, **it doesn't enforce you to use FastAPI at all** — You can build entirely headless CLI utilities, cron scripts, or background task workers and still get access to the full suite of infrastructure components such as logging, database, configuration, and dependency injection.
 
 ## Prerequisites
 
@@ -82,7 +82,7 @@ python main.py serve
 
 ## Way 2: Structured Setup (Recommended)
 
-For larger applications, we recommend a Laravel-inspired structure for better organization and maintainability.
+For larger applications, we recommend a layered, provider-driven structure for better organization and maintainability.
 
 ### Option A: Use the Boilerplate Repository
 The fastest way to get a fully configured project (including FastAPI, logging, database support, etc.) is to clone our official boilerplate:

docs/logging.md

@@ -7,7 +7,7 @@ keywords: logging, monitoring, debugging, fastapi
 
 # Logging
 
-Fastapi Startkit provides a powerful, modular, and Laravel-inspired logging system. It is built upon the concepts of **Drivers** and **Channels**, allowing you to easily route logs to files, terminal, Slack, or other services.
+Fastapi Startkit provides a powerful, modular logging system. It is built upon the concepts of **Drivers** and **Channels**, allowing you to easily route logs to files, terminal, Slack, or other services.
 
 > [!NOTE]
 > This logging system is based on [Masonite Logging](https://docs.masoniteproject.com/v3.0/official-packages/masonite-logging). We give full credit to the Masonite team for the architecture and design patterns used here.

index.md

@@ -6,7 +6,7 @@ jsonLd:
   "name": "Fastapi Startkit"
   "operatingSystem": "Linux, macOS, Windows"
   "applicationCategory": "DeveloperApplication"
-  "description": "A modular, Laravel-inspired framework for building robust FastAPI applications."
+  "description": "A modular, provider-driven framework for building robust FastAPI applications."
   "offers":
     "@type": "Offer"
     "price": "0"
@@ -25,7 +25,7 @@ features:
     details: Built for FastAPI, but completely optional. Use it as a lightweight core for any Python application.
     icon: ⚡️
   - title: Console Commands
-    details: Powerful CLI powered by Cleo, providing a Laravel-inspired developer experience.
+    details: Powerful CLI powered by Cleo, providing an expressive Artisan-style developer experience.
     icon: 💻
   - title: Advanced Logging
     details: Robust logging with dynamic configuration support and customizable channels.