@sap/cds-dk 10.0.3 → 10.0.4

package/node_modules/@cap-js/db-service/lib/common/DatabaseService.js

@@ -0,0 +1,179 @@
+const SessionContext = require('./session-context')
+const ConnectionPool = require('./generic-pool')
+const infer = require('../infer')
+const cds = require('@sap/cds')
+
+/** @typedef {unknown} DatabaseDriver */
+
+class DatabaseService extends cds.Service {
+
+  init() {
+    cds.on('shutdown', () => this.disconnect())
+    return super.init()
+  }
+
+  /**
+   * Dictionary of connection pools per tenant
+   */
+  pools = Object.setPrototypeOf({}, { _factory: this.factory })
+
+  /**
+   * Return a pool factory + options property as expected by
+   * https://github.com/coopernurse/node-pool#createpool.
+   * @abstract
+   * @type {import('./factory').Factory<DatabaseDriver>}
+   */
+  get factory() {
+    throw '2b overriden in subclass'
+  }
+
+  /**
+   * Set one or more session context variables like so:
+   *
+   *     const tx = cds.db.tx()
+   *     tx.set({ foo: 'bar' })
+   *
+   * This is used in this.begin() for standard properties
+   * like `$user.id` or `$user.locale`.
+   */
+  // eslint-disable-next-line no-unused-vars
+  set(variables) {
+    throw '2b overridden by subclass'
+  }
+
+  /**
+   * Acquires a pooled connection and starts a session, including setting
+   * session context like `$user.id` or `$user.locale`, and starting a
+   * transaction with `BEGIN`
+   * @returns this
+   */
+  async begin (min) {
+    // We expect tx.begin() being called for an txed db service
+    const ctx = this.context
+
+    // If .begin is called explicitly it starts a new transaction and executes begin
+    if (!ctx) return this.tx().begin(min)
+
+    // REVISIT: can we revisit the below revisit now?
+    // REVISIT: tenant should be undefined if !this.isMultitenant
+    let isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
+    let tenant = isMultitenant && ctx.tenant
+
+    // Setting this.pool as used in this.acquire() and this.release()
+    this.pool = this.pools[tenant] ??= new ConnectionPool(this.pools._factory, tenant)
+
+    // Acquire a pooled connection
+    this.dbc = await this.acquire()
+    this.dbc.destroy = this.destroy.bind(this) // REVISIT: this is bad
+
+    // Begin a session...
+    if (!min) try {
+      await this.set(new SessionContext(ctx))
+      await this.send('BEGIN')
+    } catch (e) {
+      this.release()
+      throw e
+    }
+    return this
+  }
+
+  /**
+   * Commits a transaction and releases the connection to the pool.
+   */
+  async commit() {
+    if (!this.dbc) return
+    await this.send('COMMIT')
+    this.release() // only release on successful commit as otherwise released on rollback
+  }
+
+  /**
+   * Rolls back a transaction and releases the connection to the pool.
+   */
+  async rollback() {
+    if (!this.dbc) return
+    try {
+      await this.send('ROLLBACK')
+    } finally {
+      this.release()
+    }
+  }
+
+  /**
+   * Acquires a connection from this.pool, stored into this.dbc
+   * This is for subclasses to intercept, if required.
+   */
+  async acquire() {
+    return await this.pool.acquire()
+  }
+
+  /**
+   * Releases own connection, i.e. tix.dbc, from this.pool
+   * This is for subclasses to intercept, if required.
+   */
+  async release() {
+    if (!this.dbc) return
+    const dbc = this.dbc
+    this.dbc = undefined
+    await this.pool.release(dbc)
+  }
+
+  /**
+   * Destroys own connection, i.e. tix.dbc, from this.pool
+   * This is for subclasses to intercept, if required.
+   */
+  async destroy() {
+    if (!this.dbc) return
+    const dbc = this.dbc
+    this.dbc = undefined
+    await this.pool.destroy(dbc)
+  }
+
+  // REVISIT: should happen automatically after a configurable time
+  async disconnect (tenant) {
+    const tenants = tenant ? [tenant] : Object.keys(this.pools)
+    await Promise.all (tenants.map (async t => {
+      const pool = this.pools[t]; if (!pool) return
+      delete this.pools[t]
+      await pool.drain()
+      await pool.clear()
+    }))
+  }
+
+  /**
+   * Infers the given query with this DatabaseService instance's model.
+   * In general `this.model` is the same then `cds.model`
+   * @param {CQN} query - the query to infer
+   * @returns {CQN} the inferred query
+   */
+  infer(query) {
+    return infer(query, this.model)
+  }
+
+  /**
+   * DatabaseServices also support passing native query strings to underlying databases.
+   */
+  run(query, data, ...etc) {
+    // Allow db.run('...',1,2,3,4)
+    if (data !== undefined && typeof query === 'string' && typeof data !== 'object') arguments[1] = [data, ...etc]
+    return super.run(...arguments) //> important to call like that for tagged template literal args
+  }
+
+  /**
+   * @returns {string} A url-like string used to print log output,
+   * e.g., in cds.deploy()
+   */
+  url4(/*tenant*/) {
+    return this.options.credentials?.url || this.options.url
+  }
+}
+
+const _as_array = changes => Object.assign ([],{ affected: changes })
+const _as_number = changes => changes
+DatabaseService.prototype._return_affected = _as_number
+DatabaseService._always_return_arrays = on_off => {
+  if (on_off === undefined) return DatabaseService.prototype._return_affected === _as_array
+  DatabaseService.prototype._return_affected = on_off ? _as_array : _as_number
+}
+DatabaseService._always_return_arrays (cds.env.features.legacy_db_results === false) // TODO: invert default value
+DatabaseService.prototype.isDatabaseService = true
+module.exports = exports = DatabaseService

