Use fetch instead of axios

.github/workflows/ci.yaml

@@ -22,7 +22,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [18.x, 20.x, 22.x]
 
     steps:
       - uses: actions/checkout@v3

NOTICE

@@ -1,5 +1,5 @@
 Apache CouchDB Nano
-Copyright [2016-2018] The Apache Software Foundation
+Copyright [2016-2013] The Apache Software Foundation
 
 This product includes software developed at
 The Apache Software Foundation (http://www.apache.org/).

README.md

@@ -4,6 +4,8 @@
 
 Offical [Apache CouchDB](https://couchdb.apache.org/) library for [Node.js](https://nodejs.org/).
 
+> Note: Nano >=11.0.0 is for Node 18/20 and above. If you are using Node 16 or older, you need Nano 10.1.2.
+
 Features:
 
 * **Minimalistic** - There is only a minimum of abstraction between you and
@@ -105,7 +107,7 @@ Note the minimum required version of Node.js is 10.
 To use `nano` you need to connect it to your CouchDB install, to do that:
 
 ```js
-const nano = require('nano')('http://localhost:5984');
+const nano = require('nano')('http://127.0.0.1:5984');
 ```
 
 > Note: Supplying authentication credentials in the URL e.g. `http://admin:mypassword@localhost:5984` is deprecated. Use `nano.auth` instead.
@@ -189,91 +191,87 @@ you have inserted a document with an _id of rabbit.
   rev: '1-6e4cb465d49c0368ac3946506d26335d' }
 ```
 
-You can also see your document in futon (http://localhost:5984/_utils).
+You can also see your document in futon (http://127.0.0.1:5984/_utils).
 
 ## Configuration
 
 Configuring nano to use your database server is as simple as:
 
 ```js
-const nano = require('nano')('http://localhost:5984')
+const nano = require('nano')('http://127.0.0.1:5984')
 const db = nano.use('foo');
 ```
 
 If you don't need to instrument database objects you can simply:
 
 ```js
 // nano parses the URL and knows this is a database
-const db = require('nano')('http://localhost:5984/foo');
-```
-
-You can also pass options to the require to specify further configuration options you can pass an object literal instead:
-
-```js
-// nano parses the URL and knows this is a database
-const opts = {
-  url: 'http://localhost:5984/foo',
-  requestDefaults: {
-    proxy: {
-      protocol: 'http',
-      host: 'myproxy.net'
-    },
-    headers: {
-      customheader: 'MyCustomHeader'
-    }
-  }
-};
-const db = require('nano')(opts);
+const db = require('nano')('http://127.0.0.1:5984/foo');
 ```
 
-Nano works perfectly well over HTTPS as long as the SSL cert is signed by a certification authority known by your client operating system. If you have a custom or self-signed certificate, you may need to create your own HTTPS agent and pass it to Nano e.g.
-
-```js
-const httpsAgent = new https.Agent({
-  ca: '/path/to/cert',
-  rejectUnauthorized: true,
-  keepAlive: true,
-  maxSockets: 6
-})
-const nano = Nano({
-  url: process.env.COUCH_URL,
-  requestDefaults: {
-    agent: httpsAgent,
-  }
-})
-```
-
-Please check [axios] for more information on the defaults. They support features like proxies, timeout etc.
-
 You can tell nano to not parse the URL (maybe the server is behind a proxy, is accessed through a rewrite rule or other):
 
 ```js
 // nano does not parse the URL and return the server api
-// "http://localhost:5984/prefix" is the CouchDB server root
+// "http://127.0.0.1:5984/prefix" is the CouchDB server root
 const couch = require('nano')(
-  { url : "http://localhost:5984/prefix"
+  { 
+    url : "http://127.0.0.1:5984/prefix"
     parseUrl : false
   });
 const db = couch.use('foo');
 ```
 
 ### Pool size and open sockets
 
-A very important configuration parameter if you have a high traffic website and are using `nano` is the HTTP pool size. By default, the Node.js HTTP global agent has a infinite number of active connections that can run simultaneously. This can be limited to user-defined number (`maxSockets`) of requests that are "in flight", while others are kept in a queue. Here's an example explicitly using the Node.js HTTP agent configured with [custom options](https://nodejs.org/api/http.html#http_new_agent_options):
+To specify the number of connections, timeouts and pool size, supply an `agentOptions` object when starting up Nano. 
 
 ```js
-const http = require('http')
-const myagent = new http.Agent({
-  keepAlive: true,
-  maxSockets: 25
-})
+const agentOptions = {
+  bodyTimeout: 30000,
+  headersTimeout: 30000,
+  keepAliveMaxTimeout: 600000,
+  keepAliveTimeout: 30000,
+  keepAliveTimeoutThreshold: 1000,
+  maxHeaderSize: 16384,
+  maxResponseSize: -1,
+  pipelining: 6,
+  connect: { 
+    timeout: 10000
+  },
+  strictContentLength: true,
+  connections: null,
+  maxRedirections: 0
+}
+const undici = require('undici')
+const undiciOptions = new undici.Agent(agentOptions)
+const nano = Nano({ url: 'http://127.0.0.1:5984', undiciOptions })
+```
 
-const db = require('nano')({
-  url: 'http://localhost:5984/foo',
-  requestDefaults : {
-    agent : myagent
-  }
-});
+The meanings of the agentOptions attributes is described [here](https://undici.nodejs.org/#/docs/api/Agent?id=new-undiciagentoptions), [here](https://undici.nodejs.org/#/docs/api/Pool?id=parameter-pooloptions) and [here](https://undici.nodejs.org/#/docs/api/Client?id=parameter-clientoptions)
+
+You may also supply a pre-existing `undici.Agent` e.g.
+
+```js
+const agent = new undici.Agent({bodyTimeout: 30000 })
+const nano = Nano({ url: 'http://127.0.0.1:5984', agentOptions: agent })
+``
+
+> Note `requestDefaults` is no longer supported.
+
+## Custom headers
+
+To supply customer headers with each request, supply a headers object when starting up Nano:
+
+
+```js
+const couch = require('nano')(
+  { 
+    url : "http://127.0.0.1:5984/prefix"
+    headers: {
+      mycustomheader: '42'
+    }
+  });
 ```
 
 ## TypeScript
@@ -283,7 +281,7 @@ There is a full TypeScript definition included in the the *nano* package. Your T
 ```ts
 import * as Nano  from 'nano'
 
-let n = Nano('http://USERNAME:PASSWORD@localhost:5984')
+let n = Nano('http://USERNAME:PASSWORD@127.0.0.1:5984')
 let db = n.db.use('people')
 
 interface iPerson extends Nano.MaybeDocument {
@@ -1201,10 +1199,7 @@ Nano supports making requests using CouchDB's [cookie authentication](http://gui
 
 ```js
 const nano = require('nano')({
-  url: 'http://localhost:5984',
-  requestDefaults: {
-    jar: true
-  }
+  url: 'http://127.0.0.1:5984'
 })
 const username = 'user'
 const userpass = 'pass'
@@ -1361,7 +1356,6 @@ npm run test
 [2]: https://github.com/apache/couchdb-nano/issues
 [4]: https://github.com/apache/couchdb-nano/blob/main/cfg/couch.example.js
 [8]: https://webchat.freenode.net?channels=%23couchdb-dev
-[axios]:  https://github.com/axios/axios
 
 https://freenode.org/
 

examples/bulk_transform.js

@@ -10,7 +10,7 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 
-const db = require('nano')('http://localhost:5984/emails')
+const db = require('nano')('http://127.0.0.1:5984/emails')
 const async = require('async')
 
 function updateRow (row, cb) {

examples/express.js

@@ -11,7 +11,7 @@
 // the License.
 
 const express = require('express')
-const db = require('nano')('http://localhost:5984/my_couch')
+const db = require('nano')('http://127.0.0.1:5984/my_couch')
 const app = module.exports = express()
 
 app.get('/', function (req, res) {

examples/lazy_creation_of_views.js

@@ -11,7 +11,7 @@
 // the License.
 
 module.exports = function () {
-  const nano = require('nano')('http://localhost:5984')
+  const nano = require('nano')('http://127.0.0.1:5984')
   const users = nano.use('users')
   const VIEWS = {
     by_twitter_id:

examples/lazy_db_creation_and_replication.js

@@ -13,8 +13,8 @@
 const nano = require('nano')
 const couch =
     {
-      master: 'http://localhost:5984/landing_m',
-      replica: 'http://localhost:5984/landing_r'
+      master: 'http://127.0.0.1:5984/landing_m',
+      replica: 'http://127.0.0.1:5984/landing_r'
     }
 
 function insertWithRetry (db, email, retries, callback) {

examples/pipe.js

@@ -11,7 +11,7 @@
 // the License.
 
 const express = require('express')
-const nano = require('nano')('http://localhost:5984')
+const nano = require('nano')('http://127.0.0.1:5984')
 const app = express.createServer()
 const dbName = 'test'
 const db = nano.use(dbName)

lib/changesreader.js

@@ -1,5 +1,5 @@
 const EventEmitter = require('events').EventEmitter
-const AbortController = global.AbortController || require('node-abort-controller').AbortController
+const AbortController = global.AbortController
 const stream = require('stream')
 const EVENT_BATCH = 'batch'
 const EVENT_CHANGE = 'change'
@@ -279,6 +279,9 @@ class ChangesReader {
     const lin = liner()
     const cp = changeProcessor(self.ee, self.batchSize)
     self.request(req)
+      .on(EVENT_ERROR, (e) => {
+        self.ee.emit(EVENT_ERROR, e)
+      })
       .pipe(lin)
       .pipe(cp)
       .on('finish', (lastSeq) => {
@@ -287,9 +290,6 @@ class ChangesReader {
           self.ee.emit('end', cp.lastSeq)
         }, 10)
       })
-      .on(EVENT_ERROR, (e) => {
-        self.ee.emit(EVENT_ERROR, e)
-      })
 
     return self.ee
   }

lib/nano.d.ts

@@ -19,26 +19,71 @@
 /// <reference types="node" />
 
 import { EventEmitter } from "events";
+import { ConnectionOptions } from "tls";
+import undici from "undici";
 
 /** nano entry function */
 declare function nano(
   config: nano.Configuration | string
 ): nano.ServerScope;
 
 declare namespace nano {
-  /** RequestDefaults.auth options */
-  interface RequestDefaultOptionsAuth {
-    username: string,
-    password: string
-  }
-
-  /** RequestDefaults options */
-  interface RequestDefaultsOptions {
-    timeout?: number;
-    agent?: any;
-    headers?: object;
-    auth?: RequestDefaultOptionsAuth;
-    jar?: boolean;
+  /** AgentOptionsConnect options */
+  interface AgentOptionsConnect extends ConnectionOptions {
+    /** An IPC endpoint, either Unix domain socket or Windows named pipe. 
+     * Default: null */
+    socketPath: string,
+    /** Maximum number of TLS cached sessions. Use 0 to disable TLS session 
+     * caching. Default: 100 */
+    maxCachedSessions: number,
+    /** Connection timeout in ms. Default: 10000 */
+    timeout?: number,
+    /** Default: null */
+    servername: string
+  }
+  /** AgentOptions options */
+  interface AgentOptions {
+    /** The timeout after which a request will time out, in milliseconds. 
+     * Monitors time between receiving body data. Use 0 to disable it entirely. 
+     * Default: 30000 */
+    bodyTimeout?: number,
+    /** The amount of time the parser will wait to receive the complete 
+     * HTTP headers while not sending the request. Default: 30000 */
+    headersTimeout?: number,
+    /** The maximum allowed keepAliveTimeout in ms when overridden by keep-alive hints 
+     * from the server. Default: 600000 */
+    keepAliveMaxTimeout?: number,
+    /** The timeout in ms after which a socket without active requests will time out. 
+     * Monitors time between activity on a connected socket. This value may be 
+     * overridden by keep-alive hints from the server. Default: 4000 */
+    keepAliveTimeout?: number,
+    /**  A number subtracted from server keep-alive hints when overriding 
+     * keepAliveTimeout to account for timing inaccuracies caused by 
+     * e.g. transport latency. Default: 1000 */
+    keepAliveTimeoutThreshold?: number,
+    /**  The maximum length of request headers in bytes. Default: 16384 */
+    maxHeaderSize?: number,
+    /** The maximum length of response body in bytes. Set to -1 to disable. Default: -1 */
+    maxResponseSize?: number,
+    /**  The amount of concurrent requests to be sent over the single TCP/TLS 
+     * connection according to RFC7230. Carefully consider your workload and 
+     * environment before enabling concurrent requests as pipelining may reduce 
+     * performance if used incorrectly. Pipelining is sensitive to network stack 
+     * settings as well as head of line blocking caused by e.g. long running r
+     * equests. Set to 0 to disable keep-alive connections. Default: 1 */
+    pipelining?: number,
+    /** Connection options */
+    connect?: AgentOptionsConnect,
+    /** Whether to treat request content length mismatches as errors. If true, 
+     * an error is thrown when the request content-length header doesn't match 
+     * the length of the request body. Default: true */
+    strictContentLength?: boolean,
+    /** The number of Client instances to create. 
+     * When set to null, the Pool instance will create an unlimited amount 
+     * of Client instances. */
+    connections: null,
+    /** The number of HTTP redirection to follow - Default: 0 */
+    maxRedirections?: null
   }
 
   /** Nano configuration */
@@ -49,10 +94,10 @@ declare namespace nano {
     url: string;
     /** For cookie authentication */
     cookie?: string;
-    /** HTTP request options
+    /** HTTP Agent options
      * @see README: {@link https://www.npmjs.com/package/nano#pool-size-and-open-sockets}
      */
-    requestDefaults?: RequestDefaultsOptions;
+    agentOptions?: AgentOptions | typeof undici.Agent | typeof undici.MockAgent | typeof undici.Dispatcher;
     /** Logging function 
      * @see README: {@link https://www.npmjs.com/package/nano#logging}
      */