test(scripts): add bounded-concurrency map helper

Generating the versions/ workspace tree is thousands of mkdir/writeFile calls;
an unbounded Promise.all over the whole tree exhausts file descriptors (EMFILE).
This adds a reusable worker-pool map that bounds in-flight work while preserving
input order, and wires `test:scripts` so it runs in CI.

Author: BridgeAR

.github/workflows/project.yml

@@ -59,6 +59,7 @@ jobs:
       - uses: ./.github/actions/node/latest
       - uses: ./.github/actions/install
       - run: npm run test:release
+      - run: npm run test:scripts
 
   generated-config-types:
     runs-on: ubuntu-latest

package.json

@@ -104,6 +104,7 @@
     "test:integration:plugins:coverage": "yarn services && node ./integration-tests/coverage/run-suite.js \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/${SPEC:-*}*.spec.js\"",
     "test:unit:plugins": "mocha \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\" \"packages/datadog-plugin-@(${PLUGINS})/test/**/*.spec.js\" --exclude \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/*.spec.js\"",
     "test:release": "mocha \"scripts/release/**/*.spec.js\"",
+    "test:scripts": "mocha \"scripts/helpers/**/*.spec.js\"",
     "test:shimmer": "mocha \"packages/datadog-shimmer/test/**/*.spec.js\"",
     "test:shimmer:ci": "nyc --silent node init && nyc -- npm run test:shimmer",
     "verify:workflow-job-names": "node scripts/verify-workflow-job-names.js",

scripts/helpers/concurrency.js

@@ -0,0 +1,36 @@
+'use strict'
+
+/**
+ * Run an async worker over every item with at most `concurrency` workers in flight. Used to bound the number of open
+ * file handles while generating workspace folders and patching peer dependencies (an unbounded `Promise.all` over the
+ * whole `versions/` tree exhausts file descriptors / `EMFILE`). Results preserve input order; the first worker error
+ * rejects the returned promise.
+ *
+ * @template T, R
+ * @param {T[]} items
+ * @param {number} concurrency Maximum number of workers running at once; must be >= 1.
+ * @param {(item: T, index: number) => Promise<R> | R} worker
+ * @returns {Promise<R[]>}
+ */
+async function mapWithConcurrency (items, concurrency, worker) {
+  if (concurrency < 1) throw new RangeError(`concurrency must be >= 1, got ${concurrency}`)
+
+  const results = new Array(items.length)
+  let nextIndex = 0
+
+  const runWorker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex
+      nextIndex += 1
+      // Sequential within a worker is intended: concurrency comes from running several workers in parallel.
+      // eslint-disable-next-line no-await-in-loop
+      results[index] = await worker(items[index], index)
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, runWorker))
+
+  return results
+}
+
+module.exports = mapWithConcurrency

scripts/helpers/concurrency.spec.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { setTimeout: delay } = require('node:timers/promises')
+
+const { describe, it } = require('mocha')
+
+const mapWithConcurrency = require('./concurrency')
+
+describe('mapWithConcurrency', () => {
+  it('resolves to an empty array for no items', async () => {
+    assert.deepEqual(await mapWithConcurrency([], 4, () => assert.fail('should not run')), [])
+  })
+
+  it('preserves input order regardless of completion order', async () => {
+    const results = await mapWithConcurrency([30, 10, 20], 3, async (ms, index) => {
+      await delay(ms)
+      return index
+    })
+    assert.deepEqual(results, [0, 1, 2])
+  })
+
+  it('runs every item exactly once', async () => {
+    const seen = []
+    await mapWithConcurrency([1, 2, 3, 4, 5], 2, item => {
+      seen.push(item)
+    })
+    assert.deepEqual(seen.sort(), [1, 2, 3, 4, 5])
+  })
+
+  it('never exceeds the concurrency limit', async () => {
+    let active = 0
+    let peak = 0
+    await mapWithConcurrency(Array.from({ length: 10 }, (_, i) => i), 3, async () => {
+      active += 1
+      peak = Math.max(peak, active)
+      await delay(5)
+      active -= 1
+    })
+    assert.equal(peak, 3)
+  })
+
+  it('rejects with the first error and stops scheduling new work', async () => {
+    let started = 0
+    await assert.rejects(
+      mapWithConcurrency([1, 2, 3, 4, 5, 6], 1, async item => {
+        started += 1
+        if (item === 2) throw new Error('boom')
+        await delay(1)
+      }),
+      /boom/
+    )
+    // With concurrency 1 the failure on item 2 prevents items 3-6 from starting.
+    assert.equal(started, 2)
+  })
+
+  it('rejects for an invalid concurrency', async () => {
+    await assert.rejects(mapWithConcurrency([1], 0, () => {}), RangeError)
+  })
+})