Laravel Cursor Pagination

Sign in Get started

This episode is for members only

Sign up to access "Laravel Cursor Pagination" right now.

Already a member? Sign in to continue

Playing

03. Creating the posts API endpoint

Episodes

0%

Your progress

Total: 25m
Played: 0m
Remaining: 25m

Join or sign in to track your progress

01. Introduction and demo

02. Setting up Laravel with Vue

03. Creating the posts API endpoint

04. Fetching and displaying posts with pagination

05. Storing a post and breaking pagination

06. Fixing with cursor pagination

Transcript

00:00

Okay, let's go ahead and build out the endpoint for our posts that we're going to see on that timeline.

00:05

First thing that we're going to do is go ahead and make a model, of course, so that's going to represent the post, and we'll go ahead and generate a migration alongside this as well. So let's go ahead and open up the create posts table migration, and let's come down and just fill in maybe just the body. Let's say table and text, and of course,

00:26

we're going to go ahead and call this body, and we can just go ahead and migrate that straight up. Now, we didn't generate a factory, so maybe we can go ahead and do that separately. So let's go ahead and say make factory, and we'll pass in the model in here to preset that, and let's go ahead and actually give this a name, post factory. There we go, and let's head over to

00:52

that post factory just so we can generate out some fake data, and of course, at the moment, we just have a body, so this is pretty straightforward. We'll go ahead and use faker to generate out a sentence here of maybe just 20 words. Great, so if we head over to our database really quickly and have a look in here, of course, it's empty. Let's go ahead and fill

01:13

that up using the factory that we've just created. So to do this, we can run php artisan tinker, we can go ahead and reference the post model, reference the factory method on this, choose how many times we want to do this, and let's just say 20, and let's go ahead and create this out. That's going to go ahead and create all of them records for us in the database. Great,

01:35

so we've got a database full of data that we can start to play with, and to play with this, we want to go ahead and create an endpoint to output this data. So we'll go ahead and create out a controller in here, and let's call that post index controller. That will deal with showing out posts, and we'll register this over in the API routes, because remember, technically,

01:59

we're hitting an API endpoint from a client, although it is within Laravel. So let's get rid of everything in here, and let's just go ahead and create this out, slash posts. We'll hook that up to the post index controller, like so, and we're pretty much done. So if we open up our post index controller, at the moment, there's nothing in here, of course. Let's just go and create an invoke

02:21

magic method in here just to deal with this, and we'll just go ahead and not use a API resource for this. We'll just say post latest and get, just to dump that data out. Of course, we could add an API resource later if we wanted to structure that data in a much better way. Okay, so now we can come over to our app, and we can go over to API slash posts and see all of our

02:45

data. Great. So we've got 20 in here, but of course, that's not what we want to do. We want to paginate this and later cursor paginate it. So let's paginate this by 10, and what Laravel will automatically do is output the data wrapped in this data property just here, but it will also give you all of the pagination information as well.

03:04

Now, this isn't the way we want to do it. When we switch this over to cursor pagination, we'll see something slightly different. So we'll take a look at that a little bit later. Okay, so now that we have our endpoint with all of our data in, we can go ahead and hook this up to the client and see the problem we're going to get when we try and load more posts.

Episode summary

In this episode, we get hands-on and build the API endpoint for our posts feature—the backbone for showing posts on the timeline.

We start by creating the Post model and its migration so we have a database structure for our posts (just a simple body field for now). After that, we generate a factory for our posts, which lets us easily make some sample data. Using Laravel's Faker, we set it up to spit out dummy sentences for each post.

Next, we actually use that factory in Tinker to quickly fill the database with 20 fake posts. With a bunch of posts in there, it's time to set up the backend so our app can fetch them. We create a controller (PostIndexController) and register a route (/api/posts) in our API routes. Inside the controller, we add an __invoke method to get all the posts ordered by latest.

To check it all works, we hit the /api/posts endpoint and see our data show up. But one problem: we don't want all the posts at once, so we move to paginating the results (10 per page for now). Laravel automatically includes pagination info for us!

Lastly, we note that the current approach isn't perfect—we'll want to switch to cursor pagination soon. But for now, we've got a working endpoint and a foundation to build on as we tie this in to the client and tackle issues like loading more posts.

Episode discussion

No comments, yet. Be the first!