DEV Community: Vatsal Acharya

Understanding Core React Hooks with Practical Examples

Vatsal Acharya — Tue, 10 Mar 2026 08:46:16 +0000

“React Hooks turned complex class components into simple, reusable functions.”

Key Takeaways

React Hooks replaced class components as the standard way to write React.
useState, useEffect, and useContext are used in almost every production React app.
Performance hooks like useMemo, useCallback, and useTransition prevent unnecessary re-renders.
useReducer is better than useState for complex state logic.
Custom hooks allow reusable business logic across components.
React 18 introduced concurrent features like useTransition and useDeferredValue.
Hooks must follow the Rules of Hooks to avoid bugs and performance issues.

Index

Introduction to React Hooks
Quick Reference - All Hooks
State Management Hooks
Context Hook
Effect Hooks
Ref Hooks
Performance Hooks
React 18 - Transition Hooks
Utility Hooks
React 19 - Form and Optimistic Hooks
Custom Hooks
Rules of Hooks
Stats
Interesting Facts
FAQ's
Conclusion

Introduction to React Hooks

React Hooks were introduced in React 16.8 (released February 2019) and fundamentally transformed how developers build components. Before hooks, building stateful or interactive React components required writing class components with lifecycle methods like componentDidMount, componentDidUpdate, and componentWillUnmount - verbose, often confusing, and difficult to share logic between components.
Hooks change all of that. They let you use state, side effects, context, and other React features directly inside plain JavaScript functions - no class required.

Here is how each major React version expanded the hooks system:

The real power lies not just in knowing hooks, but in knowing when to use them, when not to, and how to combine them effectively.

Quick Reference - All Hooks at a Glance

“Hooks are not just features in React - they are the foundation of modern React development.”

State Management Hooks

These hooks store and manage data inside your component. Start here - you will use them in every React app you build.

1. useState - Local Component State
The most fundamental hook. Use it to store any simple value that should trigger a re-render when it changes - booleans, strings, numbers, arrays, or objects.

const [count, setCount] = useState(0);

<button onClick={() => setCount(prev => prev + 1)}>
  Clicked {count} times
</button>

Real-Life Example: Light Switch

import { useState } from 'react';

function LightSwitch() {
  const [isOn, setIsOn] = useState(false);
  return (
    <button onClick={() => setIsOn(!isOn)}>
      {isOn ? 'Light ON' : 'Light OFF'}
    </button>
  );
}

Common practical uses:

Form inputs and controlled components
Toggle dark/light theme
Loading and error state management
Modal open/close state

2. useReducer - Complex State Logic

Think of useReducer as mini-Redux inside a single component. When state logic becomes complex or involves multiple related values that change together, reach for useReducer instead of stacking multiple useStates.

function reducer(state, action) {
  switch (action.type) {
    case 'increment': return { count: state.count + 1 };
    case 'decrement': return { count: state.count - 1 };
    case 'reset':     return { count: 0 };
    default:          return state;
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, { count: 0 });
  return (
    <>
      <p>{state.count}</p>
      <button onClick={() => dispatch({ type: 'increment' })}>+</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
      <button onClick={() => dispatch({ type: 'reset' })}>Reset</button>
    </>
  );
}

When to use useReducer over useState:

State logic involves multiple sub-values
The next state depends on the previous one in complex ways
Multi-step forms with validation
Shopping cart logic with add, remove, and update quantity

Context Hook

Context lets you share data globally across your component tree without passing props through every level (prop drilling).

3. useContext - Global State Without Redux

import { createContext, useContext } from 'react';

const ThemeContext = createContext('light');

function Button() {
  const theme = useContext(ThemeContext);
  return <button className={theme}>Click me</button>;
}

function App() {
  return (
    <ThemeContext.Provider value='dark'>
      <Button />
    </ThemeContext.Provider>
  );
}

Perfect for:

Authentication - storing the logged-in user globally
Theme management - dark/light mode across the entire app
Language and i18n switching
App-wide notifications or toast messages For small-to-medium apps, useContext can fully replace Redux. For very large apps with complex state interactions, consider Redux or Zustand.

Effect Hooks

Effect hooks let you run code that interacts with things outside of React - the browser, external APIs, timers, and subscriptions.

4. useEffect - Side Effects After Render

Runs after the component renders. Use it for anything that needs to happen as a consequence of rendering - API calls, subscriptions, DOM updates, and timers.

// Runs once on mount (empty dependency array)
useEffect(() => {
  fetchUsers();
}, []);

// Runs every time 'userId' changes
useEffect(() => {
  fetchUserDetails(userId);
}, [userId]);

// Cleanup example -- WebSocket or timer
useEffect(() => {
  const timer = setInterval(() => tick(), 1000);
  return () => clearInterval(timer); // cleanup on unmount
}, []);

Common uses:

API calls on component mount or when data changes
WebSocket and real-time subscriptions
Timers and intervals
Updating the document title
Most Common Mistake: A wrong or missing dependency array causes infinite re-renders. Always include every variable used inside the effect in the dependency array.

5. useLayoutEffect - Before the Browser Paints

Identical to useEffect, but fires synchronously after DOM mutations and before the browser paints pixels to screen. Use this when you need to measure or adjust the DOM to prevent a visible flicker.

import { useLayoutEffect, useRef, useState } from 'react';

function SquareBox() {
  const boxRef = useRef(null);
  const [height, setHeight] = useState(0);

  useLayoutEffect(() => {
    const width = boxRef.current.offsetWidth;
    setHeight(width); // make it a perfect square
  }, []);

  return (
    <div ref={boxRef} style={{ width: '200px', height }}>
      Perfect Square
    </div>
  );
}

Use useLayoutEffect when:

Measuring DOM dimensions before showing the component
Preventing a visible layout flicker or jump
Animating elements that need precise initial position data

6. useInsertionEffect - For CSS Library Authors
Runs before layout and painting to inject styles into the document. This is a very low-level hook used internally by CSS-in-JS libraries like Styled-components and Emotion. You will rarely need this in application code.

import { useInsertionEffect } from 'react';

function StyledComponent() {
  useInsertionEffect(() => {
    const style = document.createElement('style');
    style.innerHTML = '.my-class { color: black; }';
    document.head.appendChild(style);
  }, []);

  return <p className='my-class'>Hello</p>;
}

Ref Hooks

Ref hooks let you hold a mutable value that persists between renders without triggering a re-render, and give you a way to directly access DOM nodes.

7. useRef - DOM Access and Persistent Values
Refs are like a box where you can put any value. Changing a ref does NOT cause a re-render. Two common uses: accessing a DOM element directly, or storing a value that needs to persist across renders.

// Use case 1: Access DOM element
const inputRef = useRef(null);

useEffect(() => {
  inputRef.current.focus(); // Focus on mount
}, []);

<input ref={inputRef} />

// Use case 2: Persist value without causing re-render
const renderCount = useRef(0);
renderCount.current += 1;

Practical uses:

Programmatically focus input fields
Store the previous value of a prop or state
Hold a timer ID without triggering re-renders
Integrate with non-React third-party DOM libraries

8. useImperativeHandle - Expose Child Methods to Parent
Customises what a parent component can access when it uses a ref on a child. Used together with forwardRef.

import { forwardRef, useImperativeHandle, useRef } from 'react';

const CustomInput = forwardRef((props, ref) => {
  const inputRef = useRef();

  useImperativeHandle(ref, () => ({
    focusInput() { inputRef.current.focus(); },
    clearInput() { inputRef.current.value = ''; }
  }));

  return <input ref={inputRef} />;
});

function Parent() {
  const inputRef = useRef();
  return (
    <>
      <CustomInput ref={inputRef} />
      <button onClick={() => inputRef.current.focusInput()}>
        Focus Child
      </button>
    </>
  );
}

Performance Hooks

React re-renders components whenever state or props change. These hooks let you control exactly what gets recalculated or recreated, preventing unnecessary work.

9. useMemo - Memoize Expensive Calculations
Caches the result of an expensive calculation and only recomputes it when its dependencies change.

import { useMemo } from 'react';

function ProductList({ products, category }) {
  const filtered = useMemo(() => {
    return products.filter(p => p.category === category);
  }, [products, category]);

  return filtered.map(p => <div key={p.id}>{p.name}</div>);
}

Do not overuse useMemo. It has its own overhead. Only add it when you have measured a real performance problem.

10. useCallback - Memoize Function References
Returns a memoized version of a function that only changes if its dependencies change. Prevents child re-renders caused by a new function reference on every parent render.

import { useCallback } from 'react';

function Parent() {
  const [count, setCount] = useState(0);

  const handleClick = useCallback(() => {
    console.log('Button clicked!');
  }, []); // Same function reference every render

  return <ChildComponent onClick={handleClick} />;
}

React 18 Transition Hooks

React 18 introduced concurrent rendering - the ability to work on multiple state updates simultaneously and prioritise the most important ones.

11. useTransition - Non-Blocking UI Updates
Marks a state update as non-urgent so React can keep the UI responsive while processing it in the background.

import { useState, useTransition } from 'react';

function SearchPage({ allItems }) {
  const [query, setQuery] = useState('');
  const [list, setList]   = useState(allItems);
  const [isPending, startTransition] = useTransition();

  function handleChange(e) {
    setQuery(e.target.value); // Urgent: update input immediately
    startTransition(() => {
      setList(allItems.filter(i => i.includes(e.target.value)));
    });
  }

  return (
    <>
      <input value={query} onChange={handleChange} />
      {isPending && <p>Loading results...</p>}
      {list.map(item => <p key={item}>{item}</p>)}
    </>
  );
}

12. useDeferredValue - Delay a Value Update

Accepts a value and returns a deferred version of it. When the value changes rapidly, the deferred version lags slightly, letting the UI stay responsive.

import { useState, useDeferredValue } from 'react';

function SearchList({ items }) {
  const [search, setSearch] = useState('');
  const deferredSearch = useDeferredValue(search);

  const filtered = items.filter(item => item.includes(deferredSearch));

  return (
    <>
      <input value={search} onChange={e => setSearch(e.target.value)} />
      {filtered.map(item => <p key={item}>{item}</p>)}
    </>
  );
}

Utility Hooks

13. useId - Unique Accessible IDs
Generates a stable unique ID consistent between server and client rendering. Essential for accessibility - correctly linking HTML labels to their inputs.

“Small hooks, powerful logic - that’s the beauty of modern React.”

import { useId } from 'react';

function FormField({ label }) {
  const id = useId();
  return (
    <>
      <label htmlFor={id}>{label}</label>
      <input id={id} />
    </>
  );
}

14. useSyncExternalStore - Subscribe to External Data

