RFC: Allow Plugins to Specify a Relative Order

[ElMassimo]

Summary

Allow plugins to specify an order relative to another plugin using pre and post.

Basic Example

We can extend enforce or order from 'pre' | 'post' | null, to also support an object form: { pre?: string, post?: string }.

A plugin can then use enforce or order to specify that it should run before or after another plugin, by specifying their name:

{
  name: 'vuetify:import',
  enforce: { post: 'vite:vue' },
  async transform (code, id) {
      ...
  },
}

Rollup Proposal: hook specific

{
  name: 'vuetify:import',
  transform: {
    order: { post: 'vite:vue' },
    async handler (code, id) {
      ...
    },
  },
}

Motivation

Some plugins in Vite and Rollup need to run before or after a specific plugin (i.e. before or after the Vue or Svelte compiler transforms).

Currently, Vite and Rollup do not provide an explicit API or plugins to collaborate with each other explicitly.

As a result, userland plugins are resorting to hacks and workarounds to achieve a better UX.

With the proposed extension, plugins like Vuetify's could ensure that they always work as expected.

This would enable better compatibility between plugins that interact or extend each other, and result in a better user experience by removing the need to order plugins manually (in cases like these).

Alternatives

This problem is not new, has always existed in Rollup, and was partially mitigated by enforce in Vite, but it still exists.

As a result, there are different ways to workaround it, with varying degrees of UX and dependency on Vite's internals:

• Do nothing, which can result in incorrect behavior if placed in the wrong order by the user
• Actively check the order of plugins, and throw an error if it's in the wrong spot
• Use Vite's enforce pre or post, which works in simple cases, but can move the plugin earlier or later in the chain that it needs to be, and hides the dependency on a required plugin
• Hack the order of plugins relying on Vite's internals

Related Issues and RFCs:

• Allow using objects as hooks to change execution order rollup/rollup#4600
• https://github.com/vitejs/vite/discussions/9442

[lukastaegert]

I really like this proposal as it is very explicit in what your dependencies are (as opposed e.g. to the magic number proposal). But maybe

{ pre?: string[], post?: string[] }

instead to allow for having multiple dependencies?

One issue I foresee (that is not blocking) is that there is now the possibility to create impossible dependencies, which we need to handle in some way.

E.g. A has pre: "B" and B has pre: "A": In such a case we cannot order the plugins, the question is just, if we warn and continue without ordering or just throw.

There are more complex cases like this, but in the end, Rollup/Vite will basically need to create a directed graph of plugin dependencies and check if it has cycles. If not, we can order the plugins, otherwise we warn-and-ignore or throw. Following what has been done in rollup/rollup#4600, this could happen the first time a hook is run, after that the order would be cached.

There is another complexity hidden that we would need to figure out, imagine you have the following plugins:

• A has order: "pre"
• B has order: "post"
• C has pre: "A", post: "B"

Now we can resolve the dependencies, but we cannot satisfy the order attribute any more. Again, how to deal with this case?

In general my feeling is that all of these are edge cases that actually should not occur, but we need to handle them. Maybe just throwing is actually a good option.

[ElMassimo]

Hi Lukas! Thanks for providing feedback on this proposal!

Allowing to specify several dependencies makes sense (though I haven't seen cases like that in the wild yet).

Maybe just throwing is actually a good option

Agreed.

While it's possible that plugins specify order constraints that can't be fulfilled, it should be unlikely in practice.

In most cases, dependencies between plugins are one-way (Vuetify depends on Vue, Svelte AutoImport depends on SvelteKit).

Edge Cases

A has order: "pre", B has order: "post", C has pre: "A", post: "B"

This case seems unlikely in practice, so throwing an error makes sense. When plugins need to run between two other, the referenced plugins typically wouldn't have a custom order.

This might happen in the beginning, since Vite plugins are already using enforce:

A has no order, B has order: 'post' , C has post: "A", pre: "B"

It would desirable that it results in the [A, C, B] order.

After this proposal, some plugins will now have better tools to specify their real dependencies:

A has no order, B has post: 'A', C has post: "A", pre: "B"