package/node_modules/@cap-js/db-service/lib/common/factory.d.ts

@@ -0,0 +1,5 @@
+import { Factory as GenericFactory, Options } from 'generic-pool'
+
+export interface Factory<T> extends GenericFactory<T> {
+  options: Options
+}

package/node_modules/@cap-js/db-service/lib/common/generic-pool.js

@@ -0,0 +1,310 @@
+const cds = require('@sap/cds')
+const LOG = cds.log('db')
+
+const use_new_pool = !cds.env.features.use_generic_pool
+const createPool = use_new_pool ? (...args) => new Pool(...args) : require('generic-pool').createPool
+
+function ConnectionPool (factory, tenant) {
+  let bound_factory = { __proto__: factory, create: factory.create.bind(null, tenant) }
+  return createPool(bound_factory, factory.options)
+}
+
+function TrackedConnectionPool (factory, tenant) {
+  const pool = new ConnectionPool (factory, tenant)
+  const { acquire, release } = pool
+  return Object.assign(pool, {
+    async acquire() {
+      const connections = (this._trackedConnections ??= new Set())
+      try {
+        let dbc = await acquire.call(this)
+        connections.add((dbc._beginStack = new Error('begin called from:')))
+        return dbc
+      } catch (err) {
+        // TODO: add acquire timeout error check
+        err.stack += `\nActive connections:${connections.size}\n${[...connections].map(e => e.stack).join('\n')}`
+        throw err
+      }
+    },
+    release(dbc) {
+      this._trackedConnections?.delete(dbc._beginStack)
+      return release.call(this, dbc)
+    },
+  })
+}
+
+const DEBUG = /\bpool\b/.test(process.env.DEBUG)
+module.exports = DEBUG && !use_new_pool ? TrackedConnectionPool : ConnectionPool
+
+// Drop-in replacement for https://github.com/coopernurse/node-pool
+// TODO: fifo: true? relevant for our use case?
+
+const { EventEmitter } = require('events')
+
+const ResourceState = Object.freeze({
+  ALLOCATED: 'allocated',
+  IDLE: 'idle',
+  INVALID: 'invalid',
+  VALIDATION: 'validation'
+})
+
+const RequestState = Object.freeze({
+  PENDING: 'pending',
+  RESOLVED: 'resolved',
+  REJECTED: 'rejected'
+})
+
+class Request {
+  constructor (ttl) {
+    this.state = RequestState.PENDING
+    this.promise = new Promise((resolve, reject) => {
+      this._resolve = value => {
+        clearTimeout(this._timeout)
+        this.state = RequestState.RESOLVED
+        resolve(value)
+      }
+      this._reject = reason => {
+        clearTimeout(this._timeout)
+        this.state = RequestState.REJECTED
+        reject(reason)
+      }
+      if (typeof ttl === 'number' && ttl >= 0) {
+        const err = new Error(`Pool resource could not be acquired within ${ttl / 1000}s`)
+        this._timeout = setTimeout(() => this._reject(err), ttl).unref()
+      }
+    })
+  }
+  resolve (v) { if (this.state === RequestState.PENDING) this._resolve(v) }
+  reject (e) { if (this.state === RequestState.PENDING) this._reject(e) }
+}
+
+class PooledResource {
+  constructor(resource) {
+    this.obj = resource
+    this.creationTime = Date.now()
+    this.idle()
+  }
+
+  update(newState) {
+    this.state = newState
+  }
+  idle() {
+    this.state = ResourceState.IDLE
+    this.lastIdleTime = Date.now()
+  }
+}
+
+class Pool extends EventEmitter {
+
+constructor (factory, options = {}) {
+  super()
+  this.factory = factory
+
+  this.options = Object.assign({
+    testOnBorrow: false,
+    evictionRunIntervalMillis: 100000,
+    numTestsPerEvictionRun: 3,
+    softIdleTimeoutMillis: -1,
+    idleTimeoutMillis: 30000,
+    acquireTimeoutMillis: null,
+    destroyTimeoutMillis: null,
+    fifo: false,
+    min: 0,
+    max: 10
+  }, options)
+
+  /** @type {boolean} */
+  this._draining = false
+
+  /** @type {Set<PooledResource>} */
+  this._available = new Set()
+
+  /** @type {Map<any, { pooledResource: PooledResource }>} */
+  this._loans = new Map()
+
+  /** @type {Set<PooledResource>} */
+  this._all = new Set()
+
+  /** @type {Set<Promise<void>>} */
+  this._creates = new Set()
+
+  /** @type {Request[]} */
+  this._queue = []
+
+  this.#scheduleEviction()
+
+  const initial = this.options.min - this.size
+  for (let i = 0; i < initial; i++) this.#createResource()
+}
+
+  async acquire() {
+    if (this._draining) throw new Error('Pool is draining and cannot accept new requests')
+    const request = new Request(this.options.acquireTimeoutMillis)
+    this._queue.push(request)
+    this.#dispense()
+    return request.promise
+  }
+
+  async release(resource) {
+    if (this._draining) {
+      LOG.debug('Pool is already draining. Resource cannot be returned to pool')
+      return
+    }
+    const loan = this._loans.get(resource)
+    if (!loan) throw new Error('Resource not currently part of this pool')
+    this._loans.delete(resource)
+    const pooledResource = loan.pooledResource
+    pooledResource.idle()
+    this._available.add(pooledResource)
+    this.#dispense()
+  }
+
+  async destroy(resource) {
+    if (this._draining) {
+      LOG.debug('Pool is already draining. Resource will be destroyed anyway')
+      return
+    }
+    const loan = this._loans.get(resource)
+    if (!loan) throw new Error('Resource not currently part of this pool')
+    this._loans.delete(resource)
+    const pooledResource = loan.pooledResource
+    await this.#destroy(pooledResource)
+    this.#dispense()
+  }
+
+  async drain() {
+    this._draining = true
+    for (const request of this._queue.splice(0)) {
+      if (request.state === RequestState.PENDING) request.reject(new Error('Pool is draining and cannot fulfil request'))
+    }
+    clearTimeout(this._scheduledEviction)
+  }
+
+  async clear() {
+    await Promise.allSettled(Array.from(this._creates))
+    await Promise.allSettled(Array.from(this._all).map(resource => this.#destroy(resource)))
+  }
+
+  async #createResource() {
+    const createPromise = (async () => {
+      try {
+        const resource = new PooledResource(await this.factory.create())
+        this._all.add(resource)
+        this._available.add(resource)
+      } catch (err) {
+        this._queue.shift()?.reject(err)
+      }
+    })()
+    this._creates.add(createPromise)
+    createPromise.finally(() => {
+      this._creates.delete(createPromise)
+      this.#dispense()
+    })
+    return createPromise
+  }
+
+  async #dispense() {
+    const waiting = this._queue.length
+    if (waiting === 0) return
+    const capacity = this._available.size + this._creates.size
+    const shortfall = waiting - capacity
+    if (shortfall > 0 && this.size < this.options.max) {
+      const needed = Math.min(shortfall, this.options.max - this.size)
+      for (let i = 0; i < needed; i++) this.#createResource()
+    }
+    const dispense = async resource => {
+      const request = this._queue.shift()
+      if (!request) {
+        resource.idle()
+        this._available.add(resource)
+        return false
+      }
+      if (request.state !== RequestState.PENDING) {
+        this.#dispense()
+        return false
+      }
+      this._loans.set(resource.obj, { pooledResource: resource })
+      resource.update(ResourceState.ALLOCATED)
+      request.resolve(resource.obj)
+      return true
+    }
+
+    const _dispenses = []
+    for (let i = 0; i < Math.min(this._available.size, waiting); i++) {
+      const resource = this._available.values().next().value
+      this._available.delete(resource)
+      if (this.options.testOnBorrow) {
+        const validationPromise = (async () => {
+          resource.update(ResourceState.VALIDATION)
+          try {
+            const isValid = await this.factory.validate(resource.obj)
+            if (isValid) return dispense(resource)
+          } catch {/* marked as invalid below */}
+          resource.update(ResourceState.INVALID)
+          await this.#destroy(resource)
+          this.#dispense()
+          return false
+        })()
+        _dispenses.push(validationPromise)
+      } else {
+        _dispenses.push(dispense(resource))
+      }
+    }
+    await Promise.all(_dispenses)
+  }
+
+  async #destroy(resource) {
+    resource.update(ResourceState.INVALID)
+    this._all.delete(resource)
+    this._available.delete(resource)
+    this._loans.delete(resource.obj)
+    try {
+      const destroyPromise = Promise.resolve(this.factory.destroy(resource.obj))
+      const { destroyTimeoutMillis } = this.options
+      if (destroyTimeoutMillis && destroyTimeoutMillis > 0) {
+        const timeout = new Promise((_, reject) =>
+          setTimeout(() => reject(new Error(`Resource destruction timed out after ${destroyTimeoutMillis}ms`)), destroyTimeoutMillis).unref()
+        )
+        await Promise.race([destroyPromise, timeout])
+      } else {
+        await destroyPromise
+      }
+    } catch (e) {
+       LOG.error(e)
+       /* FIXME: We have to ignore errors here due to a TypeError in hdb */
+       /* This was also a problem with the old (generic-pool) implementation */
+       /* Root cause in hdb needs to be fixed */
+    } finally {
+      if (!this._draining && this.size < this.options.min) this.#createResource()
+    }
+  }
+
+  #scheduleEviction() {
+    const { evictionRunIntervalMillis, numTestsPerEvictionRun, softIdleTimeoutMillis, min, idleTimeoutMillis } = this.options
+    if (evictionRunIntervalMillis <= 0) return
+    this._scheduledEviction = setTimeout(async () => {
+      try {
+        const evictionCandidates = Array.from(this._available).slice(0, numTestsPerEvictionRun)
+        const destructionPromises = []
+        for (const resource of evictionCandidates) {
+          const idleTime = Date.now() - resource.lastIdleTime
+          const softEvict = softIdleTimeoutMillis > 0 && softIdleTimeoutMillis < idleTime && this._all.size > min
+          const hardEvict = idleTimeoutMillis < idleTime
+          if (softEvict || hardEvict) {
+            if (this._available.delete(resource)) {
+              destructionPromises.push(this.#destroy(resource))
+            }
+          }
+        }
+        await Promise.all(destructionPromises)
+      } finally {
+        this.#scheduleEviction()
+      }
+    }, evictionRunIntervalMillis).unref()
+  }
+
+  get size()      { return this._all.size + this._creates.size }
+  get available() { return this._available.size }
+  get borrowed()  { return this._loans.size }
+  get pending()   { return this._queue.length }
+  get tenant()    { return this.options.tenant }
+}