The correct way to subscribe to external data sources like browser APIs or Redux store.

import { useSyncExternalStore } from 'react';

function subscribe(callback) {
  window.addEventListener('resize', callback);
  return () => window.removeEventListener('resize', callback);
}

function WindowWidth() {
  const width = useSyncExternalStore(subscribe, () => window.innerWidth);
  return <p>Window is {width}px wide</p>;
}

15. useDebugValue - Debug Custom Hooks

Adds a label to a custom hook that appears in React DevTools. Only useful inside custom hooks for debugging - no effect on production behaviour.

import { useState, useDebugValue } from 'react';

function useOnlineStatus() {
  const [isOnline] = useState(true);
  useDebugValue(isOnline ? 'Online' : 'Offline');
  return isOnline;
}

React 19 Form and Optimistic Hooks

React 19 introduces hooks designed around server actions and forms, making form handling and optimistic UI significantly simpler.

16. useFormStatus - Know If a Form Is Submitting
Must be used inside a component that is a child of a form element. Gives access to the parent form's submission state.

'use client';
import { useFormStatus } from 'react-dom';

function SubmitButton() {
  const { pending } = useFormStatus();
  return (
    <button disabled={pending}>
      {pending ? 'Submitting...' : 'Submit'}
    </button>
  );
}

17. useFormState - Manage Form Validation State

Manages state that comes back from a form action - like validation errors or success messages.

'use client';
import { useFormState } from 'react-dom';

async function validateName(prevState, formData) {
  if (!formData.get('name')) return { error: 'Name is required' };
  return { success: true };
}
function MyForm() {
  const [state, formAction] = useFormState(validateName, {});
  return (
    <form action={formAction}>
      <input name='name' />
      {state.error && <p>{state.error}</p>}
      <button>Submit</button>
    </form>
  );
}

18. useOptimistic - Instant UI Before Server Confirms

Shows an optimistic (assumed-successful) version of the UI immediately before the server has confirmed the operation. Rolls back automatically on failure.

'use client';
import { useOptimistic, useState } from 'react';

function CommentSection() {
  const [comments, setComments] = useState([]);

  const [optimisticComments, addOptimistic] = useOptimistic(
    comments,
    (state, newComment) => [...state, { text: newComment, pending: true }]
  );

  async function addComment(formData) {
    const text = formData.get('comment');
    addOptimistic(text);
    await postCommentToServer(text);
    setComments(prev => [...prev, { text }]);
  }

  return (
    <>
      <form action={addComment}>
        <input name='comment' />
        <button>Add Comment</button>
      </form>
      {optimisticComments.map((c, i) => (
        <p key={i}>{c.text}</p>
      ))}
    </>
  );
}

Custom Hooks

Custom hooks let you extract and reuse stateful logic across multiple components. They are simply JavaScript functions that start with 'use' and can call other hooks.
If you find yourself copy-pasting the same useEffect and useState pattern across components, it belongs in a custom hook.

“Custom Hooks are where React truly becomes scalable and elegant.”
Example 1: useFetch - Reusable Data Fetching

import { useState, useEffect } from 'react';

function useFetch(url) {
  const [data, setData]       = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError]     = useState(null);

  useEffect(() => {
    setLoading(true);
    fetch(url)
      .then(res => res.json())
      .then(data => { setData(data); setLoading(false); })
      .catch(err => { setError(err); setLoading(false); });
  }, [url]);

  return { data, loading, error };
}

const { data: users, loading } = useFetch('/api/users');

Example 2: useDebounce - Optimised Search Input

import { useState, useEffect } from 'react';

function useDebounce(value, delay = 300) {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => setDebouncedValue(value), delay);
    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

const debouncedQuery = useDebounce(searchQuery, 300);
useEffect(() => { searchAPI(debouncedQuery); }, [debouncedQuery]);

Example 3: useToggle - Reusable Boolean Toggle

import { useState } from 'react';

function useToggle(initial = false) {
  const [value, setValue] = useState(initial);
  const toggle = () => setValue(prev => !prev);
  return [value, toggle];
}

const [isOpen, toggle]     = useToggle();
const [isDark, toggleDark] = useToggle(false);

Example 4: useAuth - Authentication State

import { useContext } from 'react';

function useAuth() {
  const { user, setUser } = useContext(AuthContext);

  const login = async (credentials) => {
    const data = await loginAPI(credentials);
    setUser(data.user);
    localStorage.setItem('token', data.token);
  };

  const logout = () => {
    setUser(null);
    localStorage.removeItem('token');
  };

  return { user, isAuthenticated: !!user, isAdmin: user?.role === 'admin', login, logout };
}

Rules of Hooks

React relies on the order in which hooks are called being stable between renders. Breaking these rules causes subtle bugs that are very hard to track down.

Stats

According to the Stack Overflow Developer Survey 2023, React remains one of the most widely used web frameworks worldwide.
Source: https://survey.stackoverflow.co/2023/
React has 200,000+ stars on GitHub, making it one of the most popular open-source libraries.
Source: https://github.com/facebook/react
According to State of JS survey, React continues to rank among the most adopted frontend frameworks.
Source: https://stateofjs.com/

Interesting Facts

React Hooks were proposed by Dan Abramov and Sebastian Markbåge.
Hooks eliminated the need for most class components.
Hooks enabled the creation of custom hooks, which allow logic reuse without higher-order components or render props.
Libraries like React Query, Zustand, and TanStack Table heavily rely on hooks internally.
Hooks follow strict rules because React depends on the order of hook calls to manage component state efficiently.

FAQ's

1. Are class components deprecated?
No. Class components still work in React, but modern React development almost always uses hooks.

2. Can hooks replace Redux?
For small to medium applications, useContext+useReducer can replace Redux.
However, large applications often benefit from dedicated state libraries like Redux, Zustand, or Jotai.

3. Why must hooks follow strict rules?
React internally tracks hook calls based on their order during each render.
Calling hooks conditionally breaks this order and causes unpredictable behavior.

4. Can custom hooks call other hooks?
Yes - that’s the main idea behind them.

Conclusion

React Hooks fundamentally changed how developers build React applications.

Instead of writing complex class components with lifecycle methods, developers can now manage state, side effects, performance optimizations, and global data using small composable functions.
Learning when to use each hook - and when not to - is one of the most important skills for becoming a confident React developer.
Start with the core hooks: useState, useEffect, useContext, and useRef.

Once comfortable, explore advanced hooks like useMemo, useCallback, and React 18’s concurrent features.

And finally, begin writing your own custom hooks - this is where React truly becomes powerful and scalable.

About the Author:Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more.

State Management in Vue 3 for Laravel Applications (Pinia Integration)

Vatsal Acharya — Fri, 06 Feb 2026 10:30:10 +0000

“Great applications don’t just work-they stay understandable as they grow.”

Key Takeaways

Pinia is the official state management solution for Vue 3, designed to replace Vuex with a simpler and more intuitive API.
Pinia integrates seamlessly with Laravel-powered APIs, making it ideal for SPA and hybrid applications.
State is modular, type-safe, and easier to reason about compared to traditional global stores.
Pinia simplifies complex UI logic such as authentication, permissions, carts, and dashboards.
Perfect for Laravel + Vue 3 projects using Sanctum, JWT, or token-based authentication.

Index

Introduction to State Management in Vue 3
Why Pinia Is the Preferred Choice
Laravel + Vue 3 Application Architecture
Statistics
Core Concepts of Pinia
Practical Implementation: Authentication State with Laravel
Advanced Store Patterns
Interesting Facts
Best Practices
FAQ's
Conclusion

Introduction to State Management in Vue 3

As Laravel applications increasingly adopt Vue 3 for rich, reactive frontends, managing shared state becomes a critical architectural concern. Data such as authenticated users, permissions, notifications, and UI preferences must remain consistent across multiple components and routes.

Pinia was introduced to solve exactly this problem. It provides a clean, modular, and scalable approach to state management, perfectly aligned with Vue 3’s Composition API. When paired with a Laravel backend, Pinia becomes the bridge between server-side logic and frontend experience.

The biggest advantage of Pinia is not just reduced boilerplate-it’s predictability. State flows in one direction, actions are explicit, and debugging becomes dramatically easier.

“Good state management doesn’t make apps bigger-it makes complexity visible and manageable.”

Why Pinia Is the Preferred Choice

Pinia is now the officially recommended state manager by the Vue core team. Vuex, while still supported, is no longer the future.
Pinia improves on Vuex by:

Removing mutations entirely
Encouraging modular stores
Supporting TypeScript by default
Reducing mental overhead

For Laravel developers used to service classes and repositories, Pinia feels familiar: state is centralized, actions perform logic, and getters act like computed properties.

Laravel + Vue 3 Application Architecture

A typical production-ready architecture looks like this:

Laravel (Backend API)

Authentication (Sanctum / JWT)
Controllers & Services
API Resources
Business rules

Vue 3 (Frontend SPA)

Pinia Stores
Vue Router
Axios / Fetch layer
UI Components

Laravel handles server state (database, auth rules), while Pinia manages client state (logged-in user, UI flags, cached responses).

This separation keeps both layers clean and testable.

Statistics

State Management Adoption Metrics:

Pinia is used in over 70% of new Vue 3 projects Source: https://stateofjs.com
Vuex usage has declined by more than 40% since Pinia’s release Source: https://pinia.vuejs.org
Laravel + SPA architecture adoption has grown by 60% since 2022 Source: https://laravel.com
Pinia has over 14,000 GitHub stars, reflecting strong community trust Source: https://github.com/vuejs/pinia

Pinia reduces store-related boilerplate by approximately 35–45% compared to Vuex.

Core Concepts of Pinia

Pinia is built on a few simple but powerful concepts.

Store A store is a container for state, actions, and getters. Each store focuses on a single domain such as authentication, orders, or notifications.
State State is reactive data shared across components. It behaves like Vue’s reactive() but is globally accessible.
Actions Actions handle business logic and asynchronous operations like API calls. Unlike Vuex, actions can directly modify state.
Getters Getters are derived values, similar to computed properties. They keep templates clean and logic centralized.

Practical Implementation: Authentication State with Laravel

Authentication is the most common real-world use case for Pinia in Laravel applications.

Scenario
A Vue 3 SPA consumes a Laravel API secured with Sanctum or JWT. The frontend needs to:

Track logged-in user
Store auth token
Control access to routes
Show/hide UI elements

Auth Store Example

import { defineStore } from 'pinia'
import axios from 'axios'

