DEV Community: Er Amit Gupta

🛡️ Say Goodbye to Spam: The Best Laravel Package for Disposable Email Detection

Er Amit Gupta — Thu, 12 Mar 2026 09:53:27 +0000

Building a great product is hard. Dealing with thousands of fake user accounts is even harder. If you’ve ever looked at your user database and seen emails like user@10minutemail.com or spam@trashmail.org, you know the frustration.

Temporary emails ruin your analytics, destroy your email deliverability, and abuse your free trials. That is why I built Laravel Disposable Email Detection—the ultimate shield for your Laravel applications.

💎 Why This is the Best Package for the Job

There are many ways to block emails, but this package is designed to be the most comprehensive and developer-friendly tool available.

🔥 1. Massive Database: 110,646+ Domains Included

Most validation rules only block a few hundred common domains. This package comes pre-loaded with an industry-leading list of 110,646+ known disposable domains. From the moment you run composer require, your app is protected by one of the largest blacklists on the market.

⚡ 2. Built for Performance (Caching)

Checking a list of 110k+ domains could slow down your signup process if done poorly. Our package includes Smart Caching support. Once the list is loaded, lookups happen in milliseconds, ensuring your user experience remains lightning-fast.

🔄 3. Auto-Sync: Never Go Out of Date

Spammers create new domains every single day. With a built-in Artisan command, you can automatically sync your local list with remote sources to stay protected against the latest temporary email providers.

🛠️ 4. Developer Experience (DX)

Whether you are a fan of clean controllers, custom rules, or Blade templates, we’ve got you covered:

Validation: Just add disposable_email to your rules.
Blade: Use @disposableEmail to show/hide UI elements.
Facade: Check emails anywhere in your logic with DisposableEmail::isDisposable().

🚀 Getting Started in 60 Seconds

Step 1: Install

composer require erag/laravel-disposable-email

Step 2: Validate

In your RegisterController or FormRequest:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

That’s it! Your application is now rejecting fake emails and keeping your database clean.

🎯 The Bottom Line

Don't let fake accounts mess up your business growth. Use a tool that is powerful, updated, and easy to use.

With 110,646+ domains blocked out of the box, this is the only protection your Laravel app needs.

Star the project on GitHub:

👉 eramitgupta/laravel-disposable-email

🛑 Stop Spam Signups: A Guide to Laravel Disposable Email Detection

Er Amit Gupta — Thu, 12 Mar 2026 09:38:11 +0000

Are your Laravel application's analytics being skewed by fake users? Are you tired of "10-minute mail" accounts abusing your free trials?

If you're a Laravel developer, you know the struggle of maintaining a clean user database. Disposable (temporary) emails are the primary tool for spammers and bots, leading to poor email deliverability and wasted resources.

Today, we’re looking at a powerful solution: the Laravel Disposable Email Detection package.

🧐 Why Should You Block Disposable Emails?

Disposable emails are temporary inboxes that expire after a short period. While they offer privacy for users, they create several headaches for developers:

Marketing Waste: You can't reach these users with newsletters or updates.
Trial Abuse: Users can infinitely sign up for free trials.
Data Integrity: Your "Total Users" count becomes a meaningless metric.
Domain Reputation: Sending emails to expired domains can hurt your SMTP sender score.

🚀 Introducing `erag/laravel-disposable-email`

This package is designed to be a "plug-and-play" solution for Laravel 10, 11, and 12. It comes pre-loaded with a massive blacklist and integrates seamlessly into your existing validation logic.

Key Features:

🔥 110,000+ Domains: Massive built-in database of known temporary providers.
🧠 Smart Validation: Add a simple rule to your Form Requests.
🌐 Auto-Sync: Keep your list updated with remote sources automatically.
⚡ Zero-Config: Works out of the box but remains fully customizable.
🧩 Blade Support: Includes a custom directive for frontend logic.

🛠 Quick Start Guide

1. Installation

Install the package via Composer:

composer require erag/laravel-disposable-email

2. Setup

Publish the configuration file to customize your blacklist or caching settings:

php artisan erag:install-disposable-email

This creates config/disposable-email.php.

💻 How to Use It

Validation in Controllers

The easiest way to use this package is within your validation array. Just add the disposable_email rule:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

Runtime Checks

Need to check an email manually in a Job or Service class? Use the Facade:

use DisposableEmail;

if (DisposableEmail::isDisposable('test@tempmail.com')) {
    // Take action against the spammer
}

Blade Directive

You can even use it directly in your views to show or hide content:

@disposableEmail('user@trashmail.com')
    <p class="text-red-500">Please provide a permanent email address.</p>
@enddisposableEmail

🔄 Keeping the List Fresh

Spammers are constantly creating new domains. This package makes it easy to stay ahead. You can sync the latest domain list with a single command:

php artisan erag:sync-disposable-email-list

You can even add your own custom domains by creating a .txt file in your storage folder—no coding required!

🎯 Conclusion

A clean database is a healthy database. By integrating Laravel Disposable Email Detection, you ensure that your community is built of real people with real mailboxes.

Ready to clean up your app?

Check out the GitHub Repository and give it a star! ⭐

🥊 The Ultimate Laravel + Inertia Localization Showdown: Why laravel-lang-sync-inertia Beats the Giants

Er Amit Gupta — Tue, 10 Mar 2026 12:13:39 +0000

If you are building a multilingual application with Laravel and Inertia.js, you need a way to share your backend PHP translations with your JavaScript frontend.

For years, developers have defaulted to the "industry standard" packages. But as Inertia.js has evolved, these legacy giants are starting to show their age. They are often bloated, framework-locked, or require frustrating build-step configurations.

Let’s put the most popular localization packages head-to-head against a powerful newcomer—Laravel Lang Sync Inertia—and see why it’s the ultimate choice for your next project.

🏗️ The Heavyweights: `vue-i18n` & `react-i18next`

These are the default, massive JavaScript internationalization libraries.

How they work: You have to manually export your Laravel translations to JSON, import them into your JS bundle, and set up a complex configuration file in your frontend.
The Problem: The Disconnect. They don't know Laravel exists. You are forced to write custom Artisan commands or build scripts just to keep your backend .php files and frontend .json files in sync. Plus, importing massive JSON dictionaries directly into your JS bundle drastically increases your frontend load time.

👑 The Popular Go-To: `laravel-vue-i18n`

This is currently one of the most popular packages for Laravel + Vue developers.

