@nxtedition/lib 19.0.51 → 19.1.1

package/couch.js

@@ -1,14 +1,14 @@
 import assert from 'node:assert'
+import stream from 'node:stream'
+import querystring from 'node:querystring'
 import createError from 'http-errors'
 import { makeWeakCache } from './weakCache.js'
 import tp from 'timers/promises'
 import { defaultDelay as delay } from './http.js'
-import querystring from 'querystring'
 import urljoin from 'url-join'
 import undici from 'undici'
 import { AbortError } from './errors.js'
 import split2 from 'split2'
-import stream from 'node:stream'
 
 // https://github.com/fastify/fastify/blob/main/lib/reqIdGenFactory.js
 // 2,147,483,647 (2^31 − 1) stands for max SMI value (an internal optimization of V8).
@@ -560,93 +560,7 @@ export function makeCouch(opts) {
 
     const { client = getClient(pathname), signal, idempotent = true, ...options } = opts
 
-    const params = {}
-    const headers = ['Accept', 'application/json']
-
-    let method = 'GET'
-    let body
-
-    if (options.conflicts) {
-      params.conflicts = true
-    }
-
-    if (options.update_seq) {
-      params.update_seq = true
-    }
-
-    if (options.descending) {
-      params.descending = true
-    }
-
-    if (options.include_docs) {
-      params.include_docs = true
-    }
-
-    if (options.include_docs) {
-      params.include_docs = true
-    }
-
-    if (options.sorted) {
-      params.sorted = true
-    }
-
-    if (options.key != null) {
-      params.key = JSON.stringify(options.key)
-    }
-
-    if (options.start_key != null) {
-      options.startkey = options.start_key
-    }
-
-    if (options.startkey != null) {
-      params.startkey = JSON.stringify(options.startkey)
-    }
-
-    if (options.startkey_docid != null) {
-      params.startkey_docid = JSON.stringify(options.startkey_docid)
-    }
-
-    if (options.end_key != null) {
-      options.endkey = options.end_key
-    }
-
-    if (options.endkey != null) {
-      params.endkey = JSON.stringify(options.endkey)
-    }
-
-    if (options.inclusive_end != null) {
-      params.inclusive_end = !!options.inclusive_end
-    }
-
-    if (options.limit != null) {
-      params.limit = options.limit
-    }
-
-    if (options.skip != null) {
-      params.skip = options.skip
-    }
-
-    if (options.stale != null) {
-      params.stale = options.stale
-    }
-
-    if (options.reduce != null) {
-      params.reduce = options.reduce
-    }
-
-    if (options.group != null) {
-      params.group = options.group
-    }
-
-    if (options.group_level != null) {
-      params.group_level = options.group_level
-    }
-
-    if (options.keys != null) {
-      method = 'POST'
-      body = { keys: options.keys }
-      headers.push('Content-Type', 'application/json')
-    }
+    const { params, method, headers, body } = _normalizeAllDocsOptions(options)
 
     const req = {
       pathname: pathname || '_all_docs',
@@ -848,3 +762,383 @@ export function makeCouch(opts) {
     up,
   })
 }