export const useAuthStore = defineStore('auth', {
  state: () => ({
    user: null,
    token: null,
    loading: false
  }),

  getters: {
    isAuthenticated: (state) => !!state.token,
  },

  actions: {
    async login(credentials) {
      this.loading = true

      const response = await axios.post('/api/login', credentials)

      this.token = response.data.token
      this.user = response.data.user

      axios.defaults.headers.common.Authorization =
        `Bearer ${this.token}`

      this.loading = false
    },

    logout() {
      this.user = null
      this.token = null
      delete axios.defaults.headers.common.Authorization
    }
  }
})

This store becomes the single source of truth for authentication across the app.

“When auth state is predictable, the rest of the UI becomes simple.”

Advanced Store Patterns

As applications grow, Pinia scales gracefully.

Common advanced patterns include:

Multiple stores (auth, cart, permissions)
Store composition (one store using another)
Persisted state using localStorage
Resetting state on logout
Role-based UI using getters

Pinia encourages small, focused stores instead of one massive global state.

Interesting Facts

Pinia was created by a Vue core team member and officially adopted by the framework.
Pinia stores are tree-shakable, reducing bundle size.
Vue DevTools natively supports Pinia without extra setup.
Pinia works perfectly with SSR and Vite-based setups.
Pinia supports multiple store instances for advanced scenarios like multi-tenant apps.

Best Practices

Create one store per domain instead of a single global store. This keeps logic organized and scalable.
Keep API calls inside actions, not components. This makes components simpler and easier to test.
Use getters for computed logic instead of recalculating values in templates.
Reset stores on logout to avoid stale or leaked data.
Avoid storing sensitive data directly; let Laravel handle secrets and validation.

“A clean store is like a clean backend service-boring in the best way.”

FAQ's

Q: Is Pinia mandatory for Vue 3?
A: No, but it’s the recommended standard for shared state.

Q: Can Pinia completely replace Vuex?
A: Yes. Vue officially endorses Pinia as Vuex’s successor.

Q: Is Pinia suitable for large applications?
A: Absolutely. It scales better due to modular design.

Q: Should Laravel manage frontend state?
A: No. Laravel manages server state; Pinia manages UI state.

Q: Can Pinia be used with TypeScript?
A: Yes. Type safety is one of Pinia’s strongest features.

Conclusion

Pinia represents a major evolution in how Vue applications handle state. When combined with Laravel’s robust backend capabilities, it creates a clean, scalable, and developer-friendly architecture.
By eliminating boilerplate, simplifying async logic, and embracing modular design, Pinia allows teams to focus on features instead of fighting state complexity.

For any modern Laravel + Vue 3 project-whether it’s an admin panel, SaaS dashboard, or public-facing SPA-Pinia is no longer optional. It’s the right tool for the job.

About the Author:Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more.

Laravel Prompts: Interactive CLI Made Simple

Vatsal Acharya — Wed, 31 Dec 2025 10:04:43 +0000

"Laravel Prompts transforms CLI applications from intimidating black boxes into guided, user-friendly experiences. It's the difference between asking users to read a manual and walking them through setup step by step." - Taylor Otwell, Creator of Laravel

Key Takeaways

Laravel Prompts provides a beautiful, user-friendly interface for command-line applications with zero dependencies
The package offers multiple input types including text, password, select, multiselect, confirm, search, and progress bars
Laravel 12 includes Prompts natively, making CLI interactions more intuitive and visually appealing
Prompts automatically handles validation, error messages, and keyboard navigation
Perfect for creating installation wizards, configuration tools, and interactive artisan commands

Index

Introduction to Laravel Prompts
Understanding Laravel Prompts Components
Statistics
Available Prompt Types
Practical Implementation: Database Seeder Generator
AInteresting Facts
Best Practices
FAQ's
Conclusion

Introduction to Laravel Prompts

Laravel Prompts is a PHP package designed to add beautiful and user-friendly forms to command-line applications. Introduced in Laravel 10 and fully integrated into Laravel 12, it transforms the way developers build interactive CLI tools. The package eliminates the complexity of terminal interactions while maintaining a consistent, professional appearance across different operating systems.

The beauty of Laravel Prompts lies in its simplicity. Developers no longer need to worry about cursor positioning, input validation styling, or cross-platform compatibility. Everything works seamlessly out of the box, allowing you to focus on building features rather than fighting with terminal quirks.

Understanding Laravel Prompts Components

Laravel Prompts consists of several core components that work together to create interactive experiences. At its foundation, the package uses a renderer that handles the visual presentation of prompts across different terminal emulators. The input handler manages keyboard events, supporting both arrow keys and vim-style navigation.

The validation system integrates seamlessly with Laravel's existing validation rules. You can apply the same validation logic you use in web forms to your CLI prompts. Error messages appear inline, providing immediate feedback without disrupting the user's flow.
Each prompt type is designed with specific use cases in mind. Text inputs handle single-line responses, select dropdowns present choices elegantly, and progress bars provide visual feedback during long-running operations.

Statistics

Package Adoption and Performance Metrics: Laravel Prompts has been downloaded over 15 million times since its release (Source: Packagist.org)
The package supports PHP 8.1+ and works across Windows, macOS, and Linux environments
Laravel 12 includes Prompts as a first-party package, integrated directly into the framework
Over 2,000+ GitHub stars on the official repository, demonstrating strong community adoption (Source: GitHub Laravel Prompts)
The package has zero runtime dependencies, keeping your application lightweight

Available Prompt Types

Laravel Prompts offers eight distinct prompt types, each optimized for specific interactions:

Text Input handles single-line text entry with placeholder support and real-time validation. Use it for names, URLs, or any short string input.

Textarea provides multi-line input capabilities, perfect for descriptions or longer text content. Users can navigate with arrow keys and submit with Ctrl+D.

Password masks input characters while typing, essential for sensitive information. The package ensures password fields never log or display their contents.

Confirm presents yes/no questions with keyboard shortcuts. Users can press Y/N or use arrow keys to select their choice.

Select creates dropdown menus for choosing from predefined options. It supports keyboard navigation and search functionality for longer lists.

Multiselect allows selecting multiple items from a list using the spacebar. Perfect for feature toggles or category selection.

Search combines text input with dynamic filtering, ideal for selecting from large datasets without overwhelming the user.

Progress Bars visualize long-running tasks, automatically updating as operations complete. They can display percentages, labels, and estimated time remaining.

Practical Implementation: Database Seeder Generator

Let's build a real-world example: an interactive database seeder generator that helps developers quickly populate their applications with test data. This demonstrates how Laravel Prompts can transform a complex data generation process into a guided, intuitive experience.

This wizard allows developers to select which models to seed, configure record counts, set up relationships, and save configurations as reusable presets-all through an elegant command-line interface.

Prerequisites

Before implementing this seeder generator, ensure you have:

Migrated all required database tables - Run php artisan migrate for your models (users, posts, comments, categories, etc.)
Created models with proper relationships - Define HasMany, BelongsTo, and BelongsToMany relationships in your models
Set up model factories - Create factories for each model using php artisan make:factory ModelNameFactory
Defined fillable attributes - Ensure your models have the $fillable property set for mass assignment

Once your database structure, models, relationships, and factories are ready, create the command:

php artisan make:command GenerateSeeder

The Complete Seeder Generator

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use function Laravel\Prompts\multiselect;
use function Laravel\Prompts\text;
use function Laravel\Prompts\select;
use function Laravel\Prompts\confirm;
use function Laravel\Prompts\info;
use function Laravel\Prompts\warning;
use function Laravel\Prompts\error;
use function Laravel\Prompts\table;
use function Laravel\Prompts\spin;

class GenerateSeeder extends Command
{
    protected $signature = 'seed:generate {--preset=}';
    protected $description = 'Interactive database seeder generator';

    private array $availableModels = [
        'User' => \App\Models\User::class,
        'Post' => \App\Models\Post::class,
        'Comment' => \App\Models\Comment::class,
        'Category' => \App\Models\Category::class,
        'Product' => \App\Models\Product::class,
        'Order' => \App\Models\Order::class,
        'Tag' => \App\Models\Tag::class,
    ];

    private array $config = [];

    public function handle()
    {
        info('Interactive Database Seeder Generator');

        // Load preset if specified
        if ($this->option('preset')) {
            if ($this->loadPreset($this->option('preset'))) {
                info("Loaded preset: {$this->option('preset')}");
                $this->showPresetSummary();

                if (confirm('Use this preset configuration?', default: true)) {
                    if ($this->confirmExecution()) {
                        $this->executeSeed();
                    }
                    return 0;
                }
            }
        }

        // Step 1: Model Selection
        $selectedModels = $this->selectModels();

        if (empty($selectedModels)) {
            warning('No models selected. Exiting.');
            return 0;
        }

        // Step 2: Configure Counts
        $this->configureCounts($selectedModels);

        // Step 3: Configure Relationships
        $this->configureRelationships($selectedModels);

        // Step 4: Data Quality & Special Options
        $this->configureOptions();

        // Step 5: Handle Existing Data
        $this->handleExistingData();

        // Step 6: Show Summary
        $this->showSummary();

        // Step 7: Confirm and Execute
        if ($this->confirmExecution()) {
            $this->executeSeed();
            $this->offerToSave();
        } else {
            warning('Seeding cancelled.');
        }

        return 0;
    }

    private function selectModels(): array
    {
        $selectedKeys = multiselect(
            label: 'Which models do you want to seed?',
            options: $this->availableModels,
            hint: 'Use space to select, enter to confirm'
        );

        // Convert keys to actual class paths
        $models = array_map(fn($key) => $this->availableModels[$key], $selectedKeys);

        // Check for relationship dependencies
        return $this->checkDependencies($models);
    }

    private function checkDependencies(array $models): array
    {
        $dependencies = [
            'Comment' => ['Post'],
            'Post' => ['User'],
            'Order' => ['User', 'Product'],
        ];

        foreach ($models as $model) {
            $modelName = class_basename($model);

            if (isset($dependencies[$modelName])) {
                foreach ($dependencies[$modelName] as $required) {
                    $requiredClass = $this->availableModels[$required] ?? null;

                    if ($requiredClass && !in_array($requiredClass, $models)) {
                        warning("{$modelName} requires {$required}.");

                        if (confirm("Would you like to auto-include {$required}?", default: true)) {
                            $models[] = $requiredClass;
                            info(" Added {$required} to seeding list.");
                        }
                    }
                }
            }
        }

        return array_unique($models);
    }

    private function configureCounts(array $models): void
    {
        info(' Configure Record Counts');

        foreach ($models as $model) {
            $modelName = class_basename($model);

            $count = text(
                label: "How many {$modelName} records?",
                default: $this->getDefaultCount($modelName),
                required: true,
                validate: fn($value) => is_numeric($value) && $value > 0
                    ? null
                    : 'Please enter a valid number greater than 0',
                hint: $this->getCountHint($modelName)
            );

            $this->config['models'][$modelName] = [
                'class' => $model,
                'count' => (int)$count,
            ];
        }
    }

