LaraNexus v1.0.0-stable | PHP 8.3 & 8.4 β€’ Laravel 12 & 13

Transform Complex Laravel Architectures into Living Mindmaps

Stop treating your codebase as a black box. LaraNexus automatically scans your routes, controllers, Eloquent models, and Blade views into a real-time, interactive visual graph.

$ composer require diusazzad/laranexus --dev
17
Routes Discovered
7
Active Controllers
14
Secured by Middleware
0ms
Production Overhead
http://127.0.0.1:8000/laranexus/mindmap
Live Architecture Graph

Full Request-to-View Transparency

Every route node renders its HTTP verbs, controller action, middleware security lock (πŸ”), and statically scanned Eloquent model and Blade view dependencies.

Route Controller Eloquent Model Blade View
// Live Mermaid Architecture Node Sample
R_Order[("/orders/create πŸ” auth")]
↳ M_Store("OrderController@store")
↳ DB: App\Models\Order
↳ View: orders.receipt
βœ“ VS Code 1-Click Jump Enabled
Architectural Reality

The Route Sprawl Crisis vs. LaraNexus Transparency

As Laravel applications evolve from prototypes to enterprise platforms, architectural visibility vanishes. Here is how LaraNexus cures application blindness.

The Problem: Architecture as a Black Box

Where developer velocity slows down

  • βœ•
    Route Fog & Sprawl: Hundreds of routes scattered across multiple files (`web.php`, `api.php`, modules) with no visible global hierarchy.
  • βœ•
    Security Blind Spots: Unprotected endpoints slip into production unnoticed due to confusing middleware groups or missing controller attributes.
  • βœ•
    Painful Onboarding: New engineers spend weeks reading code manually just to understand which controller handles what request and renders which view.
  • βœ•
    Outdated Architectural Diagrams: Confluence wikis and Figma diagrams rot within 24 hours of a sprint release.
Result: Slower PR reviews, regression bugs, security risks ❌ High Technical Debt

The Solution: LaraNexus Living Mindmap

Zero overhead, immediate clarity

  • βœ“
    Living Topology on Demand: Instant Mermaid.js graph generated straight from Laravel route collections in real-time.
  • βœ“
    Automated Security Audits: Every route node clearly highlights active middleware (πŸ” auth, throttle), exposing open routes instantly.
  • βœ“
    Static Deep Discovery: AST and Reflection scan controller bodies to display Eloquent Models queried and Blade templates rendered.
  • βœ“
    1-Click IDE Bridge: Click any controller subgraph node to instantly jump to the exact source line in VS Code.
Result: Onboard in hours, flawless audits, confident refactoring ⚑ Zero Configuration
The Horizon

Vision, Mission & Strategic Roadmap

LaraNexus is engineered not just as a visualizer, but as an architectural intelligence suite designed to eliminate complexity across the Laravel lifecycle.

Our Vision

To make architectural opacity a thing of the past in the Laravel world. We envision a future where any developerβ€”from junior intern to principal architectβ€”can clone a million-line Laravel project and achieve complete mental clarity over its entire request lifecycle within their very first hour.

Core Goals

  • Zero Runtime Penalty: Never slow down production or test suites.
  • Developer Ergonomics: Seamlessly integrate into VS Code and Git workflows.
  • Community-Driven: Built in the open with strict semantic versioning.

v1.0.x Release Milestones

Production Ready
Zero-Config Local Deployment

Works out of the box with `composer require --dev` and auto-discovers routes.

βœ“ Completed
Deep Reflection Scanner

Scans Eloquent Model dependencies and Blade template invocations.

βœ“ Completed
1-Click IDE Bridge

Click any node to jump directly to the controller file and line in VS Code.

βœ“ Completed
Live Search & SVG Export

Instant search filtering and vector diagram export for PRs and tech specs.

βœ“ Completed

v2.x Evolution Roadmap

Under Active Development
Eloquent AST Relationship Graph

Visualizing `hasMany`, `belongsTo`, and polymorphic relations directly on the canvas.

In Progress
Event & Listener Dispatch Flow

Mapping events fired by controllers and their queued listener subscribers.

Planned
Request Validation & FormRequest Scanner

Displaying incoming request validation rules and payload schemas.

Planned
AI Architectural Health Linter

AI suggestions for bloated controllers, N+1 query patterns, and missing middleware.

Planned
Production Impact

Enterprise Case Studies

Discover how engineering teams use LaraNexus to solve real architectural bottlenecks, accelerate developer onboarding, and secure complex route topologies.

