What is a service in Pinflow?

Services are the core of the application, they are responsible for interacting with the database (in the case of the monolithic architecture) and for providing an interface for the microservices to interact with the main application.

Why services?

Services are a very important part of the application, they allow for a clean separation of concerns, making the application easier to maintain and test. They also allow for a clear and consistent way to interact with the database and other services.

How do services work?

Services are simple interfaces that define a set of methods that can be called to interact with the database or other services. Each service is responsible for a specific part of the application, for example, there might be a UserService that is responsible for interacting with the user data in the database, or a ChatService that is responsible for handling real-time chat messages.

Here's an example of a simple service interface:

// UserService.ts
interface UserService {
  createUser(user: User): Promise<User>
  getUserById(id: string): Promise<User | null>
  updateUser(user: User): Promise<User>
  deleteUser(id: string): Promise<void>
}
 
// prisma.user.service.ts
class PrismaUserService implements UserService {
  async createUser(user: User): Promise<User> {
    // Create a new user in the database
  }
 
  async getUserById(id: string): Promise<User | null> {
    // Get a user by id from the database
  }
 
  async updateUser(user: User): Promise<User> {
    // Update a user in the database
  }
 
  async deleteUser(id: string): Promise<void> {
    // Delete a user from the database
  }
}

Dependency Injection

Services are created using the Dependency Injection (opens in a new tab) principle, which allows for easy testing and maintainability. The services are injected into the application at runtime, making it easy to swap out implementations or mock services for testing.

Here's an example of how we can inject a dependency into a service, in this case, we are injecting a prisma client into the UserService:

// prisma.user.service.ts
class PrismaUserService implements UserService {
 
    constructor(
      private prisma: PrismaClient
    ) {}
 
    async createUser(user: User): Promise<User> {
        // Create a new user in the database
 
        // Use the injected prisma client to create a new user
        const newUser = await this.prisma.user.create({
        data: {
            name: user.name,
            email: user.email,
            password: user.password,
        },
        })
    }
 
    async getUserById(id: string): Promise<User | null> {
        // Get a user by id from the database
    }
 
    async updateUser(user: User): Promise<User> {
        // Update a user in the database
    }
 
    async deleteUser(id: string): Promise<void> {
        // Delete a user from the database
    }
}

Conclusion

Services are a very important part of the application, they allow for a clean separation of concerns and provide a consistent way to interact with the database and other services. By following the Dependency Injection principle, services are easy to test and maintain, making the application more robust and scalable.

References

Dependency Injection, The Best Pattern (opens in a new tab) by CodeAesthetic on YouTube