How it works: It uses a Vite plugin to automatically parse your Laravel translation files and inject them into your Vue app.
The Problem:
Framework Locked: As the name implies, it’s for Vue. If you are using React with Inertia, you are out of luck.
Global Loading: It typically loads your entire language directory into the frontend. If your app has thousands of translation keys, your user is downloading megabytes of text they don't even need for the current page.
Vite Plugin Complexity: Relying on Vite plugins can sometimes cause caching issues during development or complex CI/CD pipeline setups.

🚀 The Smart Alternative: `laravel-lang-sync-inertia`

If you are using Inertia.js, you don't need heavy Vite plugins or manual JSON sync scripts. You need a package that uses Inertia's native data-sharing capabilities intelligently.

Here is why Laravel Lang Sync Inertia is the superior package for this stack:

1. Granular, Page-by-Page Loading (Zero Bloat)

Instead of forcing the frontend to download your entire translation dictionary, you load only what is necessary for the current page right from your Laravel Controller.

public function checkout()
{
    // Only sends the checkout and payment translations to the frontend!
    syncLangFiles(['checkout', 'payment']);

    return Inertia::render('Checkout');
}

The Result: Lightning-fast page loads. Your Inertia payload stays incredibly small.

2. Built for Both Vue AND React

Why lock yourself into one framework? Whether your Inertia app uses Vue 3 or React, this package provides native-feeling companion hooks (vueLang() and reactLang()) that give you the exact trans() and __() helpers you are used to in Laravel Blade.

3. Pure Runtime Magic (No Vite Plugins Required)

Because it passes data securely through Inertia’s native props, you don't have to mess with your vite.config.js. It works out of the box. No background watchers, no complex build steps.

4. Need Static JSON? It Does That Too.

If you ever decide you want to use a heavy library like vue-i18n, this package includes a blazing-fast Artisan command (php artisan erag:generate-lang) that flawlessly compiles your PHP arrays into perfectly mapped JSON files.

📊 The Head-to-Head Comparison

Feature	`laravel-lang-sync-inertia` 🏆	`laravel-vue-i18n`	Standard `vue-i18n`
Framework Support	Vue & React	Vue Only	Vue Only
Prevents Payload Bloat	Yes (Granular Controller Sync)	No (Loads all via Vite)	No (Manual imports)
Requires Vite Plugins?	No (Pure Inertia)	Yes	No
Laravel `trans()` syntax	Yes	Yes	No (Uses `$t`)
Exports to Static JSON	Yes (Built-in Command)	No	N/A

🎯 Final Verdict

If you are building a pure SPA and want to manage translations entirely in JavaScript, the standard vue-i18n is fine.

If you want your translations injected via Vite and only use Vue, laravel-vue-i18n is a solid choice.

But if you want the absolute best performance, zero build-step configuration, multi-framework support, and the ability to load translations granularly on a per-page basis, Laravel Lang Sync Inertia is the undisputed winner.

Stop sending massive translation files to your frontend. Upgrade to smart syncing today.

👉 Get it on Packagist: composer require erag/laravel-lang-sync-inertia

👉 NPM Companion: npm install @erag/lang-sync-inertia

⭐ Star the Repo: GitHub - eramitgupta/laravel-lang-sync-inertia

🔁 Automatically Map Request Keys with Laravel Case Mapper Request

Er Amit Gupta — Tue, 29 Jul 2025 09:12:27 +0000

Handling inconsistent key naming from various frontends can be a real headache. Whether it’s camelCase, snake_case, StudlyCase, or even UPPERCASE — mismatched key formats often lead to unnecessary data transformation or validation errors.

Laravel developers, meet your new best friend:
Laravel Case Mapper Request — a zero-configuration Laravel package that automatically maps incoming request keys to match your backend validation rules using PHP 8+ Attributes.

🎯 Why You Need This

Modern APIs interact with various clients — React, Vue, Angular, mobile apps — all of which may send form data in different key formats. But your Laravel backend expects consistent keys, especially when using FormRequest validation.

Instead of writing custom logic to reformat input keys every time, let Laravel Case Mapper Request handle it automatically using clean, expressive attributes.

✨ Key Features

✅ Attribute-based key mapping using #[MapName(...)]
🔄 Supports multiple naming conventions: snake_case, camelCase, StudlyCase, UPPERCASE
🔧 Extensible with your own custom mappers
🎨 Works with any frontend (React, Vue, etc.)
📦 Zero configuration, zero hacks
🧩 Seamlessly integrates with Laravel's FormRequest

💡 Works with Laravel 10, 11, and 12 — no core modification required.

⚙️ Installation

composer require erag/laravel-case-mapper-request

That’s it. No config file, no publishing needed. You’re ready to go.

🧩 How It Works — In 3 Simple Steps

1. Create a Form Request

php artisan make:request ContactRequest

2. Add the Mapper Attribute & Trait

use LaravelCaseMapperRequest\Attributes\MapName;
use LaravelCaseMapperRequest\Traits\HasKeyTransformers;
use LaravelCaseMapperRequest\Mappers\SnakeCaseMapper;

#[MapName(SnakeCaseMapper::class)]
class ContactRequest extends FormRequest
{
    use HasKeyTransformers;

    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'first_name' => 'required|string',
            'last_name' => 'required|string',
            'email_address' => 'required|email',
        ];
    }
}

3. Use the Form Request in a Controller

class ContactController extends Controller
{
    public function store(ContactRequest $request)
    {
        $validated = $request->validated();

        // Example: Contact::create($validated);

        return response()->json([
            'message' => 'Submitted successfully!',
            'data' => $validated,
        ]);
    }
}

⚡ Frontend Example (Vue + Inertia)

Let’s say your frontend sends data in camelCase format:

<script setup>
import { useForm } from '@inertiajs/vue3'

const form = useForm({
  firstName: '',
  lastName: '',
  emailAddress: ''
})

function submit() {
  form.post('/form/snake')
}
</script>

📥 Incoming Request:

{
  "firstName": "Amit",
  "lastName": "Gupta",
  "emailAddress": "amit@example.com"
}

✅ Automatically Mapped To:

[
  'first_name' => 'Amit',
  'last_name' => 'Gupta',
  'email_address' => 'amit@example.com'
]

🔧 Built-in Case Mappers

Mapper	Input Format	Mapped Output
`SnakeCaseMapper`	`firstName`	`first_name`
`CamelCaseMapper`	`first_name`	`firstName`
`StudlyCaseMapper`	`FirstName`	`first_name`
`UpperCaseMapper`	`FIRSTNAME`	`firstname`