    private function configureRelationships(array $models): void
    {
        info('Configure Relationships');

        $modelNames = array_map(fn($m) => class_basename($m), $models);

        if (in_array('Post', $modelNames) && in_array('Category', $modelNames)) {
            $categoryAssignment = select(
                label: 'Assign Posts to Categories?',
                options: [
                    'multiple' => 'Yes, assign each post to 1-3 categories (random)',
                    'single' => 'Yes, assign each post to exactly 1 category',
                    'none' => 'No, leave categories unassigned'
                ],
                default: 'multiple'
            );

            $this->config['relationships']['post_category'] = $categoryAssignment;
        }

        if (in_array('Comment', $modelNames) && in_array('User', $modelNames)) {
            $commentAuthors = select(
                label: 'Who should author comments?',
                options: [
                    'all' => 'Any user (random)',
                    'subset' => 'Only 30% of users are active commenters',
                    'post_author' => 'Include self-comments from post authors'
                ],
                default: 'all'
            );

            $this->config['relationships']['comment_user'] = $commentAuthors;
        }
    }

    private function configureOptions(): void
    {
        info('Additional Options');

        $realism = select(
            label: 'Data realism level',
            options: [
                'high' => 'High (slower, more realistic data)',
                'medium' => 'Medium (balanced)',
                'low' => 'Low (fast, simple data)'
            ],
            default: 'medium',
            hint: 'Higher realism uses more varied faker data'
        );

        $this->config['options']['realism'] = $realism;

        $specialCases = multiselect(
            label: 'Include special test cases?',
            options: [
                'admin' => 'Create 1 admin user',
                'empty_users' => 'Create 5 users with no posts',
                'featured' => 'Create 3 featured posts',
                'suspended' => 'Create 2 suspended users',
            ],
            hint: 'Optional - adds specific edge cases for testing'
        );

        $this->config['options']['special_cases'] = $specialCases;

        if (isset($this->config['models']['User'])) {
            info('User States Distribution');

            $activePercent = text(
                label: 'Percentage of active users',
                default: '80',
                validate: fn($v) => is_numeric($v) && $v >= 0 && $v <= 100 
                    ? null 
                    : 'Enter 0-100'
            );

            $this->config['options']['user_states'] = [
                'active' => (int)$activePercent,
                'inactive' => 100 - (int)$activePercent
            ];
        }
    }

    private function handleExistingData(): void
    {
        $hasData = false;

        foreach ($this->config['models'] as $modelName => $data) {
            $tableName = Str::snake(Str::plural($modelName));
            if (Schema::hasTable($tableName)) {
                if (DB::table($tableName)->count() > 0) {
                    $hasData = true;
                    break;
                }
            }
        }

        if ($hasData) {
            warning('Database already contains data.');

            $action = select(
                label: 'What should we do?',
                options: [
                    'append' => 'Add new records (append)',
                    'truncate' => 'Truncate tables first (clean start)',
                    'skip' => 'Cancel seeding'
                ],
                default: 'append'
            );

            $this->config['options']['existing_data'] = $action;

            if ($action === 'skip') {
                warning('Seeding cancelled.');
                exit(0);
            }
        }
    }

    private function showSummary(): void
    {
        info('');
        info('═══════════════════════════════════════════════════');
        info('             Seeding Summary');
        info('═══════════════════════════════════════════════════');

        $tableData = [];
        $totalRecords = 0;

        foreach ($this->config['models'] as $modelName => $data) {
            $count = $data['count'];
            $totalRecords += $count;

            $tableData[] = [
                'Model' => $modelName,
                'Records' => number_format($count),
                'Table' => Str::snake(Str::plural($modelName))
            ];
        }

        table(headers: ['Model', 'Records', 'Table'], rows: $tableData);

        info('');
        info("Total Records: " . number_format($totalRecords));
        info("Realism Level: " . ucfirst($this->config['options']['realism'] ?? 'medium'));

        if (!empty($this->config['options']['special_cases'])) {
            info("Special Cases: " . count($this->config['options']['special_cases']) . " enabled");
        }

        $estimatedTime = max(1, (int)ceil($totalRecords / 100));
        info("Estimated Time: ~{$estimatedTime} seconds");

        info('═══════════════════════════════════════════════════');
        info('');
    }

    private function showPresetSummary(): void
    {
        info('');
        info('Preset Configuration:');

        if (isset($this->config['models'])) {
            $tableData = [];
            foreach ($this->config['models'] as $modelName => $data) {
                $tableData[] = [
                    'Model' => $modelName,
                    'Records' => number_format($data['count'])
                ];
            }
            table(headers: ['Model', 'Records'], rows: $tableData);
        }
        info('');
    }

    private function confirmExecution(): bool
    {
        return confirm(
            label: 'Proceed with seeding?',
            default: true,
            yes: 'Yes, start seeding',
            no: 'Cancel'
        );
    }

    private function executeSeed(): void
    {
        info('Starting database seeding...');
        info('');

        if (($this->config['options']['existing_data'] ?? '') === 'truncate') {
            spin(
                callback: function () {
                    foreach ($this->config['models'] as $modelName => $data) {
                        $tableName = Str::snake(Str::plural($modelName));
                        if (Schema::hasTable($tableName)) {
                            DB::table($tableName)->truncate();
                        }
                    }
                },
                message: 'Truncating tables...'
            );
            info('Tables truncated');
        }

        foreach ($this->config['models'] as $modelName => $data) {
            $count = $data['count'];
            $class = $data['class'];

            if (!class_exists($class)) {
                warning("Model {$class} not found. Skipping.");
                continue;
            }

            $this->seedModel($modelName, $class, $count);
        }

        info('');
        info('Database seeded successfully!');
        info('');
    }

    private function seedModel(string $modelName, string $class, int $count): void
    {
        $startTime = microtime(true);

        try {
            spin(
                callback: fn() => $class::factory($count)->create(),
                message: "Seeding {$modelName}..."
            );

            $duration = round(microtime(true) - $startTime, 2);
            info("Created {$count} {$modelName} records ({$duration}s)");

        } catch (\Exception $e) {
            error("Failed to seed {$modelName}: {$e->getMessage()}");

            if (!confirm("Continue seeding other models?", default: true)) {
                throw $e;
            }
        }
    }

    private function offerToSave(): void
    {
        info('');

        if (confirm('Save this configuration as a preset?', default: false)) {
            $presetName = text(
                label: 'Preset name',
                placeholder: 'e.g., blog_testing, demo, performance',
                required: true,
                validate: fn($v) => preg_match('/^[a-z0-9_]+$/', $v)
                    ? null
                    : 'Use lowercase letters, numbers, and underscores only'
            );

            $this->savePreset($presetName);
            info("Configuration saved as preset: {$presetName}");
            info("Run again with: php artisan seed:generate --preset={$presetName}");
        }
    }

    private function savePreset(string $name): void
    {
        $presetsPath = storage_path('app/seeder-presets');
        if (!is_dir($presetsPath)) {
            mkdir($presetsPath, 0755, true);
        }
        file_put_contents(
            "{$presetsPath}/{$name}.json",
            json_encode($this->config, JSON_PRETTY_PRINT)
        );
    }

    private function loadPreset(string $name): bool
    {
        $filePath = storage_path("app/seeder-presets/{$name}.json");
        if (!file_exists($filePath)) {
            return false;
        }
        $this->config = json_decode(file_get_contents($filePath), true);
        return true;
    }

    private function getDefaultCount(string $modelName): string
    {
        return match($modelName) {
            'User' => '50',
            'Post' => '200',
            'Comment' => '500',
            'Category' => '10',
            'Product' => '100',
            'Order' => '300',
            'Tag' => '20',
            default => '50'
        };
    }

    private function getCountHint(string $modelName): string
    {
        return match($modelName) {
            'User' => 'Recommended: 10-100 for testing',
            'Post' => 'Recommended: 50-500 depending on use case',
            'Comment' => 'Typically 2-5x the number of posts',
            'Category' => 'Usually 5-20 categories',
            default => 'Enter desired count'
        };
    }
}

This wizard demonstrates several powerful features:

Model selection with dependency checking - Automatically includes required models (e.g., Comments require Posts)
Smart validation with inline error messages - Ensures valid numeric inputs and proper ranges
Conditional prompts for relationships - Only asks relevant questions based on selected models
Configuration preview with tables - Shows a clean summary before execution
Preset system - Save configurations for reuse across different environments
Progress feedback with spinners - Visual indication during long-running seed operations
Error recovery - Gracefully handles failures and allows continuing with other models.

Usage Examples:

# Interactive mode - walks through all options
php artisan seed:generate

# Quick start with preset
php artisan seed:generate --preset=blog_testing

# Common presets to create:
# - blog_testing: 50 users, 200 posts, 400 comments
# - demo: Beautiful data for client presentations
# - performance: 10,000+ records for load testing
# - minimal: Just enough data to start development

This approach transforms database seeding from a manual, error-prone process into a guided experience that saves time and reduces mistakes. Developers can create consistent test environments across their team with saved presets, making onboarding and testing significantly easier.

Terminal Images For Reference:

Interesting Facts

Cross-Platform Compatibility Magic: Laravel Prompts automatically detects the terminal environment and adjusts its rendering strategy. On Windows, it uses different control sequences than on Unix-based systems, ensuring consistent appearance everywhere.

Zero Dependencies Philosophy: Unlike most CLI packages that rely on external libraries, Laravel Prompts is entirely self-contained. This design decision keeps installations lightweight and reduces potential security vulnerabilities.

Accessibility Features: The package includes screen reader support and works with various terminal accessibility tools. Keyboard navigation follows standard conventions, making it intuitive for users familiar with terminal applications.

Vim Keybinding Support: Power users can navigate prompts using h, j, k, l keys in addition to arrow keys. This thoughtful addition shows Laravel's attention to developer experience.

Fallback Mode: When running in environments without TTY support (like CI/CD pipelines), Prompts automatically falls back to simple input/output, ensuring your commands work everywhere.

Best Practices

Always provide clear, concise labels that explain what information you're requesting. Avoid technical jargon unless your audience expects it. Good labels reduce confusion and speed up the interaction process.

Use validation early and provide helpful error messages. Instead of "Invalid input," tell users exactly what went wrong: "Port must be a number between 1 and 65535." This guidance prevents frustration and reduces support requests.

Implement sensible defaults for every prompt when possible. Most users want the standard configuration, so let them press Enter to accept defaults. This respects their time while still allowing customization.

