Elysia derive / macro middleware composition breaks Eden typing (media: any)

[sh4vyar]

Hi 👋

I'm running into a TypeScript / Eden Treaty issue with Elysia when composing multiple middlewares (auth → tenant → membership).

Runtime behavior works correctly, but Eden completely loses type information and collapses the router to:

(property) media: any

I've tried multiple approaches and at this point I genuinely don't know what is causing Eden to break.

---

What I'm trying to achieve

• Optional auth on some routes
• Required tenant on most routes
• Required membership for tenant-scoped routes
• Full Eden typing preserved

---

Current implementation (using derive)

Auth middleware (optional session)

import { Elysia } from "elysia";
import { getSessionFromRequest } from "@app/auth/verify";

export const authMiddleware = new Elysia({ name: "auth" }).derive(
  { as: "scoped" },
  async ({ request, status }) => {
    const session = await getSessionFromRequest(request);

    if (!session) {
      return status(401, {
        success: false,
        message: "UNAUTHORIZED",
      });
    }

    return {
      auth: session,
    };
  },
);

Tenant middleware (depends on auth)

import { extractSubdomain } from "@app/utils/extract-subdomain";
import prisma from "@app/database/prisma";

export const tenantMiddleware = new Elysia({ name: "tenant" })
  .use(authMiddleware)
  .derive({ as: "scoped" }, async ({ request, status }) => {
    const requestSubdomain = extractSubdomain(request);
    const subdomain = request.headers.get("subdomain");
    const tenant = request.headers.get("tenant");

    if (!subdomain || !tenant) {
      return status(400, { message: "BAD_REQUEST" });
    }

    if (requestSubdomain !== subdomain || requestSubdomain !== tenant) {
      return status(403, { message: "TENANT_MISMATCH" });
    }

    const tenantRecord = await prisma.organization.findFirst({
      where: { slug: requestSubdomain },
      include: { members: true },
    });

    if (!tenantRecord) {
      return status(404, { message: "TENANT_NOT_FOUND" });
    }

    return {
      tenant: tenantRecord,
      subdomain: requestSubdomain,
    };
  });

Membership middleware (depends on auth + tenant)

export const membershipMiddleware = new Elysia({ name: "membership" })
  .use(authMiddleware)
  .use(tenantMiddleware)
  .derive({ as: "scoped" }, async ({ status, auth, tenant }) => {
    const member = await prisma.member.findFirst({
      where: {
        userId: auth?.user.id,
        organizationId: tenant?.id,
      },
    });

    if (!member) {
      return status(403, { message: "NOT_MEMBER" });
    }

    return { member };
  });

---

Where Eden breaks

As soon as I compose these middlewares in a router:

export const media = new Elysia({ prefix: "/media" })
  .use(authMiddleware)
  .use(tenantMiddleware)
  .use(membershipMiddleware)
  .get("/", ({ auth, tenant, member }) => ({
    auth,
    tenant,
    member,
  }));

Eden loses all typing (media: any).

If I remove any one of the middlewares, Eden typing works again.

---

Other things I tried

I also tried:

• Rewriting everything using macro + resolve
• Using guard({ auth: true }) instead of chaining .use()
• Making auth optional vs enforced
• Returning status() vs throwing errors

All of these resulted in the same Eden typing collapse.

At this point I'm not sure:

• Whether derive middlewares are allowed to depend on each other
• Whether returning status() from derive is Eden-safe
• Whether chaining .use() with derived context is supported at all
• Or whether this is a limitation / bug in Eden's type inference

---

Why I'm confused

The documentation shows:

• derive
• macro
• resolve
• beforeHandle
• .use() chaining
• .guard()

...but it doesn't clearly explain:

• Which patterns are Eden-safe
• Where enforcement vs data exposure should live
• Whether middleware dependency chains are supported

Different examples seem to imply different answers.

---

My question

Is this derive + chained .use() pattern fundamentally incompatible with Eden typing?

If so:

• What is the recommended way to compose auth → tenant → membership?
• Should this only be done with macros + guards?
• Is derive intended only for leaf-level context, not dependency chains?

Any clarification or official guidance would be really appreciated.

[barry166]

The first thing I would change is the plugin graph. Right now the same scoped plugins are mounted multiple times: tenantMiddleware already uses authMiddleware, membershipMiddleware uses both, and then /media uses all three again. That makes Eden merge the same context extensions repeatedly, which is a common way to end up with any once inference gets too complex.

Pick one composition direction and use each dependency once. For example, if your existing membershipMiddleware already includes auth + tenant, then the route should only mount that final middleware:

export const media = new Elysia({ prefix: '/media' })
  .use(membershipMiddleware)
  .get('/', ({ auth, tenant, member }) => ({ auth, tenant, member }))

Or split the plugins so authMiddleware, tenantMiddleware, and membershipMiddleware are standalone pieces, then compose them once in a single tenantMembership plugin. The important bit is not to have both the child plugins and the parent route re-.use() the same dependencies. Also export the type from the composed sub-app if the full app is large, since the Elysia docs recommend sub-app types as a way to keep Eden inference bounded.