Composer

Overview of the Inertia Approach Building single-page applications (SPAs) often feels like managing two separate worlds: a complex JavaScript frontend and a robust PHP backend. Usually, this requires building a messy REST API and managing client-side routing, which adds significant overhead. Inertia.js solves this by acting as an adapter rather than a framework. It allows you to build fully client-side rendered SPAs using classic server-side routing and controllers. You get the snappy feel of a modern web app without the pain of manual state synchronization or token-based authentication. Prerequisites Before diving into the code, ensure you have a firm grasp of Laravel fundamentals, particularly routing and controllers. Since Inertia.js lets you use your favorite frontend tools, you should be comfortable with either Vue.js or React. You will also need Node.js and Composer installed on your local machine to manage dependencies. Key Libraries & Tools - **Laravel Installer**: The command-line utility for bootstrapping new projects. - **Laravel Breeze**: A minimal starter kit that provides a perfect starting point for Inertia.js projects. - **Inertia Adapters**: Specialized packages for Vue.js or React that bridge the gap between the backend and the frontend. Code Walkthrough: Data Exchange In a standard app, a link click reloads the whole page. Inertia.js intercepts these clicks and performs an AJAX request instead. On the backend, your controller looks surprisingly familiar: ```php use Inertia\Inertia; public function index() { return Inertia::render('Dashboard', [ 'users' => User::all(), ]); } ``` Instead of returning a Blade view, we use `Inertia::render`. This sends a JSON response containing the component name ('Dashboard') and the data (props). On the frontend, Inertia.js receives this data and swaps the current page component with the new one dynamically. Syntax Notes & Best Practices Always use the `<Link>` component provided by the Inertia.js library rather than standard `<a>` tags. Standard tags trigger a full browser refresh, defeating the purpose of the SPA. ```javascript import { Link } from '@inertiajs/vue3' <Link href="/users">View Users</Link> ``` Tips & Gotchas Don't try to use Inertia.js for public-facing websites where SEO is the top priority unless you implement Server Side Rendering (SSR). For internal dashboards and complex SaaS products, however, it shines. Remember that because Inertia.js shares the same session as your Laravel backend, you don't need to worry about OAuth or JWT for internal navigation. Use the standard Laravel auth guards you already know.

Overview Modern applications must communicate with users beyond the browser. Whether it is a password reset or a shipping confirmation, your app needs reliable ways to reach out. Laravel provides two distinct, powerful systems for this: the Mail component and the Notification component. While both can send emails, notifications are designed for multi-channel delivery, allowing you to hit Slack, SMS, and email simultaneously from a single class. Prerequisites To follow this guide, you should have a basic understanding of PHP and the Laravel framework. Familiarity with Composer for package management and the command line is essential for running migrations and generating classes. Key Libraries & Tools * **Mailables**: Dedicated classes for building emails. * **Markdown**: Used to create responsive, pre-designed email templates. * **Nexmo (Vonage)**: A popular SMS provider integrated via a community-maintained notification channel. * **Mailtrap**: A safe SMTP server for testing emails without sending them to real users. Code Walkthrough Generating a Mailable Start by creating a dedicated mail class using Artisan. This keeps your logic clean and separate from your controllers. ```bash php artisan make:mail OrderShipped ``` Inside the `build` method, you define the sender, subject, and the view. Using the `markdown` method ensures your email looks professional out of the box. ```python public function build() { return $this->from('[email protected]') ->subject('Your Order Shipped!') ->markdown('emails.orders.shipped'); } ``` Implementing Multi-Channel Notifications Notifications go a step further. You can define a `via` method to specify multiple channels like `mail` and `nexmo`. ```python public function via($notifiable) { return ['mail', 'nexmo']; } public function toNexmo($notifiable) { return (new NexmoMessage)->content('Your order is on the way!'); } ``` Syntax Notes Laravel uses **Fluent Interfaces**, allowing you to chain methods like `->subject()->attach()`. Additionally, implementing the `ShouldQueue` interface on your mail or notification classes is a best practice. It offloads the slow process of sending network requests to a background worker, keeping your app snappy for the end user. Practical Examples Use **Mailables** for content-heavy, single-channel communications like monthly newsletters. Use **Notifications** for event-driven alerts, such as notifying a team on Slack when a new subscription is purchased while simultaneously emailing the customer. Tips & Gotchas Always check your `.env` file first. If your `MAIL_MAILER` is set to `log` instead of `smtp`, your emails will only show up in your local log files. Also, remember that for SMS notifications, your User model must have a `routeNotificationForNexmo` method to tell the system which phone number to use.

Overview of Next-Generation Spark Laravel Spark serves as a dedicated SaaS toolkit designed to handle the heavy lifting of recurring billing. Unlike earlier versions, the next generation of Spark is front-end agnostic, meaning it provides a totally isolated billing portal that exists separately from your main application logic. This architectural shift grants you total freedom to use any stack—whether Vue.js, React, or simple Blade templates—without the billing logic cluttering your UI. Prerequisites and Toolkit To follow this implementation, you should be comfortable with the Laravel framework and basic terminal operations. Key Libraries & Tools * **Laravel Breeze**: A minimal, simple starter kit for scaffolding authentication. * **Paddle**: A merchant of record that handles VAT taxes and provides PayPal integration. * **Stripe**: The alternative payment provider supported by Spark. * **Tailwind CSS**: The utility-first CSS framework used for branding the portal. Implementation Walkthrough Start by scaffolding authentication using Laravel Breeze. Once your users can log in, install the Paddle edition of Spark via Composer: ```bash composer require laravel/spark-paddle php artisan spark:install ``` Next, integrate the `Billable` trait into your `User` model. This connects your database entities to the Spark billing engine. ```python use Spark\Billable; class User extends Authenticatable { use Billable; } ``` Configuring Subscription Plans Plans reside in `config/spark.php`. Here, you define your monthly and yearly IDs—which you fetch from your Paddle dashboard—along with feature lists. Spark uses these to automatically generate the pricing toggle in the billing portal. Branding and UI Integration Customizing the portal to match your brand (like the green aesthetic of Laravel Forge) happens in the `branding` section of the config. You can swap the logo and primary button colors using Tailwind CSS classes. To link users to the portal, simply point a navigation link to the `/billing` route defined in your configuration. Practical Tips & Gotchas Always use the `onTrial` method to show trial banners in your UI. One common mistake is forgetting to set up webhooks; Laravel Spark relies on webhooks to process subscription status changes. If your local environment isn't receiving these, your application won't know when a user has successfully paid.