Before / after

import { defineEventHandler, createError } from 'h3'
import { asValue } from 'awilix'
import { ZodError } from 'zod'
import { container } from '../../container'
import { buildCtx } from '../../ctx'
import { memberGuard } from '../../guards'
import { withAudit } from '../../audit'
import { ProjectsService } from '../../projects/projects.service'
import { createProjectSchema } from '../../projects/dto'

export default defineEventHandler(async (event) => {
  const ctx = await buildCtx(event)
  memberGuard(ctx) // guard, by hand
  try {
    return await withAudit(ctx, () => {
      // audit wrap, by hand
      const body = createProjectSchema.parse(ctx.body) // validate, by hand
      const scope = container.createScope() // request scope, by hand
      scope.register({ requestContext: asValue({ tenantId: ctx.tenantId, user: ctx.user }) })
      return scope.resolve<ProjectsService>('projectsService').create(body.name)
    })
  } catch (err) {
    if (err instanceof ZodError) throw createError({ statusCode: 400, data: err.issues }) // map, by hand
    throw err
  }
})

// Zero imports: the decorators/types AND your own MemberGuard / ProjectsService /
// createProjectSchema are all auto-imported (roost's runtime + the feature dir, like server/utils).
@Controller() // path defaults to the feature folder → /projects
@UseGuards(MemberGuard)
export class ProjectsController {
  constructor(private readonly projects: ProjectsService) {}

  @Post()
  // @Body(schema) injects the VALIDATED body as the argument (Nest-style). Bad input ->
  // ZodError -> 400 via the built-in filter, before this method runs. `dto` is typed by the DTO.
  create(@Body(createProjectSchema) dto: CreateProjectDto) {
    return this.projects.create(dto.name)
  }
}

import { createContainer, asFunction, Lifetime } from 'awilix'
import { ProjectStore } from './projects/projects.store'
import { ProjectsRepo } from './projects/projects.repo'
import { ProjectsService } from './projects/projects.service'

export const container = createContainer({ strict: true })

container.register({
  projectStore: asFunction(() => new ProjectStore(), { lifetime: Lifetime.SINGLETON }),
  projectsRepo: asFunction(
    ({ projectStore, requestContext }) => new ProjectsRepo(projectStore, requestContext),
    { lifetime: Lifetime.SCOPED },
  ),
  projectsService: asFunction(({ projectsRepo }) => new ProjectsService(projectsRepo), {
    lifetime: Lifetime.SCOPED,
  }),
  // a second feature → six more lines, by hand…
})

// No imports — Injectable / Scoped and the RequestContext type are auto-imported.
@Injectable() // SINGLETON
export class ProjectStore {}

@Scoped() // tenant-bound, per request (shorthand for @Injectable({ scope: 'scoped' }))
export class ProjectsRepo {
  constructor(
    private readonly store: ProjectStore,
    private readonly ctx: RequestContext,
  ) {}
}

@Scoped()
export class ProjectsService {
  constructor(private readonly repo: ProjectsRepo) {}
}