Creating a Mini Blog API with Lithe and Eloquent

Step 1: Install Lithe

The first step is to install Lithe in your project. If you haven’t done that yet, simply run the following command in the terminal:

composer create-project lithephp/lithephp mini-blog-api

This command creates a new project using Lithe. Lithe automatically configures Eloquent for you, but we need to adjust some settings in the .env file to connect to the database.

Step 2: Configure the Database

Now, let’s configure the database. Open the .env file at the root of your project and edit the database settings. To use Eloquent ORM with MySQL, the settings should look like this:

DB_CONNECTION_METHOD=eloquent
DB_CONNECTION=mysql
DB_HOST=localhost
DB_NAME=lithe_eloquent
DB_USERNAME=root
DB_PASSWORD=
DB_SHOULD_INITIATE=true

Since Lithe automatically configures Eloquent, the next step is to ensure Eloquent ORM is installed. If you haven’t done so, run the following command to install Eloquent ORM:

composer require illuminate/database

After installation, Lithe will be ready to use Eloquent ORM and interact with the database. With that, the database is now correctly configured for our Mini Blog API!

Step 3: Create the Model and Migration for Posts

Now, let’s create the model and migration to define the posts table in our database.

First, create the Post model with the following command:

php line make:model Post

Next, create the migration for the posts table:

php line make:migration create_posts_table

The model and migration are now created. Let’s configure them.

Post Model

The Post model is located in src/models/Post.php. Edit the file like this:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // The table associated with the model
    protected $table = 'posts';

    // Fields that can be filled via mass-assignment
    protected $fillable = ['title', 'content'];

    // Use timestamps for created_at and updated_at
    public $timestamps = true;
}

In this code, we define the title and content fields as fillable, meaning they can be automatically populated when creating or updating a post.

Posts Table Migration

The generated migration will be located in src/database/migrations/{timestamp}_create_posts_table.php. Edit the migration to create the structure of the posts table:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Capsule\Manager as Capsule;

return new class
{
    public function up(): void
    {
         Capsule::schema()->create('posts', function (Blueprint $table) {
            $table->id(); // Creates the auto-incrementing id field
            $table->string('title'); // Creates the title field
            $table->text('content'); // Creates the content field
            $table->timestamps(); // Creates created_at and updated_at fields
        });
    }

    public function down(): void
    {
         Capsule::schema()->dropIfExists('posts');
    }
};

Here, we are creating the posts table with the fields id, title, content, and the date-time fields created_at and updated_at.

Step 4: Run the Migration

With the migration and model ready, let's run the migration to create the posts table in the database. Execute the following command:

php line migrate

This command will create the posts table in the database with the fields we defined in the migration.

Step 5: Create the Post Controller

Now, let's create a controller to manage the posts of the API. The controller will be responsible for handling HTTP requests and returning the data in an organized way.

To create the controller, execute:

php line make:controller PostController

This will generate a file in src/http/Controllers/PostController.php. Edit this file to include the CRUD (create, read, update, and delete) methods for the posts.

Here’s an example of how the PostController might look:

namespace App\Http\Controllers;

use App\Models\Post;
use Lithe\Http\Request;
use Lithe\Http\Response;

class PostController
{
    // List all posts
    public function index(Request $req, Response $res)
    {
        $posts = Post::all(); // Returns all posts
        return $res->json($posts);
    }

    // Show a specific post
    public function show(Request $req, Response $res)
    {
        $id = $req->param('id');

        $post = Post::find($id); // Find post by ID
        return $res->json($post);
    }

    // Create a new post
    public function store(Request $req, Response $res)
    {
        $data = (array) $req->body(); // Get data from request

        $post = Post::create($data); // Create a new post
        return $res->status(201)->json($post); // Return the created post with status 201
    }

    // Update an existing post
    public function update(Request $req, Response $res)
    {
        $id = $req->param('id');

        $data = (array) $req->body(); // Request data
        $post = Post::find($id); // Find post by ID

        if ($post) {
            $post->update($data); // Update post
            return $res->json($post);
        }

        return $res->status(404)->json(['message' => 'Post not found']);
    }

    // Delete a post
    public function destroy(Request $req, Response $res)
    {
        $id = $req->param('id');
        $post = Post::find($id);

        if ($post) {
            $post->delete(); // Delete post
            return $res->json(['message' => 'Post deleted']);
        }

        return $res->status(404)->json(['message' => 'Post not found']);
    }
}

Here, we have five basic methods:

index: Lists all posts.
show: Displays a specific post.
store: Creates a new post.
update: Updates an existing post.
destroy: Deletes a post.

Step 6: Define the API Routes

Now, let's define the routes for our post API. Open the file src/App.php and add the following code:

$app = new \Lithe\App;

$app->set('routes', __DIR__ . '/routes');

$app->listen();

The code above creates an instance of the Lithe app. The line $app->set('routes', __DIR__ . '/routes'); tells Lithe where to find the route files. Lithe will automatically load all files inside the src/routes folder. Each route file will be mapped to the URL based on its name. For example:

The file cart.php will go to the /cart route.
The file admin/dashboard.php will go to the /admin/dashboard route.

The line $app->listen(); makes Lithe "listen" for requests, i.e., it waits for incoming requests and directs them to the defined routes.

Now, create a file called posts.php inside the src/routes/posts folder to represent the /posts route and add the following code:

use App\Http\Controllers\PostController;
use function Lithe\Orbis\Http\Router\{get, post, put, delete};

get('/posts', [PostController::class, 'index']);
get('/posts/:id', [PostController::class, 'show']);
post('/posts', [PostController::class, 'store']);
put('/posts/:id', [PostController::class, 'update']);
delete('/posts/:id', [PostController::class, 'destroy']);

These routes connect the methods in PostController to the API URLs.

Step 7: Test the API

Now that everything is set up, you can test your API with tools like Postman or Insomnia. Here are the endpoints you can test:

GET /posts: Returns all posts.
GET /posts/:id: Returns a specific post.
POST /posts: Creates a new post.
PUT /posts/:id: Updates an existing post.
DELETE /posts/:id: Deletes a post.

Now, you've just created a Mini Blog API with Lithe and Eloquent ORM! Lithe automatically set up Eloquent for you, and we just made a few adjustments to the environment variables and created the necessary models and controllers. Now you have a complete RESTful API to manage blog posts.

For more information and details on how to use Lithe and Eloquent ORM, visit the official Lithe documentation here: Lithe Documentation.

Blog