🛠️ Create Your Own Mapper

Need a custom casing logic like kebab-case?

Just implement the CaseMapperContract:

use LaravelCaseMapperRequest\Contracts\CaseMapperContract;

class KebabCaseMapper implements CaseMapperContract
{
    public static function map(array $data): array
    {
        return collect($data)
            ->mapWithKeys(fn($value, $key) => [Str::kebab($key) => $value])
            ->toArray();
    }
}

Then use it like this:

#[MapName(KebabCaseMapper::class)]

✅ Who Should Use This?

Laravel backend developers dealing with multiple frontend teams
Projects with mixed casing inputs (camelCase, snake_case, etc.)
APIs that require flexible, clean, and consistent request data
Teams looking to eliminate boilerplate request formatting logic

🧠 Final Thoughts

Laravel Case Mapper Request is a must-have for teams building robust APIs or multi-client Laravel apps. It simplifies input handling, reduces validation bugs, and keeps your code expressive and DRY — all using modern PHP 8+ attribute syntax.

No config. No hacks. Just clean input mapping.

📦 Install Now

composer require erag/laravel-case-mapper-request

📘 GitHub Repo → eramitgupta/laravel-case-mapper-request

🔗 Connect with the Author

Made with ❤️ by Amit Gupta

🐦 Twitter
💼 LinkedIn

⭐ Found it useful?

Give it a ⭐ on GitHub and help others discover it too!

Streamline Your Laravel API with Automatic Request Key Mapping

Er Amit Gupta — Wed, 23 Jul 2025 04:37:26 +0000

Building modern web applications often means dealing with the naming convention mismatch between frontend and backend systems. Your React or Vue frontend might use camelCase (firstName, emailAddress), while your Laravel backend expects snake_case (first_name, email_address). This disconnect creates friction in development and requires manual transformation logic that clutters your codebase.

Enter the Laravel Case Mapper Request package—a elegant solution that automatically transforms incoming request keys to match your validation expectations using PHP 8+ attributes.

The Problem: Frontend-Backend Naming Convention Conflicts

Modern frontend frameworks like React and Vue.js typically follow camelCase naming conventions:

const userData = {
  firstName: "John",
  lastName: "Doe", 
  emailAddress: "john@example.com",
  phoneNumber: "123-456-7890"
}

However, Laravel and PHP generally follow snake_case conventions:

$rules = [
  'first_name' => 'required|string',
  'last_name' => 'required|string', 
  'email_address' => 'required|email',
  'phone_number' => 'required|string'
];

Traditionally, developers solve this by manually transforming keys in controllers or middleware, leading to repetitive code and potential inconsistencies across the application.

The Solution: Attribute-Based Request Mapping

The Laravel Case Mapper Request package introduces a clean, declarative approach using PHP 8+ attributes. Simply annotate your FormRequest classes with the desired mapping strategy, and the package handles the transformation automatically.

Key Features

Zero Configuration: No config files to publish or core modifications required
Attribute-Based Syntax: Clean, declarative mapping using #[MapName(...)]
Multiple Case Formats: Support for camelCase, snake_case, StudlyCase, and UPPERCASE
Seamless Integration: Works directly with Laravel FormRequest validation
Extensible: Create custom mappers for specialized transformation logic
Framework Agnostic: Compatible with any frontend framework (React, Vue, Angular, etc.)

Supported Case Transformations

The package includes four built-in mappers to handle common naming convention scenarios:

Mapper Class	Input Format	Output Format	Use Case
`SnakeCaseMapper`	`firstName`	`first_name`	Frontend camelCase → Backend snake_case
`CamelCaseMapper`	`first_name`	`firstName`	Backend snake_case → Frontend camelCase
`StudlyCaseMapper`	`FirstName`	`first_name`	PascalCase → snake_case
`UpperCaseMapper`	`FIRSTNAME`	`firstname`	UPPERCASE → lowercase

Implementation Guide

Installation

Install the package via Composer:

composer require erag/laravel-case-mapper-request

No additional configuration or publishing steps required—the package is ready to use immediately.

Step 1: Create a Form Request

Generate a new FormRequest using Laravel's artisan command:

php artisan make:request ContactRequest

Step 2: Configure the Mapping

Add the required trait and attribute to your FormRequest class:

 'required|string|max:255',
            'last_name' => 'required|string|max:255',
            'email_address' => 'required|email',
            'phone_number' => 'nullable|string'
        ];
    }
}

The #[MapName(SnakeCaseMapper::class)] attribute tells the package to transform incoming camelCase keys to snake_case before validation.

Step 3: Use in Controller

Your controller remains clean and focused on business logic:

validated();

        $contact = Contact::create($validated);

        return response()->json([
            'message' => 'Contact created successfully!',
            'data' => $contact
        ], 201);
    }
}

Step 4: Frontend Implementation

Your frontend can maintain its preferred naming convention. Here's a Vue.js example using Inertia:













      Submit Contact





import { useForm } from '@inertiajs/vue3'

const form = useForm({
  firstName: '',
  lastName: '',
  emailAddress: '',
  phoneNumber: ''
})

function submitForm() {
  form.post('/contacts')
}

The Magic: Automatic Transformation

When the form is submitted, the package automatically transforms the request data:

Frontend sends:

{
  "firstName": "John",
  "lastName": "Doe", 
  "emailAddress": "john@example.com",
  "phoneNumber": "123-456-7890"
}

Backend receives for validation:

[
  'first_name' => 'John',
  'last_name' => 'Doe',
  'email_address' => 'john@example.com', 
  'phone_number' => '123-456-7890'
]

The transformation happens before validation, ensuring your validation rules work seamlessly with the expected key names.

Creating Custom Mappers

For specialized transformation requirements, you can create custom mappers by implementing the CaseMapperContract:

mapWithKeys(fn($value, $key) => [
                Str::kebab($key) => $value
            ])
            ->toArray();
    }
}

Then apply it to any FormRequest:

#[MapName(KebabCaseMapper::class)]
class ProductRequest extends FormRequest
{
    use HasKeyTransformers;

    // Implementation...
}

Advanced Use Cases

API Versioning

Different API versions might require different naming conventions:

// v1 API - snake_case
#[MapName(SnakeCaseMapper::class)]
class V1UserRequest extends FormRequest
{
    // ...
}

// v2 API - camelCase  
#[MapName(CamelCaseMapper::class)]
class V2UserRequest extends FormRequest
{
    // ...
}

