Nice Tutorial to get started with APIs in Laravel.

Madhavendra DuttDec 1·6 min read

What is API?

An API — Application Programming Interface, is a computing interface that defines interactions between multiple software intermediaries. It is a way to programmatically interact with a separate software component or resource.

What is REST?

REST is an acronym for REpresentational State Transfer. This term was coined by Roy Fielding in 2000. It is an architecture style for designing loosely coupled applications over HTTP, that is often used in the development of web services.

REST defines 6 architectural constraints that make any web service a true RESTful API.

1. Client-server — By separating the user interface from the data storage, we improve the portability of the user interface across multiple platforms and improve scalability by simplifying the server components.
2. Stateless — Each request from the client to the server must contain all of the information necessary to understand the request, and cannot take advantage of any stored context on the server. Session state is therefore kept entirely on the client.
3. Cacheable — Cache constraints require that the data within a response to a request be implicitly or explicitly labeled as cacheable or non-cacheable. If a response is cacheable, then a client cache is given the right to reuse that response data for later, equivalent requests.
4. Uniform interface — By applying the principle of generality to the component interface, the overall system architecture is simplified and the visibility of interactions is improved.
5. Layered system — The layered system style allows an architecture to be composed of hierarchical layers by constraining component behavior such that each component cannot “see” beyond the immediate layer with which they are interacting.
6. Code on demand (optional) — REST allows client functionality to be extended by downloading and executing code in the form of applets or scripts. This simplifies clients by reducing the number of features required to be pre-implemented.

Now let’s jump into creating and consuming RESTful API in Laravel. I would recommend to read and implement Migration and data seeding & Creating Relationships before you dive into this tutorial.

Consumers of our API will be able to perform a few limited tasks. There would be the following endpoints:

API endpoints for the unauthenticated route

Related to category:

• Get all categories GET /categories
• Get all posts of a category GET /categories/{id}/posts

Related to the post:

• Get all posts GET /posts
• Get a post by ID GET /posts/{id}
• Get all comments on a post GET /posts/{id}/comments

Related to the author:

• Get details of an author GET /authors/{id}
• Get all posts by an author GET /authors/posts
• Get all comments by an author GET /authors/{id}/comments

Related to the tag:

• Get all posts of a tag GET /tags/{id}/posts

API endpoint for the authenticated route

Related to comment:

• Store user comment POST /comments/posts/{id}

You have to create API Resources, Controllers, and API Routes for the above-mentioned API endpoints.

Step 1: Let’s first create API Resources. To do so follow the below-mentioned steps (don’t forget to implement the Migration and Relationship part):

When building an API, you may need a transformation layer that sits between your Eloquent models and the JSON responses that are actually returned to your application’s users. Laravel’s resource classes allow you to expressively and easily transform your models and model collections into JSON.

Run the command php artisan make:resource CategoryResource. It will create CategoryResource in app\Http\Resources directory.

Open this file and return the desired data, eg. category_id in place of id. You can do a lot more than just masking the field names or number of fields to be returned like- we can return additional information with API, etc.

public function toArray($request)
{
 return [
  'category_id' => $this->id,
  'category_title' => $this->title,
  'category_color' => $this->color,
 ];
}// (Optional) Additional code is attached to the response
public function with($request){
 return [
  'version' => "1.0.0",
  'author_url' => "https://mditech.net"
 ];
}

The same way you have to create other required resources — CommentResource, PostResource, TagResource, UserResource, ImageResource, and VideoResource. Create these resources or check them out from the repository.

Step 2: The next activity is to create the required controllers. To do so follow the below steps:

Run the command php artisan make:controller Api\\CategoryApiController. It will create CategoryApiController in theapp\Http\Controllers\Api directory. Open that file and write the methods to perform actions.

public function index()
{
 $categories = Category::all();
 return CategoryResource::collection($categories);
}public function posts($id)
{
 $posts = Post::where('category_id', $id)->orderBy('id', 'desc')->paginate();
 return PostResource::collection($posts);
}

