Is hookable adequate for sequential plugin systems?

[ChrisGV04]

Hi!

I'm building an internal ecommerce software for my company using Nuxt and Nitro. I'm planning on adding a plugin system to it that allows extending the behavior of the core.

I would like to add certain hooks for most core processes such as order:before-create and order:after-create to which plugins can hook into and either perform an action, or provide new data to override the core functionality.

Example

I install a GiftPlugin which will add a gift to every order above $100. To achieve this, I would have a POST /api/orders endpoint at the core of the system, and before saving the order to the database I would call the order:before-create hook with the core order data as an argument.

The GiftPlugin will add the gift product to the line items and return the new order data. The order returned by the plugin is the one that should be saved to the database.

Also, the core should allow multiple plugins to edit the order sequentially and each hook would receive the result from the previous plugin.

What I tried

I added a hook to my Nitro app called order:before-create and called it like this:

/** POST /api/orders */
export default defineEventHandler(async (event) => {
  const nitro = useNitroApp();

  // Create core order
  const coreOrder: Order = {
    /* Order fields... */
  };

  /** Before create hook */
  const orderData = await nitro.hooks.callHookWith(
    async (hooks, args) => {
      let hookResult: Order = args[0];

      for (const hook of hooks) {
        hookResult = await hook(hookResult);
      }

      return hookResult;
    },
    'orders:before-create',
    coreOrder,
  );

  // Save the order after hooks
  await orderData.save();

  // Other core functionality...

  return { id: coreOrder.id };
});

I would love to know if this is an adequate implementation of what I'm trying to achieve, if there's something I'm doing wrong or if hookable is even the right choice for something like this.

Thank you!