Multi-Platform Support

Support different client platforms with varying conventions:

// Mobile app requests (camelCase)
#[MapName(SnakeCaseMapper::class)]
class MobileUserRequest extends FormRequest
{
    // ...
}

// Legacy system integration (UPPERCASE)
#[MapName(UpperCaseMapper::class)]  
class LegacyUserRequest extends FormRequest
{
    // ...
}

Performance Considerations

The package performs key transformation during the request lifecycle, specifically before validation. The overhead is minimal since it's a simple array key mapping operation using Laravel's efficient Collection methods.

For high-traffic applications, the transformation cost is negligible compared to database operations and other request processing overhead.

Benefits for Development Teams

Consistency Across Projects

Standardize how different naming conventions are handled across your Laravel applications.

Reduced Boilerplate Code

Eliminate repetitive key transformation logic in controllers and services.

Better Developer Experience

Frontend developers can use their preferred naming conventions without backend constraints.

Maintainable Codebase

Centralized transformation logic makes updates and changes easier to manage.

Type Safety

Works seamlessly with Laravel's validation system and IDE autocompletion.

Best Practices

Choose the Right Mapper

Select mappers based on your primary frontend framework:

React/Vue.js: Use SnakeCaseMapper to convert camelCase to snake_case
Legacy systems: Use UpperCaseMapper for UPPERCASE transformations
Mixed environments: Create custom mappers for specific transformation rules

Consistent Application

Apply the same mapping strategy across related FormRequests to maintain consistency in your API.

Documentation

Document your chosen naming conventions in API documentation to help frontend developers understand the expected formats.

Conclusion

The Laravel Case Mapper Request package solves a common pain point in modern web development by providing a clean, attribute-based solution for handling naming convention mismatches between frontend and backend systems.

By eliminating the need for manual key transformation and providing a declarative syntax, it helps teams maintain cleaner codebases while supporting flexible naming conventions across different platforms and frameworks.

Whether you're building a new Laravel API or refactoring an existing one, this package offers a zero-configuration solution that integrates seamlessly with Laravel's existing FormRequest validation system.

🚫 Stop Disposable Emails in Laravel: The Ultimate `laravel-disposable-email` Guide

Er Amit Gupta — Fri, 11 Jul 2025 07:02:47 +0000

Are you tired of spam or temporary emails like tempmail.com, 10minutemail.com, or mailinator.com messing up your Laravel application?

Let me introduce you to laravel-disposable-email – a lightweight yet powerful Laravel package that detects and blocks disposable email addresses using validation rules, runtime checks, Blade directives, and more.

✅ Already includes over 106,000+ disposable email domains – updated regularly!

🔍 Why Block Disposable Emails in Laravel?

Disposable or temporary email services are used to:

Bypass email verification
Spam your app with fake signups
Skew analytics and user data
Abuse trial-based services or coupons

By using this package, you can keep your user base clean and your analytics real.

⚙️ Key Features

✅ 106,000+ disposable email domains included
🧠 Smart validation rule (new DisposableEmailRule())
🧩 Blade directive: @disposableEmail(...)
💡 Runtime check using helper or facade
⚡ Optional cache support for high-performance
🔁 Auto-sync with open-source blocklists
🧠 Add your own custom domains without coding
🛠 Laravel 10, 11, and 12 support

🚀 Installation

composer require erag/laravel-disposable-email

Then publish the config and domain file:

php artisan erag:install-disposable-email

✅ How to Use in Laravel

🔒 1. Validate in Form Requests

Object Rule:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

$request->validate([
    'email' => ['required', 'email', new DisposableEmailRule()],
]);

String Rule:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

⚡ 2. Runtime Check

use DisposableEmail;

if (DisposableEmail::isDisposable('test@10minutemail.com')) {
    // Block or log user
}

🧩 3. Blade Directive

@disposableEmail('fake@mailinator.com')
    <p class="text-red-600">Disposable email detected!</p>
@else
    <p class="text-green-600">Looks good!</p>
@enddisposableEmail

🔄 Sync Disposable Domains

This package fetches updated disposable domain lists from trusted open-source sources like:

Update list manually with:

php artisan erag:sync-disposable-email-list

🧠 Add Your Own Domains (Custom Blacklist)

Just add domain names (one per line) to:

storage/app/blacklist_file/disposable_domains.txt

Example:

fakemail.org
trashbox.io
noemail.net

No commands needed — the package automatically reads them.

⚡ Enable Caching (Recommended for Performance)

In config/disposable-email.php, set:

'cache_enabled' => true,
'cache_ttl' => 60, // minutes

Clear cache if needed:

php artisan cache:clear

💻 Compatible With Laravel 10, 11, 12

Whether you’re using Laravel 10, 11, or 12, this package works flawlessly.

🔗 GitHub & Packagist

🔗 GitHub: eramitgupta/laravel-disposable-email
📦 Packagist: erag/laravel-disposable-email

🙌 Conclusion

If you're serious about stopping fake signups, improving user data quality, and securing your Laravel app, laravel-disposable-email is a must-have.

It’s simple, powerful, and ready to use in minutes. Install today and protect your application like a pro.

📢 Share this with your Laravel community

If you found this useful, give it a ⭐ on GitHub and share the package with your dev team or community. Every spam-free app makes the web better!

🌐 Easy Laravel Translation Sync for Inertia (Vue.js / React)

Er Amit Gupta — Mon, 19 May 2025 07:43:41 +0000

Laravel Lang Sync Inertia helps you add different languages to your Laravel app with Vue or React. It makes translations easy!

✨ Features

⚙️ Inertia.js integration with automatic sharing
📂 Load single or multiple language files
🔄 Dynamic replacement support in translations
🧩 Supports both Vue.js and React
🧵 Built-in middleware for automatic sharing
🛠️ Helper functions like trans() and __() for frontend usage
🌍 Automatically switches language folder based on current Laravel locale

📦 Installation

To install the package, run the following command via Composer:

composer require erag/laravel-lang-sync-inertia

🛠️ Publish Configuration & Composables

To publish the configuration and composables, run:

php artisan erag:install-lang

This will publish:

✅ config/inertia-lang.php — for customizing the language path
✅ resources/js/composables/useLang.ts — for Vue (if selected)
✅ resources/js/hooks/useLang.tsx — for React (if selected)

During installation, you'll be prompted to choose either Vue or React for your frontend framework.

🚀 Usage Guide: `syncLangFiles()`

