@sap/cds-dk 10.1.0 → 10.1.2

package/node_modules/@sap/cds-mtxs/srv/worker/job-worker-pool.js

@@ -0,0 +1,212 @@
+'use strict'
+
+const { Worker } = require('worker_threads')
+const path = require('path')
+const cds = require('@sap/cds')
+
+const LOG = cds.log('mtx')
+const WORKER_PATH = path.join(__dirname, 'job-worker.js')
+
+const IDLE = 'idle'
+const BUSY = 'busy'
+const BOOTING = 'booting'
+
+class DeploymentPool {
+
+  constructor(size) {
+    this.size = size
+    this.workers = []       // { worker, state, pending: Map<id, {resolve,reject}> }
+    this.waitQueue = []     // queued acquire requests: { resolve, reject }
+    this._idCounter = 0
+    this._shuttingDown = false
+  }
+
+  /**
+   * Spawn a new worker, bootstrap it, and add it to the pool.
+   * Returns a promise that resolves when the worker is ready.
+   */
+  _spawn() {
+    return new Promise((resolve, reject) => {
+      const worker = new Worker(WORKER_PATH, { env: process.env, workerData: { cdsEnv: cds.env, cdsRoot: cds.root } })
+      const entry = { worker, state: BOOTING, pending: new Map() }
+      this.workers.push(entry)
+
+      const onReady = (msg) => {
+        if (msg.ready) {
+          worker.off('message', onReady)
+          worker.off('error', onError)
+          entry.state = IDLE
+          worker.on('message', (msg) => this._onMessage(entry, msg))
+          worker.on('error', (err) => this._onError(entry, err))
+          worker.on('exit', (code) => this._onExit(entry, code))
+          resolve(entry)
+        } else if (msg.error) {
+          worker.off('message', onReady)
+          worker.off('error', onError)
+          this.workers = this.workers.filter(e => e !== entry)
+          reject(new Error(msg.error))
+        }
+      }
+
+      const onError = (err) => {
+        worker.off('message', onReady)
+        this.workers = this.workers.filter(e => e !== entry)
+        reject(err)
+      }
+
+      worker.on('message', onReady)
+      worker.on('error', onError)
+    })
+  }
+
+  /**
+   * Handle messages from a worker (command responses).
+   */
+  _onMessage(entry, { id, result, error }) {
+    const pending = entry.pending.get(id)
+    if (!pending) return
+    entry.pending.delete(id)
+    if (error) pending.reject(new Error(error))
+    else pending.resolve(result)
+  }
+
+  /**
+   * Handle worker errors.
+   */
+  _onError(entry, err) {
+    LOG.error('Deployment worker error:', err.message)
+    // Reject all pending tasks on this worker
+    for (const [, { reject }] of entry.pending) {
+      reject(new Error(`Worker error: ${err.message}`))
+    }
+    entry.pending.clear()
+  }
+
+  /**
+   * Handle worker exit — reject in-flight tasks and replace the worker.
+   */
+  _onExit(entry, code) {
+    this.workers = this.workers.filter(e => e !== entry)
+
+    // Reject any in-flight tasks
+    for (const [, { reject }] of entry.pending) {
+      reject(new Error(`Worker exited unexpectedly with code ${code}`))
+    }
+    entry.pending.clear()
+
+    // Do not replace workers during shutdown
+    if (this._shuttingDown) return
+
+    // Immediately replace the crashed worker
+    LOG.warn('Deployment worker exited with code', code, '- spawning replacement')
+    this._spawn().then(newEntry => {
+      // If there are queued requests waiting, serve them
+      if (this.waitQueue.length > 0 && newEntry.state === IDLE) {
+        newEntry.state = BUSY
+        const { resolve } = this.waitQueue.shift()
+        resolve(newEntry)
+      }
+    }).catch(err => {
+      LOG.error('Failed to spawn replacement worker:', err.message)
+      // If there are queued requests waiting, reject the first one
+      if (this.waitQueue.length > 0) {
+        const { reject } = this.waitQueue.shift()
+        reject(err)
+      }
+    })
+  }
+
+  /**
+   * Acquire an idle worker. If none available and pool not full, spawns a new one.
+   * If all workers are busy and pool is full, queues the request.
+   */
+  async acquire() {
+    // Try to find an idle worker
+    const idle = this.workers.find(e => e.state === IDLE)
+    if (idle) {
+      idle.state = BUSY
+      return idle
+    }
+
+    // Pool not full — spawn a new worker
+    if (this.workers.length < this.size) {
+      const entry = await this._spawn()
+      entry.state = BUSY
+      return entry
+    }
+
+    // All busy — wait in queue
+    return new Promise((resolve, reject) => {
+      this.waitQueue.push({ resolve, reject })
+    })
+  }
+
+  /**
+   * Release a worker back to idle state. Serves the next queued request if any.
+   */
+  release(entry) {
+    if (this.waitQueue.length > 0) {
+      entry.state = BUSY
+      const { resolve } = this.waitQueue.shift()
+      resolve(entry)
+    } else {
+      entry.state = IDLE
+    }
+  }
+
+  /**
+   * Execute a service action on a worker.
+   * Acquires a worker, sends the command, waits for the result, releases the worker.
+   */
+  async exec(service, op, tenant, args) {
+    const entry = await this.acquire()
+    const id = ++this._idCounter
+    try {
+      const result = await new Promise((resolve, reject) => {
+        entry.pending.set(id, { resolve, reject })
+        entry.worker.postMessage({ id, service, op, tenant, args, cdsEnv: cds.env })
+      })
+      return result
+    } finally {
+      this.release(entry)
+    }
+  }
+
+  /**
+   * Shut down all workers. Sends a shutdown message to each worker and waits for them to exit.
+   */
+  async shutdown() {
+    this._shuttingDown = true
+
+    // Reject all queued acquire requests
+    for (const { reject } of this.waitQueue) {
+      reject(new Error('Worker pool is shutting down'))
+    }
+    this.waitQueue = []
+
+    // Send shutdown message to all workers and wait for them to exit
+    await Promise.all(this.workers.map(entry => {
+      for (const [, { reject }] of entry.pending) {
+        reject(new Error('Worker pool is shutting down'))
+      }
+      entry.pending.clear()
+      entry.worker.postMessage({ shutdown: true })
+      return new Promise(resolve => entry.worker.once('exit', resolve))
+    }))
+    this.workers = []
+  }
+}
+
+let _pool
+
+/**
+ * Returns the singleton DeploymentPool instance.
+ * @param {number} size - Pool size (number of workers)
+ */
+module.exports = function getDeploymentPool(size) {
+  if (!_pool) {
+    _pool = new DeploymentPool(size)
+    cds.on('shutdown', async () => _pool.shutdown())
+  }
+  return _pool
+}

