This page lists the JavaScript 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 8 look-alike cases for JavaScript: 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)

23 supported, 3 partly, 4 not yet.

Name Status Ways of using it that were tested
@apollo/server supported yes: app.use('/graphql', expressMiddleware(server))
@azure/functions (v3 programming model) supported yes: <FunctionName>/function.json httpTrigger route + methods, code in index.js as module.exports = async function (context, req)
yes: function.json httpTrigger with no route and no methods: every verb at /api/<FunctionName>
@fastify/autoload supported yes: the fastify-cli generated layout: app.js registers AutoLoad for plugins/ and routes/; routes/<folder>/index.js gets the folder prefix
@feathersjs/feathers not yet no: app.use('/messages', new Service()) gives REST find/get/create/remove
@google-cloud/functions-framework supported yes: functions.http('name', handler)
@hapi/hapi partly yes: server.route({ method, path, handler })
yes: server.route([ {...}, {...} ]) with an array of route objects
no: plugin registered with { routes: { prefix } }
@koa/router supported yes: const router = new Router(); router.get(path, h)
yes: new Router({ prefix }) in its own file, then router.get/post
yes: a Router held in a variable not called router (audit), mounted with router.use(path, audit.routes())
@remix-run/node (Remix v2) supported yes: app/routes/<dotted>.js resource route with loader and action, in JavaScript
@sveltejs/kit supported yes: src/routes/<path>/+server.js in JavaScript with JSDoc types, a [param], a group and a [...rest]
@tinyhttp/app supported yes: new App().get().post() (ES module)
Cloudflare Pages Functions supported yes: functions/<path>.js exporting function onRequestGet / onRequestPost ...
yes: functions/<dir>/[param].js and [[param]].js
connect not yet no: connect().use(path, handler): any verb
express supported yes: app.get/app.post(path, handler) on the app object
yes: Router() in its own file, module.exports, mounted with app.use(prefix, router)
yes: app.route(path).put(h).delete(h) chain
yes: router mounted inside a router: app.use("/v2", v2); v2.use("/promos", promos)
express-file-routing supported yes: await createRouter(app) binding routes/ directly to the app, in JavaScript (ESM)
fastify partly yes: fastify.get(path, handler)
yes: fastify.route({ method, url, handler })
yes: fastify.route({ method: [PUT, PATCH], url })
no: plugin in another file registered with { prefix }
firebase-functions partly yes: exports.name = functions.https.onRequest(handler): path is the export name
yes: v2 onRequest(options, handler)
partly: Express app passed to onRequest: routes under the export name
Gatsby Functions (gatsby) supported yes: src/api/<path>.js default export handler(req, res)
koa-router supported yes: legacy koa-router package, router.get and router.del
micro + microrouter not yet no: module.exports = router(get(path, h), post(path, h))
Netlify Edge Functions supported yes: netlify/edge-functions/<name>.js with export const config = { path }
Netlify Functions (@netlify/functions) supported yes: netlify/functions/<name>.mjs default export with export const config = { path }
Netlify Functions (@netlify/functions), Lambda-compatible supported yes: netlify/functions/<name>.js with exports.handler = async (event, context): /.netlify/functions/<name>
next supported yes: pages/api/auth/[...nextauth].js: export default NextAuth(options), a catch-all API route in JavaScript
yes: pages/api/<path>/[[...slug]].js beside a fixed file in the same folder (fixed routes win)
yes: app/<path>/route.js in JavaScript, with a dynamic segment and a route group
next (pages router) supported yes: pages/api/<path>.js default export handler, verb from req.method
yes: pages/api/catalog/[id].js dynamic segment
polka supported yes: polka().get(...).post(...) chained on the constructor call
restify supported yes: server.get/post/del(path, handler)
sails not yet no: config/routes.js object map 'VERB /path': 'Controller.action'
serverless framework (AWS Lambda) supported yes: serverless.yml functions.<name>.events http/httpApi path+method, handler file.export
Vercel Functions (@vercel/node), no framework supported yes: api/<name>.js with module.exports = (req, res) => {}: every verb
yes: api/<name>.mjs exporting GET, POST: the export name is the verb
yes: api/<dir>/[param].js: one segment, value in req.query
ws supported yes: new WebSocketServer({ port, path }); wss.on('connection')

The language's own HTTP server

0 supported, 0 partly, 5 not yet.

Name Status Ways of using it that were tested
Bun.serve not yet no: Bun.serve({ fetch(req) }) with new URL(req.url).pathname comparison
no: Bun.serve({ routes: { "/path/:id": { GET, DELETE } } }) route table
node:http not yet no: http.createServer(handler) with if/else on req.method and new URL(req.url).pathname
no: switch over ${req.method} ${req.url} with one case per route
no: new http.Server() then server.on('request', handler)
node:http2 not yet no: http2.createSecureServer().on('stream') reading headers[':path']
node:https not yet no: https.createServer(tlsOptions, handler) with req.url comparison
node:net not yet no: net.createServer(socket => ...).listen(port): a raw TCP service (not HTTP)

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