The syncLangFiles() function is a Laravel helper provided by this package. Use it inside your controller methods to load translation files and automatically share them with your Vue or React frontend via Inertia.js.

✅ Think of syncLangFiles() as a bridge between Laravel’s backend translations and your Inertia-powered frontend.

🧪 How It Works

Suppose you have the following language file:

📁 resources/lang/en/auth.php

return [
    'welcome' => 'Welcome, {name}!',
    'greeting' => 'Hello!',
];

Now, you want to show auth.welcome and auth.greeting on the frontend using Vue or React.

🔁 Step-by-Step Example

🔹 1. Load Translations in Controller

use Inertia\Inertia;

public function login()
{
    // Load the auth.php language file
    syncLangFiles('auth');

    return Inertia::render('Login');
}

🧠 This loads the file resources/lang/en/auth.php based on the current Laravel locale and shares its content with Inertia.

💡 Frontend Usage

✅ Vue Example

<template>
    <div>
        <h1>{{ __('auth.greeting') }}</h1>
        <p>{{ trans('auth.welcome', { name: 'John' }) }}</p>
    </div>
</template>

<script setup>
import { useLang } from '@/composables/useLang'

const { trans, __ } = useLang()
</script>

✅ React Example

import React from 'react'
import { useLang } from '@/hooks/useLang'

export default function Login() {
    const { trans, __ } = useLang()

    return (
        <div>
            <h1>{__('auth.greeting')}</h1>
            <p>{trans('auth.welcome', { name: 'John' })}</p>
        </div>
    )
}

📤 Output on Page

When the above code is rendered, this will be the output:

Hello!
Welcome, John!

🧠 Notes on `trans()` vs `__()`

Function	Use Case	Description
`trans()`	Advanced	Use when you need to pass dynamic placeholders like `{name}`
`__()`	Simple	Shortcut for quick access to translated strings

✅ You can use them interchangeably for basic translations.
✅ Both support placeholder replacement.

🛠 Example with Plain String

Sometimes, you might want to append something without a key:

__('auth.welcome', 'Vue Developer')
// Output: "Welcome, {name}! Vue Developer" (if placeholder is not used)

But recommended usage is always with an object:

trans('auth.welcome', { name: 'Amit' })
// Output: "Welcome, Amit!"

📡 Access Inertia Shared Props

Vue:

import { usePage } from '@inertiajs/vue3'

const { lang } = usePage().props

React:

import { usePage } from '@inertiajs/react'

const { lang } = usePage().props

You can directly access the full language object shared by Inertia.

🗂️ Translation File Location

Language files are loaded based on the current Laravel locale. By default, Laravel uses resources/lang/{locale} structure:

resources/lang/
├── en/
│   └── auth.php
├── hi/
│   └── auth.php

When calling:

syncLangFiles('auth');

It dynamically loads resources/lang/{locale}/auth.php.

⚙️ Configuration

You can customize the language directory by modifying config/inertia-lang.php:

return [
    'lang_path' => lang_path(), // Default: /resources/lang
];

🧩 Composables Location

Vue: resources/js/composables/useLang.ts
React: resources/js/hooks/useLang.tsx

You can modify the location or structure of these files by adjusting the published files.

📄 License

This package is licensed under the MIT License.

🤝 Contributing

Pull requests and issues are welcome!
Let’s work together to improve localization in Laravel! 💬

The Best Laravel Disposable Email Detection Package for Your Projects

Er Amit Gupta — Sat, 26 Apr 2025 16:38:24 +0000

If you're developing a Laravel application that requires user registrations, you've likely encountered the issue of disposable email addresses. These temporary email services can lead to spam, fake accounts, and security concerns for your platform. Today, I'm excited to share what I believe is the best Laravel package for handling this common problem: Laravel Disposable Email Detection by Erag.

Why You Need Disposable Email Detection

Before diving into the package details, let's understand why detecting disposable emails matters:

Reduced Spam: Temporary emails are often used by spammers to bypass verification
Better User Quality: Real email addresses typically indicate more genuine user interest
Enhanced Security: Limiting disposable emails can reduce fraudulent accounts
Cleaner Database: Your user list contains higher quality, reachable contacts

Introducing Laravel Disposable Email Detection

The Laravel Disposable Email Detection package stands out for several reasons. Let's explore what makes it exceptional:

Impressive Domain Coverage

This package comes pre-loaded with over 106,580 known disposable email domains. That's an extensive database that will catch the vast majority of temporary email services right out of the box.

Flexible Implementation Options

What I particularly love about this package is its flexibility. You can integrate it into your application in multiple ways:

Form Request Validation

You can validate emails directly in your form requests using either a custom rule:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

$request->validate([
    'email' => ['required', 'email', new DisposableEmailRule()],
]);

Or use the simpler string-based rule format:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

Runtime Checking

For situations where you need to check emails programmatically during execution:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

if (DisposableEmailRule::isDisposable('test@tempmail.com')) {
    // Handle disposable email logic
}

Or via the provided facade:

use DisposableEmail;

if (DisposableEmail::isDisposable('agedmail.com')) {
    // Handle disposable email logic
}

Blade Directive Support

The package even includes a Blade directive for your views:

@disposableEmail('amit@0-mail.com')
    <p class="text-red-600">Disposable email detected!</p>
@else
    <p class="text-green-600">Valid email.</p>
@enddisposableEmail

Easy Installation and Setup

Getting started is straightforward:

Install via Composer:

composer require erag/laravel-disposable-email

Run the installation command:

php artisan erag:install-disposable-email

That's it! The package works with zero configuration, though you can customize it to your needs.

Regular Updates and Remote Sync

The package allows you to keep your disposable domain list up-to-date with a simple command:

php artisan erag:sync-disposable-email-list

This syncs with remote domain lists to ensure you're always protected against the newest disposable email services.

Custom Domain Blacklisting

Need to add your own disposable domains? The package makes this simple:

Create or edit storage/app/blacklist_file/disposable_domains.txt
Add your custom domains, one per line
No additional commands needed - it automatically detects your changes

Broad Laravel Compatibility

The package works with Laravel 8, 9, 10, 11, and 12, making it suitable for both older and the latest Laravel projects.

Real-World Implementation

In a recent project, I integrated this package to clean up our user registration process. Within the first month, we saw:

15% reduction in fake account creation
Improved deliverability of our marketing emails
Better overall engagement metrics from registered users

The implementation was seamless, and the performance impact was negligible despite the large domain database.

Conclusion