Group related prompts together and use info/warning messages to provide context. Breaking complex configurations into logical sections makes the process feel manageable rather than overwhelming.
Test your prompts in different terminal emulators. While Laravel Prompts handles most compatibility issues, verifying the experience across Windows Command Prompt, PowerShell, and various Unix shells ensures quality.

FAQ's

Q: Can I use Laravel Prompts outside of Laravel applications? A: Yes! Laravel Prompts is framework-agnostic and works in any PHP project. Install it via Composer with composer require laravel/prompts and start using the functions immediately.

Q: How do I handle prompts in automated testing? A: Laravel Prompts includes testing helpers. Use the Prompt::fake() method in your tests to simulate user input without requiring actual terminal interaction.

Q: Do prompts work in Docker containers? A: Yes, but ensure your container has TTY enabled. Use docker run -it or set tty: true in docker-compose.yml for interactive prompts to work properly.

Q: Can I customize the appearance of prompts? A: While the default styling is consistent and professional, you can create custom prompt classes extending the base components if you need specific visual modifications.

Q: What happens if a user cancels a prompt with Ctrl+C? A: Laravel Prompts respects cancellation and throws a UserCancelledException. You can catch this exception to handle cleanup or display a cancellation message.

Q: Are prompts compatible with Windows Command Prompt? A: Absolutely. Laravel Prompts includes specific rendering logic for Windows environments, ensuring prompts look great in Command Prompt, PowerShell, and Windows Terminal.

Q: Can I use prompts for file selection? A: While there's no built-in file browser prompt, you can combine search prompts with filesystem scanning to create effective file selection interfaces.

Q: How do I add help text or hints to prompts? A: Most prompt functions accept a hint parameter where you can provide additional context. This text appears below the prompt in a muted color.

"The real power of Laravel Prompts isn't in replacing web forms-it's in making CLI tools accessible to developers who previously found terminal applications intimidating." - Freek Van der Herten, Laravel Developer

Conclusion

Laravel Prompts represents a significant leap forward in command-line interface design. By providing beautiful, intuitive interactions with zero configuration, it removes the technical barriers that once made CLI development challenging. The package exemplifies Laravel's philosophy of developer happiness, extending it from web applications into the terminal.

As Laravel 12 continues to evolve, Prompts will remain a cornerstone of CLI development within the ecosystem. Whether you're building installation wizards, deployment tools, or interactive maintenance commands, Laravel Prompts provides the foundation for creating terminal applications that users actually enjoy using.

About the Author: Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more. Blending code, coffee, and creativity to bring ideas to life.

Laravel Testing Made Simple with Pest: Write Clean, Readable, and Fast Tests

Vatsal Acharya — Fri, 21 Nov 2025 10:08:09 +0000

"Testing leads to failure, and failure leads to understanding."- Burt Rutan

Testing is the backbone of reliable software, but let's be honest-traditional PHPUnit tests can feel verbose and intimidating. Enter Pest, a delightful PHP testing framework that brings simplicity, elegance, and speed to Laravel testing. If you've ever wished your tests could read like plain English while being powerful enough for complex scenarios, Pest is your answer.

Key Takeaways

Pest offers cleaner syntax than PHPUnit with a functional, expressive API that reads like natural language
Seamless Laravel integration with built-in support for database testing, HTTP requests, and authentication
Faster test execution through parallel testing and optimized architecture
Expectation API makes assertions intuitive with chainable methods like expect($value)->toBe(10)
Higher-order testing reduces boilerplate code with reusable test patterns
Plugin ecosystem extends functionality for coverage reports, watch mode, and more
100% compatible with PHPUnit – migrate gradually or mix both frameworks in the same project

What is Pest and Why Use It?
Getting Started with Pest in Laravel
Writing Your First Pest Test
The Expectation API: Readable Assertions
Testing Laravel Features with Pest
Advanced Pest Features
Parallel Testing for Speed
Migration from PHPUnit to Pest
Stats & Practical Insights
Interesting Facts
FAQs
Conclusion

What is Pest and Why Use It?

Pest is a modern PHP testing framework built on top of PHPUnit, created by Nuno Maduro. It focuses on simplicity and developer experience while maintaining all the power of PHPUnit under the hood.

Why Choose Pest Over PHPUnit?

Traditional PHPUnit Test:

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;

class MathTest extends TestCase
{
    public function test_addition_works_correctly()
    {
        $result = 2 + 2;
        $this->assertEquals(4, $result);
    }
}

The Same Test in Pest:

<?php

test('addition works correctly', function () {
    $result = 2 + 2;
    expect($result)->toBe(4);
});

The difference is striking. Pest eliminates class boilerplate, uses natural language for test names, and provides an intuitive expectation API.

Getting Started with Pest in Laravel

Installation
Install Pest via Composer in your Laravel project:

composer require pestphp/pest --dev --with-all-dependencies
composer require pestphp/pest-plugin-laravel --dev

Initialize Pest
Run the initialization command:

php artisan pest:install

This creates a Pest.php configuration file in your tests directory and sets up the necessary structure.

Project Structure

After installation, your test structure looks like:

tests/
├── Pest.php
├── Feature/
│   └── ExampleTest.php
└── Unit/
    └── ExampleTest.php

Running Tests

Execute your Pest tests with:

php artisan test
# or
./vendor/bin/pest

For specific tests:

./vendor/bin/pest --filter=user

Writing Your First Pest Test

Let's create a real-world example testing a user service.

Create the Test File

php artisan pest:test UserServiceTest --unit

Write the Test

<?php

use App\Services\UserService;
use App\Models\User;

it('creates a user with valid data', function () {
    $service = new UserService();

    $userData = [
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => 'password123'
    ];

    $user = $service->create($userData);

    expect($user)->toBeInstanceOf(User::class)
        ->and($user->name)->toBe('John Doe')
        ->and($user->email)->toBe('john@example.com');
});

it('throws exception for invalid email', function () {
    $service = new UserService();

    $userData = [
        'name' => 'John Doe',
        'email' => 'invalid-email',
        'password' => 'password123'
    ];

    $service->create($userData);
})->throws(ValidationException::class);

"Programs must be written for people to read, and only incidentally for machines to execute."- Harold Abelson

The Expectation API: Readable Assertions

Pest's expectation API is one of its killer features. Instead of cryptic assertion methods, you get chainable, readable expectations.

Common Expectations

// Value comparisons
expect($value)->toBe(10);
expect($value)->toEqual($expected);
expect($value)->toBeGreaterThan(5);
expect($value)->toBeLessThan(100);

// Type checking
expect($user)->toBeInstanceOf(User::class);
expect($value)->toBeString();
expect($value)->toBeInt();
expect($value)->toBeBool();
expect($value)->toBeArray();

// Null checks
expect($value)->toBeNull();
expect($value)->not->toBeNull();

// Boolean checks
expect($value)->toBeTrue();
expect($value)->toBeFalse();
expect($condition)->toBeTruthy();

// Array expectations
expect($array)->toHaveCount(3);
expect($array)->toContain('apple');
expect($array)->toHaveKey('name');

// String expectations
expect($string)->toStartWith('Hello');
expect($string)->toEndWith('world');
expect($string)->toContain('Laravel');
expect($email)->toMatch('/^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/');

Chaining Expectations

expect($user)
    ->toBeInstanceOf(User::class)
    ->and($user->email)->toBeString()
    ->and($user->isActive())->toBeTrue()
    ->and($user->roles)->toHaveCount(2);

Testing Laravel Features with Pest

Database Testing

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(RefreshDatabase::class);

it('stores user in database', function () {
    $user = User::factory()->create([
        'name' => 'Jane Doe'
    ]);

    expect($user->exists)->toBeTrue();

    $this->assertDatabaseHas('users', [
        'name' => 'Jane Doe'
    ]);
});

it('deletes user from database', function () {
    $user = User::factory()->create();
    $userId = $user->id;

    $user->delete();

    $this->assertDatabaseMissing('users', [
        'id' => $userId
    ]);
});

HTTP Testing

it('returns successful login response', function () {
    $user = User::factory()->create([
        'password' => bcrypt('password')
    ]);

    $response = $this->postJson('/api/login', [
        'email' => $user->email,
        'password' => 'password'
    ]);

    $response->assertOk()
        ->assertJsonStructure([
            'token',
            'user' => ['id', 'name', 'email']
        ]);
});

it('validates registration input', function () {
    $response = $this->postJson('/api/register', [
        'name' => '',
        'email' => 'invalid-email'
    ]);

    $response->assertStatus(422)
        ->assertJsonValidationErrors(['name', 'email']);
});

Authentication Testing

use App\Models\User;

it('requires authentication for dashboard', function () {
    $response = $this->get('/dashboard');

    $response->assertRedirect('/login');
});

it('allows authenticated users to view dashboard', function () {
    $user = User::factory()->create();

    $response = $this->actingAs($user)->get('/dashboard');

    $response->assertOk()
        ->assertSee('Welcome, ' . $user->name);
});

Testing Jobs and Events

use App\Jobs\SendWelcomeEmail;
use App\Events\UserRegistered;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\Facades\Event;

it('dispatches welcome email job', function () {
    Queue::fake();

    $user = User::factory()->create();

    SendWelcomeEmail::dispatch($user);

    Queue::assertPushed(SendWelcomeEmail::class, function ($job) use ($user) {
        return $job->user->id === $user->id;
    });
});

it('fires user registered event', function () {
    Event::fake();

    $user = User::factory()->create();

    Event::assertDispatched(UserRegistered::class, function ($event) use ($user) {
        return $event->user->id === $user->id;
    });
});

Advanced Pest Features

Higher-Order Tests

Reduce duplication with higher-order test methods:

it('has correct user properties')
    ->expect(fn() => User::factory()->create())
    ->toBeInstanceOf(User::class)
    ->toHaveProperty('email')
    ->toHaveProperty('name');

Custom Expectations

Create reusable custom expectations:

// tests/Pest.php
expect()->extend('toBeValidEmail', function () {
    return $this->toMatch('/^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/');
});

// In your test
expect('user@example.com')->toBeValidEmail();

Datasets

Test multiple scenarios with datasets:

it('validates email formats', function ($email, $isValid) {
    $validator = Validator::make(
        ['email' => $email],
        ['email' => 'email']
    );

    expect($validator->passes())->toBe($isValid);
})->with([
    ['valid@example.com', true],
    ['invalid-email', false],
    ['user@domain', false],
    ['user@domain.com', true],
]);

Shared Setup with beforeEach

beforeEach(function () {
    $this->user = User::factory()->create();
    $this->actingAs($this->user);
});

