This page lists the TypeScript libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).

The test catalog also holds 19 look-alike cases for TypeScript: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.

Web frameworks and HTTP servers (the routes your code serves)

45 supported, 3 partly, 4 not yet.

Name Status Ways of using it that were tested
@adonisjs/core partly yes: router.get(path, handler) in start/routes.ts
no: router.resource('podcasts', Controller).only([...])
yes: router.group(() => {...}).prefix('/admin')
@analogjs/platform supported yes: src/server/routes/api/<path>.<verb>.ts: Analog API routes (Nitro), verb from the file name
yes: src/server/routes/api/<path>/[param].ts: a dynamic Analog API route, every verb
@angular/router supported yes: Routes array { path: 'quotes/:id', component }: client-side routes, NOT endpoints
@azure/functions (v3 programming model) supported yes: <FunctionName>/function.json with an httpTrigger binding: route (with {param}, {param:constraint}, {param?}) and methods, under host.json routePrefix (default api)
yes: function.json httpTrigger with no route: /api/<FunctionName>, the folder name
@azure/functions (v4) supported yes: app.http('name', { methods, route, handler }); served under /api
yes: app.get / app.post / app.put / app.patch / app.deleteRequest(name, handler or options): the verb is the call, the route is options.route or the name
@builder.io/qwik-city supported yes: src/routes/<path>/index.ts exporting onGet, onPost, ...: a Qwik City endpoint (only index files are routes)
yes: src/routes/<path>/[param]/index.ts: a dynamic Qwik City endpoint
yes: index.ts exporting onRequest: one handler for every method, here under a [...rest] folder
yes: src/routes/(group)/<path>/index.ts: a grouped folder is left out of the URL
@fastify/autoload supported yes: register(AutoLoad, { dir: 'routes' }): each folder's name prefixes the routes its plugin registers (dirNameRoutePrefix default true)
yes: routeParams: true: a folder named _param becomes :param in the prefix
yes: options: { prefix } on the AutoLoad registration, plus export const autoPrefix in the plugin file
@loopback/rest not yet no: lower-case @get('/x/{id}') and @post('/x') on methods
@nestjs/common partly yes: @Controller('prefix') class with @Get(), @Get(':id'), @Post()
yes: @Put(path), @Patch(path), @Delete(path) with stacked decorators
partly: app.setGlobalPrefix('api') in main.ts applies to every controller
partly: @Controller({ path, version }) with URI versioning
@oak/oak (Deno) supported yes: new Router().get().post() imported from jsr:@oak/oak
@react-router/dev (React Router v7 framework mode) supported yes: app/routes.ts config: route('api/stock/:sku', './api/stock.ts') and prefix('v2', [...]) name the path and the module
@react-router/fs-routes (React Router v7 framework mode) supported yes: app/routes.ts export default flatRoutes() and app/routes/<dotted>.ts resource routes (loader GET, action POST/PUT/PATCH/DELETE)
@remix-run/node supported yes: app/routes/<dotted.path>.tsx exporting loader (GET) and action (POST)
@remix-run/node (Remix v2) supported yes: a resource route: a route module with a loader and no default component, serving GET only
yes: <parent>._index.ts: the index route of a parent path
yes: <path>.$.ts: a splat route, params['*'] holds the rest of the URL
yes: layout.<path>.ts: a leading underscore segment is a pathless layout, left out of the URL
yes: <segment>
.<rest>.ts: a trailing underscore opts out of the parent layout; the underscore is not in the URL
yes: ($param).<path>.ts: an optional segment, matching with and without it
yes: [.] or [.ext] in a file name keeps a literal dot in the URL
yes: <path>/route.ts: a folder route; other modules in the folder are not routes
@solidjs/start supported yes: src/routes/<path>.ts exporting GET, POST, ... (no default component): a SolidStart API route
yes: src/routes/<path>/[param].ts: a dynamic SolidStart API route
yes: src/routes/<path>/[...rest].ts: a catch-all SolidStart API route, verb bound by export const GET = handler
yes: src/routes/(group)/<path>/[[optional]].ts: a group folder and an optional parameter; one function bound to two verbs
@sveltejs/kit supported yes: src/routes/<path>/+server.ts exporting GET/POST/DELETE (const or function)
yes: src/routes/<path>/[param]/+server.ts: a dynamic segment
yes: src/routes/<path>/[...rest]/+server.ts: a rest parameter, which may match zero segments
yes: src/routes/<path>/[[optional]]/...: an optional parameter in the middle of the path
yes: src/routes/(group)/<path>/+server.ts: a group folder is left out of the URL
yes: src/routes/<path>/[id=matcher]/+server.ts: a parameter with a matcher from src/params
yes: +server.ts exporting fallback: serves every method with no handler of its own
yes: +page.server.ts export const actions: form actions answer POST at the page's path (default) or ?/name
yes: +server.ts beside +page.svelte in one folder (content negotiation): GET with Accept text/html goes to the page, others to +server
@tanstack/react-start supported yes: src/routes/<path>.ts: createFileRoute('/path')({ server: { handlers: { GET, POST } } }); a file may also hold a component
yes: src/routes/<path>/$param.ts, $.ts splat and [.] escape in a server route
@tanstack/start (before the Vite move) supported yes: app/routes/api/<path>.ts: export const APIRoute = createAPIFileRoute('/api/path')({ GET, POST })
@trpc/server not yet no: t.router({ ns: t.router({ q: procedure.query(), m: procedure.mutation() }) }): GET /trpc/ns.q, POST /trpc/ns.m
astro supported yes: src/pages/<path>.ts exporting GET/POST APIRoute
yes: src/pages/<path>/[param].ts in server output: a dynamic endpoint; _file and _folder are excluded
yes: src/pages/<path>/[...path].ts: a rest parameter, which also matches the bare path
yes: src/pages/<name>.<ext>.ts: the output extension stays in the URL (feed.json.ts -> /feed.json), also after a parameter
AWS SAM template.yaml supported yes: Events: Type: HttpApi Properties: Path, Method; Handler names the export
aws-lambda (API Gateway v2) not yet no: switch (event.routeKey) { case 'GET /claims': ... }
bun (Bun.FileSystemRouter) supported yes: new Bun.FileSystemRouter({ style: 'nextjs', dir }) with router.match(req) in Bun.serve: Next.js-style file names under dir, no method chosen
Cloudflare Pages Functions supported yes: functions/<path>.ts exporting onRequest: every verb at the file's path
yes: exports onRequestGet, onRequestPost, onRequestPut, onRequestPatch, onRequestDelete, onRequestHead, onRequestOptions: the export name is the verb
yes: functions/index.ts serves / and functions/<dir>/index.ts serves /<dir>
yes: functions/<dir>/[param].ts: one segment, value in context.params
yes: functions/<dir>/[[param]].ts: matches any depth, params.param is an array
yes: _routes.json in the build output folder: exclude wins over include, an excluded path never reaches a function
elysia partly yes: new Elysia().get().post() chained
no: app.group('/prefix', app => app.get(...))
elysia-autoload supported yes: app.use(await autoload({ dir, prefix })): routes/<path>.ts default-exports (app) => app.get('', ...); [id].ts and [...].ts
Expo Router API routes (expo-router) supported yes: app/<path>+api.ts exporting GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS with web Request and Response
yes: app/<dir>/[param]+api.ts: one segment, passed as the second argument
yes: a (group) folder adds nothing to the URL
yes: app/<dir>/[...rest]+api.ts: catch-all
express supported yes: typed Router (Request<Params>, Response) mounted with app.use("/api", router)
express-file-routing supported yes: routes/<path>.ts exporting get, post, put, patch, del; mounted with app.use('/api', await router())
yes: a default export serves every method; [...path].ts is a catch-all (not the base path alone)
fastify supported yes: Fastify().withTypeProvider<T>().get(path, { schema }, h); fastify.post<{ Body }>(path, h)
fresh (deno.land/x/fresh, Fresh 1) supported yes: routes/<path>.ts: export const handler: Handlers = { GET, POST }
fresh (jsr:@fresh/core, Fresh 2) supported yes: routes/<path>.ts: export const handler = define.handlers({ GET, POST, ... })
yes: define.handlers((ctx) => ...): one function serves every method
yes: [...path] catch-all, [[optional]] parameter and (group) folder in Fresh routes
Gatsby Functions (gatsby) supported yes: src/api/<path>.ts default export handler(req, res): /api/<path>, every verb
yes: src/api/<dir>/index.ts: /api/<dir>
yes: src/api/<dir>/[param].ts: one segment, value in req.params
yes: src/api/<dir>/[...].ts (or [...name].ts): matches everything after the splat
h3 supported yes: createRouter().get(path, defineEventHandler(...))
hono supported yes: app.get/app.post(path, handler)
yes: app.route('/prefix', subApp)
yes: new Hono().basePath('/api').get(path)
honox supported yes: app/routes/<path>.ts: export default createRoute(...) serves GET
yes: app/routes/<path>.ts: export const POST = createRoute(...) and the other verbs
inversify-express-utils not yet no: @controller('/x') with @httpGet, @httpPost, @httpDelete
Netlify Edge Functions (@netlify/edge-functions) supported yes: netlify/edge-functions/<name>.ts default export with export const config = { path }
Netlify Functions (@netlify/functions) supported yes: netlify/functions/<name>.mts default export (req, context) with no config.path: /.netlify/functions/<name>
yes: export const config: Config = { path: '/x/:id', method: [...] }: the path replaces /.netlify/functions/<name>
yes: config.path as an array, with * wildcards and :named groups
yes: netlify/functions/<name>/index.mts or <name>/<name>.mts is function <name>; other files in the folder are helpers
Netlify Functions (@netlify/functions), Lambda-compatible supported yes: netlify/functions/<name>.ts exporting handler(event, context): served at /.netlify/functions/<name>, every verb
netlify.toml supported yes: [functions] directory = '<dir>': functions are read from that folder instead of netlify/functions
yes: [[redirects]] from = '/x/' to = '/.netlify/functions/<name>' status = 200: a rewrite to a function
yes: [[edge_functions]] path = '/x/
' function = '<name>': routes an edge function from config
next supported yes: app/<path>/[[...slug]]/route.ts: optional catch-all segment, also matches the bare folder path
yes: app/<path>/[...slug]/route.ts: catch-all segment in the app router
yes: app/(group)/<path>/route.ts: a route group folder is left out of the URL
yes: app/<path>/_folder/...: a private folder opts out of routing; %5Ffolder is the escape that keeps a literal underscore
yes: a route.ts handler in a child segment of a page, outside app/api; page.tsx, layout.tsx and proxy.ts are not endpoints
yes: route.ts with export const runtime = 'edge': an edge route handler
yes: a folder whose name holds a dot, app/rss.xml/route.ts, serves /rss.xml
yes: metadata route files app/sitemap.ts and app/robots.ts are special route handlers serving /sitemap.xml and /robots.txt
yes: src/app/<path>/route.ts: the app router placed under src/
yes: src/pages/api/<name>.ts: the pages router API placed under src/
yes: pages/api/<path>/[...slug].ts: catch-all API route, as NextAuth's pages/api/auth/[...nextauth].ts
yes: pages/api/<path>/[[...slug]].ts: optional catch-all API route, also matches the bare path
yes: app/ at the root and src/app both present: src/app is ignored
next (app router) supported yes: app/api/<path>/route.ts exporting GET/POST functions
yes: app/api/products/[id]/route.ts dynamic segment
next (pages router) supported yes: pages/api/<name>.ts typed NextApiRequest handler
nitropack (standalone Nitro) supported yes: a standalone Nitro app: routes/<path>.ts under srcDir (server/ here), verb from the file name
yes: a standalone Nitro app: api/<path>.ts served under /api
nuxt (nitro) supported yes: server/api/<name>.<verb>.ts default defineEventHandler: path and verb from the file name
yes: server/routes/<name>.ts: any verb, no /api prefix
yes: server/api/<path>/[id].get.ts: a dynamic segment with a verb in the file name; also two parameters in two folders
yes: server/api/<path>/index.post.ts: an index file with a verb serves the folder's own path
yes: server/api/<path>/[...slug].ts: a named catch-all, which also matches the base path
yes: server/api/<path>/[...].ts: an unnamed catch-all (params._)
RedwoodJS functions (@redwoodjs/api) supported yes: api/src/functions/<name>.ts exporting handler(event, context): served at /<name>
yes: api/src/functions/<name>/<name>.ts or <name>/index.ts: function <name>; other files there are not exposed
routing-controllers supported yes: @JsonController('/x') with @Get('/'), @Get('/:id'), @Post('/')
tsoa supported yes: @Route('x') class extends Controller with @Get('{id}') and @Post()
type-graphql supported yes: @Resolver class with @Query/@Mutation, served by Apollo on /graphql
Vercel Functions (@vercel/node), no framework supported yes: api/<name>.ts default export handler(req: VercelRequest, res: VercelResponse): path from the file, every verb
yes: api/<name>.ts exporting GET, POST, ... with web Request and Response: the export name is the verb
yes: api/<name>.ts default export { fetch(request) }: one handler for every verb
yes: api/index.ts serves /api and api/<dir>/index.ts serves /api/<dir>
yes: api/<dir>/[param].ts: a bracketed file name is one path segment, value in req.query
yes: api/<dir>/[...name].ts outside Next.js: still ONE segment, not a catch-all
yes: api/<name>.ts with export const config = { runtime: 'edge' }: same path rule as Node
vercel.json supported yes: rewrites: [{ source, destination: '/api/<fn>' }]: the source path is served by that function
yes: cleanUrls: true: a function is served without its extension; the extension form only redirects
yes: routes: [{ src: <regex>, methods, dest: '/api/<fn>' }]: regex source, optional verbs