Here you created two methods index and posts inside CategoryApiController.

The index method will return all the categories wrapped inside CategoryResource.

The posts method will return all the posts belonging to a specific category wrapped inside PostResource.

The same way create the desired methods in CommentApiController, PostApiController, TagApiController, and UserApiController or checkout repository.

Step 3: The last step is to create routes for the API. Proceed to the routes directory and open the api.php file and create the API endpoints that will reference the methods created in CategoryApiController, CommentApiController, PostApiController, TagApiController, and UserApiController.

<?php
use App\Http\Controllers\Api\CategoryApiController;
use App\Http\Controllers\Api\CommentApiController;
use App\Http\Controllers\Api\PostApiController;
use App\Http\Controllers\Api\TagApiController;
use App\Http\Controllers\Api\UserApiController;
use Illuminate\Support\Facades\Route;Route::get('authors/{id}', [UserApiController::class, 'show']);
Route::get('authors/{id}/posts', [UserApiController::class, 'posts']);
Route::get('authors/{id}/comments', [UserApiController::class, 'comments']);
Route::get('categories', [CategoryApiController::class, 'index']);
Route::get('categories/{id}/posts', [CategoryApiController::class, 'posts']);
Route::get('posts', [PostApiController::class, 'index']);
Route::get('posts/{id}', [PostApiController::class, 'show']);
Route::get('posts/{id}/comments', [PostApiController::class, 'comments']);
Route::get('tags/{id}/posts', [TagApiController::class, 'posts']);
Route::middleware('auth:sanctum')->group(function () {
Route::post('comments/posts', [CommentApiController::class, 'store']);
});

Testing the API endpoints

Start the database and run php artisan serve command. Laravel development server will start on http://127.0.0.1:8000

Open Postman and test all routes defined in api.php, but make sure to append your route with /api/

To get all categories you should send a GET request to http://127.0.0.1:8000/api/categories

Now lets test authenticated route as well. There is only one authenticated route for storing comment of logged in user on a post.

We are using Laravel Sanctum for authentication and authorization. We will issue an API token and use that in Postman to authenticate the request.

Laravel Sanctum provides a featherweight authentication system for SPAs (single page applications), mobile applications, and simple, token based APIs. Sanctum allows each user of your application to generate multiple API tokens for their account. These tokens may be granted abilities / scopes which specify which actions the tokens are allowed to perform.

To issuse an API token we will run tinker command

php artisan tinker

It will now allow us to interact with the Laravel application from the command line. Here you need to create an API token for a user using createToken() method.

Copy plainTextToken, to be used in Postman.

Now open Postman and do the following:

• New POST request to http://127.0.0.1:8000/api/comments/posts
• In Authorization tab select Type as Bearer Token and paste the plainTextToken in Token text box.
• Then in Headers tab Key as Accept and Value as application/json.
• Then in Body tab select form-data radio button and in Key, Value write id — 159, comment — Testing some comment on post 159
• Now hit the send button and you will get back the newly created comment.

In this article, we have been able to build and consume (Consumer was Postman)RESTful API using Laravel. We covered the API Resource creation, API Controller creation, and tested Authenticated and Non-Authenticated API Routes.

The source code is available at Github for you to refer to.

Read the previous part, Creating Relationships of this tutorial.

Read the next part, Creating the Front End for Admin user.

Twitter: kotagin

GitHub: mdutt247

E-mail: m.dutt@mditech.net

• Laravel
• Laravel Api
• Laravel Sanctum
• Web Development

Madhavendra Dutt

Facilitator | Freelancer | Software Develop

Open in appSamson Omojola

WHAT WE’LL BE BUILDING

In this tutorial, you’ll learn how to use Laravel Lumen (version 8) to create REST APIs.

We’ll be creating a Lumen microservice that implements all the types of HTTP requests. Our microservice will help us manage users. So, from any frontend application we connect to our microservice, we should be able to:

– Create a new user (POST Request)

– Edit the details of a user (PUT Request)

– Request for the details of users (GET Request)

– Delete a user (DELETE Request)

Here’s a link to the GitHub repo of this project: Repo

Tools Required:

· You need to have PHP installed. The minimum PHP version that is compatible with Lumen 8 is PHP 7.3. If you have the latest XAMPP, WAMP, or LAMP installed, you should be good to go.

· You also need to have Composer installed. If you don’t have it, click here to get it.

Knowledge Required:

• Basic knowledge of Laravel will help you follow along.

Let’s Get Started!

Install lumen on your system by running the command below via a CLI:

composer global require “laravel/lumen-installer”

Next, in your CLI, navigate to the directory that you want your project to be located in and create a lumen project using the command:

composer create-project — prefer-dist laravel/lumen projectName

NB: Replace “projectName” with whatever you want to name your project.

Lumen comes with some boilerplate code; a simple template that we can build upon. If you want to take a quick look at it, run php -S localhost:8000 -t public via your CLI and run localhost:8000 in your browser. You should see something like this:

Now, let’s continue with creating our microservice.

The next thing we want to do is create a database for our microservice. This is where all the details of our users will be stored. There are a number of ways to do this. I’m going to stick with MySQL, and I’ll make use of PHPmyAdmin. Feel free to use whatever option you deem best.

Make sure your server is running(XAMPP, WAMP, or LAMP). Go to your browser and enter localhost/phpmyadmin. Create a new database and take note of the name you used.

Next, let’s add our database details to our lumen project, so as to connect both together.

Open the newly created lumen project with any code editor of your choice, navigate to the .env file, and update the name of the database, the username, and the password.

By default, the username should be “root” and there should be no password.

Now that our database is set, we can start working on the actual project. In this project, we’ll be making use of Laravel’s Eloquent and Facades classes. In Lumen, these classes come disabled, so we have to enable them ourselves. To do this, navigate to boostrap/app.php and uncomment the lines below:

//$app->withFacades();

//$app->withEloquent();

Now, your bootstrap/app.php file should look like this:https://omojolasamsonade.medium.com/media/68dd19d605319f97a4cb061e715cd5b4

We’ll be making use of Eloquent and Facades in our routes and controller files.

Now that we have that set up, let’s create our users table in the database we just created. Run the following command in your CLI:

php artisan make:migration create_users_table

Navigate to the migrations folder and open the newly created users migration file. This is where we decide what columns the users table should have.

Each user should have a first name, a last name, and an email address. So let’s go ahead and create columns for them.

$table->string(‘first_name’);

$table->text(‘last_name’);

$table->integer(‘email_address’);

Now, your users migration file should look like this:https://omojolasamsonade.medium.com/media/0caf4f7320a9f21e3159fbc2f5741ebf

To create the table, run the following command in your CLI:

php artisan migrate

Now that we’ve successfully created our users table, the next step is to create our User model. In Lumen, there’s no CLI command for creating models, so navigate to your app/Models folder, create a file and name it User.php. If you find a User.php file already created in that folder, just use that instead. Now, let’s map it to our database:

protected $fillable =[‘first_name’, ‘last_name’, ‘email_address’,];

It should look like this now:https://omojolasamsonade.medium.com/media/05657cd2cae8ab19b8e53a881583d282

Now we need to create the appropriate routes for our microservice. The code that will process API calls will be in a controller file named UserController. UserController will contain different methods for handling all the different HTTP requests, and each method will need a route pointing to it. The routes will serve as triggers for these methods. Every time they are called, the methods will be executed. We’ll be giving all the routes a common prefix “api/v1” (think of it as them all belonging to the same family).

Navigate to routes/web.php and add the needed routes:

$router->group([‘prefix’ => ‘api/v1’], function () use ($router) {

$router->post(‘users/add’, ‘UserController@createUser’);

$router->get(‘users/view/{id}’, ‘UserController@viewUser’);

$router->put(‘users/edit/{id}’, ‘UserController@updateUser’);

$router->delete(‘users/delete/{id}’, ‘UserController@deleteUser’);

$router->get(‘users/index’, ‘UserController@index’);

});

Your web.php should look like this:https://omojolasamsonade.medium.com/media/8ae6347853eb6a9604c797d0068e5403

(The comment above each route explains what the route does).

Now that our routes are set, we need to actually create that controller file with the methods we are referencing above. These methods will be in charge of handling our API calls and processing our requests.

Go to app/Http/Controllers and create a file named UserController.php

These are the methods we need:

Create New User

public function createUser(Request $request){

$user = User::create($request->all());

return response()->json($user);

}

update user details

public function updateUser(Request $request, $id){

$user = User::find($id);

$user->first_name = $request->input(‘first_name’);

$user->last_name = $request->input(‘last_name’);

$user->email_address = $request->input(‘email_address’);

$user->save();

return response()->json($user);

}

view user

public function viewUser($id){

$user = User::find($id);

return response()->json($user);

}

delete user

public function deleteUser($id){

$user = User::find($id);

$user->delete();

return response()->json(‘Removed successfully’);

}

list users

public function index(){

$user =User::all();

return response()->json($user);

}

Your User Controller should look like this:https://omojolasamsonade.medium.com/media/2d970a97395fe287e49e3d980da9c2e3

The first method createUser() allows you to create a new user.

The second method updateUser() allows you to update the details of an already existing user.

The third method viewUser() allows you to view the details of a user you created.

The fourth method deleteUser() allows you to delete a user from your database.

The fifth method index() allows you to list all the users you created.

Now, if a call is made to any of the routes in web.php, the corresponding method in UserController is triggered.

You can use Postman to make the http request. To do that, make sure your lumen server is running. Use this command to get it started: php -S localhost:8000 -t public

Next, fire up postman.

Let’s test createUser() first. Send this HTTP request via Postman: http://localhost:8000/api/v1/users/add

Create the required fields and supply them with values.

(Use the POST option)

You should get the details of the user you just created as a JSON response.

Next, let’s test updateUser(). We can edit the details of the user we just created. Send this HTTP request via Postman: http://localhost:8000/api/v1/users/edit/1

Supply the previously created fields with new values.

(Use the PUT option)

You should get the details you just entered back as a JSON response.

Next, let’s test viewUser(). We can view the details of the user we just created. Send this HTTP request via Postman: http://localhost:8000/api/v1/users/view/1

(Use the GET option)

You should get the details of the user you created back as a JSON response.

Next, let’s test deleteUser(). We can delete the user we just created. Send this HTTP request via Postman: http://localhost:8000/api/v1/users/delete/1

(Use the DELETE option)

You should get a success message back.

Lastly, let’s test index(). This will list out all the users we have in our database. Send this HTTP request via Postman: http://localhost:8000/api/v1/users/index

(Use the GET option)

BUILDING A CLIENT APPLICATION TO CONSUME THE API

Let’s create a very simple frontend application to consume the API we just created. A simple PHP application will suffice. Navigate to xampp/htdocs and create a folder for your frontend app. I’ll name mine “userfrontend”. Next, create a file in the folder and name it “index.php”.

Make sure your lumen microservice and your XAMPP are running.

We can use php’s curl function to make the API request, like this:

$url = ‘http://localhost:8000/api/v1/users/index’;

curl_setopt($curl, CURLOPT_URL, $url);

$data = curl_exec($curl);

Next, you convert the data to JSON format:

$decodeUsers = json_decode($data, true);

And lastly, loop through the data with a foreach loop and display each user’s data.

Now, if you go to your browser and run http://localhost/userfrontend, you should see the details of the users in your database.

Here’s a link to the GitHub repo of this project: Repo

• Laravel8
• Lumen
• Restful Api
• Laravel
• Rest

More from Samson Omojola