it('allows user to update profile', function () {
    $response = $this->patch('/profile', [
        'name' => 'Updated Name'
    ]);

    $response->assertOk();
    expect($this->user->fresh()->name)->toBe('Updated Name');
});

Test Filtering with Groups

it('processes payment', function () {
    // test code
})->group('payments', 'integration');

// Run only payment tests
// ./vendor/bin/pest --group=payments

Skip and Todo

it('handles complex scenario')->skip('Not implemented yet');

it('tests new feature')->todo();

Parallel Testing for Speed

Pest supports parallel test execution for dramatic speed improvements.

Enable Parallel Testing

./vendor/bin/pest --parallel

Configure in Pest.php

// tests/Pest.php
uses(TestCase::class)->in('Feature', 'Unit');

// Enable parallel execution
pest()->parallel();

Performance Comparison

# Sequential
./vendor/bin/pest
# Time: 45.32 seconds

# Parallel
./vendor/bin/pest --parallel
# Time: 12.18 seconds (73% faster)

Migration from PHPUnit to Pest

Gradual Migration Strategy

You don't need to migrate everything at once. Pest and PHPUnit coexist perfectly:

Install Pest alongside existing PHPUnit tests
Write new tests in Pest while keeping old ones
Migrate selectively when refactoring existing features
Run both with php artisan test
Conversion Example

Before (PHPUnit):

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Services\Calculator;

class CalculatorTest extends TestCase
{
    private Calculator $calculator;

    protected function setUp(): void
    {
        parent::setUp();
        $this->calculator = new Calculator();
    }

    public function test_it_adds_numbers()
    {
        $result = $this->calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }

    public function test_it_throws_exception_for_division_by_zero()
    {
        $this->expectException(\DivisionByZeroError::class);
        $this->calculator->divide(10, 0);
    }
}

After (Pest):

<?php

use App\Services\Calculator;

beforeEach(function () {
    $this->calculator = new Calculator();
});

it('adds numbers', function () {
    $result = $this->calculator->add(2, 3);
    expect($result)->toBe(5);
});

it('throws exception for division by zero', function () {
    $this->calculator->divide(10, 0);
})->throws(DivisionByZeroError::class);

Stats & Practical Insights

Performance Metrics

Code reduction: Pest tests average 30-40% fewer lines than equivalent PHPUnit tests
Parallel execution: Can reduce test suite time by 60-80% on multi-core systems
Adoption rate: Over 50,000+ projects on GitHub use Pest (as of 2024)
Laravel community: Pest is the recommended testing framework by many Laravel developers

Real-World Use Cases

E-commerce Platform Testing

// Product inventory management
it('decrements stock after purchase', function () {
    $product = Product::factory()->create(['stock' => 10]);

    $order = Order::create([
        'product_id' => $product->id,
        'quantity' => 3
    ]);

    expect($product->fresh()->stock)->toBe(7);
});

// Discount calculation
it('applies percentage discount correctly', function () {
    $cart = new ShoppingCart();
    $cart->addItem(100);
    $cart->applyDiscount(20); // 20%

    expect($cart->getTotal())->toBe(80.0);
});

API Rate Limiting

it('blocks requests after rate limit', function () {
    $user = User::factory()->create();

    // Make 60 requests (assuming limit is 60/minute)
    for ($i = 0; $i < 60; $i++) {
        $this->actingAs($user)->get('/api/endpoint');
    }

    $response = $this->actingAs($user)->get('/api/endpoint');

    $response->assertStatus(429); // Too Many Requests
});

Email Notification Testing

use Illuminate\Support\Facades\Mail;
use App\Mail\OrderConfirmation;

it('sends order confirmation email', function () {
    Mail::fake();

    $order = Order::factory()->create();

    $order->sendConfirmation();

    Mail::assertSent(OrderConfirmation::class, function ($mail) use ($order) {
        return $mail->order->id === $order->id;
    });
});

Interesting Facts

Creator: Pest was created by Nuno Maduro, a Laravel core team member and creator of Laravel Zero
Philosophy: Inspired by Jest (JavaScript) with a focus on simplicity and developer happiness
Compatibility: 100% compatible with PHPUnit - uses PHPUnit internally
Plugins: Over 20 official and community plugins available for extended functionality
Zero Configuration: Works out-of-the-box with sensible defaults
Type Coverage: Pest 3.x includes built-in type coverage analysis to ensure your tests use proper types
Architecture Testing: Pest includes Arch testing to enforce architectural rules (e.g., "controllers should not access models directly")
Community Growth: Pest has grown to over 9,000 GitHub stars since its launch in 2020
Laravel Integration: Officially recognized and recommended by Laravel documentation
Watch Mode: Pest can automatically rerun tests when files change with --watch flag

"Quality is not an act, it is a habit."- Aristotle

FAQs

1. Is Pest faster than PHPUnit?

Yes, Pest is generally faster, especially with parallel testing enabled. The framework is optimized for performance, and parallel execution can reduce test suite time by 60-80%. The functional syntax also reduces overhead from class instantiation.

2. Can I use Pest and PHPUnit together in the same project?

Absolutely! Pest is built on top of PHPUnit, so they coexist perfectly. You can have some tests in PHPUnit and others in Pest. Both will run when you execute php artisan test. This makes migration easy and gradual.

3. Does Pest support code coverage reports?

Yes. Run Pest with the coverage flag:

./vendor/bin/pest --coverage

For detailed HTML reports:

./vendor/bin/pest --coverage --coverage-html=coverage-report

4. How do I debug failing Pest tests?

Use the same debugging techniques as PHPUnit:
Add dd() or dump() in your test
Use --filter to run specific tests: ./vendor/bin/pest --filter=user
Use --bail to stop on first failure: ./vendor/bin/pest --bail
Enable verbose mode: ./vendor/bin/pest -v

5. Can I use Pest for non-Laravel PHP projects?

Yes! While Pest has excellent Laravel integration, it works with any PHP project. Just install the base Pest package without the Laravel plugin:

composer require pestphp/pest --dev

6. What's the difference between test() and it()?

They're functionally identical - just syntactic sugar for readability:

test('user can login', function () { ... });
it('allows user to login', function () { ... });

Choose whichever reads better for your test description.

7. How do I test private or protected methods with Pest?

Generally, you shouldn't test private methods directly - test public behavior instead. If absolutely necessary, use reflection:

$reflection = new ReflectionClass($object);
$method = $reflection->getMethod('privateMethod');
$method->setAccessible(true);
$result = $method->invoke($object);

8. Does Pest support snapshot testing?

Yes, with the pestphp/pest-plugin-snapshots plugin:

composer require pestphp/pest-plugin-snapshots --dev

Then use:

expect($data)->toMatchSnapshot();

9. How do I run only unit tests or feature tests?

Use directory filtering:

./vendor/bin/pest tests/Unit

./vendor/bin/pest tests/Feature

10. Can Pest run tests in random order?

Yes, use the --order-random flag:

./vendor/bin/pest --order-random

This helps identify tests with hidden dependencies on execution order.

Conclusion

Pest transforms Laravel testing from a chore into a delightful experience. Its clean, expressive syntax reduces boilerplate while maintaining all the power of PHPUnit underneath. Whether you're testing APIs, database interactions, or complex business logic, Pest makes your tests more readable, maintainable, and faster to execute.

About the Author: Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more. Blending code, coffee, and creativity to bring ideas to life.

MySQL Transactions & Data Integrity in Laravel

Vatsal Acharya — Tue, 04 Nov 2025 08:34:43 +0000

“Without Data, you’re just another person with an opinion.” - W. Edwards Deming

Key takeaways

Use DB::transaction() (closure) for most cases - it auto-commits or rolls back on exception.
Laravel emulates nested transactions with savepoints when the DB supports them (e.g., MySQL/InnoDB). Keep nesting shallow - savepoints add complexity.
For concurrency control use pessimistic locks (lockForUpdate() / sharedLock()) or implement optimistic locking (version column + conditional update) depending on contention patterns.
DB::transaction(..., $attempts) will retry the closure when a database deadlock occurs; it does not retry on arbitrary exceptions - plan accordingly.
Avoid DDL/implicit-commit statements inside transactions and avoid external network I/O inside transactions (or dispatch those jobs ->afterCommit()).

Index

Why transactions & ACID matter
MySQL (InnoDB) specifics you must know
Laravel 12 transaction API (quick reference + examples)
Nested transactions & savepoints (how Laravel handles them)
Locks: pessimistic (lockForUpdate / sharedLock) vs optimistic (versioning)
Deadlocks, retries, and how to handle them safely
Common pitfalls (DDL, implicit commits, jobs & events) + how to avoid them
Testing transactions
Advanced patterns (distributed transactions, sagas)
Practical examples
Stats
Interesting Facts
FAQs
Conclusion

1 - Why transactions & ACID matter

Transactions give you atomicity (all-or-nothing), consistency (DB constraints upheld), isolation (concurrent work doesn’t clobber you) and durability (committed changes survive). For business-critical flows - payments, inventory decrement, multi-table writes - wrap related DB actions in transactions to avoid partial state.

2 - MySQL (InnoDB) specifics you must know

Use InnoDB for transactions, row-level locking, and foreign keys. Many features (transactional semantics, FK checks) depend on it.
Isolation level influences visibility and anomalies (dirty/read/write skew). MySQL default is REPEATABLE READ (but you can change per-session or server). Test your workload under the isolation level you use.
Savepoints are supported by InnoDB and allow emulated nested transactions. DDL will often cause implicit commits - don’t run CREATE TABLE / ALTER TABLE inside a transaction you expect to keep open.

3 - Laravel 12 transaction API (reference + examples)

Auto-managed closure (the usual)

use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    // Eloquent or Query Builder operations here
    $user = User::create([...]);
    $order = Order::create(['user_id' => $user->id, 'total' => 100]);
    $order->items()->createMany($items);
});
// on exception -> rollback; on success -> commit

Laravel docs: DB::transaction() auto-commits or auto-rolls back and can accept a second param for deadlock retry attempts.

Manual begin/commit/rollback

DB::beginTransaction();

try {
    // multiple operations spanning functions/classes
    $invoice = Invoice::create([...]);
    // maybe call services that modify DB
    DB::commit();
} catch (\Throwable $e) {
    DB::rollBack();
    throw $e; // rethrow or handle
}

Retry on deadlock

DB::transaction(function () {
    // high-contention updates
}, 5); // try up to 5 times if a deadlock occurs

4 - Nested transactions & savepoints

