Run side effects when entities are updated/deleted

[m1212e]

Question

Hi, I'm writing a system where my entities are closely coupled to entities in another external system which I can access through API calls. I need to partially mirror the data in my system to the external system. So for every created entity in my db I need to make a creation call, for every deletion the same etc.
Since there are some cool database features like cascading or batch delete I was wondering if prisma allows for some kind of side effects to simplify this procedure and prevent gaps in "coverage" so it's harder to forget any necessary calls.
I'd be thankful for general adivce on how to implement something like this with prisma and especially any tricks on how to do something like this with prisma. I was considering something like a repository pattern but I'm not sure if this is the best way to do this.

Thanks a lot for you time!

How to reproduce (optional)

No response

Expected behavior (optional)

No response

Information about Prisma Schema, Client Queries and Environment (optional)

No response

[ludralph]

Hi @m1212e

Prisma does not directly support side effects or hooks that would allow you to automatically trigger API calls on database operations like create, update, or delete.

One way to do this is by using the repository pattern, as you mentioned. In this pattern, you would create a repository for each entity in your system. Each repository would contain the logic for interacting with the database using Prisma, as well as the logic for making the necessary API calls to the external system. For example:

class UserRepository {
  constructor(prismaClient, externalApiClient) {
    this.prisma = prismaClient;
    this.externalApi = externalApiClient;
  }

  async createUser(data) {
    // Create user in your database
    const user = await this.prisma.user.create({ data });

    // Make API call to external system
    await this.externalApi.createUser(user);

    return user;
  }

  async deleteUser(id) {
    // Delete user from your database
    await this.prisma.user.delete({ where: { id } });

    // Make API call to external system
    await this.externalApi.deleteUser(id);
  }

  // ...other methods for updating, finding, etc...
}

The UserRepository class encapsulates the logic for creating and deleting users. When you call createUser or deleteUser, it performs the operation in your database using Prisma and then makes the corresponding API call to the external system.
This approach ensures that the necessary API calls are always made when you perform database operations, and it keeps this logic centralized in one place, making it easier to manage and less likely that you'll forget to make a necessary call.

[m1212e]

Ok, thanks for the response. A thing I especially would wish for were actions on cascading events. I'll probably do repo pattern but things like automatic cascading deletions would have to be implemented manually this way. Would be a cool feature to have in prisma! Thanks for taking the time to respond!

[ludralph]

Hi @m1212e

Prisma does support cascading deletes at the database level, but triggering additional side effects like API calls would need to be handled in your application code. You can specify cascading deletes in your Prisma schema by using the onDelete: CASCADE option in your relation fields. This will automatically delete related records in your database when you delete a record. See the documentation on referential actions

[nikolasburk]

Hey @m1212e 👋

Just adding to what @ludralph has already mentioned, I think there are two other approaches that you can consider for this:

• Prisma Pulse: Pulse is able to capture all your database events in real-time and syncing data into other systems is one of its primary use cases.
• Prisma Client extensions: Client extensions allow you to hook into the query lifecycle and execute your own code before or after the query was sent to the database.