@sap/cds-dk 10.0.7 → 10.1.1

package/node_modules/@sap/cds-mtxs/srv/plugins/hana/serverless.js

@@ -0,0 +1,271 @@
+const cds = require('@sap/cds')
+const AbstractContainerManagerClient = require('./ctnr-mgr-base')
+const { token, fetchResiliently } = require('../../../lib/utils')
+const { uuid } = cds.utils
+const LOG = cds.log('mtx'), DEBUG = cds.debug('mtx|serverless')
+
+const API = '/serverless/v1/containers'
+
+class ServerlessClient extends AbstractContainerManagerClient {
+  constructor(credentials) {
+    super({ clientid: credentials.identity?.clientid, url: credentials.identity?.url })
+    this.gateway = credentials.url
+    this.identity = credentials.identity
+    this.certificate = this.identity?.certificate
+    this.key = this.identity?.key
+    this.certurl = this.identity?.certurl
+    this.url = this.identity?.url
+    this.clientid = this.identity?.clientid
+    this.credentialCache = {}
+    this.tokenCache = new Map()
+    this.delete = this.remove
+  }
+
+  static defaultInstance() {
+    ServerlessClient._defaultInstance ??= ServerlessClient.newInstance(ServerlessClient._resolveCredentials())
+    return ServerlessClient._defaultInstance
+  }
+
+  static _resolveCredentials() {
+    const credentials = { ...cds.env.requires.db.credentials }
+    let vcap
+    const _vcap = () => (vcap ??= (() => { try { return JSON.parse(process.env.VCAP_SERVICES || '{}') } catch { return {} } })())
+    if (!credentials.url) {
+      const serverless = (_vcap()['hana-cloud'] || []).find(s => s.plan === 'serverless') || (_vcap()['hana-cloud'] || [])[0]
+      const gw = credentials.credentials?.url || serverless?.credentials?.url || serverless?.credentials?.credentials?.url
+      if (gw) credentials.url = gw
+    }
+    const iasBinding = (_vcap().identity || [])[0]?.credentials
+    if (iasBinding) credentials.identity = iasBinding
+    else if (!credentials.identity) credentials.identity = credentials.credentials?.identity
+    if (!credentials.identity?.certificate) {
+      const identityBinding = ServerlessClient._resolveIdentityBinding()
+      if (identityBinding?.certificate) credentials.identity = identityBinding
+    }
+    return credentials
+  }
+
+  static _resolveIdentityBinding() {
+    const isIdentity = conf => conf?.kind === 'ias' || conf?.vcap?.label === 'identity'
+    for (const conf of Object.values(cds.env.requires || {})) {
+      if (isIdentity(conf) && conf.credentials?.certificate) return conf.credentials
+    }
+    return undefined
+  }
+
+  static newInstance(credentials) {
+    if (!credentials?.url) cds.error('Serverless gateway URL is not configured in credentials')
+    if (!credentials.identity?.certificate) cds.error('No identity (IAS) credentials found for the serverless Tenant API')
+    return new ServerlessClient(credentials)
+  }
+
+  _tokenFor = async () => {
+    const cached = this.tokenCache.get('provider')
+    if (cached && cached.expiry >= Date.now() + 30_000) return `Bearer ${cached.access_token}`
+    const raw = await token(this.identity, { form: { grant_type: 'client_credentials' }, path: '/oauth2/token' })
+    const { access_token, expires_in } = JSON.parse(raw)
+    this.tokenCache.set('provider', { access_token, expiry: Date.now() + expires_in * 1000 })
+    return `Bearer ${access_token}`
+  }
+
+  _api = async (tenant, path, conf = {}) => {
+    conf.headers ??= {}
+    conf.headers.Authorization ??= await this._tokenFor(tenant)
+    conf.headers['Accept'] ??= 'application/json'
+    conf.headers['Content-Type'] ??= 'application/json'
+    conf.headers['X-CorrelationID'] ??= cds.context?.id
+    const { retries, maxRetryAfter } = cds.requires?.multitenancy?.serviceManager ?? cds.requires?.multitenancy?.containerManager ?? {}
+    return fetchResiliently(this.gateway + path, conf, { retriesLeft: retries ?? 10, maxRetryAfter: maxRetryAfter ?? 5000 })
+  }
+
+  _pollLocation = async (tenant, location, extract) => {
+    let attempts = 0
+    const maxAttempts = 60, interval = 3000
+    for (;;) {
+      const { data } = await this._api(tenant, location.startsWith('http') ? location.slice(this.gateway.length) : location, { method: 'GET' })
+      const state = extract(data)
+      if (state === true) return data
+      if (state === 'FAILED') cds.error(`Serverless operation failed for ${location}: ${JSON.stringify(data)}`)
+      if (++attempts > maxAttempts) cds.error(`Polling ${location} timed out after ${(interval * maxAttempts) / 1000} seconds`)
+      await new Promise(r => setTimeout(r, interval))
+    }
+  }
+
+  _matchingContainers = (list, tenant) => {
+    const base = this._baseName(tenant)
+    return (list || []).filter(c => (c.labels || []).includes(`tenant_id=${tenant}`) || c.name === base || (c.name || '').startsWith(`${base}_`))
+  }
+
+  _findContainer = async (tenant) => {
+    const { data } = await this._api(tenant, API, { method: 'GET' })
+    const usable = c => !/(FAILED|DELETED|NOT_EXIST)$/.test(c.status?.state || '')
+    return this._matchingContainers(data.data, tenant).find(usable)
+  }
+
+  _removeStaleContainers = async (tenant) => {
+    const { data } = await this._api(tenant, API, { method: 'GET' })
+    const stale = this._matchingContainers(data.data, tenant).filter(c => /FAILED$/.test(c.status?.state || ''))
+    for (const c of stale) {
+      LOG.info('removing stale serverless container for', { tenant }, 'container', c.name, 'in state', c.status?.state)
+      const del = await this._api(tenant, `${API}/${c.id}`, { method: 'DELETE' }).catch(() => ({}))
+      const location = del.headers?.['location']
+      if (location) await this._pollLocation(tenant, location, d => /(SUCCEEDED|DELETED|NOT_EXIST)$/.test(d.status?.state || '') ? true : false).catch(() => {})
+    }
+  }
+
+  _findCredentials = async (tenant, containerId) => {
+    const { data } = await this._api(tenant, `${API}/${containerId}/credentials`, { method: 'GET' })
+    const list = data.data || []
+    return list.find(x => (x.state || '').endsWith('SUCCEEDED')) || list[0]
+  }
+
+  _credentialsDetail = async (tenant, containerId, credentialId) => {
+    const { data } = await this._api(tenant, `${API}/${containerId}/credentials/${credentialId}`, { method: 'GET' })
+    return this._toHdiCredentials(data)
+  }
+
+  _toHdiCredentials = (c) => ({
+    host: c.host,
+    port: String(c.port),
+    driver: c.driver || 'com.sap.db.jdbc.Driver',
+    schema: c.schema,
+    hdi_user: c.hdiUser,
+    hdi_password: c.hdiPassword,
+    user: c.user,
+    password: c.password,
+    certificate: c.certificate,
+    encrypt: true,
+    sslTrustAll: false,
+    validate_certificate: true,
+  })
+
+  get = async (tenant, options = {}) => {
+    const { disableCache } = options
+    if (!tenant) throw new Error('Tenant name is required')
+    if (!disableCache && this.credentialCache[tenant]) return this.credentialCache[tenant]
+    const container = await this._findContainer(tenant)
+    if (!container) cds.error(`Tenant '${tenant}' does not exist`, { status: 404 })
+    const credential = await this._findCredentials(tenant, container.id)
+    if (!credential) cds.error(`Tenant '${tenant}' has no usable credentials`, { status: 404 })
+    const credentials = await this._credentialsDetail(tenant, container.id, credential.id)
+    LOG.info('resolved serverless container for', { tenant }, 'container', container.name, 'schema', credentials.schema)
+    return this.credentialCache[tenant] = { name: container.name, tenant_id: tenant, credentials, container, tags: ['hana'] }
+  }
+
+  _waitContainerReady = async (tenant, containerId) => {
+    await this._pollLocation(tenant, `${API}/${containerId}`, d =>
+      d.status?.ready === true || d.status?.state?.endsWith('SUCCEEDED') ? true : (d.status?.state?.endsWith('FAILED') ? 'FAILED' : false)
+    )
+  }
+
+  _awaitBrokerContainer = async (tenant, attempts = 20, interval = 3000) => {
+    for (let i = 0; i < attempts; i++) {
+      const container = await this._findContainer(tenant)
+      if (container) return container
+      await new Promise(r => setTimeout(r, interval))
+    }
+    return undefined
+  }
+
+  create = async (tenant, parameters) => {
+    LOG.info('creating serverless HDI container for', { tenant })
+    let container = await this._findContainer(tenant)
+    const t0 = cds.env.requires.multitenancy?.t0 ?? 't0'
+    if (!container && tenant !== t0 && cds.env.requires.multitenancy?.serverless?.autoSubscription) {
+      LOG.info('awaiting broker-provisioned serverless container for', { tenant })
+      container = await this._awaitBrokerContainer(tenant)
+    }
+    if (!container) {
+      await this._removeStaleContainers(tenant)
+      const create = await this._api(tenant, API, {
+        method: 'POST',
+        data: { name: this._newContainerName(tenant), type: 'hdi', labels: [`tenant_id=${tenant}`, ...(parameters?.customLabels ?? [])] },
+      })
+      const location = create.headers['location']
+      await this._pollLocation(tenant, location, d => d.status?.state?.endsWith('SUCCEEDED') ? true : (d.status?.state?.endsWith('FAILED') ? 'FAILED' : false))
+      container = await this._findContainer(tenant)
+      if (!container) cds.error(`Serverless container for tenant '${tenant}' not found after creation`)
+    }
+    await this._waitContainerReady(tenant, container.id)
+    let credential = await this._findCredentials(tenant, container.id)
+    if (!credential) {
+      const create = await this._api(tenant, `${API}/${container.id}/credentials`, { method: 'POST', data: {} })
+      const location = create.headers['location']
+      await this._pollLocation(tenant, location, d => d.state?.endsWith('SUCCEEDED') ? true : (d.state?.endsWith('FAILED') ? 'FAILED' : false))
+      credential = await this._findCredentials(tenant, container.id)
+    }
+    const credentials = await this._credentialsDetail(tenant, container.id, credential.id)
+    LOG.info('created serverless container for', { tenant }, 'container', container.name, 'schema', credentials.schema)
+    return this.credentialCache[tenant] = { name: container.name, tenant_id: tenant, credentials, container, tags: ['hana'] }
+  }
+
+  getAll = async (tenants = '*', options = {}) => {
+    const seed = tenants === '*' ? null : tenants
+    const listTenant = seed?.[0]
+    let containers = []
+    if (listTenant) {
+      const { data } = await this._api(listTenant, API, { method: 'GET' })
+      containers = (data.data || []).filter(c => (c.labels || []).some(l => l.startsWith('tenant_id=')))
+    }
+    const results = []
+    for (const c of containers) {
+      const tenant_id = (c.labels.find(l => l.startsWith('tenant_id=')) || '').split('=')[1]
+      if (!tenant_id) continue
+      const entry = { labels: { tenant_id: [tenant_id] }, container: c }
+      if (options.skipCredentials) { results.push(entry); continue }
+      try {
+        const { credentials } = await this.get(tenant_id, options)
+        results.push({ ...entry, credentials })
+      } catch (e) {
+        if (e.status === 404) DEBUG?.('skipping tenant', tenant_id, 'without usable credentials')
+        else throw e
+      }
+    }
+    return results
+  }
+
+  remove = async (tenant) => {
+    const container = await this._findContainer(tenant)
+    if (!container) { delete this.credentialCache[tenant]; return {} }
+    const { data } = await this._api(tenant, `${API}/${container.id}/credentials`, { method: 'GET' })
+    for (const cred of data.data || []) {
+      const del = await this._api(tenant, `${API}/${container.id}/credentials/${cred.id}`, { method: 'DELETE' })
+      const location = del.headers['location']
+      if (location) await this._pollLocation(tenant, location, d => d.state?.endsWith('SUCCEEDED') || d.state?.endsWith('DELETED') ? true : false).catch(() => {})
+    }
+    const del = await this._api(tenant, `${API}/${container.id}`, { method: 'DELETE' })
+    const location = del.headers['location']
+    if (location) await this._pollLocation(tenant, location, d => d.status?.state?.endsWith('SUCCEEDED') || d.status?.state?.endsWith('DELETED') ? true : false).catch(() => {})
+    delete this.credentialCache[tenant]
+    return { container: container.id }
+  }
+
+  _createParams = (tenant, params = {}, metadata) => {
+    const hdiParams = this._hdiParams(tenant, params, metadata) ?? {}
+    const result = {}
+    const { custom_label } = hdiParams?.create ?? {}
+    if (custom_label) {
+      const [k] = custom_label.split('=')
+      if (k === 'tenant_id') cds.error('"tenant_id" is not allowed as a custom label key')
+      result.customLabels = [custom_label]
+    }
+    return Object.keys(result).length > 0 ? result : null
+  }
+
+  _encryptionParams = () => {
+    return {}
+  }
+
+  _baseName = (tenant) => {
+    let sanitized = String(tenant).replace(/[^A-Za-z0-9_]/g, '_').toUpperCase()
+    if (!/^[A-Za-z0-9]/.test(sanitized)) sanitized = `T${sanitized}`
+    return sanitized.slice(0, 24)
+  }
+
+  _newContainerName = (tenant) => {
+    const suffix = uuid().replace(/-/g, '').toUpperCase()
+    return `${this._baseName(tenant)}_${suffix}`.slice(0, 62)
+  }
+}
+
+module.exports = ServerlessClient

