Welcome back! In your last lesson, you learned about services in Rails and how they help manage business logic. Today, we’ll build on that by discussing dependency management for service objects. Properly managing dependencies is crucial to building scalable and maintainable Ruby on Rails applications.

Dependency management refers to how different parts of your code rely on each other and get what they need to work. By managing these dependencies, you can make each part of your code more independent and easier to test. In Ruby on Rails, this involves managing instances of service objects in a way that avoids unnecessary duplication and ensures they can access their own dependencies.

To make the code more independent, follow these steps:

1. Service objects will always return a "response object" with a specific shape.
2. Service objects maintain their own dependencies.
3. Service objects should handle their own failure as well as surface the failures of any dependencies.

One way to manage dependencies is by using Rails initializers to create singletons for your services. This ensures that the same instance of a service is used throughout the application. Singletons are preferable in this case because they ensure consistency and reduce the overhead of creating multiple instances, making dependency management more efficient across an application.

First, let's define a simple logging service to illustrate:

Now, create an initializer to instantiate a singleton of LoggingService:

This config object makes the service accessible across the entire application.

Next, we'll use this singleton in a NotifierService that depends on LoggingService:

Here, we inject the singleton LoggingService instance from the Rails configuration. This ensures we are not creating a new instance every time.

Let's consider a more complex example where services have their own dependencies. Suppose we have a PaymentService that depends on LoggingService and a TransactionValidator:

First, define TransactionValidator:

Then, set up the initializer:

Now, let's create the PaymentService:

Finally, let’s use PaymentService within a controller. We’ll create a PaymentsController that initializes the service and uses it in an action method:

And update the routes in routes.rb:

As you can see, we have added a post route in the routes definition, mapping it directly to a controller action. When a POST request is made to /payments/create, it routes the request to the create method within the PaymentsController, which processes the request and renders the result.

Fantastic! You’ve just learned how to manage dependencies effectively in your Rails applications. In this example, we made the code independent by configuring singletons in initializers and injecting these dependencies into service objects, reducing redundancy and ensuring consistency. By making each service object handle its own dependencies and failures, we enhance the modularity, maintainability, and testability of our Rails application.

Excited to see how it all works in action? Let's move on to the practice section where you'll get to implement dependency management yourself. Keep up the great work!