package/node_modules/@sap/cds-mtxs/srv/worker/job-worker.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { parentPort, workerData } = require('worker_threads')
+const cds = require('@sap/cds')
+const { _import, isfile, path } = cds.utils
+
+if (workerData?.cdsRoot) cds.root = workerData.cdsRoot
+if (workerData?.cdsEnv) cds.env.add(workerData.cdsEnv)
+
+async function bootstrap() {
+  const services = [
+    '@sap/cds-mtxs/srv/deployment-service',
+    '@sap/cds-mtxs/srv/model-provider',
+    '@sap/cds-mtxs/srv/cf/saas-provisioning-service',
+    '@sap/cds-mtxs/srv/extensibility-service',
+  ]
+  await _local_cli_js()
+  cds.emit('bootstrap')
+  const model = await cds.load([...services, '@sap/cds-mtxs/db/extensions'])
+  cds.model = cds.compile.for.nodejs(model)
+  const unserved = !cds.services['cds.xt.DeploymentService']
+  if (unserved) await cds.serve(services)
+  await cds.plugins
+  await cds.emit('served', cds.services)
+  parentPort.postMessage({ ready: true })
+}
+
+async function _local_cli_js() {
+  const _local = file => isfile(file) || isfile(path.join(cds.env.folders.srv, file))
+  const cli_js = process.env.CDS_TYPESCRIPT && (_local('cli.ts') || _local('server.ts')) || _local('cli.js') || _local('server.js')
+  if (cli_js) await _import(cli_js)
+}
+
+parentPort.on('message', async (msg) => {
+  if (msg.shutdown) {
+    await cds.shutdown()
+    process.exit(0)
+  }
+  const { id, service, op, tenant, args, cdsEnv } = msg
+  if (cdsEnv) cds.env.add(cdsEnv)
+  const srv = cds.services[service]
+  if (!srv) {
+    parentPort.postMessage({ id, error: `Service ${service} not available` })
+    return
+  }
+  try {
+    const result = await srv[op](tenant, ...Object.values(args))
+    parentPort.postMessage({ id, result })
+  } catch (e) {
+    const error = e.message ?? 'Unknown error'
+    parentPort.postMessage({ id, error })
+  } finally {
+    // cds.db.disconnect(cds.env.requires.multitenancy.t0 ?? 't0')
+    // cds.db.disconnect(tenant)
+  }
+})
+
+bootstrap().catch(e => {
+  parentPort.postMessage({ error: `Bootstrap failed: ${e.message}` })
+  process.exit(1)
+})