14 supported, 5 partly, 2 not yet.

Name Status Ways of using it that were tested
@apollo/client supported yes: useQuery(gql...) and useMutation in JSX, uri set on ApolloClient in another module
axios partly no: axios.create({ baseURL: import.meta.env.X ?? default }) exported from one module, api.get(path) in another
yes: axios.get(${BASE}/path)
yes: axios.post(literalUrl, body)
no: axios({ method, url, data }) called as a function
yes: const api = axios.create({ baseURL }); api.get(path)
partly: axios.request({ url, method })
partly: this.http = axios.create({ baseURL: env }) in a constructor; this.http.get(path)
axios (any client) supported yes: the call sits in a const arrow function: const f = () => axios.get(url)
yes: the call sits in a method of an object literal
yes: the call sits in exports.name = () => ...
bent not yet no: bent(base, 'json') returns a function called with the path
cross-fetch supported yes: crossFetch(url)
got supported yes: got(url).json() called as a function
yes: got.post(url, { json })
yes: got.extend({ prefixUrl }) then client.get(relative)
graphql-request partly no: request(endpoint, query)
yes: new GraphQLClient(endpoint).request(query)
isomorphic-fetch supported yes: require('isomorphic-fetch') then the global fetch(url)
make-fetch-happen not yet no: require(...).defaults(opts) then fetch(url)
needle supported yes: needle('get', url): verb as the first argument
yes: needle.post(url, data)
node-fetch supported yes: fetch(url, { method }) imported from node-fetch under another name
ofetch partly yes: ofetch(url)
no: ofetch.create({ baseURL }) then api(path)
phin supported yes: phin({ url, method, data })
react-router-dom supported yes: createBrowserRouter([{ path, loader({ params }) { fetch(...) } }])
yes: route action({ request }) posting with fetch
redaxios supported yes: redaxios.get(url)
request (deprecated) supported yes: request.get(url, cb)
yes: request({ uri, method }, cb)
superagent supported yes: superagent.get(url)
yes: superagent.delete(url)
yes: superagent.post(url).send(body).set(h) chain
swr partly yes: useSWR(url, fetcher) in a JSX component
partly: useSWRMutation(url, (url, { arg }) => fetch(url, { method: 'POST' }))
undici partly yes: request(url) from undici
yes: undici.fetch(url)
partly: new Pool(origin).request({ path, method })
vue (single-file component) supported yes: <script setup> in a .vue file calling axios.get
wretch supported yes: wretch(url).delete().res()
yes: wretch(base).url(path).post(body)

The language's own HTTP client

8 supported, 1 partly, 2 not yet.

Name Status Ways of using it that were tested
@sveltejs/kit supported yes: export async function load({ fetch }) in +page.js using the fetch it is given
fetch (any client) supported yes: the call sits in an async arrow with a block body
yes: the call sits in a class field holding an arrow function
fetch (browser) supported yes: fetch(url) in an async function inside useEffect, in a .jsx file
fetch (global) partly yes: fetch(literalUrl)
yes: fetch(${BASE}/path, { method }) with BASE from process.env ?? default
partly: fetch(new Request(url, { method }))
yes: a project wrapper api(path, opts) around fetch, called with the path
node:http supported yes: http.request({ hostname, port, path, method }, cb)
yes: http.request(urlString, { method }, cb)
yes: http.get(url, cb)
node:http2 not yet no: http2.connect(origin).request({ ':path', ':method' })
node:https supported yes: https.get(url, cb)
yes: https.request({ host, port, path, method }, cb)
node:net not yet no: net.createConnection({ host, port }): raw TCP client
svelte (component) supported yes: fetch inside <script> of a .svelte component
vue (single-file component) supported yes: <script setup> in a .vue file calling fetch with a method
WebSocket (global) supported yes: new WebSocket('ws://host/path') (global since Node 22)

gRPC

3 supported, 2 partly, 0 not yet.

Name Status Ways of using it that were tested
@grpc/grpc-js partly partly: server streaming: client.method(req).on('data')
no: promisify(client.method).bind(client) passed as a value (gRPC plan 8.1: code, later)
yes: literal_path: new grpc.Client(addr).makeUnaryRequest('/pkg.S/M', ...)
@grpc/grpc-js (static codegen) supported yes: constructor: new services.{S}Client(addr, creds) from *_grpc_pb
@grpc/grpc-js (static grpc-tools codegen) supported yes: server.addService(services.{S}Service, { method }) with *_grpc_pb.js checked in, paths written in the generated object
@grpc/grpc-js + @grpc/proto-loader supported yes: grpc-node-addservice: server.addService(proto.{S}.service, { method: impl }) after loadSync(proto)
yes: constructor: new proto.{S}(addr, creds) from loadPackageDefinition, then client.method(req, cb)
grpc (deprecated native package) partly yes: grpc.load(proto); server.addService(proto.pkg.{S}.service, impl)
partly: constructor: new pkg.{S}(addr, creds) after grpc.load

