AxioDBCloud

Basic Connection

1const { AxioDBCloud } = require('axiodb');
2
3// Connect to remote AxioDB server
4const client = new AxioDBCloud("axiodb://localhost:27019");
5
6// Establish connection
7await client.connect();
8
9// Use exactly like embedded AxioDB!
10const db = await client.createDB("ProductionDB");
11const users = await db.createCollection("Users");
12
13// All operations work identically
14await users.insert({ name: "Alice", email: "[email protected]" });
15
16const results = await users.query({ name: "Alice" })
17  .Limit(10)
18  .Skip(0)
19  .Sort({ createdAt: -1 })
20  .exec();
21
22console.log(results);
23
24// Disconnect when done
25await client.disconnect();

Advanced Options

1const client = new AxioDBCloud("axiodb://localhost:27019", {
2  timeout: 30000,           // Request timeout (ms)
3  reconnectAttempts: 10,    // Max reconnect attempts
4  reconnectDelay: 1000,     // Initial delay (ms)
5  heartbeatInterval: 30000, // Heartbeat every 30s
6  maxPoolSize: 10,          // Concurrent connections in the pool (default: 10)
7  username: 'admin',        // Only needed if the server has TCPAuth: true
8  password: 'admin',
9});

maxPoolSize mirrors MongoDB's driver option of the same name. AxioDBCloud opens this many concurrent TCP connections to the server and routes each command to whichever connected member currently has the fewest in-flight requests (least-busy), so a burst of concurrent requests isn't serialized over a single socket, and a slow command on one connection doesn't queue new work behind it while other members sit idle. Each pooled connection reconnects and re-authenticates independently, so one dropped connection never blocks commands routed to the others.

Each pool member is a socket, and the server holds one socket per connected client - both count against the OS's open-file-descriptor limit (ulimit -n, often 1024 by default on Linux). At the default pool size that's enough for roughly 100 clients before the server starts refusing new connections. If you're deploying towards the 1,000+ concurrent connections the server supports, raise the limit (e.g. ulimit -n 65536, or docker run --ulimit nofile=65536:65536) rather than raising maxPoolSize per client.

The server also caps concurrent connections at 100 per remote IP, independent of the global 1,000-connection budget - so a single misbehaving or malicious client can't claim the entire pool of server connections for itself. This is checked at connect time, before authentication, and rejects the extra connection with a 429 ("Too many concurrent connections from this IP address"). A single client at the default maxPoolSize: 10 is nowhere near this limit.

If maxPoolSize asks for more connections than the server allows (from the per-IP cap above, or any other reason a handful of pool members fail),connect() doesn't reject outright - it resolves as long as at least one pool member connected, and emits a poolDegraded event so the app knows it's running with fewer connections than requested instead of failing (or silently under capacity):

1client.on('poolDegraded', ({ requested, connected, failed, errors }) => {
2  console.warn(`Pool came up smaller than requested: ${connected}/${requested} connected, ${failed} failed`);
3  console.warn(errors[0].message); // e.g. "Too many concurrent connections from this IP address"
4});
5
6await client.connect(); // resolves even if some pool members were rejected

The one exception is the very first connection in the pool - if that one fails,connect() still rejects entirely, since it's the signal that the server is reachable and credentials are valid at all.

The 100-per-IP cap only bounds concurrent connections - by itself it wouldn't stop an attacker who never holds more than a few sockets open but rapidly opens and drops them, since each attempt still costs a TCP handshake and an accept/reject cycle. A separate per-IP rate limiter tracks connection attempts (successful or rejected, either counts) in a trailing 10-second window; once an IP crosses 300 attempts, every new connection from it is rejected with a 429 for the next 30 seconds. A normal client - even one repeatedly reconnecting a full maxPoolSize: 10 pool - is nowhere near this threshold.