1. Intro & Setup
Welcome to the Laravel API course! Get ready to dive into the exciting world of building APIs with Laravel, the powerful and flexible PHP framework.
15:57
2. Cleaning up Laravel
Ready to supercharge your Laravel project for an API-first approach? Let’s dive into optimizing and cleaning it up to make it lightning-fast and ultra-efficient!
16:19
3. Data Modeling
When building an API, mastering the art of structuring your data and defining dynamic relationships between various entities is absolutely essential in Laravel 11.
24:27
4. API Design
When you design an API, it’s absolutely crucial to understand that every API should have a meaningful purpose!
33:09
5. Authentication & Authorization
Say goodbye to the hassle of manually crafting every single detail, and say hello to a streamlined, efficient process that keeps your endpoints vividly documented and ready to go!
14:15
6. Rate Limiting
When it comes to managing API requests, rate limiting is a key player. You don’t want to open the floodgates and let users bombard your API with endless requests.
8:24
7. API Versioning
API versioning might sound like a minor detail at first, but trust me, it's one of those decisions that can make or break the future usability of your API.
22:22
8. Pagination
When you're handling requests that could return extensive lists of resources, it's essential to implement pagination to ensure your responses are manageable and user-friendly.
11:43
9. API Standards
API standards, while useful, aren’t the be-all and end-all. What often takes precedence is discoverability and consistency in your API design.
26:17
10. Handling Errors
Today, we'll explore how to leverage Laravel 11’s error handling system by implementing the API Problem Specification and enhancing it with custom packages to provide consistent, informative error responses.
26:49
11. Write Operations
Let’s explore the steps to manage resources in a Laravel 11 API, focusing on creating, validating, updating, and deleting resources. We’ll use a real-world approach to ensure clarity and usability.
29:30
12. Internationalization
In our previous video, we dove deep into handling write operations—everything from data validation and authorization to deciding between synchronous and asynchronous processing.
11:44
13. Caching Data
In our previous video, we dove deep into handling write operations—everything from data validation and authorization to deciding between synchronous and asynchronous processing.
18:08
14. Basic Security
When it comes to API security, think of it not as a threat but as an opportunity—a chance to build robust, multilayered defenses around your API.
9:53
15. Cache Requests
In Laravel 11, we can take advantage of built-in HTTP features to manage our cache more effectively, streamlining both the response time and the overall user experience.
8:40
16. Scheduling tasks & Sending requests
When working on a Laravel API, the task scheduling system plays a significant role in automating background jobs.
40:33
17. Notifications
Whether you're building a ping service or any application that requires user communication, you’ll likely need to notify users when certain actions occur, such as a service failure.
15:57
18. Monitoring and Logging
When you're developing APIs, it's important to have a clear picture of how your API is performing in real-time.
21:33
19. Testing
When you're developing APIs or any web-based product using Laravel 11, testing plays a crucial role in ensuring that your application behaves as expected.
18:01
20. API Platform
When it comes to building web applications, Laravel has long been a go-to framework for many developers. It's a robust framework, especially for full-stack applications.
17:16
21. Feature Flags
When it comes to building web applications, Laravel has long been a go-to framework for many developers. It's a robust framework, especially for full-stack applications.
11:05
22. Web Sockets
When you're working with APIs, there's a common misconception that WebSockets aren't relevant.
9:58
23. Search API
When you're building APIs, one key feature that often gets overlooked is search. That's what we’ll explore today using TypeSense(https://typesense.org/), a powerful open-source search engine.
15:30
24. Documenting your API
By default, API Platform will give you an OpenAPI specification (currently version 3.1). This standard format allows your API to be easily understood by machines and developers alike.
07:06
Write Operations
Let’s explore the steps to manage resources in a Laravel 11 API, focusing on creating, validating, updating, and deleting resources. We’ll use a real-world approach to ensure clarity and usability. If you haven’t already, check out the Laravel 11 Documentation for more in-depth information.
Creating Resources with Laravel 11
When building a Laravel 11 API, creating new resources efficiently and securely is important. Here’s a step-by-step guide to handling resource creation.
Setting Up the Store Request
To start, you need to create a form request that aligns with your API version. Let’s begin by generating a form request for storing resources.
php artisan make:request V1/Services/StoreRequest
Next, integrate this request into your controller:
use App\Http\Requests\V1\Services\StoreRequest;
public function store(StoreRequest $request): Response
{
// Your store logic here
}
Validating the Input
Define validation rules in your StoreRequest class to ensure data integrity.
For example:
public function rules(): array
{
return [
'name' => 'required|string|min:2|max:255',
'url' => 'required|url|min:11|max:255',
];
}
Handling the Request
In your controller, validate the request and store the resource:
public function store(StoreRequest $request): Response
{
$service = Service::query()->create($request->validated());
return new JsonResponse(new ServiceResource($service), Response::HTTP_CREATED);
}
Consider using background jobs for handling long-running processes. To do this, generate a background job:
php artisan make:job CreateServiceJob
And dispatch it:
CreateServiceJob::dispatch($request->validated());
Updating Resources
Updating resources follows a similar process. Let’s create an update request:
php artisan make:request V1/Services/UpdateRequest
Integrate it into your controller:
use App\Http\Requests\V1\Services\UpdateRequest;
public function update(UpdateRequest $request, string $id): Response
{
// Your update logic here
}
Validating Updates
Define validation rules that accommodate both partial and full updates:
public function rules(): array
{
return [
'name' => 'sometimes|string|min:2|max:255',
'url' => 'sometimes|url|min:11|max:255',
];
}
Handling the Update Request
Update the resource and dispatch a background job if needed:
public function update(UpdateRequest $request, string $id): Response
{
$service = Service::findOrFail($id);
$service->update($request->validated());
return new JsonResponse(new ServiceResource($service), Response::HTTP_ACCEPTED);
}
Deleting Resources
For resource deletion, ensure the user has permission to delete:
public function destroy(string $id): Response
{
$service = Service::findOrFail($id);
if (Gate::denies('delete', $service)) {
return new JsonResponse(['message' => 'Unauthorized'], Response::HTTP_FORBIDDEN);
}
$service->delete();
return new JsonResponse(['message' => 'Service deleted successfully'], Response::HTTP_ACCEPTED);
}
Implementing Background Jobs
Using background jobs helps keep your API responsive. To handle background jobs, create a job class:
php artisan make:job DeleteServiceJob
Inside the job class, use database transactions to ensure consistency:
public function handle(DatabaseManager $database): void
{
$database->transaction(
callback: function () {
// Perform the delete operation
},
attempts: 3,
);
}
Dispatch the job from your controller:
DeleteServiceJob::dispatch($service);