@nxtedition/lib 18.0.10 → 19.0.0

package/couch.js

@@ -1,3 +1,4 @@
+import assert from 'node:assert'
 import createError from 'http-errors'
 import { makeWeakCache } from './weakCache.js'
 import tp from 'timers/promises'
@@ -225,16 +226,21 @@ export function makeCouch(opts) {
       }
     }
 
-    async function* continuous() {
+    async function* parse(live) {
+      let remaining = Number(options.limit) || Infinity
+
+      const params2 = {
+        ...params,
+        ...options.query,
+        feed: live ? 'continuous' : 'normal',
+      }
+
+      if (Number.isFinite(remaining)) {
+        params.limit = remaining
+      }
+
       const req = {
-        path:
-          dbPathname +
-          '/_changes' +
-          `?${new URLSearchParams({
-            ...params,
-            ...options.query,
-            feed: 'continuous',
-          })}`,
+        path: `${dbPathname}/_changes?${new URLSearchParams(params2)}`,
         idempotent: false,
         blocking: true,
         method,
@@ -245,10 +251,14 @@ export function makeCouch(opts) {
           'request-id': genReqId(),
           ...(body ? { 'content-type': 'application/json' } : {}),
         },
+        throwOnError: true,
         highWaterMark: 256 * 1024, // TODO (fix): Needs support in undici...
         bodyTimeout: 2 * (params.heartbeat || 60e3),
       }
 
+      const HEAD = '{"results":['
+      const TAIL = '],'
+
       try {
         const res = await client.request(req)
 
@@ -262,29 +272,68 @@ export function makeCouch(opts) {
 
         retryCount = 0
 
+        const decoder = new TextDecoder()
+
         let str = ''
+        let state = 0
         for await (const chunk of res.body) {
-          const lines = (str + chunk).split('\n')
+          str += decoder.decode(chunk, { stream: true })
+
+          const lines = str.split('\n')
           str = lines.pop() ?? ''
 
-          const results = batched ? [] : null
+          const changes = []
           for (const line of lines) {
-            if (line) {
-              const change = JSON.parse(line)
-              if (change.seq) {
-                params.since = change.seq
+            if (line === '') {
+              continue
+            }
+            if (live) {
+              const data = JSON.parse(line)
+              if (data.last_seq) {
+                params.since = data.last_seq
+                assert(params.since, 'invalid last_seq: ' + params.since)
+              } else {
+                params.since = data.seq || params.since
+                changes.push(data)
               }
-              if (results) {
-                results.push(change)
+            } else {
+              // NOTE: This makes some assumptions about the format of the JSON.
+              if (state === 0) {
+                if (line === HEAD) {
+                  state = 1
+                } else {
+                  assert(line.length < HEAD.length, 'invalid line: ' + line)
+                }
+              } else if (state === 1) {
+                if (line === TAIL) {
+                  state = 2
+                } else {
+                  const idx = line.lastIndexOf('}') + 1
+                  assert(idx > 0, 'invalid line; ' + line)
+                  const data = JSON.parse(line.slice(0, idx))
+                  params.since = data.seq || params.since
+                  changes.push(data)
+                }
+              } else if (state === 2) {
+                state = 3
+                params.since = JSON.parse('{' + line).last_seq
+                assert(params.since, 'invalid last_seq: ' + params.since)
               } else {
-                yield change
+                assert(false, 'invalid state: ' + state)
               }
             }
           }
 
-          if (results?.length) {
-            yield results
+          if (changes.length > 0) {
+            if (batched) {
+              yield changes
+            } else {
+              yield* changes
+            }
           }
+
+          remaining -= changes.length
+          assert(remaining >= 0, 'invalid remaining: ' + remaining)
         }
       } catch (err) {
         Object.assign(err, { data: req })
@@ -292,108 +341,17 @@ export function makeCouch(opts) {
       }
     }
 
-    async function* normal() {
-      const batchSize =
-        options.batch_size ?? options.batchSize ?? (params.include_docs ? 512 : 4096)
-      let remaining = parseInt(options.limit) || Infinity
-
-      const next = async () => {
-        const req = {
-          path:
-            dbPathname +
-            '/_changes' +
-            `?${new URLSearchParams({
-              ...params,
-              ...options.query,
-              limit: Math.min(remaining, batchSize),
-              feed: live ? 'longpoll' : 'normal',
-            })}`,
-          idempotent: true,
-          blocking: live,
-          method,
-          maxRedirects: 4,
-          body: JSON.stringify(body),
-          signal: ac.signal,
-          headers: {
-            'user-agent': userAgent,
-            'request-id': genReqId(),
-            ...(body ? { 'content-type': 'application/json' } : {}),
-          },
-        }
-
-        try {
-          const res = await client.request(req)
-
-          if (res.statusCode < 200 || res.statusCode >= 300) {
-            throw makeError(req, {
-              status: res.statusCode,
-              headers: res.headers,
-              data: await res.body.text(),
-            })
-          }
-
-          return await res.body.json()
-        } catch (err) {
-          Object.assign(err, { data: req })
-          throw err
-        }
-      }
-
-      let promise
-      while (remaining) {
-        const { last_seq: seq, results, err } = await (promise ?? next())
-        promise = null
-
-        if (err) {
-          throw err
-        }
-
-        retryCount = 0
-
-        if (seq) {
-          params.since = seq
-          if (results.length > 0 && !results.at(-1)?.seq) {
-            results.at(-1).seq = seq
-          }
-        }
-
-        remaining -= results.length
-
-        if (!live && results.length === 0) {
-          return
-        }
-
-        promise = next().catch((err) => ({ err }))
-
-        if (batched) {
-          yield results
-        } else {
-          yield* results
-        }
-      }
-    }
-
     try {
       while (true) {
         try {
-          if (live && !options.batchSize && !options.batch_size) {
-            yield* continuous()
-          } else {
-            yield* normal()
-          }
+          yield* parse(live)
           return
         } catch (err) {
-          err.reason ??= err.body?.reason
-          if (err.name === 'AbortError' || client.destroyed) {
+          if (err.name === 'AbortError') {
             throw err
           } else if (typeof retry === 'function') {
             const retryState = { since: params.since }
-            Object.assign(
-              retryState,
-              await retry(err, retryCount++, retryState, { signal }, () =>
-                delay(err, retryCount, { signal }),
-              ),
-            )
+            Object.assign(retryState, await retry(err, retryCount++, retryState, { signal }))
             params.since = retryState.since ?? 0
           } else {
             await delay(err, retryCount, { signal })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "18.0.10",
+  "version": "19.0.0",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",