Databases and data stores

23 supported, 1 partly, 4 not yet.

Name Status Ways of using it that were tested
@aws-sdk/client-dynamodb supported yes: client.send(new PutItemCommand({ TableName }))
@aws-sdk/client-s3 supported yes: s3.send(new PutObjectCommand({ Bucket, Key }))
@aws-sdk/lib-dynamodb supported yes: DynamoDBDocumentClient.from(client).send(new GetCommand({ TableName }))
@elastic/elasticsearch supported yes: es.search({ index }) / es.index({ index, document })
aws-sdk (v2) supported yes: new AWS.DynamoDB.DocumentClient().put({ TableName }).promise()
better-sqlite3 supported yes: db.prepare(sql).get()/run(); db.exec(sql)
bookshelf not yet no: bookshelf.model('Book', { tableName }) then fetch()/fetchAll()
cassandra-driver supported yes: client.execute(cql, params, { prepare })
dynamoose supported yes: dynamoose.model('Device', schema); Device.get/create
firebase-admin supported yes: admin.firestore().collection('x').doc(id).get()/set(); collection('x').add()
ioredis supported yes: redis.get/set/hset/incr on new Redis(url)
yes: main reads a key another service writes
knex supported yes: knex('table').where().select() / insert()
yes: knex.select('*').from('table')
yes: knex.raw(sql)
yes: knex.schema.createTable('t', fn) (DDL)
lowdb not yet no: JSONFilePreset('db.json', defaults); db.data.x.push(); db.write()
mongodb supported yes: const col = db.collection('x'); col.find()/insertOne()/updateOne()/aggregate()
yes: client.db('x').collection('y').deleteOne() in one chain
yes: main reads a collection another service writes
mongoose supported yes: mongoose.model('Cart', schema): collection is the plural, lower-cased name
yes: mongoose.model('Audit', schema, 'audit_trail') third argument
mssql supported yes: pool.request().input(...).query(sql)
yes: sql.query... tagged template
mysql supported yes: pool.query(sql, params, callback) (legacy mysql package)
mysql2 supported yes: mysql2/promise pool.execute(sql, params)
nano not yet no: nano.db.use('db').get()/insert()
neo4j-driver supported yes: session.run(cypher) and session.executeWrite(tx => tx.run(cypher))
objection not yet no: class X extends Model { static get tableName() }; X.query().findById()
oracledb supported yes: conn.execute(sql, binds)
pg supported yes: pool.query(sqlText, params) for SELECT, INSERT, DELETE
yes: client.query({ text, values }) config object
yes: table name from a constant in a template literal
yes: main reads a table another service writes (cross-service data link)
pg-promise supported yes: db.any/none/one(sql, params)
postgres (postgres.js) supported yes: sqlSELECT ... FROM t WHERE id = ${id} tagged template
yes: sql.unsafe(sqlText)
redis supported yes: createClient({ url }); client.set/get/hGetAll (v4 camelCase)
sequelize partly no: sequelize.define('Model', attrs, { tableName }) then Model.findAll()
no: class X extends Model {}; X.init(attrs, { sequelize, tableName }); X.create()
yes: sequelize.query(sql, { type })
sqlite3 supported yes: db.all/db.run/db.get(sql, params, cb)

Messaging and events (queues, topics, streams)

9 supported, 16 partly, 1 not yet.