If you're looking for a disposable email detection solution for your Laravel project, this package offers the perfect combination of extensive domain coverage, flexible implementation options, and ease of use.

The ability to customize and extend the domain list makes it adaptable to your specific needs, while the simple validation rules make implementation a breeze.

For a clean, spam-resistant user database, I highly recommend giving the Laravel Disposable Email Detection package a try in your next project.

Have you implemented disposable email detection in your applications? What benefits have you seen? I'd love to hear about your experiences in the comments below!

Laravel PWA Master Guide: Build App-Like Experiences with Laravel in 5 Minutes

Er Amit Gupta — Sat, 26 Apr 2025 08:22:02 +0000

Introduction

In today's mobile-first world, Progressive Web Applications (PWAs) have revolutionized how users interact with websites. For Laravel developers looking to enhance user experience, PWAs offer the perfect solution by combining the best features of web and mobile applications. This guide will walk you through integrating PWA functionality into your Laravel projects using the powerful erag/laravel-pwa package.

What Are Progressive Web Applications?

Progressive Web Applications are websites that function like native mobile applications. They offer:

Offline Access: Users can access your application even without an internet connection
Fast Loading: PWAs load quickly, even on slow networks
Home Screen Installation: Users can add your app to their home screen
Native-Like Experience: Smooth transitions and responsive design

Why Add PWA to Your Laravel Project?

Enhanced User Experience: Provide a seamless, app-like experience
Increased Engagement: Users spend 40% more time on PWAs than on regular websites
Better Conversion Rates: PWAs have shown to increase conversions by up to 36%
Reduced Development Costs: Build once for all platforms instead of separate native apps
Improved SEO: Google ranks mobile-friendly websites higher

Getting Started with Laravel PWA Integration

Let's transform your Laravel application into a PWA with the erag/laravel-pwa package.

Step 1: Install the Package

Begin by installing the package via Composer:

composer require erag/laravel-pwa

Step 2: Run the Installation Command

Once installed, publish the PWA configuration files using:

php artisan erag:install-pwa

This command creates the necessary configuration files and sets up the PWA foundation for your application.

Step 3: Configure Your PWA

The installation creates a config/pwa.php file where you can customize all aspects of your PWA:

return [
    'install-button' => true, // Control visibility of the install button

    'manifest' => [
        'name' => 'Your App Name',
        'short_name' => 'App',
        'background_color' => '#6777ef',
        'display' => 'fullscreen',
        'description' => 'Your app description here',
        'theme_color' => '#6777ef',
        'icons' => [
            [
                'src' => 'logo.png',
                'sizes' => '512x512',
                'type' => 'image/png',
            ],
        ],
    ],

    'debug' => env('APP_DEBUG', false),
];

Step 4: Update Your Layout Files

To integrate PWA functionality, add the following Blade directives to your layout file:

In the <head> section:

@PwaHead

Before the closing </body> tag:

@RegisterServiceWorkerScript

Step 5: Update the Manifest

After customizing your configuration, update the manifest file:

php artisan erag:update-manifest

This generates a manifest.json file in your public directory.

Step 6: Add a Custom Logo

For the best user experience, add a custom logo:

Create a form with a file input field named "logo"
Process the upload with the provided utility method:

namespace App\Http\Controllers;

use EragLaravelPwa\Core\PWA;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;

class SettingsController extends Controller
{
    public function uploadLogo(Request $request)
    {
        $response = PWA::processLogo($request);

        if ($response['status']) {
            return redirect()->back()->with('success', $response['message']);
        }

        return redirect()->back()->withErrors($response['errors']);
    }
}

Advanced Configuration Options

Customizing the Install Button

You can control the visibility of the install button globally in the config file or conditionally in your views:

@if(auth()->user()->isPremium())
    @PwaInstallButton
@endif

Offline Page Customization

The package automatically generates an offline page. You can customize this by creating your own offline template in resources/views/vendor/pwa/offline.blade.php.

Service Worker Strategies

For advanced users, you can modify the caching strategies in the service worker file:

Publish the service worker template
Adjust caching rules for different file types
Implement custom fetch handlers

Testing Your PWA

Before deployment, test your PWA thoroughly:

Lighthouse Audit: Use Chrome's Lighthouse to audit your PWA
Offline Testing: Test functionality without an internet connection
Installation Flow: Verify the app installs correctly on various devices
Performance: Check loading times and responsiveness

Common Issues and Solutions

HTTPS Requirement

Issue: PWAs require HTTPS to function correctly.
Solution: Set up SSL certificates for your production environment. For local development, use Laravel Valet or Laravel Homestead which provide HTTPS support.

Service Worker Not Registering

Issue: The service worker fails to register.
Solution: Ensure the service worker path is correct and accessible. Check browser console for errors.

Manifest Not Found

Issue: Browser cannot find the manifest file.
Solution: Verify the manifest.json is in the public directory and properly referenced in your HTML.

Compatibility

The erag/laravel-pwa package supports:

Laravel 8, 9, 10, 11, and 12
All major browsers (Chrome, Firefox, Safari, Edge)
Mobile and desktop devices

Conclusion

Implementing PWA functionality in your Laravel application enhances user experience dramatically while potentially boosting engagement and conversion rates. With the erag/laravel-pwa package, this integration becomes straightforward, allowing you to focus on building great features rather than wrestling with PWA complexities.

Take your Laravel application to the next level by transforming it into a Progressive Web App today. Your users will thank you with increased engagement and loyalty.

Updated: April 2025 | Laravel PWA Implementation Guide

Laravel Disposable Email Detection: Block Temporary Emails and Improve User Verification

Er Amit Gupta — Sat, 26 Apr 2025 08:18:20 +0000

Why You Need to Block Disposable Email Addresses

Disposable email addresses present a significant challenge for web applications. These temporary email services allow users to register with throwaway addresses that expire after a short time, often leading to:

Increased spam in your application
Fraudulent accounts that bypass verification
Lost communication with users when emails expire
Reduced quality of your user database

Fortunately, Laravel developers now have an elegant solution with the Laravel Disposable Email Detection package by Erag.

What Makes This Package Stand Out

The Laravel Disposable Email Detection package offers a robust solution with several impressive features:

Massive Database: Contains over 106,580 known disposable email domains
Multiple Integration Methods: Form validation, runtime checking, and Blade directives
Auto-Sync Capability: Keeps your blacklist updated from remote sources
Custom Blacklisting: Easily add your own domains to block
Zero Configuration: Works out of the box with sensible defaults
Laravel Compatibility: Works with Laravel 8, 9, 10, 11, and 12

