Now the ice cream shop can receive and process orders, and with many customers coming in, it's easy to run out of stock. Let's find out how to handle this situation.

You need to add a service that checks the remaining ice cream and toppings every morning, sets the inventory status in the system, and automatically disables orders when the inventory is depleted.

First, let's create a Scalar to represent individual stock items. Think of a Scalar as a reusable data building block - like Lego pieces that can be combined into larger structures. Unlike a full Model that has its own database collection, a Scalar is embedded within other models. In our case, the Stock scalar will be used inside the Inventory model.

Use the CLI to generate the scalar structure:

Now define the Stock scalar with the item type and quantity tracking:

Let's understand the Stock scalar structure:

Add dictionary entries for the scalar. Notice how we reuse the topping translations from the icecreamOrder dictionary:

Now let's create an Inventory module to manage daily stock records. Think of this like the daily inventory sheet that a shop manager fills out each morning - it contains all the stock items and their quantities for that specific day.

Create the inventory module using the CLI:

Define the Inventory model with embedded Stock scalars:

Key features of the Inventory model:

Add dictionary entries with helpful error messages for inventory operations:

Now let's implement the core business logic for inventory management. Just like a real ice cream shop needs rules for using stock and refilling supplies, we need to encode these operations in our document and service layers.

First, define the document methods for stock operations and daily inventory generation:

Let's understand the key document methods:

Now create the service layer to expose these operations:

Now comes the magic - connecting the inventory system to our existing ice cream order flow. When a customer places an order, the system should automatically deduct the used ingredients from inventory. This is like how a real POS system updates stock counts in real-time as sales are made.

Inject the InventoryService into IcecreamOrderService and use the _preCreate hook to deduct stock:

Key aspects of this integration:

To allow the frontend to interact with inventory, we need API endpoints. Staff should be able to view today's inventory and refill stock when running low. Let's create the signal endpoints and frontend store.

Create the inventory endpoints:

Add dictionary entries for the endpoints:

Now create the frontend store to manage inventory state:

Now let's bring everything together in the UI. The customer-facing order form needs to check inventory and disable options that are out of stock. Staff also need a dashboard to monitor inventory levels and refill when needed. This creates a complete inventory management system!

First, update the order template to check inventory before displaying options:

Key features of the inventory-aware template:

Add the isInStock helper method to the Inventory constant:

Now let's create utility components for staff to refill inventory:

Create a visual dashboard showing stock levels with color-coded status indicators:

Add helper methods to the Stock scalar for status calculation:

Create a Zone component for real-time inventory monitoring:

Finally, put it all together in the main page with both inventory dashboard and order management:

In the next tutorial, we'll explore Insight - a powerful feature for aggregating and analyzing data across your models. This will allow you to create analytics dashboards and gain business intelligence from your ice cream shop data.