package/node_modules/@cap-js/db-service/lib/common/session-context.js

@@ -0,0 +1,46 @@
+const cds = require('@sap/cds')
+
+class SessionContext {
+  constructor(ctx) {
+    Object.defineProperty(this, 'ctx', { value: ctx })
+  }
+  get '$user.id'() {
+    return (super['$user.id'] = this.ctx.user?.id || 'anonymous')
+  }
+  get '$user.locale'() {
+    return (super['$user.locale'] = this.ctx.locale || cds.env.i18n.default_language)
+  }
+  // REVISIT: should be decided in spec meeting for definitive name
+  get $now() {
+    return (super.$now = (this.ctx.timestamp || new Date()).toISOString())
+  }
+}
+
+class TemporalSessionContext extends SessionContext {
+  get '$valid.from'() {
+    return (super['$valid.from'] = this.ctx._?.['VALID-FROM'] ?? this.ctx._?.['VALID-AT'] ?? new Date().toISOString())
+  }
+  get '$valid.to'() {
+    return (super['$valid.to'] =
+      this.ctx._?.['VALID-TO'] ??
+      this.ctx._?.['VALID-AT']?.replace(/\.(\d*)(Z?)$/, (_, d, z) => `.${parseInt(d) + 1}${z}`) ??
+      (new Date(Date.now() + 1)).toISOString())
+  }
+}
+
+// Set all getters as enumerable
+const iterate = { enumerable: true }
+const getters = (obj) => {
+  const prot = obj.prototype
+  const patch = {}
+  for (const [key, value] of Object.entries(Object.getOwnPropertyDescriptors(prot))) {
+    if (!value.get) continue
+    patch[key] = iterate
+  }
+  Object.defineProperties(prot, patch)
+}
+getters(SessionContext)
+getters(TemporalSessionContext)
+
+// REVISIT: only set temporal context if required!
+module.exports = TemporalSessionContext

package/node_modules/@cap-js/db-service/lib/converters.d.ts

@@ -0,0 +1,24 @@
+declare function ConverterFunction(expression: string): string
+export type Converter = typeof ConverterFunction
+
+export type Converters = {
+  UUID: Converter
+  String: Converter
+  LargeString: Converter
+  Binary: Converter
+  LargeBinary: Converter
+  Boolean: Converter
+  Integer: Converter
+  UInt8: Converter
+  Int16: Converter
+  Int32: Converter
+  Int64: Converter
+  Float: Converter
+  Double: Converter
+  Decimal: Converter
+  DecimalFloat: Converter
+  Date: Converter
+  Time: Converter
+  DateTime: Converter
+  Timestamp: Converter
+}