Installation and Setup (Quick Start)

Getting started with the package is straightforward:

1. Install via Composer

composer require erag/laravel-disposable-email

2. Publish the Configuration

php artisan erag:install-disposable-email

This creates a config/disposable-email.php file where you can customize the package's behavior.

Implementation Methods (with Code Examples)

Method 1: Form Validation Rules

The package provides multiple ways to validate email addresses in your forms:

Using the Custom Rule Object:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

$request->validate([
    'email' => ['required', 'email', new DisposableEmailRule()],
]);

Using String-Based Validation:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

Method 2: Runtime Email Checking

You can programmatically check email domains anywhere in your application:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

if (DisposableEmailRule::isDisposable('user@tempmail.com')) {
    // This is a disposable email - handle accordingly
}

Or use the convenient facade:

use DisposableEmail;

if (DisposableEmail::isDisposable('temporarymail.org')) {
    // Block registration, show warning, etc.
}

Method 3: Blade Directive for Templates

The package includes a Blade directive for conditional rendering:

@disposableEmail('support@example.com')
    <div class="alert alert-danger">
        This appears to be a disposable email address. Please use your primary email.
    </div>
@else
    <div class="alert alert-success">
        Email address accepted!
    </div>
@enddisposableEmail

Maintaining Your Disposable Email Database

Automatic Synchronization

Keep your disposable email list current by running:

php artisan erag:sync-disposable-email-list

This command fetches the latest known disposable domains from remote sources defined in your config file.

Adding Custom Domains

You can easily extend the blacklist with your own domains:

Navigate to storage/app/blacklist_file/
Create or edit disposable_domains.txt
Add domains (one per line):

   throwaway-domain.com
   temporary-mail.net
   fakeuser.org

Real-World Implementation Examples

User Registration Form

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

class RegistrationController extends Controller
{
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => ['required', 'email', 'unique:users', new DisposableEmailRule()],
            'password' => 'required|min:8|confirmed',
        ]);

        // Create user if validation passes
        $user = User::create($validated);

        // Continue with registration...
    }
}

Email Change Verification

public function updateEmail(Request $request)
{
    $request->validate([
        'new_email' => ['required', 'email', 'unique:users,email', 'disposable_email'],
    ]);

    // Process email change...
}

Configuration Options

The package is highly customizable through the config/disposable-email.php file:

return [
    'blacklist_file' => storage_path('app/blacklist_file'),

    'remote_url' => [
        'https://raw.githubusercontent.com/disposable/disposable-email-domains/master/domains.txt',
        'https://raw.githubusercontent.com/7c/fakefilter/refs/heads/main/txt/data.txt',
    ],
];

You can modify these settings to:

Change the location of your blacklist file
Add or modify remote sources for disposable domains
Customize validation error messages

Performance Considerations

The package maintains an optimal balance between accuracy and performance:

Uses efficient file caching for domain lists
Performs fast string comparisons for email validation
Minimal impact on application performance

Conclusion: Protecting Your Application's Integrity

Implementing the Laravel Disposable Email Detection package provides a powerful layer of protection for your application. By preventing disposable email registrations, you can:

Ensure reliable communication with your users
Reduce spam and fraudulent accounts
Maintain a higher quality user database
Improve overall platform security

Whether you're building a new Laravel application or enhancing an existing one, this package offers an elegant solution to the persistent problem of throwaway email addresses.

Installation Links

Packagist: erag/laravel-disposable-email
GitHub: eramitgupta/laravel-disposable-email

Best Laravel Disposable Email Detector Package (2025) — Block Temporary Emails Easily

Er Amit Gupta — Sat, 26 Apr 2025 08:17:28 +0000

Best Laravel Disposable Email Detector Package (2025)

Are you tired of fake or temporary email signups in your Laravel app?

Meet erag/laravel-disposable-email, the best Laravel package to detect and block disposable email addresses during form validation or runtime checks!

✅ Already covers 106,000+ disposable domains and supports Laravel 8, 9, 10, 11, 12.

🚀 Why You Need a Disposable Email Detection Package?

Disposable emails are used to bypass real email verification, spam systems, and create fake accounts.

Blocking them can:

Improve your user quality
Protect your platform from spammers
Reduce fake registrations
Maintain a clean email database

🌟 Why `erag/laravel-disposable-email` Is the Best Choice?

Here’s why developers love it:

🔥 106,580+ known disposable domains already included
🧠 Smart validation rule for quick integration
⚙️ Runtime checking via helper and facade
🧩 Blade directive for easy frontend conditionals
🌐 Auto-sync from trusted remote sources
✏️ Custom blacklist support (no coding needed)
⚡ Zero-configuration setup with artisan command
📦 Optimized for performance even with a huge domain list

📦 How to Install in Laravel?

Installation is super easy:

composer require erag/laravel-disposable-email

Then publish the configuration file:

php artisan erag:install-disposable-email

Done! 🎯

✅ How to Use It?

1. Form Request Validation

Use the custom rule:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

$request->validate([
    'email' => ['required', 'email', new DisposableEmailRule()],
]);

or use string-based validation:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

2. Check Directly at Runtime

use DisposableEmail;

if (DisposableEmail::isDisposable('test@tempmail.com')) {
    // Do something
}

3. Blade Directive (Frontend Condition)

@disposableEmail('amit@0-mail.com')
    <p class="text-red-600">Disposable email detected!</p>
@else
    <p class="text-green-600">Valid email.</p>
@enddisposableEmail

🔄 How to Sync Disposable Domain List?

You can manually update the disposable domain list anytime:

php artisan erag:sync-disposable-email-list

It will fetch fresh domains from trusted remote sources automatically.

🧩 How to Add Your Own Disposable Domains?

📌 No Coding Needed!

Just create a file:

storage/app/blacklist_file/disposable_domains.txt

and add domains like:

tempmail.com
fakemail.org
trashmail.io

Each line = one domain name.

The package will automatically detect your custom domains.

✨ Conclusion

If you are building a serious Laravel app in 2025,

blocking disposable emails is a must to ensure real, quality users.

With erag/laravel-disposable-email, you can easily:

Validate emails at registration
Prevent fake signups
Keep your system clean & secure

🚀 Install it today and protect your Laravel application in minutes!

🔗 Install Now:

👉 Packagist Link

👉 GitHub Repo

Laravel disposable email validation
Best Laravel package block disposable email
Laravel email validation temporary
Block temp email Laravel
Laravel fake email detector
Disposable email checker Laravel