package/node_modules/@sap/cds-mtxs/srv/plugins/hana.js

@@ -15,8 +15,9 @@ const resources = new Map()
 
 const { deepMerge } = require('../../lib/utils')
 
-if (db?.kind === 'hana') {
-  if (!db.credentials?.sm_url && !db.credentials?.baseurl) cds.error('No Service Manager credentials found. Make sure the application is bound to a BTP Service Manager instance.')
+if (db?.kind === 'hana' || db?.kind === 'hana-serverless') {
+  const serverless = db.serverless || db.kind === 'hana-serverless' || (db.credentials?.url && db.credentials?.identity)
+  if (!db.credentials?.sm_url && !db.credentials?.baseurl && !serverless) cds.error('No Service Manager credentials found. Make sure the application is bound to a BTP Service Manager instance.')
 
   const hana = require('./hana/hdi-ctnr-mgr').defaultInstance()
   exports.activated = 'HANA Database'
@@ -324,14 +325,10 @@ async function _deploy (req, _container, { skipExt = false, skipResources = fals
     if (cacheBindings) {
       // health-check credentials for DB connection, get uncached if stale
 
-      let driver = 'hdb'
-      const projectPackage = require(cds.root + '/package.json')
-      const dependencies = {
-        ...projectPackage.dependencies,
-        ...(process.env.NODE_ENV !== 'production' && projectPackage.devDependencies),
-      }
-      if (dependencies.hdb) driver = 'hdb'
-      if (dependencies['@sap/hana-client']) driver = '@sap/hana-client'
+      let driver
+      try { require.resolve('hdb'); driver = 'hdb' } catch { /* continue */ }
+      if (!driver) try { require.resolve('@sap/hana-client'); driver = '@sap/hana-client' } catch { /* continue */ }
+      if (!driver) cds.error('No HANA client driver found. Add hdb or @sap/hana-client to your sidecar dependencies.')
 
       const client = require(driver).createClient(container.credentials)
       const connect = promisify(client.connect.bind(client))

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/@sap/xsenv/CHANGELOG.md

@@ -5,6 +5,13 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## 6.2.2 - 2026-08-11
+
+### Updated
+- Updated `filter-node-package` dependency to 6.2.2
+- Updated `mocha` dependency to 11.8.0
+- Updated `diff` dependency to 9
+
 ## 6.2.1 - 2026-05-13
 
 ### Updated

package/node_modules/@sap/xsenv/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/xsenv",
-  "version": "6.2.1",
+  "version": "6.2.2",
   "description": "Utility for easy setup and access of SAP HANA XS Advanced environment variables",
   "repository": {},
   "license": "SEE LICENSE IN LICENSE",
@@ -23,13 +23,13 @@
     "prepareRelease": "clean-packages -i"
   },
   "devDependencies": {
-    "@eslint/js": "9.39.4",
+    "@eslint/js": "9.39.5",
     "@eslint/eslintrc": "3.3.5",
-    "@babel/eslint-parser": "7.28.6",
+    "@babel/eslint-parser": "7.29.7",
     "c8": "11.0.0",
-    "filter-node-package": "6.2.0",
+    "filter-node-package": "6.2.2",
     "lodash": "4.18.1",
-    "mocha": "11.7.5",
+    "mocha": "11.8.0",
     "mock-fs": "5.5.0",
     "node-build": "^3.0.0",
     "node-style": "2.0.0",
@@ -43,7 +43,10 @@
   },
   "overrides": {
     "mocha": {
-      "glob": "^13.0.0"
-    }
+      "glob": "^13.0.0",
+      "serialize-javascript": "^7.0.0"
+    },
+    "diff": "^9.0.0",
+    "lodash": "4.18.1"
   }
 }

package/node_modules/body-parser/node_modules/content-type/README.md

@@ -36,6 +36,8 @@ The parser is lenient and does not error. You should validate `type` and `parame
 #### Options
 
 - `parameters` (default: `true`): Set to `false` to skip parameters.
+- `comma` (default: `false`): Set to `true` to stop on a comma. This can be used to parse the media range in an `Accept` header.
+- `start` (default: `0`): Set index to start parsing from.
 
 ### contentType.format(obj)
 

package/node_modules/body-parser/node_modules/content-type/dist/index.d.ts

@@ -8,6 +8,7 @@
  */
 export interface ContentType {
     type: string;
+    index: number;
     parameters: Record<string, string>;
 }
 /**
@@ -18,7 +19,26 @@ export declare function format(obj: Partial<ContentType>): string;
  * Options for parsing a `Content-Type` header.
  */
 export interface ParseOptions {
+    /**
+     * Exit early on the first semicolon, returning only the type.
+     * This is useful for parsing the MIME from `Content-Type` headers.
+     *
+     * @default false
+     */
     parameters?: boolean;
+    /**
+     * Exits early on a comma, returning the first value and parameters.
+     * This is useful for parsing `Accept` headers.
+     *
+     * @default false
+     */
+    comma?: boolean;
+    /**
+     * The index to start parsing from.
+     *
+     * @default 0
+     */
+    start?: number;
 }
 /**
  * Parse a `Content-Type` header.