@nxtedition/lib 26.4.4 → 26.4.6

package/app.js

@@ -129,8 +129,26 @@ export function makeApp(appConfig, onTerminate) {
   const serviceModule = appConfig.module ?? 'main'
   const serviceWorkerId = appConfig.workerId ?? threadId
   const serviceInstanceId =
-    // process.env.name is the pm2 name of the process
-    appConfig.instanceId ?? appConfig.containerId ?? process.env.name ?? os.hostname()
+    appConfig.instanceId ??
+    appConfig.containerId ??
+    (() => {
+      if (!isProduction) {
+        // We are not running in docker, so we use pid as instance id.
+        return `pid${process.pid}`
+      }
+
+      try {
+        // Normally we have the container ID as hostname, but that can be changed
+        // so we read it from mountinfo instead. This is not 100% reliable as it
+        // depends on the container runtime.
+        return fs
+          .readFileSync('/proc/self/mountinfo', { encoding: 'utf8' })
+          .match(/[/]([0-9a-f]{64})[/]hostname/)[1]
+          .slice(0, 12)
+      } catch {}
+
+      return os.hostname()
+    })()
 
   if (!serviceName) {
     throw new Error('Service name is required')
@@ -141,7 +159,7 @@ export function makeApp(appConfig, onTerminate) {
     (serviceName &&
       `${serviceName}/${
         serviceVersion || '*'
-      } (module:${serviceModule}; instance:${serviceInstanceId}) worker:${serviceWorkerId} Node/${process.version}`) ??
+      } (module:${serviceModule}; instance:${serviceInstanceId}; worker:${serviceWorkerId}) Node/${process.version}`) ??
     null)
 
   if (isMainThread && serviceName) {

package/http.js

@@ -423,6 +423,7 @@ export class ServerResponse extends http.ServerResponse {
 
   /**
    * @returns {{
+   *   created: number,
    *   connect: number,
    *   headers: number,
    *   data: number,
@@ -431,6 +432,7 @@ export class ServerResponse extends http.ServerResponse {
    */
   get timing() {
     return {
+      created: performance.timeOrigin + this.#created,
       connect: this.#connect,
       headers: this.#headers,
       data: this.#data,
@@ -656,8 +658,18 @@ export class Http2ServerResponse extends http2.Http2ServerResponse {
   #data = -1
   #end = -1
 
+  /**
+   * @returns {{
+   *   created: number,
+   *   connect: number,
+   *   headers: number,
+   *   data: number,
+   *   end: number
+   * }}
+   */
   get timing() {
     return {
+      created: performance.timeOrigin + this.#created,
       connect: this.#connect,
       headers: this.#headers,
       data: this.#data,

package/package.json

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

package/rxjs/auditMap.js

@@ -5,6 +5,7 @@ function auditMapImpl(project) {
     let pendingValue = null
     let hasPendingValue = false
     let isComplete = false
+    let abortController = null
 
     let innerSubscription = null
     let outerSubscription = null
@@ -15,6 +16,7 @@ function auditMapImpl(project) {
 
     function _innerComplete() {
       innerSubscription = null
+      abortController = null
 
       if (hasPendingValue) {
         const value = pendingValue
@@ -30,9 +32,30 @@ function auditMapImpl(project) {
       o.next(val)
     }
 
+    function _drain() {
+      if (!hasPendingValue) {
+        return
+      }
+      const value = pendingValue
+      pendingValue = null
+      hasPendingValue = false
+      return { value }
+    }
+
     function _tryNext(value) {
       try {
-        const result = project(value)
+        const result = project(value, {
+          get signal() {
+            if (!abortController) {
+              abortController = new AbortController()
+              if (hasPendingValue) {
+                abortController.abort()
+              }
+            }
+            return abortController.signal
+          },
+          _drain,
+        })
         const observable = typeof result.then === 'function' ? from(result) : result
         innerSubscription = observable.subscribe({
           next: _innerNext,
@@ -51,6 +74,7 @@ function auditMapImpl(project) {
       if (innerSubscription) {
         pendingValue = value
         hasPendingValue = true
+        abortController?.abort()
       } else {
         _tryNext(value)
       }
@@ -60,6 +84,8 @@ function auditMapImpl(project) {
       isComplete = true
       if (!innerSubscription) {
         o.complete()
+      } else {
+        abortController?.abort()
       }
     }
 

package/rxjs/auditMap.test.js

@@ -0,0 +1,64 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import auditMap from './auditMap.js'
+import * as rxjs from 'rxjs'
+import tp from 'node:timers/promises'
+
+test('auditMap sync', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of(1, 2, 3)
+    .pipe(
+      auditMap((val) => rxjs.of(val * 2)),
+      rxjs.toArray(),
+    )
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [2, 4, 6])
+    })
+})
+
+test('auditMap async', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of(1, 2, 3)
+    .pipe(
+      auditMap(async (val) => val * 2),
+      rxjs.toArray(),
+    )
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [2, 6])
+    })
+})
+
+test('auditMap drain', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of(1, 2, 3)
+    .pipe(
+      auditMap(async (val, { _drain }) => {
+        await tp.setTimeout(1)
+        return _drain()?.value ?? val
+      }),
+      rxjs.toArray(),
+    )
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [3])
+    })
+})
+
+test('auditMap signal', (t) => {
+  t.plan(1, { wait: true })
+  rxjs
+    .of(1, 2, 3)
+    .pipe(
+      auditMap(async (val, { signal }) => {
+        await tp.setTimeout(1)
+        assert.strictEqual(signal.aborted, val === 1)
+        return val
+      }),
+      rxjs.toArray(),
+    )
+    .subscribe((val) => {
+      t.assert.deepStrictEqual(val, [1, 3])
+    })
+})

package/rxjs/retry.js

@@ -0,0 +1,112 @@
+import { operate } from 'rxjs/internal/util/lift'
+import { createOperatorSubscriber } from 'rxjs/internal/operators/OperatorSubscriber'
+import { identity, timer } from 'rxjs'
+import { innerFrom } from 'rxjs/internal/observable/innerFrom'
+
+// This is from https://github.com/ReactiveX/rxjs/blob/7.x/src/internal/operators/retry.ts
+// But with some custom code added to emit a value on each retry attempt.
+// The default delay function is also changed to use exponential backoff, capped at 1 minute.
+//
+// It uses internals from rxjs, but otherwise the code would have to be modified more heavily.
+
+const DEFAULT_DELAY = (err, retryCount) => {
+  return timer(Math.min(2 ** (retryCount - 1) * 1000, 60_000))
+}
+
+export function retry(configOrCount) {
+  let config
+  if (configOrCount && typeof configOrCount === 'object') {
+    config = configOrCount
+  } else {
+    config = {
+      count: configOrCount,
+    }
+  }
+  const { count = Infinity, delay = DEFAULT_DELAY, resetOnSuccess = false, emitOnRetry } = config
+
+  return count <= 0
+    ? identity
+    : operate((source, subscriber) => {
+        let soFar = 0
+        let innerSub
+        const subscribeForRetry = () => {
+          let syncUnsub = false
+          innerSub = source.subscribe(
+            createOperatorSubscriber(
+              subscriber,
+              (value) => {
+                // If we're resetting on success
+                if (resetOnSuccess) {
+                  soFar = 0
+                }
+                subscriber.next(value)
+              },
+              // Completions are passed through to consumer.
+              undefined,
+              (err) => {
+                if (soFar++ < count) {
+                  // We are still under our retry count
+                  const resub = () => {
+                    if (innerSub) {
+                      innerSub.unsubscribe()
+                      innerSub = null
+                      subscribeForRetry()
+                    } else {
+                      syncUnsub = true
+                    }
+                  }
+
+                  // ------- START CUSTOM CODE -------
+                  if (emitOnRetry) {
+                    try {
+                      subscriber.next(emitOnRetry(err, soFar))
+                    } catch (e) {
+                      subscriber.error(e)
+                      return
+                    }
+                  }
+                  // ------- END CUSTOM CODE -------
+
+                  if (delay != null) {
+                    // The user specified a retry delay.
+                    // They gave us a number, use a timer, otherwise, it's a function,
+                    // and we're going to call it to get a notifier.
+                    const notifier =
+                      typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar))
+                    const notifierSubscriber = createOperatorSubscriber(
+                      subscriber,
+                      () => {
+                        // After we get the first notification, we
+                        // unsubscribe from the notifier, because we don't want anymore
+                        // and we resubscribe to the source.
+                        notifierSubscriber.unsubscribe()
+                        resub()
+                      },
+                      () => {
+                        // The notifier completed without emitting.
+                        // The author is telling us they want to complete.
+                        subscriber.complete()
+                      },
+                    )
+                    notifier.subscribe(notifierSubscriber)
+                  } else {
+                    // There was no notifier given. Just resub immediately.
+                    resub()
+                  }
+                } else {
+                  // We're past our maximum number of retries.
+                  // Just send along the error.
+                  subscriber.error(err)
+                }
+              },
+            ),
+          )
+          if (syncUnsub) {
+            innerSub.unsubscribe()
+            innerSub = null
+            subscribeForRetry()
+          }
+        }
+        subscribeForRetry()
+      })
+}

package/s3.js

@@ -327,7 +327,16 @@ function getTransformedHeaders(headers) {
    */
   const transformedHeaders = {}
 
+  const isRangedResponse = headers['content-range'] != null
+
   for (const name of Object.keys(headers)) {
+    // Google Cloud S3 returns checksums for the full object
+    // even with range requests, which causes checksum mismatches.
+    // I assume the checksum headers shouldn't be sent with ranged responses.
+    if (isRangedResponse && /^x-amz-checksum-/i.test(name)) {
+      continue
+    }
+
     const headerValues = headers[name]
     transformedHeaders[name] = Array.isArray(headerValues)
       ? headerValues.join(',')

package/serializers.js

@@ -140,7 +140,6 @@ export default {
     ureq && {
       url: getUrl(ureq),
       id: ureq.id || getHeader(ureq, 'request-id'),
-      userAgent: ureq.userAgent ?? getHeader(ureq, 'user-agent'),
       timing: ureq.timing,
       method: ureq.method,
       body: typeof ureq.body === 'string' ? ureq.body : undefined,
@@ -156,7 +155,6 @@ export default {
   ures: (ures) =>
     ures && {
       id: ures.id || getHeader(ures, 'request-id') || getHeader(ures.req, 'request-id'),
-      userAgent: ures.userAgent ?? getHeader(ures, 'user-agent'),
       timing: ures.timing,
       statusCode: ures.statusCode ?? ures.status,
       bytesRead: ures.bytesRead,