Enterprise Productivity FinTech Core Platform (450+ Endpoints)

Cutting Developer Onboarding Time by 85%

Legacy Monolith Architecture Exploration

Impact Metric From 14 Days to 2 Hours
Challenge:

A financial services platform with 450+ routes and 12 years of legacy commits took junior and mid-level engineers an average of 2 full weeks just to map out request flows and identify which controllers owned critical business logic.

Implementation:

By introducing LaraNexus into the local docker development environment, new engineers visualised the entire API topology in a single interactive canvas. Clicking on nodes opened controller methods directly in VS Code, removing documentation lag entirely.

Key Outcomes:
  • βœ“ Onboarding cycle reduced from 14 days to under 2 hours
  • βœ“ Zero documentation maintenance overhead (self-generating)
  • βœ“ Eliminated tribal knowledge silos across engineering squads
Security & Compliance HealthTech SaaS Provider (HIPAA / GDPR Compliance)

Preventing Production Data Leaks with Visual Auditing

Automated Middleware Detection & Route Hygiene

Impact Metric 17 Unprotected Endpoints Discovered
Challenge:

During a quarterly security audit, developers were manually cross-checking `routes/web.php` and `routes/api.php` line by line. Hidden sub-routes inside resource controllers were accidentally deployed without the `auth:sanctum` or role-verification middleware.

Implementation:

LaraNexus automatically parsed middleware chains into explicit visual badges (`πŸ” auth`, `throttle`, `verified`). Unprotected endpoints stood out immediately in red and slate without security badges.

Key Outcomes:
  • βœ“ Flagged 17 unprotected endpoints before ISO-27001 audit
  • βœ“ Real-time security auditing during every PR review
  • βœ“ Visual proof of compliance for security auditors in SVG format
Architecture Refactoring E-Commerce Marketplace (High Throughput)

Deconstructing God Controllers into Domain Services

Static Model & View Dependency Analysis

Impact Metric 60% Reduction in Controller Cyclomatic Complexity
Challenge:

The main `OrderController.php` spanned over 2,400 lines, rendering 14 blade views and querying 9 different Eloquent models. Developers were terrified to touch it due to unexpected side-effects across payment processing and inventory views.

Implementation:

Using LaraNexus deep discovery reflection, the architecture team visually grouped all connected models and blade templates. They cleanly separated checkout, invoicing, and refunds into dedicated domain action classes.

Key Outcomes:
  • βœ“ God controller cleanly decomposed into 4 discrete micro-actions
  • βœ“ Zero regressions during refactoring thanks to visual boundary verification
  • βœ“ Architectural blueprints exported as SVG directly into Git architecture docs
Rapid Onboarding

Up and Running in 60 Seconds

No complex migrations, no external database dependencies. LaraNexus integrates cleanly into any Laravel 12 or 13 app.

STEP 01

Install Package

Add LaraNexus as a local development dependency via Composer:

composer require diusazzad/laranexus --dev
STEP 02

Publish Config (Optional)

Customize URL prefix, middleware, or ignored namespaces:

php artisan vendor:publish --tag="laranexus-config"
STEP 03

Explore Mindmap

Navigate to your dashboard path in your browser:

http://127.0.0.1:8000/laranexus
Community Powered

Contributing to LaraNexus

LaraNexus is 100% free, MIT-licensed open source software. We welcome contributions of all kindsβ€”from documentation fixes and issue triage to cutting-edge AST reflection engines.

The 5-Step Pull Request Lifecycle

1

Fork & Branch

Fork repository on GitHub, then create a branch:

git switch -b feat/my-enhancement
2

Implement Code

Write clean, strictly-typed PHP code with declare statement:

declare(strict_types=1);
3

Format with Pint

Ensure strict PSR-12 adherence using Laravel Pint:

./vendor/bin/pint
4

Verify Tests

Execute PHPUnit/Pest automated test suite:

php artisan test
5

Submit PR

Open PR with our structured template & screenshots:

git push origin feat/...

Coding Standards & Conventions

  • ● Strict Typing: Every PHP file must declare declare(strict_types=1);.
  • ● Explicit Typehints: Full return types and parameter types on all methods.
  • ● Zero Production Footprint: LaraNexus must remain dev-only and never leak into production.
  • ● Semantic Commits: Use conventional commit prefixes (feat:, fix:, docs:, test:).

Developer Links & Fast-Track

Ready to make your first commit? Read our comprehensive markdown documents or open an issue on GitHub.

Command copied to clipboard!