The good thing about API routes in XDS is that they are not GED by default. This is because in normal use cases we invoke APIs for doing something dynamic, so it would be bad if the API route handler doesn't execute because of some weird ging. As a demonstration, we create a simple route handler that exports a post method. As you can see, there is nothing dynamic about this code. It'll always return the same JSN payload. However, this will not be cd. As with all things caching, we need to build our application to validate our knowledge. Because caching is disabled during development with our production app running, we can verify

that this particular request is never going to get caged because every single time we send a new request, we get a new log on the console. In fact, the only method that you can even enable caching for is the HTP get. For this, we can use the route config options that we've also previously seen for page files. To start off, we create a new route handler and export a get method just like we did for the post and once more. There is nothing dynamic in this code. If you run a production application and invoke this method, you can see that it is executing every single time. There is no caching that is going to happen by default.

Let's duplicate a route into a new file. To demonstrate the full static option, we mark this new route file to be fully caged by exporting a variable called dynamic and setting its value to four static. This will turn this file into a static route and we can even verify it from the build output. You can see that this new route that we created is static, whereas the previous one without the four static option was considered dynamic. Let's verify this by running our production build. Now when we execute, you can see that we are not getting anything on the console because that function was only executed during bill time and the result was GD

and we are only getting the caged response. The other option related to caching that we've looked at is for incremental static regeneration, which is revalidate. We're setting the revalidate value over here to 10 seconds. So this route will be static initially, but after 10 seconds since the last response, it'll execute again to get an updated result. And we can see this in the build output as well. The route is originally static, but it has a revalidate time for 10 seconds. So if you test this route within the production build for application, the function will only execute if the last time it was invoked is more than 10 seconds ago.

So while that timeout hasn't expired, we make the request again and again and we get no log. But after the 10 seconds, we do get a log on the console. Note that if you put any of the methods other than get in a route file, then even the GET is not going to get ged. We know that right now the get within this file is going to be GED because we are marking it as for static. However, if you export a post method from the same file, then the whole route is marked as dynamic and even the get is no longer caged. And we can verify this from the production builder of our application. We know that other methods like post

and put on a caged, which is why whenever we call them we see a new log on the console. But because we put this post in the same file as the get even the get is not going to be caged. So when we invoke the get, we see you a new log on the console for every invocation to get around this, you can put your caged, get handlers in separate routes than your other handlers.