Laravel Disposable Email Detection Package 2025

Er Amit Gupta — Sat, 19 Apr 2025 13:23:07 +0000

Laravel Disposable Email Detection

A Laravel package to detect and block disposable (temporary) email addresses during validation or runtime logic.

Already contains 106,580+ disposable email domains! 🔥

🚀 Installation

composer require erag/laravel-disposable-email

🛠 Configuration

Publish the config file:

 php artisan erag:install-disposable-email

This will create config/disposable-email.php.

⚙ Usage

1. Form Request Validation

✅ Custom Rule:

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

$request->validate([
    'email' => ['required', 'email', new DisposableEmailRule()],
]);

✅ String-based Rule:

$request->validate([
    'email' => 'required|email|disposable_email',
]);

2. Direct Runtime Check

use EragLaravelDisposableEmail\Rules\DisposableEmailRule;

if (DisposableEmailRule::isDisposable('test@tempmail.com')) {
    // Do something if email is disposable
}

Or via facade:

use DisposableEmail;

if (DisposableEmail::isDisposable('agedmail.com')) {
    // Do something
}

3. Blade Directive

@disposableEmail('amit@0-mail.com')
    <p class="text-red-600">Disposable email detected!</p>
@else
    <p class="text-green-600">Valid email.</p>
@enddisposableEmail

📦 Features

106,580+ known disposable domains out-of-the-box
Uses latest community sources
Supports auto-syncing from remote URLs
Custom validation rule
Facade and Blade support

🔄 Sync From Remote (Optional)

Update the list manually

php artisan erag:sync-disposable-email-list

🔗 Config Options (config/disposable-email.php)

return [
    'blacklist_file' => storage_path('app/blacklist_file),

    'remote_url' => [
        'https://raw.githubusercontent.com/disposable/disposable-email-domains/master/domains.txt',
        'https://raw.githubusercontent.com/7c/fakefilter/refs/heads/main/txt/data.txt',
    ],
];

✅ Note: The .txt files from remote_url must follow this format:

Each line should contain only a domain name, like:

0-00.usa.cc
0-30-24.com
0-attorney.com
0-mail.com
00-tv.com
00.msk.ru
00.pe
00000000000.pro
000728.xyz
000777.info
00082cc.com
00082dd.com
00082ss.com

If the file contains anything other than plain domains (like comments or extra data), it may cause parsing issues.

🧩 Add Your Own Disposable Domains

✅ Want to block additional disposable domains?

You can easily extend the list manually — no coding, no command required!

Step	Action
🔹 1	Go to the following path: `storage/app/blacklist_file/`
🔹 2	Create or edit this file: `disposable_domains.txt`
🔹 3	Add your custom domains like: `abakiss.com` `fakemail.org` `trashbox.io` (one per line)

📌 Important Notes:

Each line must contain only the domain name – no extra symbols, no comments.

The package will automatically detect and use the domains from this file.

You do not need to run any Artisan command. 🧙‍♂️

⚙️ Ensure File Path Matches Configuration

Your file path must match the one defined in config/disposable-email.php:

'blacklist_file' => storage_path('app/blacklist_file'),

If the path or filename is different, the package will not load your custom list. ✅

DEV Community: Er Amit Gupta

🛡️ Say Goodbye to Spam: The Best Laravel Package for Disposable Email Detection

💎 Why This is the Best Package for the Job

🔥 1. Massive Database: 110,646+ Domains Included

⚡ 2. Built for Performance (Caching)

🔄 3. Auto-Sync: Never Go Out of Date

🛠️ 4. Developer Experience (DX)

🚀 Getting Started in 60 Seconds

Step 1: Install

Step 2: Validate

🎯 The Bottom Line

🛑 Stop Spam Signups: A Guide to Laravel Disposable Email Detection

🧐 Why Should You Block Disposable Emails?

🚀 Introducing erag/laravel-disposable-email

Key Features:

🛠 Quick Start Guide

1. Installation

2. Setup

💻 How to Use It

Validation in Controllers

Runtime Checks

Blade Directive

🔄 Keeping the List Fresh

🎯 Conclusion

🥊 The Ultimate Laravel + Inertia Localization Showdown: Why laravel-lang-sync-inertia Beats the Giants

🏗️ The Heavyweights: vue-i18n & react-i18next

👑 The Popular Go-To: laravel-vue-i18n

🚀 The Smart Alternative: laravel-lang-sync-inertia

1. Granular, Page-by-Page Loading (Zero Bloat)

2. Built for Both Vue AND React

3. Pure Runtime Magic (No Vite Plugins Required)

4. Need Static JSON? It Does That Too.

📊 The Head-to-Head Comparison

🎯 Final Verdict

🔁 Automatically Map Request Keys with Laravel Case Mapper Request

🎯 Why You Need This

✨ Key Features

⚙️ Installation

🧩 How It Works — In 3 Simple Steps

1. Create a Form Request

2. Add the Mapper Attribute & Trait

3. Use the Form Request in a Controller

⚡ Frontend Example (Vue + Inertia)

📥 Incoming Request:

✅ Automatically Mapped To:

🔧 Built-in Case Mappers

🛠️ Create Your Own Mapper

✅ Who Should Use This?

🧠 Final Thoughts

📦 Install Now

🔗 Connect with the Author

⭐ Found it useful?

Streamline Your Laravel API with Automatic Request Key Mapping

The Problem: Frontend-Backend Naming Convention Conflicts

The Solution: Attribute-Based Request Mapping

Key Features

Supported Case Transformations

Implementation Guide

Installation

Step 1: Create a Form Request

Step 2: Configure the Mapping

Step 3: Use in Controller

Step 4: Frontend Implementation

The Magic: Automatic Transformation

Creating Custom Mappers

Advanced Use Cases

API Versioning

Multi-Platform Support

Performance Considerations

Benefits for Development Teams

Consistency Across Projects

Reduced Boilerplate Code

Better Developer Experience

Maintainable Codebase

Type Safety

Best Practices

Choose the Right Mapper

Consistent Application

Documentation

Conclusion

🚀 Introducing `erag/laravel-disposable-email`

🏗️ The Heavyweights: `vue-i18n` & `react-i18next`

👑 The Popular Go-To: `laravel-vue-i18n`

🚀 The Smart Alternative: `laravel-lang-sync-inertia`

🚀 Usage Guide: `syncLangFiles()`

🧠 Notes on `trans()` vs `__()`