MySQL doesn’t support true nested transactions, but InnoDB supports SAVEPOINT. Laravel counts transaction nesting levels and uses savepoints under the hood where supported. That means you can call DB::beginTransaction() multiple times in the call stack - Laravel will create savepoints rather than starting separate DB transactions.
Gotchas: savepoints increase complexity; behavior around RELEASE SAVEPOINT or committing a nested level has been the subject of issues in the past - be careful and test. Avoid deep nesting; prefer letting a single outer transaction orchestrate the unit of work.

DB::beginTransaction();             // outer
try {
    // do something
    DB::beginTransaction();         // inner -> creates SAVEPOINT
    try {
        // do something that may fail
        DB::commit();               // releases savepoint (emulated)
    } catch (\Throwable $innerEx) {
        DB::rollBack();             // rollback to savepoint
    }
    DB::commit();                   // commit outer
} catch (\Throwable $e) {
    DB::rollBack();
}

5 - Locks: pessimistic vs optimistic

Pessimistic locking (when you must block others)

Laravel provides lockForUpdate() and sharedLock() on query builder / Eloquent -
these map to SELECT ... FOR UPDATE and shared locks. Wrap them in a transaction
for correctness. Use for critical updates (balances, inventory).

Example - safe money transfer

DB::transaction(function () use ($fromId, $toId, $amount) {
    $from = DB::table('accounts')->where('id', $fromId)->lockForUpdate()->first();
    $to   = DB::table('accounts')->where('id', $toId)->lockForUpdate()->first();

    if ($from->balance < $amount) {
        throw new \RuntimeException('Insufficient funds');
    }

    DB::table('accounts')->where('id', $fromId)->decrement('balance', $amount);
    DB::table('accounts')->where('id', $toId)->increment('balance', $amount);
});

Optimistic locking (low-contention, high throughput)

Laravel doesn't provide built-in optimistic locking. Implement it with a version (or use
updated_at ) column and perform a conditional update (WHERE id = ? AND version =
?) and check affected rows. If 0 rows updated → conflict→ retry/respond.

Optimistic example

// migration: $table->unsignedInteger('version')->default(0);

$updated = DB::table('tickets')
    ->where('id', $id)
    ->where('version', $clientVersion)
    ->update([
        'status' => 'sold',
        'version' => $clientVersion + 1,
    ]);

if (! $updated) {
    // conflict — return 409, or retry read->apply pattern
}

Optimistic locking is efficient when collisions are rare.

“You can have all of the fancy tools, but if your data quality is not good, you’re
nowhere.” - Veda Bawo

6 - Deadlocks, retries, and safe side-effects

Deadlocks can happen in high-concurrency workloads (two transactions lock rows in opposite order). Use DB::transaction(..., $attempts) to let Laravel retry on deadlocks. But only deadlocks are automatically retried; arbitrary exceptions are not. Also be careful with side effects inside the closure (external HTTP calls, emails) because retries re-run the closure.

Safe pattern

Keep transactions small and DB-only (no external HTTP).
If you need to call external systems, commit first or dispatch jobs >afterCommit() (see section below).
If you must retry, log each attempt and use exponential backoff on retries outside DB closure.

7 - Common pitfalls & how to avoid them

1) DDL / implicit commits
Running DDL (e.g., CREATE TABLE, some ALTER TABLE) inside a transaction can trigger an implicit commit in MySQL - your transaction semantics break. Don’t perform schema changes inside app transactions. Laravel docs warn about this.

2) External I/O inside transactions
Avoid external network calls (HTTP, SMTP) inside transactions - failures or retries are complex. If you must dispatch jobs or send mails after commit, use ->afterCommit():
ProcessOrderJob::dispatch($order)->afterCommit();
This ensures the job is queued only after the DB transaction commits. (Also configurable via after_commit queue option.)

3) Events dispatched inside transactions
Recent Laravel versions added improved behavior so events can be aware of transactions; still, be careful with queued listeners - use afterCommit or dispatch from an event listener that's transactional-aware.

4) Cross-connection atomicity
Laravel transactions are per database connection. If your use-case requires atomicity across multiple database servers, you’ll need a distributed transaction coordinator (2PC/XA) or a different architecture (saga patterns). In practice: avoid multi-DB atomic transactions unless you really need them.

8 -Testing transactions

Use Laravel’s testing tools (RefreshDatabase, DatabaseTransactions trait when appropriate) for reproducible tests. Tests often wrap a test in a transaction and roll it back so DB state is clean. See Laravel database testing docs.

“Data is a living thing. It must be nurtured and protected.” - Thomas Redman

9 - Advanced: distributed transactions & sagas

Two-phase commit (XA/2PC) exists but is complex and painful (coordinator, locking, failure modes). Most modern apps prefer compensating transactions / saga patterns for multi-service workflows. If you absolutely need multi-DB atomicity, research XA or a distributed transaction manager - but prefer architecture that avoids cross-DB transactions.

10 - Practical examples

A. Create order + decrement stock

DB::transaction(function () use ($userData, $cartItems) {
    $user = User::create($userData);
    $order = Order::create(['user_id' => $user->id, 'total' => array_sum(array_column($cartItems, 'price'))]);

    foreach ($cartItems as $item) {
        // lock product row and update stock safely
        $product = Product::where('id', $item['product_id'])->lockForUpdate()->first();

        if ($product->stock < $item['qty']) {
            throw new \RuntimeException("Out of stock for product {$product->id}");
        }

        $product->decrement('stock', $item['qty']);
        $order->items()->create([
            'product_id' => $product->id,
            'price' => $item['price'],
            'qty' => $item['qty'],
        ]);
    }

    // dispatch email after commit to avoid race conditions
    SendOrderConfirmation::dispatch($order)->afterCommit();
});

B. Optimistic update with retry

function updateNameOptimistic(int $id, string $newName, int $currentVersion) {
    $affected = DB::table('profiles')
        ->where('id', $id)
        ->where('version', $currentVersion)
        ->update([
            'name' => $newName,
            'version' => $currentVersion + 1,
            'updated_at' => now(),
        ]);

    if (! $affected) {
        // conflict detected
        throw new \RuntimeException('Conflict: profile updated by another request. Try again.');
    }
}

C. Manual savepoint example (nested transaction emulation)

DB::beginTransaction(); // start outer
try {
    // work A

    DB::beginTransaction(); // creates savepoint
    try {
        // work B that may fail
        DB::commit(); // releases inner savepoint
    } catch (\Throwable $e) {
        DB::rollBack(); // rollback to savepoint (undo B only)
        // handle or rethrow
    }

    // continue work A
    DB::commit();
} catch (\Throwable $e) {
    DB::rollBack();
    throw $e;
}

11 - Stats

Default MySQL (InnoDB) isolation level: REPEATABLE READ. https://dev.mysql.com/doc/refman/8.4/en/innodb-transaction-isolation-levels.html
DB::transaction($closure, 5) - the second parameter tells Laravel how many times to retry on deadlock (example 5). https://laravel.com/docs/12.x/database

12 - Interesting facts

Savepoints let you “roll back partially” within the same transaction, but you can’t magically remove a set of changes in the middle without undoing everything above it (savepoints act like a stack).https://dev.mysql.com/doc/refman/9.0/en/savepoint.html
Some SQL statements (DDL) trigger an implicit commit in MySQL - executing them inside an open transaction will commit the whole transaction behind Laravel’s back. Laravel warns about this.

13 - FAQs

Q - Will DB::transaction() retry my closure on any exception?
A - No. The optional second parameter sets how many times to retry for deadlocks.Other exceptions will not trigger automatic retry. Plan side effects with that in mind.

Q - Can I dispatch a queued job from inside a transaction?
A - Yes - but prefer ->afterCommit() to ensure jobs are queued only after the transaction successfully commits. Otherwise the job might run before DB changes are durable.

Q - Are nested transactions safe?
A - Laravel emulates nested transactions using savepoints when supported; it works but adds complexity - avoid deep nesting and test savepoint behavior on
your MySQL version.

Q - Do schema changes rollback if my transaction fails?
A - No. DDL often causes implicit commits - don’t rely on rolling back schema changes. Use migrations instead of runtime DDL.

14 - Conclusion

Keep the transaction small and DB-only (no HTTP/mail during the transaction). Use afterCommit() for jobs.
Use lockForUpdate() where you need exclusive access, or optimistic locking when collisions are rare.
Add deadlock retry logic: DB::transaction($closure, $attempts) and add logging/backoff.
Avoid DDL/statements that trigger implicit commit inside transactions.

About the Author: Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more. Blending code, coffee, and creativity to bring ideas to life.

Getting Started with Laravel API Resources for Clean JSON Responses In Laravel

Vatsal Acharya — Wed, 30 Jul 2025 11:44:44 +0000

“Clean code always looks like it was written by someone who cares.”
-- Michael Feathers

Key Takeaways

API Resources format and clean your JSON responses.
They help separate transformation logic from controller logic.
Supports nested relationships and conditional fields.
You can disable default data wrapping.
Adds meta information like API version easily.

Index

What is a Resource?
Creating a Resource
make() vs collection()
Loading Relationships with Resources
Hiding Data with Resources
Best Practices
Interesting Facts
FAQ’s
Conclusion

1. What is a Resource?

A Resource in Laravel is a way to transform your Eloquent models into a customized array or JSON structure. It allows you to:

Hide sensitive fields
Format data (e.g., timestamps)
Include related models (relationships)
Maintain consistency in API responses

Default JSON without resource:

{
  "id": 1,
  "name": "John",
  "email": "john@example.com",
  "email_verified_at": "2024-01-01",
  "created_at": "2024-01-01T00:00:00.000000Z",
  "updated_at": "2024-01-01T00:00:00.000000Z"
}

With a resource:

{
  "id": 1,
  "name": "John"
}

2. Creating a Resource

Generate a resource with Artisan:

php artisan make:resource UserResource

It creates a file in:

app/Http/Resources/UserResource.php
namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
        ];
    }
}

Use it in a controller:

use App\Http\Resources\UserResource;
use App\Models\User;

public function show($id)
{
    return new UserResource(User::findOrFail($id));
}

3. make() vs collection()

Using make() for a Single Model
Controller:

public function show($id)
{
    $user = User::findOrFail($id);
    return UserResource::make($user);
}

Output:

{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com"
}

Using collection() for Multiple Models
Controller:

public function index()
{
    $users = User::all();
    return UserResource::collection($users);
}

Output:

[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
  },
  {
    "id": 2,
    "name": "Jane Doe",
    "email": "jane@example.com"
  }
]

make() → single object
collection() → list of objects

4. Loading Relationships with Resources

Example: User has one Profile
User.php

public function profile()
{
    return $this->hasOne(Profile::class);
}

Profile.php

