@nxtedition/lib 26.8.8 → 27.0.0

package/app.js

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs'
 import * as inspector from 'node:inspector'
 import fs from 'node:fs'
 import os from 'node:os'
@@ -7,9 +8,9 @@ import assert from 'node:assert'
 import cluster from 'node:cluster'
 import stream from 'node:stream'
 import { Buffer } from 'node:buffer'
-import { getDockerSecretsSync } from './docker-secrets.js'
-import { getUTCRangeForLocalTime } from './time.js'
-import fp from 'lodash/fp.js'
+import v8 from 'node:v8'
+import { isPrimary } from 'node:cluster'
+import { monitorEventLoopDelay } from 'node:perf_hooks'
 import {
   isMainThread,
   parentPort,
@@ -17,13 +18,16 @@ import {
   BroadcastChannel,
   resourceLimits,
 } from 'node:worker_threads'
+
+import { getDockerSecretsSync } from './docker-secrets.js'
+import { getUTCRangeForLocalTime } from './time.js'
+import fp from 'lodash/fp.js'
 import deepstream from '@nxtedition/deepstream.io-client-js'
 import { createLogger } from './logger.js'
 import nconf from 'nconf'
 import { makeCouch } from './couch.js'
-import { makeTemplateCompiler } from './util/template/index.js'
+import { makeTemplateCompiler } from '@nxtedition/template'
 import { makeDeepstream } from './deepstream.js'
-import v8 from 'v8'
 import * as rxjs from 'rxjs'
 import rx from 'rxjs/operators'
 import { performance } from 'perf_hooks'
@@ -31,15 +35,18 @@ import hashString from './hash.js'
 import { makeTrace } from './trace.js'
 import { compose, createServer } from './http.js'
 import { json } from 'node:stream/consumers'
-import { monitorEventLoopDelay } from 'node:perf_hooks'
 import xuid from 'xuid'
 import { isTimeBetween } from './time.js'
 import makeUnderPressure from './under-pressure.js'
-import { isPrimary } from 'node:cluster'
 import { nice } from '@nxtedition/sched'
 import { setAffinity } from './numa.js'
 
-export function makeApp(appConfig, onTerminate) {
+/**
+ * @param {object} appConfig
+ * @param {object} [meta]
+ * @returns {object}
+ */
+export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
   let ds
   let nxt
   let couch
@@ -49,6 +56,27 @@ export function makeApp(appConfig, onTerminate) {
   let logger
   let trace
 
+  let onTerminate
+  let meta
+
+  if (typeof onTerminateOrMeta === 'function') {
+    meta = metaOrNull
+  } else {
+    meta = onTerminateOrMeta ?? metaOrNull
+  }
+
+  if (onTerminate != null && typeof onTerminateOrMeta !== 'function') {
+    throw new Error('onTerminate must be a function or null')
+  }
+
+  if (meta != null && typeof meta !== 'object') {
+    throw new Error('meta must be an object or null')
+  }
+
+  const pkg = meta?.url
+    ? JSON.parse(readFileSync(new URL('../package.json', meta.url).pathname).toString())
+    : null
+
   /** @type {Array<rxjs.Subscription|Function|AsyncFunction|Disposable|AsyncDisposable>} */
   const destroyers = []
 
@@ -119,6 +147,9 @@ export function makeApp(appConfig, onTerminate) {
     }
   }
 
+  appConfig.name ||= pkg?.name ?? null
+  appConfig.version ||= pkg?.version ?? null
+
   assert(appConfig.name, 'name is required')
 
   const appDestroyers = []

package/couch.d.ts

@@ -21,6 +21,7 @@ export interface CouchRequestOptions<Stream extends boolean = false> {
   bodyTimeout?: number
   dispatcher?: Dispatcher
   query?: {
+    key?: string
     startkey?: string
     endkey?: string
     update?: boolean

package/couch.js

@@ -2,7 +2,7 @@ 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 { makeWeakCache } from '@nxtedition/weak-cache'
 import { defaultDelay as delay } from './http.js'
 import urljoin from 'url-join'
 import { AbortError } from './errors.js'

package/numa.js

@@ -3,6 +3,21 @@ import path from 'node:path'
 
 import { sched_setaffinity } from '@nxtedition/sched'
 
+function parseRange(value) {
+  const range = []
+  for (const part of value.split(',')) {
+    if (part.includes('-')) {
+      const [start, end] = part.split('-').map(Number)
+      for (let i = start; i <= end; i++) {
+        range.push(i)
+      }
+    } else {
+      range.push(Number(part))
+    }
+  }
+  return range
+}
+
 /**
  *
  * @param {number|number[]} numa
@@ -14,6 +29,8 @@ export function setAffinity(numa) {
     throw new Error('NUMA node must be a non-negative integer')
   }
 
+  const isolated = parseRange(fs.readFileSync('/sys/devices/system/cpu/isolated', 'utf8').trim())
+
   const allNodes = []
   for (const entry of fs.readdirSync('/sys/devices/system/node')) {
     if (!entry.startsWith('node')) {
@@ -23,25 +40,17 @@ export function setAffinity(numa) {
     const cpulist = fs
       .readFileSync(path.join('/sys/devices/system/node', entry, 'cpulist'), 'utf8')
       .trim()
-    const cpus = []
-    for (const part of cpulist.split(',')) {
-      if (part.includes('-')) {
-        const [start, end] = part.split('-').map(Number)
-        for (let i = start; i <= end; i++) {
-          cpus.push(i)
-        }
-      } else {
-        cpus.push(Number(part))
-      }
-    }
-    allNodes.push(cpus)
+
+    allNodes.push(parseRange(cpulist))
   }
 
   if (allNodes.length === 0) {
     throw new Error('No NUMA nodes found')
   }
 
-  const affinity = indices.flatMap((i) => allNodes[i % allNodes.length] ?? [])
+  const affinity = indices
+    .flatMap((i) => allNodes[i % allNodes.length] ?? [])
+    .filter((cpu) => !isolated.includes(cpu))
   sched_setaffinity(0, affinity)
   globalThis.__nxt_sched_affinity = {
     cpulist: affinity,

package/package.json

@@ -1,25 +1,22 @@
 {
   "name": "@nxtedition/lib",
-  "version": "26.8.8",
-  "license": "MIT",
+  "version": "27.0.0",
+  "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
   "files": [
     "index.d.ts",
     "hash.js",
     "ass.js",
-    "rxjs/*",
     "util/*",
     "cache.js",
     "fixed-queue.js",
-    "http-client.js",
     "subtract-ranges.js",
     "serializers.js",
     "platform.js",
     "elasticsearch.js",
     "merge-ranges.js",
     "http.js",
-    "s3.js",
     "time.js",
     "mutex.js",
     "deepstream.js",
@@ -33,8 +30,6 @@
     "proxy.js",
     "timers.js",
     "trace.js",
-    "weakCache.js",
-    "weakCache.d.ts",
     "couch.js",
     "couch.d.ts",
     "app.js",
@@ -43,57 +38,34 @@
     "errors.d.ts",
     "worker.js",
     "stream.js",
-    "timeline.js",
     "transcript.js",
     "docker-secrets.js",
     "wordwrap.js",
-    "under-pressure.js",
-    "yield.js"
+    "under-pressure.js"
   ],
   "scripts": {
     "test": "node --test-timeout 60000 --test",
-    "test:types": "tsd",
-    "prepare": "husky"
-  },
-  "lint-staged": {
-    "*.{js,jsx,md,ts}": [
-      "eslint",
-      "prettier --write"
-    ]
-  },
-  "prettier": {
-    "printWidth": 100,
-    "semi": false,
-    "singleQuote": true
+    "test:types": "tsd"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.918.0",
     "@elastic/elasticsearch": "^8.17.1",
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^6.4.17",
     "@nxtedition/sched": "^1.0.2",
-    "@smithy/node-http-handler": "^4.4.3",
-    "acorn": "^8.15.0",
-    "astring": "^1.9.0",
-    "date-fns": "^4.1.0",
+    "@nxtedition/template": "^1.0.0-alpha.0",
+    "@nxtedition/weak-cache": "^1.0.0-alpha.0",
     "diff": "5.2.0",
     "fast-querystring": "^1.1.2",
-    "hasha": "^7.0.0",
     "http-errors": "^2.0.0",
-    "json5": "^2.2.3",
     "lodash": "^4.17.21",
     "lru-cache": "^11.2.2",
     "mime": "^4.0.7",
     "mitata": "^1.0.34",
-    "moment-timezone": "^0.5.48",
     "nconf": "^0.13.0",
     "object-hash": "^3.0.0",
-    "p-queue": "^9.0.0",
     "pino": "^10.1.0",
     "qs": "^6.14.0",
     "request-target": "^1.0.2",
-    "smpte-timecode": "^1.3.6",
-    "split-string": "^6.0.0",
     "url-join": "^5.0.0",
     "xuid": "^4.1.5",
     "yocto-queue": "^1.2.1"
@@ -103,20 +75,9 @@
     "@types/lodash": "^4.17.20",
     "@types/node": "^24.9.1",
     "canvas": "^3.1.0",
-    "eslint": "^9.38.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^17.23.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^7.2.1",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.6",
-    "prettier": "^3.6.2",
     "rxjs": "^7.8.2",
     "tsd": "^0.33.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.6.0",
@@ -124,6 +85,7 @@
     "@nxtedition/deepstream.io-client-js": ">=14.1.0",
     "canvas": "^3.1.0",
     "pino": ">=7.0.0",
-    "rxjs": ">=6.0.0"
-  }
+    "rxjs": "^7.0.0"
+  },
+  "gitHead": "8c7a9f6b7dbf185d39f5927c779265415fb29bfb"
 }

package/rxjs/auditMap.js

@@ -1,111 +0,0 @@
-import { Observable, from } from 'rxjs'
-
-function auditMapImpl(project) {
-  return new Observable((o) => {
-    let pendingValue = null
-    let hasPendingValue = false
-    let isComplete = false
-    let abortController = null
-
-    let innerSubscription = null
-    let outerSubscription = null
-
-    function _error(err) {
-      o.error(err)
-    }
-
-    function _innerComplete() {
-      innerSubscription = null
-      abortController = null
-
-      if (hasPendingValue) {
-        const value = pendingValue
-        pendingValue = null
-        hasPendingValue = false
-        _tryNext(value)
-      } else if (isComplete) {
-        o.complete()
-      }
-    }
-
-    function _innerNext(val) {
-      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, {
-          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,
-          error: _error,
-          complete: _innerComplete,
-        })
-        if (innerSubscription && innerSubscription.closed) {
-          innerSubscription = null
-        }
-      } catch (err) {
-        o.error(err)
-      }
-    }
-
-    function _next(value) {
-      if (innerSubscription) {
-        pendingValue = value
-        hasPendingValue = true
-        abortController?.abort()
-      } else {
-        _tryNext(value)
-      }
-    }
-
-    function _complete() {
-      isComplete = true
-      if (!innerSubscription) {
-        o.complete()
-      } else {
-        abortController?.abort()
-      }
-    }
-
-    outerSubscription = this.subscribe({
-      next: _next,
-      error: _error,
-      complete: _complete,
-    })
-
-    return () => {
-      if (innerSubscription) {
-        innerSubscription.unsubscribe()
-      }
-      outerSubscription.unsubscribe()
-    }
-  })
-}
-
-Observable.prototype.auditMap = auditMapImpl
-
-export default function auditMap(project) {
-  return (o) => auditMapImpl.call(o, project)
-}

package/rxjs/auditMap.test.js

@@ -1,64 +0,0 @@
-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/combineMap.d.ts

@@ -1,6 +0,0 @@
-import type { ObservableInput, OperatorFunction } from 'rxjs'
-
-export default function combineMap<T, R>(
-  project: (value: T) => ObservableInput<R>,
-  equals?: (a: T, b: T) => boolean,
-): OperatorFunction<T[], R[]>

package/rxjs/combineMap.js

@@ -1,152 +0,0 @@
-import { Observable, from, throwError } from 'rxjs'
-
-const EMPTY = Object.freeze([])
-
-function combineMapImpl(project, equals = (a, b) => a === b) {
-  return new Observable((o) => {
-    let curr = EMPTY
-    let scheduled = false
-    let disposed = false
-    let dirty = false
-    let active = 0
-    let empty = 0
-
-    const _error = (err) => o.error(err)
-
-    function _update() {
-      scheduled = false
-
-      if (empty > 0) {
-        return
-      }
-
-      if (dirty) {
-        dirty = false
-        o.next(curr.map(({ value }) => value))
-      }
-
-      if (active === 0) {
-        o.complete()
-      }
-    }
-
-    function update() {
-      if (!scheduled && !disposed) {
-        scheduled = true
-        queueMicrotask(_update)
-      }
-    }
-
-    active += 1
-    const subscription = this.subscribe({
-      next(keys) {
-        keys = Array.isArray(keys) ? keys : EMPTY
-
-        // TODO (perf): Avoid array allocation & copy if nothing has updated.
-        const prev = curr
-        curr = new Array(keys.length)
-
-        const prevLen = prev.length
-        const currLen = curr.length
-
-        if (currLen !== prevLen || prev === EMPTY) {
-          dirty = true
-        }
-
-        for (let n = 0; n < currLen; ++n) {
-          const key = keys[n]
-
-          if (n < prevLen && prev[n] && equals(prev[n].key, key)) {
-            curr[n] = prev[n]
-            prev[n] = null
-            continue
-          }
-
-          dirty = true
-
-          // TODO (perf): Guess start index based on n, e.g. n - 1 and n + 1 to check if
-          // a key has simply been added or removed.
-          const i = prev.findIndex((entry) => entry && equals(entry.key, key))
-
-          if (i !== -1) {
-            curr[n] = prev[i]
-            prev[i] = null
-          } else {
-            let observable
-            try {
-              observable = from(project(keys[n]))
-            } catch (err) {
-              observable = throwError(() => err)
-            }
-
-            const entry = {
-              key,
-              value: EMPTY,
-              subscription: null,
-            }
-
-            empty += 1
-            entry.subscription = observable.subscribe({
-              next(value) {
-                if (entry.value === EMPTY) {
-                  empty -= 1
-                }
-
-                entry.value = value
-                dirty = true
-
-                update()
-              },
-              error: _error,
-            })
-
-            active += 1
-            entry.subscription.add(() => {
-              active -= 1
-
-              if (entry.value === EMPTY) {
-                empty -= 1
-              }
-
-              update()
-            })
-
-            if (disposed) {
-              entry.subscription.unsubscribe()
-            } else {
-              curr[n] = entry
-            }
-          }
-        }
-
-        // TODO (perf): start from index where prev[n] is not null.
-        for (let n = 0; n < prevLen; n++) {
-          prev[n]?.subscription?.unsubscribe()
-        }
-
-        update()
-      },
-      complete: () => {
-        active -= 1
-        update()
-      },
-      error: _error,
-    })
-
-    return () => {
-      disposed = true
-
-      for (const entry of curr) {
-        entry?.subscription?.unsubscribe()
-      }
-
-      subscription.unsubscribe()
-    }
-  })
-}
-
-Observable.prototype.combineMap = combineMapImpl
-
-export default function combineMap(project, equals) {
-  return (o) => combineMapImpl.call(o, project, equals)
-}