@nxtedition/lib 21.6.3 → 21.8.0

package/app.js

@@ -1,7 +1,9 @@
 import * as inspector from 'node:inspector'
 import os from 'node:os'
+import http from 'node:http'
 import net from 'node:net'
 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'
@@ -802,46 +804,138 @@ export function makeApp(appConfig, onTerminate) {
     }
   }
 
-  const inspectBC = new BroadcastChannel('nxt:inspect')
-  const inspectSet = new Set()
+  if (appConfig.inspect !== false && !cluster.isWorker) {
+    // TODO (fix): What about cluster?
 
-  if (serviceWorkerId) {
-    inspectBC.onmessage = ({ data }) => {
-      const { type, id } = data
+    const inspectBC = new BroadcastChannel('nxt:inspect')
+    let inspectOpen = false
 
-      if (id !== serviceWorkerId) {
-        return
-      }
+    if (!isMainThread) {
+      inspectBC.onmessage = ({ data }) => {
+        const { type, id } = data
+
+        if (id !== threadId) {
+          return
+        }
 
-      if (type === 'inspect:open') {
-        // TODO (fix): What happens if you call inspect:open multiple times?
-        inspector.open(data.port, data.hostname)
-      } else if (type === 'inspect:close') {
-        inspector.close()
+        if (type === 'inspect:open') {
+          // TODO (fix): What happens if you call inspect:open multiple times?
+          if (!inspectOpen) {
+            inspector.open(data.port, data.hostname)
+            inspectOpen = true
+          }
+        } else if (type === 'inspect:close') {
+          if (inspectOpen) {
+            inspector.close()
+            inspectOpen = false
+          }
+        }
       }
-    }
 
-    inspectBC.postMessage({ type: 'inspect:register', id: serviceWorkerId })
-    destroyers.unshift(() => {
-      inspector.close()
-      inspectBC.postMessage({ type: 'inspect:unregister', id: serviceWorkerId })
-      setTimeout(() => {
-        inspectBC.close()
-      }, 100)
-    })
-  } else {
-    inspectBC.onmessage = ({ data }) => {
-      const { type } = data
+      inspectBC.postMessage({
+        type: 'inspect:register',
+        id: threadId,
+        worker: {
+          id: threadId,
+          name: serviceName,
+          module: serviceModule,
+          version: serviceVersion,
+          workerId: serviceWorkerId,
+          instanceId: serviceInstanceId,
+          threadId,
+          processId: process.pid,
+        },
+      })
+      destroyers.unshift(() => {
+        if (inspectOpen) {
+          inspector.close()
+          inspectOpen = false
+        }
+        inspectBC.postMessage({ type: 'inspect:unregister', id: threadId })
+        setTimeout(() => {
+          inspectBC.close()
+        }, 100)
+      })
+    } else {
+      const inspectMap = new Set()
+
+      inspectBC.onmessage = ({ data }) => {
+        const { type, worker } = data
 
-      if (type === 'inspect:register') {
-        inspectSet.add(data.id)
-      } else if (type === 'inspect:unregister') {
-        inspectSet.delete(data.id)
+        if (type === 'inspect:register') {
+          inspectMap.set(data.id, worker)
+        } else if (type === 'inspect:unregister') {
+          inspectMap.delete(data.id)
+        }
       }
+      destroyers.unshift(() => inspectBC.close())
+
+      // TODO (fix): Determinisitc port also in dev mode... hash of something?
+      const port =
+        appConfig.inspect?.port ?? (isProduction ? 38603 : Math.floor(38000 + Math.random() * 1000))
+      const server = http
+        .createServer(async (req, res) => {
+          try {
+            // TOOD (fix); Better matching...
+            if (!req.url.startsWith('/inspect')) {
+              res.statusCode = 404
+              res.end()
+              return
+            }
+
+            if (req.method === 'GET') {
+              res.end(
+                JSON.stringify({
+                  workers: Array.from(inspectMap.values()),
+                }),
+              )
+              return
+            }
+
+            if (req.method === 'POST') {
+              const m = req.url.match(/^\/inspect\/([^/]+)/)
+              if (!m) {
+                res.statusCode = 404
+                res.end()
+                return
+              } else {
+                const { port, hostname } = await json(req)
+
+                // TODO (fix): What about return value & errors?
+                inspectBC.postMessage({
+                  type: port || hostname ? 'inspect:open' : 'inspect:close',
+                  id: parseInt(m[1]),
+                  port,
+                  hostname,
+                })
+
+                res.end()
+                return
+              }
+            }
+
+            res.statusCode = 405
+            res.end()
+          } catch (err) {
+            logger?.error({ err }, 'inspect http error')
+
+            if (res.headersSent) {
+              res.destroy()
+            } else {
+              res.statusCode = 500
+              res.end()
+            }
+          }
+        })
+        .listen(port)
+
+      logger.debug({ port }, 'inspect listening')
+
+      destroyers.unshift(() => new Promise((resolve) => server.close(resolve)))
     }
-    destroyers.unshift(() => inspectBC.close())
   }
 
+  // TODO (fix): Deprecate
   if (appConfig.http) {
     const httpConfig = { ...appConfig.http, ...config.http }
 
@@ -864,36 +958,6 @@ export function makeApp(appConfig, onTerminate) {
               return next()
             }
           },
-          async ({ req, res }, next) => {
-            if (req.url.startsWith('/inspect')) {
-              if (req.method === 'GET') {
-                res.end(JSON.stringify({ workers: Array.from(inspectSet).map((id) => ({ id })) }))
-              } else if (req.method === 'POST') {
-                const m = req.url.match(/^\/inspect\/([^/]+)/)
-                if (!m) {
-                  res.statusCode = 404
-                  res.end()
-                } else {
-                  const { port, hostname } = await json(req)
-
-                  // TODO (fix): What about return value & errors?
-                  inspectBC.postMessage({
-                    type: port || hostname ? 'inspect:open' : 'inspect:close',
-                    id: m[1],
-                    port,
-                    hostname,
-                  })
-
-                  res.end()
-                }
-              } else {
-                res.statusCode = 405
-                res.end()
-              }
-            } else {
-              return next()
-            }
-          },
           appConfig.http.request
             ? appConfig.http.request
             : typeof appConfig.http === 'function'

package/couch.js

@@ -119,7 +119,7 @@ export function makeCouch(opts) {
    * @param {string} [options.since=null] - The sequence number to start from.
    * @param {number} [options.highWaterMark=128 * 1024] - Buffering.
    * @param {object} [options.selector=null] - The selector to filter changes.
-   * @yields {Array<{ id: string, seq?: string, doc?: Object, deleted?: boolean, changes: Array<{ rev: string }> }>}
+   * @return {AsyncGenerator<Array<{ id: string, seq?: string, doc?: Object, deleted?: boolean, changes: Array<{ rev: string }>}> & { lastSeq: string | null | 0 }}
    */
   async function* changes({ client = defaultClient, signal = null, logger, ...options } = {}) {
     const params = {}

package/merge-ranges.js

@@ -29,7 +29,13 @@ export default function mergeRanges(ranges) {
     const range = ranges[n]
     const top = stack[stack.length - 1]
 
-    if (range.length !== 2 || !Number.isFinite(range[0]) || !Number.isFinite(range[1])) {
+    if (
+      !Array.isArray(range) ||
+      range.length !== 2 ||
+      !Number.isFinite(range[0]) ||
+      !Number.isFinite(range[1]) ||
+      range[0] > range[1]
+    ) {
       continue
     }
 

package/package.json

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

package/s3.js

@@ -10,13 +10,13 @@ const QUEUE = new PQueue({ concurrency: 8 })
 const MD5_HEX_EXPR = /^[A-F0-9]{32}$/i
 
 /**
- * @typedef {import('undici').Dispatcher} Dispatcher
- * @typedef {import('@aws-sdk/client-s3').S3ClientConfig & {dispatcher?: Dispatcher}} S3ClientConfig
+ * @import { Dispatcher } from 'undici'
+ * @import { S3ClientConfig, CreateMultipartUploadRequest } from '@aws-sdk/client-s3'
  */
 
 export class S3Client extends AWS.S3Client {
   /**
-   * @param {S3ClientConfig} config
+   * @param {S3ClientConfig & { dispatcher?: Dispatcher }} config
    */
   constructor(config) {
     const { dispatcher, ...options } = config
@@ -79,12 +79,11 @@ class UndiciRequestHandler extends NodeHttpHandler {
  * @param {Object} options.logger - The logger to use.
  * @param {number} [options.partSize=16e6] - The size of each part in the multipart upload.
  * @param {PQueue} [options.queue] - The queue to use for part uploads.
- * @param {Object} options.params - The parameters for the upload.
- * @param {Buffer|NodeJS.ReadStream} options.params.Body - The data to upload.
- * @param {string} options.params.Key - The key of the object.
- * @param {string} options.params.Bucket - The name of the bucket.
- * @param {string} [options.params.ContentMD5] - The MD5 hash of the object as base64 string.
- * @param {number} [options.params.ContentLength] - The length of the object.
+ * @param {CreateMultipartUploadRequest & {
+ *   Body: Buffer | NodeJS.ReadStream,
+ *   ContentMD5?: string,
+ *   ContentLength?: number,
+ * }} options.params - The parameters for the upload.
  * @returns {Promise<Object>} The result of the upload.
  */
 export async function upload({
@@ -107,7 +106,7 @@ export async function upload({
     throw new Error('Invalid params')
   }
 
-  const { Body, Key, Bucket, ContentMD5, ContentLength } = params
+  const { Body, Key, Bucket, ContentMD5, ContentLength, ...createMultipartParams } = params
 
   const size = ContentLength != null ? Number(ContentLength) : null
 
@@ -144,7 +143,7 @@ export async function upload({
     }
 
     const multipartUploadOutput = await s3.send(
-      new AWS.CreateMultipartUploadCommand({ Bucket, Key }),
+      new AWS.CreateMultipartUploadCommand({ ...createMultipartParams, Bucket, Key }),
       { abortSignal: uploader.signal },
     )
     uploader.signal.throwIfAborted()