# Supported in JavaScript

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

**What the marks mean.**

- **Supported:** Niro recognised every way of using it that the test code tries.

- **Partly:** Niro recognised some of those ways, or recognised one only in part.

- **Not yet:** Niro did not recognise it in the test code.

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](https://help.niroai.dev/cli/coverage-audit-and-consent/)).

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: sql`SELECT ... 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 |