The language's own HTTP server

0 supported, 0 partly, 3 not yet.

Name Status Ways of using it that were tested
Bun.serve not yet no: Bun.serve({ routes: { '/path': { GET, POST } } }) in TS
Deno.serve not yet no: Deno.serve(opts, handler) with new URL(req.url).pathname comparison
Deno.serve + URLPattern not yet no: new URLPattern({ pathname: '/x/:id' }).exec(req.url)

HTTP client libraries (the calls your code makes to other services)

10 supported, 8 partly, 8 not yet.

Name Status Ways of using it that were tested
@angular/common/http partly no: provideHttpClient(withInterceptors([...])) in app.config.ts (standalone bootstrap)
yes: class AuthInterceptor implements HttpInterceptor registered through HTTP_INTERCEPTORS (adds a header only)
@angular/common/http HttpClient not yet no: private http = inject(HttpClient) in a standalone component; this.http.put<T>(${environment.apiUrl}/path)
no: functional HttpInterceptorFn that puts environment.apiUrl in front of relative URLs; services call this.http.get<T>(relative)
no: NgModule app with HttpClientModule; service with constructor(private httpClient: HttpClient); get<T>(${environment.apiUrl}/x/${id}, { params })
no: constructor(private http: HttpClient); this.http.get<T>(${environment.x}/path)
no: this.http.post<T>(${this.base}/path, body) with the base in a class field
no: this.http.delete<T>(url with id)
@apollo/client supported yes: useQuery<T>(gql) and useMutation(gql) in a .tsx component, uri on the client in another module
yes: new ApolloClient({ uri }); client.query({ query: gql... })
@builder.io/qwik-city partly no: export const useX = routeLoader$(async () => fetch(...))
yes: server$(async function (...) { fetch(...) })
@nestjs/axios HttpService partly partly: this.httpService.get(url) wrapped in firstValueFrom
yes: this.httpService.axiosRef.post(url, body)
@reduxjs/toolkit (RTK Query) not yet no: createApi({ baseQuery: fetchBaseQuery({ baseUrl }), endpoints: b => ({ x: b.query({ query: () => 'path' }) }) })
@tanstack/react-query supported yes: useQuery({ queryKey, queryFn }) where queryFn calls fetch
yes: useMutation({ mutationFn }) where mutationFn calls axios.post
@trpc/client not yet no: createTRPCProxyClient({ links: [httpBatchLink({ url })] }); trpc.ns.proc.query()
axios partly no: export const http: AxiosInstance = axios.create({ baseURL: import.meta.env.X ?? default }); http.get<T>(path) in another module
partly: const api: AxiosInstance = axios.create({ baseURL }); api.get<T>(path)
ky supported yes: ky.get(url).json<T>()
yes: ky.create({ prefixUrl }) then api.post(relative, { json })
next partly partly: base URL from process.env.NEXT_PUBLIC_API_URL ?? default in a shared lib module
next (app router) partly partly: fetch(url, { next: { revalidate } }) in an async server component
next (middleware) not yet no: NextResponse.rewrite(new URL(path, backendOrigin)) in middleware.ts
next (next.config.js) not yet no: rewrites() returning { source, destination } that proxies to a backend
no: redirects() sending the browser to a backend URL
next (pages router) supported yes: export const getServerSideProps: GetServerSideProps = async () => fetch(...)
next (server actions) partly partly: 'use server' module exporting an async action that calls fetch
nuxt ($fetch in .vue) supported yes: $fetch(url, { method }) in a .vue function
nuxt (useFetch in .vue) not yet no: const { data } = await useFetch<T>(url) in <script setup lang="ts">
nuxt (useFetch in a composable) not yet no: useFetch(path, { baseURL }) in composables/*.ts
ofetch supported yes: ofetch(url, { method: 'DELETE' })
ofetch ($fetch, Nuxt) supported yes: $fetch(path, { baseURL })
openapi-fetch not yet no: createClient<paths>({ baseUrl }).GET('/path/{id}', { params })
react-router-dom supported yes: route object loader: async ({ params }: LoaderFunctionArgs) => fetch(...)
solid-js supported yes: createResource(fetcher) where the fetcher calls fetch
swr partly partly: useSWRMutation(url, fetcher with { arg }) in .tsx
yes: useSWR(url, fetcher): the key is the URL and the fetcher calls fetch(url)
vue (single-file component, lang ts) supported yes: axios.post in <script setup lang="ts">

The language's own HTTP client

2 supported, 1 partly, 5 not yet.

Name Status Ways of using it that were tested
astro (.astro page) not yet no: fetch in the --- frontmatter of a .astro page
EventSource (browser) not yet no: new EventSource(url) for server-sent events
fetch (browser) partly partly: fetch(${API}/path) in a function inside useEffect, base from import.meta.env ?? default
fetch (global) not yet no: async function http<T>(path, init) { fetch(${BASE}${path}, init) }; http<Fare>(/fares/${id})
navigator.sendBeacon (browser) not yet no: navigator.sendBeacon(url, data): a POST
svelte (component, lang ts) supported yes: fetch in <script lang="ts"> of a .svelte file
WebSocket (browser) supported yes: new WebSocket('ws://host/path')
XMLHttpRequest (browser) not yet no: xhr.open('POST', url); xhr.send(body)

gRPC

3 supported, 1 partly, 1 not yet.

Name Status Ways of using it that were tested
@connectrpc/connect (connect-es) supported yes: router.service(Desc, { method(req) {...} }) inside connectNodeAdapter({ routes })
yes: createClient(Desc, createConnectTransport({ baseUrl })); client.method(req)
@grpc/grpc-js + ts-proto not yet no: server.addService(XService, impl) where impl is a typed const, not an object literal in the call
no: new XClient(addr, creds) from makeGenericClientConstructor; client.method(req, cb)
@nestjs/microservices (gRPC transport) supported yes: nestjs-grpc-method: @GrpcMethod('Service', 'Method') with package and protoPath in createMicroservice options
yes: @GrpcStreamMethod('Service', 'Method') with Observable in and out
yes: @GrpcMethod('Service') with the RPC name taken from the method name, capitalised
yes: service_lookup: client.getService<T>('Service') then svc.method(req); package and url in ClientsModule.register
grpc-web supported yes: new {S}Client(url) from *_grpc_web_pb; client.method(req, metadata, cb)
yes: new {S}PromiseClient(url).method(req)
nice-grpc partly no: createServer().add(XDefinition, { method(req) {...} }) with ts-proto generic definitions
partly: createClient(XDefinition, createChannel(addr)); client.method(req)

Databases and data stores

5 supported, 3 partly, 7 not yet.

Name Status Ways of using it that were tested
@libsql/client supported yes: client.execute(sql) and client.execute({ sql, args })
@mikro-orm/core not yet no: @Entity({ tableName }); em.find(Entity, q); em.nativeDelete(Entity, q)
@neondatabase/serverless not yet no: const sql = neon(url); await sqlSELECT ...
@nestjs/mongoose not yet no: @Schema({ collection }) class; @InjectModel(X.name) private model: Model<X>; this.model.find()
@nestjs/typeorm not yet no: constructor(@InjectRepository(Entity) private repo: Repository<Entity>); this.repo.find()
@prisma/client partly no: prisma.<model>.findMany/create where schema.prisma maps the model with @@map("table")
no: prisma.<model>.findUnique with no @@map: the table is the model name
yes: prisma.$queryRawSELECT ... tagged template
no: main reads a table another service writes, through its own Prisma schema
@supabase/supabase-js partly yes: supabase.from('table').select()/update()
no: supabase.storage.from('bucket').upload()
yes: main reads a table another service writes
@typegoose/typegoose not yet no: @modelOptions({ schemaOptions: { collection } }); getModelForClass(C).find()
@upstash/redis supported yes: new Redis({ url, token }).incr/get(key)
@vercel/postgres supported yes: sqlSELECT ... imported from @vercel/postgres
dexie not yet no: class X extends Dexie { t!: Table }; db.t.add(); db.t.where().equals().toArray()
drizzle-orm partly yes: pgTable('table', cols) in schema.ts; db.select().from(table) / insert(table) / delete(table)
no: db.execute(sql...)
kysely supported yes: db.selectFrom('t').selectAll().execute(); insertInto('t'); deleteFrom('t')
sequelize-typescript not yet no: @Table({ tableName }) class X extends Model; X.findAll()/create()
typeorm supported yes: @Entity('table') class; dataSource.getRepository(Entity).find()/save()
yes: createQueryBuilder().select().from(Entity, 'alias').getOne()
yes: dataSource.query(sql, params)

Messaging and events (queues, topics, streams)

4 supported, 1 partly, 4 not yet.

Name Status Ways of using it that were tested
@azure/functions (v4) supported yes: app.serviceBusQueue('name', { queueName, handler })
@nestjs/bullmq not yet no: @Processor('queue') class extends WorkerHost { process(job) }
no: @InjectQueue('queue') private q: Queue; this.q.add('job', data)
@nestjs/event-emitter supported yes: this.events.emit('name') and @OnEvent('name') handler
@nestjs/microservices partly yes: @MessagePattern('pattern') request-reply handler
yes: @EventPattern('pattern') event handler
no: @Inject('X') private client: ClientKafka; this.client.emit('pattern', data)
no: this.client.send('pattern', data) request-reply
@nestjs/websockets supported yes: @SubscribeMessage('event') on a @WebSocketGateway; this.server.emit('event')
AWS SAM template.yaml not yet no: Events: Type: SQS Properties: Queue, the handler consumes the queue
inngest not yet no: inngest.createFunction({ id }, { event: 'name' }, handler)
no: inngest.send({ name, data })
mitt supported yes: const bus = mitt<Events>(); bus.on('x', h); bus.emit('x', data)
socket.io-client not yet no: io(url).emit('event') and socket.on('event') in a React component

Build tools and package managers

9 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Angular CLI workspace supported yes: angular.json with an application and a library under projects/, ng-package.json, tsconfig paths pointing the library at dist/
Deno (deno.json imports) supported yes: deno.json "imports" map naming a local library folder and jsr:/npm: specifiers; tasks; no package.json
Deno 2 workspaces supported yes: root deno.json "workspace": ["./api", "./money"], each member with its own deno.json name and exports
Nx (integrated repo) supported yes: nx.json, project.json per project with projectType, no package.json in apps or libs, tsconfig.base.json paths for libs
Nx (package-based repo) supported yes: npm workspaces plus nx.json; each package has package.json and a project.json with projectType
tsconfig paths supported yes: one app with "baseUrl": "." and "paths": { "@app/": ["src/"], "@lib/": ["lib/"] }, imports through the aliases
Turborepo supported yes: turbo.json tasks, apps/web (Next.js) and apps/api (fastify), packages/ui, plus config-only packages (tsconfig, eslint-config)
TypeScript project references supported yes: root tsconfig.json "references" to packages/core and packages/server, composite true, outDir lib/ per package; no workspaces
Vite supported yes: vite.config.ts resolve.alias "@" to src and "~ui" to a sibling package folder, dist/ output, plus tsconfig paths for the same "@"

Project and folder layouts

3 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
code generators (GraphQL codegen, Relay, OpenAPI, Prisma) supported yes: src/gen/ with a "generated, do not edit" header, generated/ next to components, prisma client in node_modules
Next.js (app router) supported yes: src/app/ with route.ts handlers and server components, src/lib helpers, "@/*" alias, .next/ output
Storybook supported yes: .storybook/ config, *.stories.tsx next to components, storybook-static/ build output

Deployment files

1 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
docker-compose.yml at the monorepo root supported yes: compose services with build: ./apps/x and build: { context: ., dockerfile: apps/y/Dockerfile }, init ONCE at the repository root
yes: the same repository, but each app folder added to one project with its own niro-local init (how the coverage-run monorepos were measured)