+
+/* eslint-disable camelcase */
+function _normalizeAllDocsOptions({
+  conflicts,
+  update_seq,
+  descending,
+  include_docs,
+  sorted,
+  key,
+  startkey,
+  start_key,
+  startkey_docid,
+  endkey,
+  end_key,
+  endkey_docid,
+  inclusive_end,
+  limit,
+  skip,
+  stale,
+  reduce,
+  stable,
+  update,
+  keys,
+  group,
+  group_level,
+  ...rest
+}) {
+  if (Object.keys(rest).length > 0) {
+    throw new Error('invalid options: ' + JSON.stringify(rest))
+  }
+  const params = {}
+  const headers = {
+    Accept: 'application/json',
+  }
+
+  let method = 'GET'
+  let body
+
+  if (conflicts) {
+    params.conflicts = true
+  }
+
+  if (update_seq) {
+    params.update_seq = true
+  }
+
+  if (descending) {
+    params.descending = true
+  }
+
+  if (include_docs) {
+    params.include_docs = true
+  }
+
+  if (sorted) {
+    params.sorted = true
+  }
+
+  if (key != null) {
+    params.key = JSON.stringify(key)
+  }
+
+  if (startkey != null || start_key != null) {
+    params.startkey = JSON.stringify(startkey ?? start_key)
+  }
+
+  if (startkey_docid != null) {
+    params.startkey_docid = JSON.stringify(startkey_docid)
+  }
+
+  if (endkey != null || end_key != null) {
+    params.endkey = JSON.stringify(endkey ?? end_key)
+  }
+
+  if (inclusive_end != null) {
+    params.inclusive_end = !!inclusive_end
+  }
+
+  if (limit != null) {
+    params.limit = limit
+  }
+
+  if (skip != null) {
+    params.skip = skip
+  }
+
+  if (stale != null) {
+    params.stale = stale
+  }
+
+  if (reduce != null) {
+    params.reduce = reduce
+  }
+
+  if (group != null) {
+    params.group = group
+  }
+
+  if (group_level != null) {
+    params.group_level = group_level
+  }
+
+  if (update != null) {
+    params.update = update
+  }
+
+  if (stable != null) {
+    params.stable = stable
+  }
+
+  if (keys != null) {
+    method = 'POST'
+    body = JSON.stringify({ keys })
+    headers['Content-Type'] = 'application/json'
+  }
+
+  return {
+    method,
+    params,
+    headers,
+    body,
+  }
+}
+
+class Handler extends undici.DecoratorHandler {
+  #str
+  #decoder
+  #onAbort
+  #signal
+  #statusCode
+  #statusText
+  #opts
+  #handler
+
+  constructor({ opts, signal, handler }) {
+    super(handler)
+
+    this.#handler = handler
+    this.#opts = opts
+    this.#signal = signal
+  }
+
+  onConnect(abort) {
+    if (this.#signal?.aborted) {
+      abort(this.#signal.reason)
+    } else {
+      if (this.#signal) {
+        this.#onAbort = () => abort(this.#signal.reason)
+        this.#signal.addEventListener('abort', this.#onAbort)
+      }
+
+      this.#str = ''
+      this.#decoder = null
+      this.#handler.onConnect?.(abort)
+    }
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusText) {
+    this.#statusCode = statusCode
+    this.#statusText = statusText
+
+    if (this.#statusCode >= 200 && this.#statusCode < 300) {
+      this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusText)
+    } else {
+      this.#decoder = new TextDecoder()
+    }
+  }
+
+  onData(data) {
+    if (this.#decoder) {
+      this.#str += this.#decoder.decode(data, { stream: true })
+    } else {
+      return this.#handler?.onData(data)
+    }
+  }
+
+  onComplete(trailers) {
+    if (this.#decoder) {
+      let body
+      let reason
+      let error
+      try {
+        body = JSON.parse(this.#str)
+        reason = body.reason
+        error = body.error
+      } catch {
+        // Do nothing...
+      }
+
+      this.onFinally(
+        Object.assign(new Error(this.#statusText ?? reason), {
+          reason,
+          error,
+          data: {
+            req: this.#opts,
+            res: {
+              body,
+              statusCode: this.#statusCode,
+            },
+          },
+        }),
+      )
+    } else {
+      this.onFinally(null, trailers)
+    }
+  }
+
+  onError(err) {
+    this.onFinally(err)
+  }
+
+  onFinally(err, val) {
+    if (this.#signal) {
+      this.#signal.removeEventListener('abort', this.#onAbort)
+    }
+
+    if (err) {
+      this.#handler.onError?.(err)
+    } else {
+      this.#handler.onComplete?.(val)
+    }
+  }
+}
+
+class StreamOutput extends stream.Readable {
+  #str
+  #resume
+  #abort
+  #state
+  #decoder
+  #didPush = false
+
+  constructor({ highWaterMark }) {
+    super({ objectMode: true, highWaterMark })
+  }
+
+  _read() {
+    this.#resume?.()
+  }
+
+  _destroy(err, callback) {
+    this.#abort?.(err)
+    callback(err)
+  }
+
+  onConnect(abort) {
+    if (this.destroyed) {
+      abort(this.errored)
+    } else if (!this.#didPush) {
+      this.#state = 0
+      this.#str = ''
+      this.#abort = abort
+      this.#decoder = new TextDecoder()
+    } else {
+      throw new Error('unusable')
+    }
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusText) {
+    if (statusCode >= 300 || statusCode < 200) {
+      throw new Error('invalid status code: ' + statusCode)
+    }
+
+    this.#resume = resume
+  }
+
+  onData(data) {
+    const lines = this.#decoder.decode(data, { stream: true }).split(/\r?\n+/)
+    lines[0] = this.#str + lines[0]
+    this.#str = lines.pop() ?? ''
+
+    for (const line of lines) {
+      if (this.#state === 0) {
+        if (line.endsWith('[')) {
+          this.#state = 1
+        } else {
+          throw new Error('unexpected data')
+        }
+      } else if (this.#state === 1) {
+        if (line.startsWith(']')) {
+          this.#state = 2
+        } else {
+          this.push(JSON.parse(line.slice(0, line.lastIndexOf('}') + 1)))
+          this.#didPush = true
+        }
+      }
+    }
+
+    return this.readableLength < this.readableHighWaterMark
+  }
+
+  onComplete() {
+    assert(this.#state === 2)
+    this.push(null)
+  }
+
+  onError(err) {
+    this.destroy(err)
+  }
+}
+
+class PromiseOutput {
+  #resolve
+  #reject
+  #str
+  #decoder
+
+  constructor({ resolve, reject }) {
+    this.#resolve = resolve
+    this.#reject = reject
+  }
+
+  onConnect() {
+    this.#decoder = new TextDecoder()
+    this.#str = ''
+  }
+
+  onHeaders(statusCode, rawHeaders, resume, statusText) {
+    if (statusCode >= 300 || statusCode < 200) {
+      throw new Error('invalid status code: ' + statusCode)
+    }
+  }
+
+  onData(data) {
+    this.#str += this.#decoder.decode(data, { stream: true })
+  }
+
+  onComplete() {
+    this.#str += this.#decoder.decode(undefined, { stream: false })
+    this.#resolve(JSON.parse(this.#str))
+  }
+
+  onError(err) {
+    this.#reject(err)
+  }
+}
+
+export function request(
+  url,
+  {
+    body,
+    method = body ? 'POST' : 'GET',
+    query,
+    headers,
+    dispatcher = undici.getGlobalDispatcher(),
+    signal,
+    stream,
+  },
+) {
+  url = new URL(url)
+  if (url.search) {
+    throw new Error('invalid url: ' + url.href)
+  }
+  const opts = {
+    origin: url.origin,
+    path: url.pathname + '?' + querystring.stringify(query),
+    method,
+    headers: {
+      'content-type': body != null && typeof body === 'object' ? 'application/json' : 'plain/text',
+      accept: 'application/json',
+      ...headers,
+    },
+    body: body != null && typeof body === 'object' ? JSON.stringify(body) : body,
+  }
+
+  dispatcher = dispatcher.compose(
+    (dispatch) => (opts, handler) => dispatch(opts, new Handler({ opts, signal, handler })),
+  )
+
+  if (stream) {
+    const handler = new StreamOutput({ highWaterMark: stream.highWaterMark ?? 128 })
+    dispatcher.dispatch(opts, handler)
+    return handler
+  } else {
+    return new Promise((resolve, reject) => {
+      const handler = new PromiseOutput({ resolve, reject })
+      dispatcher.dispatch(opts, handler)
+    })
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "19.0.51",
+  "version": "19.1.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -75,10 +75,10 @@
     "/__tests__"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.552.0",
+    "@aws-sdk/client-s3": "^3.554.0",
     "@elastic/elasticsearch": "^8.13.1",
-    "@elastic/transport": "^8.5.0",
-    "@nxtedition/nxt-undici": "^2.0.45",
+    "@elastic/transport": "^8.5.1",
+    "@nxtedition/nxt-undici": "^2.0.46",
     "date-fns": "^3.6.0",
     "fast-querystring": "^1.1.1",
     "hasha": "^6.0.0",
@@ -94,13 +94,13 @@
     "p-queue": "^8.0.1",
     "pino": "^8.20.0",
     "pino-std-serializers": "^6.2.2",
-    "qs": "^6.12.0",
+    "qs": "^6.12.1",
     "request-target": "^1.0.2",
     "smpte-timecode": "^1.3.5",
     "split-string": "^6.0.0",
     "split2": "^4.2.0",
     "toobusy-js": "^0.5.1",
-    "undici": "^6.12.0",
+    "undici": "^6.13.0",
     "url-join": "^5.0.0"
   },
   "devDependencies": {
@@ -111,7 +111,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.1.0",
+    "eslint-plugin-n": "^17.2.1",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.0.0",
     "husky": "^9.0.11",