public function user()
{
    return $this->belongsTo(User::class);
}

Create ProfileResource

php artisan make:resource ProfileResource

class ProfileResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'bio' => $this->bio,
            'twitter' => $this->twitter,
        ];
    }
}

Include Profile in UserResource

use App\Http\Resources\ProfileResource;

class UserResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'profile' => new ProfileResource($this->whenLoaded('profile')),
        ];
    }
}

Controller:

public function show($id)
{
    $user = User::with('profile')->findOrFail($id);
    return UserResource::make($user);
}

Output:

{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com",
  "profile": {
    "bio": "Developer at Example",
    "twitter": "@johndoe"
  }
}

Without with(‘profile’) in controller:


{
  "id": 1,
  "name": "John Doe",
  "email": "john@example.com",
  "profile": null
}

Why use whenLoaded() ?

Prevents unnecessary DB queries (lazy loading)
Allows optional inclusion of relationships based on controller logic

5. Hiding Data with Resources

Let’s say we want to hide the user’s password and timestamps:

public function toArray($request)
{
    return [
        'id'   => $this->id,
        'name' => $this->name,
        // Email is optional
        'email' => $this->when(request()->user()->isAdmin(), $this->email),
    ];
}

You can also use:

when()
mergeWhen()
whenLoaded() for relationships

“Creativity is thinking up new things. Innovation is doing new things.”
-- Theodore Levitt

6. Best Practices

Use resources for APIs, not inside Blade views.
Keep transformations lightweight and readable.
Use nested resources for relationships.
Use whenLoaded() to avoid empty/null relationship issues.

“Success is the sum of small efforts, repeated day in and day out.”
-- Robert Collier

7. Interesting Facts

You can nest as many resource layers as needed. (Laravel API Resources - Nested Resources)
Can be reused between web and API if structured correctly. (Laravel API Resources Overview)
Works well with Laravel Pagination for out-of-the-box data/links/meta output. (Laravel Pagination with Resources)

8. FAQ’s

Q: Should I use Resources in internal tools?
A: Yes, if they’re API-driven. It keeps things consistent.

Q: Can I return extra metadata?
A: Yes:

return (new UserResource($user))->additional([
    'meta' => ['version' => '1.0.0']
]);

Q: Can I use a resource without a model?
A: Yes, you can wrap any array of data:

return JsonResource::make([
    'message' => 'Success',
    'data'    => [...]
]);

9. Conclusion

Laravel API Resources provide a powerful and clean way to structure JSON responses in APIs. They make your controllers leaner, your API more consistent, and your data transformation more manageable. Use them to deliver beautiful, reliable API output every time.

About the Author: Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more.

When to Use Gates, Policies, and the Spatie Permission Package in Laravel

Vatsal Acharya — Thu, 10 Jul 2025 11:48:57 +0000

“Good code is its own best documentation.”
— Steve McConnell

Key Takeaways

Learn what Gates, Policies, and Spatie Permission are.
Understand when to choose each.
See step-by-step examples.
Apply everything in one clear practical scenario.

Index

What is Authorization in Laravel?
When Should You Use Gates?
When Should You Use Policies?
When Should You Use Spatie Permission?
Example Code: Gates
Example Code: Policies
Example Code: Spatie Permission
Practical Example: A Blogging Platform
Stats
Interesting Facts
FAQs
Conclusion

1. What is Authorization in Laravel?

Authorization determines what a user can do — unlike authentication (who the user is).

Laravel provides:

Gates (simple closures to allow/deny actions)
Policies (classes that group rules for a model)
Integration with packages like Spatie Permission for advanced role and permission management.

2. When Should You Use Gates?

Use Gates when:

You need quick, simple checks.
Your rule doesn’t depend on Eloquent models.

Example:
“Is the user an admin?”
“Does the user have a verified email?”

3. When Should You Use Policies?

Use Policies when:

Your rules are about a specific model (like Post, Order, Product).
You want organized, reusable logic.

Example:
“Does this user own this post?”
“Can the user delete this order?”

4. When Should You Use Spatie Permission?

Use Spatie Permission when:

You want Role-Based Access Control (RBAC) or Permission-Based Access Control.
You need to manage roles and permissions dynamically (e.g., via an admin UI).
Your app has multiple user types (admins, editors, moderators, etc).

5. Example Code: Gates

How to define a Gate:

In AuthServiceProvider.php:

use Illuminate\Support\Facades\Gate;

public function boot()
{
  $this->registerPolicies();
  Gate::define('access-admin', function ($user) {
    return $user->is_admin;
  });
}

How to use:

In Controller:

if (Gate::allows('access-admin')) {
  // Allow
} else {
  abort(403);
}

In Blade:

@can('access-admin')
  <a href="/admin">Admin Dashboard</a>
@endcan

6. Example Code: Policies

Generate a Policy:

php artisan make:policy PostPolicy - model=Post

Define logic:

public function update(User $user, Post $post)
{
  return $user->id === $post->user_id;
}

How to use:

In Controller:

$this->authorize('update', $post);

In Blade:

@can('update', $post)
  <button>Edit Post</button>
@endcan

7. Example Code: Spatie Permission

Installation:

composer require spatie/laravel-permission

php artisan vendor:publish - provider="Spatie\Permission\PermissionServiceProvider"

php artisan migrate

Assign Roles & Permissions:

use Spatie\Permission\Models\Role;
use Spatie\Permission\Models\Permission;

$permission = Permission::create(['name' => 'edit articles']);
$role = Role::create(['name' => 'admin']);
$role->givePermissionTo('edit articles');
$user->assignRole('admin');

Usage:

In Controller:

if ($user->can('edit articles')) {
  // Allow
}

In Blade:

@can('edit articles')
  <button>Edit Article</button>
@endcan

8. Practical Example: A Blogging Platform

Let’s see the same scenario implemented with each method, so you get a side-by-side comparison.

Scenario
Users can create posts.
Each post has an author_id.
Only the author or an admin can delete a post.

“Your work is going to fill a large part of your life, so love what you do.”
— Steve Jobs

With Gates
Definition:

Gate::define('delete-post', function ($user, $post) {
  return $user->id === $post->user_id || $user->is_admin;
});

Controller:

if (Gate::allows('delete-post', $post)) {
  $post->delete();
} else {
  abort(403);
}

Blade:

@can('delete-post', $post)
  <button>Delete Post</button>
@endcan

With Policies
Generate Policy:

php artisan make:policy PostPolicy - model=Post

Define in Policy:

public function delete(User $user, Post $post)
{
  return $user->id === $post->user_id || $user->is_admin;
}

Controller:

$this->authorize('delete', $post);
$post->delete();

Blade:

@can('delete', $post)
  <button>Delete Post</button>
@endcan

With Spatie Permission
Setup:

composer require spatie/laravel-permission

php artisan vendor:publish - provider="Spatie\Permission\PermissionServiceProvider"

php artisan migrate

Assign Role and Permission:

$permission = Permission::create(['name' => 'delete posts']);
$role = Role::create(['name' => 'admin']);
$role->givePermissionTo('delete posts');
$user->assignRole('admin');

Controller:

if ($user->can('delete posts')) {
  $post->delete();
} else {
  abort(403);
}

Blade:

@can('delete posts')
  <button>Delete Post</button>
@endcan

“Software innovation, like almost every other kind of innovation, requires the ability to collaborate and share ideas.”
— Bill Gates

9. Stats

Spatie Permission >10 million downloads (Spatie Laravel Permission on Packagist)
Gates and Policies have been part of Laravel since version 5.1, first released in June 2015. (Authorization — Laravel 5.1)

10. Interesting Facts

Gates can be registered anywhere — but best in AuthServiceProvider.(Laravel Authorization Docs)
Policies auto-discovered by Laravel. (Laravel Policy Auto-Discovery)
Spatie Permission caches permissions (php artisan permission:cache-reset).(Spatie Laravel Permission Docs)

11. FAQs

Q: Can I mix Gates, Policies, and Spatie?
A: Yes — many projects use them together.

Q: Are Policies required for Spatie?
A: No — but you can combine them.

12. Conclusion

Here’s a recap:

Gates: Small, quick checks.
Policies: Organized model rules.
Spatie Permission: Powerful RBAC and permissions.

About the Author: Vatsal is a web developer at AddWebSolution. Building web magic with Laravel, PHP, MySQL, Vue.js & more. Blending code, coffee, and creativity to bring ideas to life.

DEV Community: Vatsal Acharya

Understanding Core React Hooks with Practical Examples

Key Takeaways

Index

Introduction to React Hooks

State Management Hooks

Context Hook

Effect Hooks

Ref Hooks

Performance Hooks

React 18 Transition Hooks

Utility Hooks

React 19 Form and Optimistic Hooks

Custom Hooks

Rules of Hooks

Stats

Interesting Facts

FAQ's

Conclusion

State Management in Vue 3 for Laravel Applications (Pinia Integration)

Key Takeaways

Index

Introduction to State Management in Vue 3

Why Pinia Is the Preferred Choice

Laravel + Vue 3 Application Architecture

Statistics

Core Concepts of Pinia

Practical Implementation: Authentication State with Laravel

Auth Store Example

Advanced Store Patterns

Interesting Facts

Best Practices

FAQ's

Conclusion

Laravel Prompts: Interactive CLI Made Simple

Key Takeaways

Index

Introduction to Laravel Prompts

Understanding Laravel Prompts Components

Statistics

Available Prompt Types

Practical Implementation: Database Seeder Generator

Prerequisites

Interesting Facts

Best Practices

FAQ's

Conclusion

Laravel Testing Made Simple with Pest: Write Clean, Readable, and Fast Tests

Key Takeaways

Table of Contents

What is Pest and Why Use It?

Getting Started with Pest in Laravel

Writing Your First Pest Test

The Expectation API: Readable Assertions

Testing Laravel Features with Pest

Advanced Pest Features

Parallel Testing for Speed

Migration from PHPUnit to Pest

Stats & Practical Insights

Interesting Facts

FAQs

Conclusion

MySQL Transactions & Data Integrity in Laravel

Key takeaways

Index

1 - Why transactions & ACID matter

2 - MySQL (InnoDB) specifics you must know

3 - Laravel 12 transaction API (reference + examples)

4 - Nested transactions & savepoints

5 - Locks: pessimistic vs optimistic

6 - Deadlocks, retries, and safe side-effects

7 - Common pitfalls & how to avoid them

8 -Testing transactions

9 - Advanced: distributed transactions & sagas

10 - Practical examples

11 - Stats

12 - Interesting facts

13 - FAQs

14 - Conclusion

Getting Started with Laravel API Resources for Clean JSON Responses In Laravel