Name Status Ways of using it that were tested
@aws-sdk/client-sns supported yes: sns.send(new PublishCommand({ TopicArn }))
@aws-sdk/client-sqs partly partly: sqs.send(new ReceiveMessageCommand({ QueueUrl })) polling loop
partly: sqs.send(new SendMessageCommand({ QueueUrl: env ?? default }))
@azure/event-hubs partly no: new EventHubConsumerClient(group, conn, 'hub').subscribe({...})
yes: new EventHubProducerClient(conn, 'hub').sendBatch(batch)
@azure/service-bus partly no: sb.createReceiver('queue').subscribe({ processMessage })
yes: sb.createSender('queue').sendMessages({ body })
@google-cloud/pubsub partly no: pubsub.subscription('sub').on('message', h)
yes: pubsub.topic('t').publishMessage({ json })
@stomp/stompjs partly no: client.subscribe('/queue/x', h)
partly: client.publish({ destination, body })
agenda supported yes: agenda.define('job-name', handler)
yes: agenda.now('job', data); agenda.every(interval, 'job')
amqplib partly partly: ch.consume('queue', handler)
partly: assertExchange + bindQueue(q, exchange, pattern) + consume(q)
partly: ch.sendToQueue('queue', buf)
partly: ch.publish('exchange', 'routing.key', buf)
aws-sdk (v2) partly partly: new AWS.SQS().sendMessage({ QueueUrl }).promise()
bee-queue partly partly: new BeeQueue('name').process(handler)
partly: queue.createJob(data).save()
bull partly partly: new Queue('name', redisUrl).process(handler)
yes: new Queue('name', url).add(data)
bullmq partly yes: new Worker('queue', processor, { connection })
partly: new Queue('name', { connection }).add('job', data)
events (EventEmitter) supported yes: class X extends EventEmitter; bus.on('name', h); bus.emit('name', data)
firebase-functions supported yes: Firestore trigger onDocumentCreated('collection/{id}')
ioredis supported yes: sub.subscribe('channel'); sub.on('message', h)
yes: redis.publish('channel', msg)
kafkajs partly yes: consumer.subscribe({ topic }) then consumer.run({ eachMessage })
yes: consumer.subscribe({ topics: [a, b] })
yes: producer.send({ topic, messages })
no: producer.sendBatch({ topicMessages: [{ topic }] })
yes: producer.send({ topic: literal }) in main, consumed by kafkajs-svc
yes: producer.send({ topic: TOPICS.X }) with the topic in a constant object
mqtt supported yes: client.subscribe('topic'); client.on('message', h)
yes: client.publish('topic', payload)
nats partly yes: nc.subscribe('subject') with for await
no: nc.subscribe('subject', { queue, callback })
yes: request side nc.request; reply side subscribe + m.respond
yes: nc.publish('subject', data)
yes: await nc.request('subject', data)
node-rdkafka supported yes: consumer.subscribe(['topic']); consumer.on('data', h)
yes: producer.produce('topic', partition, buffer)
pg partly no: client.query('LISTEN channel'); client.on('notification', h)
partly: SELECT pg_notify('channel', payload)
redis supported yes: await subscriber.subscribe('channel', listener)
yes: client.xReadGroup(group, consumer, [{ key }]) (streams)
yes: client.publish('channel', msg); client.xAdd('stream', '*', fields)
rhea supported yes: connection.open_receiver('address'); container.on('message', h)
yes: connection.open_sender('address').send({ body })
socket.io partly partly: io.on('connection', s => s.on('event', h)); io.emit('event')
socket.io-client partly partly: io(url).emit('event', data); socket.on('event', h)
sqs-consumer not yet no: Consumer.create({ queueUrl, handleMessage })
zeromq partly yes: new zmq.Subscriber(); sock.subscribe('topic')
partly: new zmq.Publisher(); pub.send(['topic', msg])

Build tools and package managers

9 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Bun workspaces supported yes: package.json workspaces with bun.lock, an app using Bun.serve and no server framework dependency
Lerna supported yes: lerna.json "packages": ["packages/*"] with fixed versioning; packages named by their package.json
npm supported yes: one package.json, src/ code, test/ tests, dist/ output gitignored
npm workspaces supported yes: root package.json "workspaces": ["apps/", "packages/"], sibling dependency by name with "*"
pnpm workspaces supported yes: pnpm-workspace.yaml packages list, "workspace:*" protocol, catalog: versions
Rush supported yes: rush.json "projects": [{ packageName, projectFolder }] with folders that are not one glob; common/ holds tool config
webpack supported yes: webpack.config.js resolve.alias { Utilities: path.resolve(__dirname, "src/utilities/") } imports, a minified vendor file in public/
yarn 1 (classic) workspaces supported yes: "workspaces": { "packages": [...], "nohoist": [...] } object form, yarn.lock v1
yarn 2+ (berry) with Plug n Play supported yes: .yarnrc.yml nodeLinker pnp, "workspace:^" protocol, generated .pnp.cjs and .yarn/ folder

Project and folder layouts

6 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Babel or tsc output folders supported yes: source in src/, CommonJS output in lib/ and ESM output in es/ (both gitignored), "main": "lib/index.js"
Electron supported yes: one package with main/ (Node process), preload/ and renderer/ (browser), electron-builder output in release/
Jest, Mocha, Cypress supported yes: tests/ folders, colocated *.test.js, test/ for Mocha, cypress/e2e, and coverage/lcov-report output
Next.js (pages router) supported yes: pages/ and pages/api/ at the root, lib/ helpers, .next/ build output and out/ static export
Node module systems supported yes: "type": "module" package with .mjs and .cjs files, createRequire, an "exports" map with subpaths and conditions, "imports" #aliases
Yeoman supported yes: generator-<name>/generators/<sub>/index.js with templates/ holding EJS-templated JS that is not valid code