Controllers should show type errors if a plugin is installed without the correct context.

[winstxnhdw]

I have the following controller.

  const controller = new Elysia()
    .decorate('env', null as unknown as Bindings)
    .use(grammy())  // no errors as expected

grammy relies on the env field within the Context.

export async function grammy() {
  return new Elysia()
    .decorate('env', null as unknown as Bindings)
    .derive(factory)
    .as('scoped');
}

However, if I were to remove decorate,

  const controller = new Elysia()
    .use(grammy())  // still no errors but may throw an error during runtime if `env` is never installed

TypeScript knows that grammY relies on a env decorator, so why can't Elysia use this information to check if the controller, at the point of installation, has the field installed?

[NongTham]

I think the issue comes from how Elysia’s plugin typing works today.

Right now, a plugin can add fields to the context (decorate, derive), but there’s no mechanism for a plugin to declare that it requires certain fields to already exist before installation.

In this case, grammy() internally expects an env field.
However, from TypeScript’s perspective, the plugin only augments context — it doesn’t specify any required context. Because of that, Elysia can’t statically verify whether the controller has installed env beforehand.

So even though grammY relies on Context['env'], there’s no type-level constraint in Elysia indicating:

.use(grammy()) // requires env to exist before installation

TypeScript has no way to enforce this because Elysia doesn’t expose a “required decorator” or “plugin dependency contract”.

In short:

• Elysia plugins can provide context.
• But they cannot declare dependencies on existing context.
• So TypeScript cannot warn when required fields are missing.

If Elysia eventually supports a type signature like:

asScoped<{ requires: { env: Bindings } }>()

or a similar dependency annotation, then TypeScript could catch this at compile time.
For now, missing decorators will only fail at runtime.

[winstxnhdw]

I think decorate and derive are the perfect constructs for Elysia to have bi-directional type awareness. The grammY framework is able to do this by propagating the updated context down the chain, and the user can ‘specify’ the dependencies via the plugin’s function signature. Would definitely like to see Elysia implement something like this. It seems to me that most things are already in place.