Build an E-Commerce Platform

Sign in Get started

This episode is for members only

Sign up to access "Build an E-Commerce Platform" right now.

Already a member? Sign in to continue

Playing

21. Caching the cart instance

Episodes

0%

Your progress

Total: 8h 42m
Played: 0m
Remaining: 8h 42m

Join or sign in to track your progress

01. Introduction and demo

02. Installing Laravel, Breeze and Livewire

03. Creating categories

04. Recursively displaying categories

05. Product model and migration

06. Showing a product

07. Product variation setup

08. Creating the product selector

09. Loading child variation dropdowns

10. Faking adding the final variation

11. Setting up product stock

12. Calculating variation stock levels

13. Adding product images with MediaLibrary

14. Creating the product gallery

15. Providing a fallback image

16. Adding media to product variations

17. Creating the cart model

18. Registering the cart service

19. Creating a cart session

20. Showing the cart in the navigation

21. Caching the cart instance

22. Adding items to the cart

23. Creating the notification component

24. Showing the user's cart

25. Outputting cart items

26. Showing variation specifics

27. Updating item quantity

28. Removing an item from the cart

29. Calculating the cart summary

30. Showing the category products page

31. Indexing products in Meilisearch

32. Hooking up products to categories

33. Building the product browser

34. Showing child categories

35. Indexing product variations for filtering

36. Outputting variations for filtering

37. Hooking up product filters with Livewire

38. Filtering products

39. Filtering by price

40. Adding global navigation search

41. Handling products that are not live

42. Price range category fix

43. Scaffolding the checkout page

44. Listing shipping options

45. Calculating the cart totals

46. Validating the account form

47. Validating the shipping form

48. Saving the shipping address

49. Selecting a saved shipping address

50. Fix shipping address error for non authenticated users

51. Redirecting if the cart is empty

52. Checking for quantity changes

53. Syncing if quantities have changed

54. Flashing a message when quantities have changed

55. Setting up for orders

56. Creating an order

57. Attaching variations to order

58. Reducing stock after ordering

59. Meilisearch filter query fix

60. Showing the order confirmation page

61. Attaching orders for registering guest users

62. Scaffolding the orders page

63. Filling in order variation details

64. Returning the order status

65. Detecting order status changes

66. Sending the order status change email

67. Sending an order confirmation email

68. Handling deleted cart records

69. Transferring the guest cart

70. Creating a presenter for the order status

71. Setting up Stripe

72. Creating and updating a PaymentIntent

73. The Stripe card form

74. Validating before payment

75. Submitting a payment

76. Checking for a successful payment

77. Handling Stripe client errors

78. Entangling Stripe customer data

Transcript

00:00

Okay, we're going to need to tweak this along the way with things like ego loading inside of our cart class, but for now, I'm going to go ahead and open up Laravel Debug Bar and check out the additional queries that we're making when we refresh this page.

00:13

Now, at the moment, it's actually not too bad. We have no duplicates. But let's say in several other locations on this page, we were reading cart data, which is highly likely. Let's just simulate this now by just copying and pasting this cart contents countdown.

00:29

A few times, of course, that's not what we want to do, but this is going to give us a really good idea as to what's happening. Now, just by duplicating that a few times, we've now added a huge amount of duplicate queries. Let's go all the way down and have a look at these. And you can see that pretty much every time we call that method,

00:46

we are re-grabbing out the cart from the database by the session UUID and all the variations as well. So this really isn't going to work. The more we use our cart on the same page, the more queries we are going to create. Now, the solution for this is to cache the cart instance that we have created here.

01:07

And by that, I don't mean cache this in some sort of store like Redis or memcached. I mean, just cache this inside of this class. Now, if we cast our mind back to when we created our cart service provider, we created this as a singleton. So what this means is we could just add this to a property inside of this class

01:28

and then check just here if we have that property filled with a cart model already and then return that instead of redoing the database lookup. So this is just a very simple way to cache something within a class. So to do this, at the same time as returning this,

01:45

we're also going to go ahead and set a property on this overall class called instance. So let's go up to the top and just add that in there. So protected instance, because we don't need to be able to grab the outside of here. And then down here, what we're going to do is add a check in to say,

02:01

well, if that instance already exists, this instance, then return, and that's not a method, then return this instance. So what's happening here is the first time around, this is going to be false. So we're not going to return this instance. That will be null. And the second time around, the instance would have been set as well as being returned.

02:25

So next time we make a call to, for example, contents count, and we access the instance here, that will return to us the cached version directly within this class. Let's go over and see the difference with this very simple change. So I'm going to give that a refresh. And there we go. We are back to eight queries.

02:44

We're only doing that lookup once now. We can use this as many times as we want, and that value will always be cached inside of here. Let's finish up by just going over to our navigation, getting rid of all of these. And that's a very simple way to cache a model we've already looked up.

Episode summary

In this episode, we dig into one of those sneaky performance issues that often happens: making lots of duplicate database queries when reading cart data multiple times on the same page. We use Laravel Debug Bar to check out the extra queries and then intentionally simulate a situation where the cart data is accessed several times.

After duplicating our cart code a few times, it's obvious we're re-fetching the cart from the database over and over, which is super inefficient. To fix this, we don't reach for an external cache like Redis; instead, we cache the cart inside our class by storing it as a property. Because our cart service is a singleton in the service provider, this works perfectly.

With just a few lines of code, we make sure the cart model is only loaded from the database once per request, no matter how many times we call it. We double check with Debug Bar that duplicate queries are gone, and everything looks much better. We wrap up by cleaning up our navigation markup and confirming this is an easy win for performance!

Episode discussion

No comments, yet. Be the first!