Build An Uptime Monitor with Inertia

Sign in Get started

This episode is for members only

Sign up to access "Build An Uptime Monitor with Inertia" right now.

Already a member? Sign in to continue

Playing

10. Enum endpoint frequencies

Episodes

0%

Your progress

Total: 4h 59m
Played: 0m
Remaining: 4h 59m

Join or sign in to track your progress

01. Introduction

01. Introduction and demo

02. A fresh Inertia project

02. Sites

03. Site and dashboard setup

04. Building the site selector dropdown

05. Making use of API resources

06. Setting the default site

07. Setting up Vue modals

08. Creating a site

03. Endpoints

09. Setting up endpoints

10. Enum endpoint frequencies

11. Creating the endpoint form

12. Storing an endpoint

13. Validating and authorizing endpoint stores

14. Normalizing the endpoint location

15. Displaying endpoints

16. Deleting endpoints

17. Toggling inline editing for endpoints

18. Applying a watcher to the endpoint form

19. Storing endpoint edits

04. Checking endpoints

20. Determining endpoints to check

21. Creating a job to perform a check

22. Making an HTTP request

23. Scheduling checks every second

24. Setting up the check relationship

25. Updating the job

26. Showing the last status

27. Expanded list of checks

28. The response body modal

29. Authorizing the endpoint details

30. Calculating uptime for endpoints

05. Queuing

31. Setting up queues

32. Queuing the endpoint check

06. Email notifications

33. Setting up email in Laravel

34. Site model email notification storage

35. Adding email addresses via the UI

36. Listing and deleting email addresses

07. Downtime notifications

37. Observing when to notify

38. Creating an endpoint down notification

39. Creating an endpoint recovery notification

40. Making the emails a bit friendlier

08. Extras

41. Deleting sites

42. Eager loading

43. Recovery notification bug

44. No sites fix and placeholder

Transcript

00:00

What we're doing with frequencies here is a really good candidate to introduce an enum. What this will allow us to do is create a class-like thing which has predefined values in

00:09

that we can use to access the values out of our database and transform them perhaps into a label, but also just make sure we have a predefined set of values that we can use through validation to put into the database. So if we head over to our database here, the reason that this works really nicely

00:25

is because under our endpoints, obviously our frequency is just an integer. So if we weren't validating this for any reason, obviously we could have any number in here and that would allow the user to choose something, but even if we were validating, it means that we have a really loose set of values that we could potentially put in here.

00:45

If we store these in an enum, they're all going to be in one place, which makes it much easier to update and also then transform these values into labels that we can use in the UI. Now, if that doesn't make any sense, don't worry at all. We're going to go through everything that we need to set up here.

00:59

So we're going to put this enum just in an enums directory. Of course, as your app grows, it's probably a good idea to structure this in a slightly different way, but this is fine for now. And we're going to call this endpoint frequency.

01:11

And let's go ahead and set this up. So the namespace here is now under app and enums. And let's go ahead and create this enum out. So rather than say class, we're going to actually say enum.

01:21

And we're going to, of course, give this a name endpoint frequency. And we need to type in this. So we need to tell this what the values of the enum are going to be. They can either be a string or they can be an integer.

01:33

In our case, it's going to be an integer because we know we're working with second values. So all we need to do here is set up all the enum values. And this is going to be a backed enum, which means that each of these values or each of these enum cases has a value.

01:48

So I'm going to choose this standard to call them one minute, for example. And we know that one minute is 60 seconds. So we can define as many of these as we want. And just think of these as the allowed options for your endpoint frequency.

02:03

Now, to make this a little bit easier, I'm going to go ahead and multiply each of these 60 seconds by how many minutes I want this to be. This just, for me at least, makes it a little bit more readable. So, for example, five minutes is going to be five times 60 seconds.

02:18

And we can just go down and create as many of these as we want to. So let's go ahead and say 30 minutes. And, of course, make that 30 times 60. And let's go ahead and say one hour.

02:29

And as we know, that's going to be 60 times 60. So that is our enum. We're going to add a little bit more to this later. But for now, that's all we need to do.

02:38

What we want to do now is go over to the create endpoints table. And we want to set the default based on this value. We don't need to do this. But it's a good idea to, every time we touch this frequency data, always refer to our enum.

02:51

So we're going to choose the one minute value here. And we're going to update this endpoint to use this as the default value. So let's go back over to here. Of course, we're going to go ahead and roll back our migration,

03:01

because we're going to be modifying this. And inside of default, let's look at how we get the value for one minute. So let's go ahead and use our endpoint frequency enum. And we're going to go ahead and say one minute.

03:14

In fact, let's make the default five minutes. I think that makes more sense. And then we're going to grab the value from that. So what we're saying now is, from this enum, grab five minutes

03:23

and grab the actual value you want from this. So now, if we go ahead and re-migrate this, let's head over to the database, look at the schema here. And you can see that, sure enough, the default has changed to 300.

03:36

So we're making use of our enum already to add in that default. And of course, we have all of these values, which we're eventually going to iterate through, show in our form, and also use these values to validate the data that's coming in when we create our endpoint.

Episode summary

In this episode, we're diving into how to use enums to handle endpoint frequencies in our app. Instead of using random integers for frequency values in our database, we set up an enum to keep things organized and consistent. This way, we have a central place where all possible frequency options (like 1 minute, 5 minutes, 30 minutes, etc.) are defined, making our code easier to maintain and less prone to errors.

We go through creating an EndpointFrequency enum, storing it in its own directory, and defining the different frequency options using seconds as values (for example, ONE_MINUTE = 60, FIVE_MINUTES = 5*60, etc.). This not only makes the code more readable, but it also helps when we need to display user-friendly labels in the UI or validate input.

After setting up the enum, we update our database migration for the endpoints table so that the default frequency value now comes from the enum—no more hardcoded magic numbers! We see how to reference the enum value for, say, five minutes, and use it as the default in the table.

By the end of this video, we’re already using our enum to power migrations and set defaults, laying the groundwork to use these values all over the app, whether it’s for validation or generating dropdowns in forms. If you’re new to enums, don’t worry—we go step by step and you’ll see just how useful this approach can be as your app grows.

Episode discussion

No comments, yet. Be the first!