package/node_modules/proxy-addr/HISTORY.md

@@ -1,144 +1,150 @@
-2.0.7 / 2021-05-31
-==================
+2.0.8
+=====
+
+  * Fix [CVE-2026-90711](https://www.cve.org/CVERecord?id=CVE-2026-90711) ([GHSA-jqcg-44mw-7w3h](https://github.com/jshttp/proxy-addr/security/advisories/GHSA-jqcg-44mw-7w3h))
+
+
+2.0.7
+=====
 
   * deps: forwarded@0.2.0
     - Use `req.socket` over deprecated `req.connection`
 
-2.0.6 / 2020-02-24
-==================
+2.0.6
+=====
 
   * deps: ipaddr.js@1.9.1
 
-2.0.5 / 2019-04-16
-==================
+2.0.5
+=====
 
   * deps: ipaddr.js@1.9.0
 
-2.0.4 / 2018-07-26
-==================
+2.0.4
+=====
 
   * deps: ipaddr.js@1.8.0
 
-2.0.3 / 2018-02-19
-==================
+2.0.3
+=====
 
   * deps: ipaddr.js@1.6.0
 
-2.0.2 / 2017-09-24
-==================
+2.0.2
+=====
 
   * deps: forwarded@~0.1.2
     - perf: improve header parsing
     - perf: reduce overhead when no `X-Forwarded-For` header
 
-2.0.1 / 2017-09-10
-==================
+2.0.1
+=====
 
   * deps: forwarded@~0.1.1
     - Fix trimming leading / trailing OWS
     - perf: hoist regular expression
   * deps: ipaddr.js@1.5.2
 
-2.0.0 / 2017-08-08
-==================
+2.0.0
+=====
 
   * Drop support for Node.js below 0.10
 
-1.1.5 / 2017-07-25
-==================
+1.1.5
+=====
 
   * Fix array argument being altered
   * deps: ipaddr.js@1.4.0
 
-1.1.4 / 2017-03-24
-==================
+1.1.4
+=====
 
   * deps: ipaddr.js@1.3.0
 
-1.1.3 / 2017-01-14
-==================
+1.1.3
+=====
 
   * deps: ipaddr.js@1.2.0
 
-1.1.2 / 2016-05-29
-==================
+1.1.2
+=====
 
   * deps: ipaddr.js@1.1.1
     - Fix IPv6-mapped IPv4 validation edge cases
 
-1.1.1 / 2016-05-03
-==================
+1.1.1
+=====
 
   * Fix regression matching mixed versions against multiple subnets
 
-1.1.0 / 2016-05-01
-==================
+1.1.0
+=====
 
   * Fix accepting various invalid netmasks
     - IPv4 netmasks must be contingous
     - IPv6 addresses cannot be used as a netmask
   * deps: ipaddr.js@1.1.0
 
-1.0.10 / 2015-12-09
-===================
+1.0.10
+======
 
   * deps: ipaddr.js@1.0.5
     - Fix regression in `isValid` with non-string arguments
 
-1.0.9 / 2015-12-01
-==================
+1.0.9
+=====
 
   * deps: ipaddr.js@1.0.4
     - Fix accepting some invalid IPv6 addresses
     - Reject CIDRs with negative or overlong masks
   * perf: enable strict mode
 
-1.0.8 / 2015-05-10
-==================
+1.0.8
+=====
 
   * deps: ipaddr.js@1.0.1
 
-1.0.7 / 2015-03-16
-==================
+1.0.7
+=====
 
   * deps: ipaddr.js@0.1.9
     - Fix OOM on certain inputs to `isValid`
 
-1.0.6 / 2015-02-01
-==================
+1.0.6
+=====
 
   * deps: ipaddr.js@0.1.8
 
-1.0.5 / 2015-01-08
-==================
+1.0.5
+=====
 
   * deps: ipaddr.js@0.1.6
 
-1.0.4 / 2014-11-23
-==================
+1.0.4
+=====
 
   * deps: ipaddr.js@0.1.5
     - Fix edge cases with `isValid`
 
-1.0.3 / 2014-09-21
-==================
+1.0.3
+=====
 
   * Use `forwarded` npm module
 
-1.0.2 / 2014-09-18
-==================
+1.0.2
+=====
 
   * Fix a global leak when multiple subnets are trusted
   * Support Node.js 0.6
   * deps: ipaddr.js@0.1.3
 
-1.0.1 / 2014-06-03
-==================
+1.0.1
+=====
 
   * Fix links in npm package
 
-1.0.0 / 2014-05-08
-==================
+1.0.0
+=====
 
   * Add `trust` argument to determine proxy trust on
     * Accepts custom function
@@ -150,12 +156,12 @@
   * Add `proxyaddr.compile` to pre-compile `trust` function
     to make subsequent calls faster
 
-0.0.1 / 2014-05-04
-==================
+0.0.1
+=====
 
   * Fix bad npm publish
 
-0.0.0 / 2014-05-04
-==================
+0.0.0
+=====
 
   * Initial release

package/node_modules/proxy-addr/README.md

@@ -37,7 +37,7 @@ proxyaddr(req, function (addr) { return addr === '127.0.0.1' })
 proxyaddr(req, function (addr, i) { return i < 1 })
 ```
 
-The `trust` arugment may also be a single IP address string or an
+The `trust` argument may also be a single IP address string or an
 array of trusted addresses, as plain IP addresses, CIDR-formatted
 strings, or IP/netmask strings.
 

package/node_modules/proxy-addr/index.js

@@ -256,6 +256,13 @@ function trustMulti (subnets) {
     if (!isip(addr)) return false
 
     var ip = parseip(addr)
+
+    if (ip.kind() === 'ipv6' && ip.isIPv4MappedAddress()) {
+      // Canonicalize IPv4-mapped candidates to IPv4 so a mapped address
+      // cannot bypass the cross-family guard via the same-family path
+      ip = ip.toIPv4Address()
+    }
+
     var ipconv
     var kind = ip.kind()
 
@@ -272,6 +279,12 @@ function trustMulti (subnets) {
           continue
         }
 
+        if (subnetkind !== 'ipv4' && !(subnetrange >= 96 && subnetip.isIPv4MappedAddress())) {
+          // IPv6 subnet only spans IPv4 when it is a mapped subnet whose
+          // prefix covers the ::ffff: marker; otherwise it must not match IPv4
+          continue
+        }
+
         if (!ipconv) {
           // Convert IP to match subnet IP kind
           ipconv = subnetkind === 'ipv4'
@@ -280,6 +293,9 @@ function trustMulti (subnets) {
         }
 
         trusted = ipconv
+      } else if (kind === 'ipv6' && subnetip.isIPv4MappedAddress()) {
+        // A native IPv6 candidate cannot match an IPv4-mapped subnet
+        continue
       }
 
       if (trusted.match(subnetip, subnetrange)) {
@@ -308,6 +324,13 @@ function trustSingle (subnet) {
     if (!isip(addr)) return false
 
     var ip = parseip(addr)
+
+    if (ip.kind() === 'ipv6' && ip.isIPv4MappedAddress()) {
+      // Canonicalize IPv4-mapped candidates to IPv4 so a mapped address
+      // cannot bypass the cross-family guard via the same-family path
+      ip = ip.toIPv4Address()
+    }
+
     var kind = ip.kind()
 
     if (kind !== subnetkind) {
@@ -316,10 +339,19 @@ function trustSingle (subnet) {
         return false
       }
 
+      if (!subnetisipv4 && !(subnetrange >= 96 && subnetip.isIPv4MappedAddress())) {
+        // IPv6 subnet only spans IPv4 when it is a mapped subnet whose
+        // prefix covers the ::ffff: marker; otherwise it must not match IPv4
+        return false
+      }
+
       // Convert IP to match subnet IP kind
       ip = subnetisipv4
         ? ip.toIPv4Address()
         : ip.toIPv4MappedAddress()
+    } else if (kind === 'ipv6' && subnetip.isIPv4MappedAddress()) {
+      // A native IPv6 candidate cannot match an IPv4-mapped subnet
+      return false
     }
 
     return ip.match(subnetip, subnetrange)

package/node_modules/proxy-addr/package.json

@@ -1,7 +1,7 @@
 {
   "name": "proxy-addr",
   "description": "Determine address of proxied request",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "author": "Douglas Christopher Wilson <doug@somethingdoug.com>",
   "license": "MIT",
   "keywords": [
@@ -10,6 +10,10 @@
     "x-forwarded-for"
   ],
   "repository": "jshttp/proxy-addr",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/express"
+  },
   "dependencies": {
     "forwarded": "0.2.0",
     "ipaddr.js": "1.9.1"
@@ -17,11 +21,11 @@
   "devDependencies": {
     "benchmark": "2.1.4",
     "beautify-benchmark": "0.2.4",
-    "deep-equal": "1.0.1",
+    "deep-equal": "1.1.2",
     "eslint": "7.26.0",
     "eslint-config-standard": "14.1.1",
-    "eslint-plugin-import": "2.23.4",
-    "eslint-plugin-markdown": "2.2.0",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-markdown": "2.2.1",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-promise": "4.3.1",
     "eslint-plugin-standard": "4.1.0",

package/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -64,46 +64,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;