@sap/cds-dk 10.0.3 → 10.0.5

package/node_modules/@cap-js/db-service/lib/SQLService.js

@@ -0,0 +1,581 @@
+const cds = require('@sap/cds')
+const DEBUG = cds.log('sql|db')
+const { Readable, Transform } = require('stream')
+const { pipeline } = require('stream/promises')
+const DatabaseService = require('./common/DatabaseService')
+const cqn4sql = require('./cqn4sql')
+const { resolveTable } = require('./utils')
+
+// REVISIT: make string the default in next major
+const _count_as_string = cds.env.features.count_as_string
+const _count = _count_as_string ? { func: 'count', cast: { type: 'cds.String' } } : { func: 'count' }
+
+const BINARY_TYPES = {
+  'cds.Binary': 1,
+  'cds.hana.BINARY': 1
+}
+
+/**
+ * Checks if parameter is an object that at least contains one property.
+ *
+ * @param {*} obj
+ * @returns Boolean
+ */
+const _hasProps = (obj) => {
+  if (!obj) return false
+  for (const p in obj) {
+    return true
+  }
+  return false
+}
+
+/** @typedef {import('@sap/cds/apis/services').Request} Request */
+
+/**
+ * @callback Handler
+ * @param {Request} req
+ * @param {(err? : Error) => {Promise<unknown>}} next
+ * @returns {Promise<unknown>}
+ */
+
+class SQLService extends DatabaseService {
+  init() {
+    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
+    this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
+    if (cds.env.features.db_strict) {
+      this.before(['INSERT', 'UPSERT', 'UPDATE'], ({ query }) => {
+        const elements = query._target?.elements
+        if (!elements) return
+        const kind = query.kind || Object.keys(query)[0]
+        const operation = query[kind]
+        if (!operation.columns && !operation.entries && !operation.data) return
+        const columns =
+          operation.columns ||
+          Object.keys(
+            operation.data ||
+            operation.entries?.reduce((acc, obj) => {
+              return Object.assign(acc, obj)
+            }, {}),
+          )
+        const invalidColumns = columns.filter(c => !(c in elements))
+
+        if (invalidColumns.length > 0) {
+          cds.error(`STRICT MODE: Trying to ${kind} non existent columns (${invalidColumns})`)
+        }
+      })
+    }
+    this.on(['SELECT'], this.onSELECT)
+    this.on(['INSERT'], this.onINSERT)
+    this.on(['UPSERT'], this.onUPSERT)
+    this.on(['UPDATE'], this.onUPDATE)
+    this.on(['DELETE'], this.onDELETE)
+    this.on(['CREATE ENTITY', 'DROP ENTITY'], this.onSIMPLE)
+    this.on(['BEGIN', 'COMMIT', 'ROLLBACK'], this.onEVENT)
+    this.on(['*'], this.onPlainSQL)
+    return super.init()
+  }
+
+  _changeToStreams(columns, rows, one) {
+    if (!rows || !columns) return
+    if (!Array.isArray(rows)) rows = [rows]
+    if (!rows.length || !Object.keys(rows[0]).length) return
+
+    let changes = false
+    for (let col of columns) {
+      const name = col.as || col.ref?.[col.ref.length - 1] || (typeof col === 'string' && col)
+      if (col.element?.isAssociation) {
+        if (one) this._changeToStreams(col.SELECT.columns, rows[0][name], false)
+        else
+          changes = rows.some(row => !this._changeToStreams(col.SELECT.columns, row[name], false))
+      } else if (col.element?.type === 'cds.LargeBinary') {
+        changes = true
+        if (one) rows[0][name] = this._stream(rows[0][name])
+        else
+          rows.forEach(row => {
+            row[name] = this._stream(row[name])
+          })
+      } else if (col.element?.type in BINARY_TYPES) {
+        changes = true
+        if (one) rows[0][name] = this._buffer(rows[0][name])
+        else
+          rows.forEach(row => {
+            row[name] = this._buffer(row[name])
+          })
+      }
+    }
+    return changes
+  }
+
+  _stream(val) {
+    if (val === null) return null
+    if (val instanceof Readable) return val
+    // Buffer.from only applies encoding when the input is a string
+    let raw = typeof val === 'string' ? Buffer.from(val.toString(), 'base64') : val
+    return new Readable({
+      read(size) {
+        if (raw.length === 0) return this.push(null)
+        const chunk = raw.slice(0, size)
+        raw = raw.slice(size)
+        this.push(chunk)
+      },
+    })
+  }
+
+  _buffer(val) {
+    if (val === null) return null
+    return Buffer.from(val, 'base64')
+  }
+
+  /**
+   * Handler for SELECT
+   * @type {Handler}
+   */
+  async onSELECT({ query, data, iterator, objectMode }) {
+    // REVISIT: for custom joins, infer is called twice, which is bad
+    //          --> make cds.infer properly work with custom joins and remove this
+    if (!(query._target instanceof cds.entity)) {
+      try { this.infer(query) } catch { /**/ }
+    }
+    if (!query._target?._unresolved) { // REVISIT: use query._target instead
+      // Will return multiple rows with objects inside
+      query.SELECT.expand = 'root'
+    }
+
+    const { sql, values, cqn } = this.cqn2sql(query, data)
+    const expand = query.SELECT.expand
+    delete query.SELECT.expand
+    const isOne = cqn.SELECT.one || query.SELECT.from?.ref?.[0].cardinality?.max === 1
+
+    let ps = await this.prepare(sql)
+    let rows = iterator ? await ps.stream(values, isOne, objectMode) : await ps.all(values)
+    try {
+      if (rows.length)
+        if (expand) rows = rows.map(r => (typeof r._json_ === 'string' ? JSON.parse(r._json_) : r._json_ || r))
+
+      if (!iterator) {
+        this._changeToStreams(cqn.SELECT.columns, rows, query.SELECT.one)
+      } else if (objectMode) {
+        const converter = (row) => this._changeToStreams(cqn.SELECT.columns, row, true)
+        const changeToStreams = new Transform({
+          objectMode: true,
+          transform(row, enc, cb) {
+            converter(row)
+            cb(null, row)
+          }
+        })
+        pipeline(rows, changeToStreams)
+        rows = changeToStreams
+      }
+
+      if (cqn.SELECT.count) {
+        // REVISIT: the runtime always expects that the count is preserved with .map, required for renaming in mocks
+        return SQLService._arrayWithCount(rows, await this.count(query, rows))
+      }
+
+      return !iterator && isOne ? rows[0] : rows
+    } catch (err) {
+      // Ensure that iterators receive pre stream errors
+      if (iterator) rows.emit('error', err)
+      throw err
+    }
+  }
+
+  /**
+   * Handler for INSERT
+   * @type {Handler}
+   */
+  async onINSERT({ query, data }) {
+    const { sql, entries, cqn } = this.cqn2sql(query, data)
+    if (!sql) return // Do nothing when there is nothing to be done // REVISIT: fix within mtxs
+    const ps = await this.prepare(sql)
+    const results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    return new this.class.InsertResults(cqn, results)
+  }
+
+  /**
+   * Handler for UPSERT
+   * @type {Handler}
+   */
+  async onUPSERT({ query, data }) {
+    const { sql, entries } = this.cqn2sql(query, data)
+    if (!sql) return // Do nothing when there is nothing to be done // REVISIT: When does this happen?
+    let ps = await this.prepare(sql)
+    let results = entries ? await Promise.all(entries.map(e => ps.run(e))) : await ps.run()
+    let changes = results.reduce?.((total,r) => total + r.changes, 0) ?? results.changes
+    return this._return_affected(changes)
+  }
+
+  /**
+   * Handler for UPDATE
+   * @type {Handler}
+   */
+  async onUPDATE(req) {
+    // noop if not a touch for @cds.on.update
+    if (
+      !_hasProps(req.query.UPDATE.data) &&
+      !_hasProps(req.query.UPDATE.with) &&
+      !Object.values(req.target?.elements || {}).some(e => e['@cds.on.update'])
+    )
+      return this._return_affected(0)
+    return this.onSIMPLE(req)
+  }
+
+  /**
+   * Handler for CREATE, DROP, UPDATE, DELETE, with simple CQN
+   * @type {Handler}
+   */
+  async onSIMPLE({ query, data }) {
+    const { sql, values } = this.cqn2sql(query, data)
+    let ps = await this.prepare(sql)
+    let { changes } = await ps.run(values)
+    return this._return_affected(changes)
+  }
+
+  get onDELETE() {
+    // REVISIT: It's not yet 100 % clear under which circumstances we can rely on db constraints
+    return (super.onDELETE = /* cds.env.features.assert_integrity === 'db' ? this.onSIMPLE : */ deep_delete)
+    async function deep_delete(/** @type {Request} */ req) {
+      const resolve = this.resolve
+      const transitions = resolve.transitions(req.query)
+      if (transitions.target !== transitions.queryTarget) {
+        const keys = []
+        const transitionsTarget = transitions.queryTarget.keys || transitions.queryTarget.elements
+        for (const key in transitionsTarget) {
+          const exists = e => e && !e.virtual && !e.value && !e.isAssociation
+          if (exists(transitionsTarget[key])) keys.push(key)
+        }
+        const matchedKeys = keys.filter(key => transitions.mapping.has(key)).map(k => ({ ref: [k] }))
+        const query = DELETE.from({
+          ref: [
+            {
+              id: transitions.target.name,
+              where: [
+                { list: matchedKeys.map(k => transitions.mapping.get(k.ref[0])) },
+                'in',
+                SELECT.from(req.query.DELETE.from).columns(matchedKeys).where(req.query.DELETE.where),
+              ],
+            },
+          ],
+        })
+        return this.onDELETE({ query, target: transitions.target })
+      }
+      const table = resolveTable(req.target)
+      const { compositions } = table
+      if (compositions) {
+        // Transform CQL`DELETE from Foo[p1] WHERE p2` into CQL`DELETE from Foo[p1 and p2]`
+        let { from, where } = req.query.DELETE
+        if (typeof from === 'string') from = { ref: [from] }
+        if (where) {
+          let last = from.ref.at(-1)
+          if (last.where) [last, where] = [last.id, [{ xpr: last.where }, 'and', { xpr: where }]]
+          from = { ref: [...from.ref.slice(0, -1), { id: last, where }] }
+        }
+        // Process child compositions depth-first
+        let { depth = 0, visited = [] } = req
+        visited.push(req.target.name)
+        await Promise.all(
+          Object.values(compositions).map(c => {
+            if (c._target['@cds.persistence.skip'] === true) return
+            if (c._target === req.target) {
+              // the Genre.children case
+              if (++depth > (c['@depth'] || 3)) return
+            } else if (visited.includes(c._target.name))
+              throw new Error(
+                `Transitive circular composition detected: \n\n` +
+                `  ${visited.join(' > ')} > ${c._target.name} \n\n` +
+                `These are not supported by deep delete.`,
+              )
+            // Prepare and run deep query, à la CQL`DELETE from Foo[pred]:comp1.comp2...`
+            const query = DELETE.from({ ref: [...from.ref, c.name] })
+            query._target = c._target
+            return this.onDELETE({ query, depth, visited: [...visited], target: c._target })
+          }),
+        )
+      }
+      return this.onSIMPLE(req)
+    }
+  }
+
+  /**
+   * Handler for BEGIN, COMMIT, ROLLBACK, which don't have any CQN
+   * @type {Handler}
+   */
+  async onEVENT({ event }) {
+    if (DEBUG._debug) DEBUG.debug(event) // in the other cases above DEBUG happens in cqn2sql
+    return await this.exec(event)
+  }
+
+  /**
+   * Handler for SQL statements which don't have any CQN
+   * @type {Handler}
+   */
+  async onPlainSQL({ query, data }, next) {
+    if (typeof query === 'string') {
+      if (DEBUG._debug) DEBUG.debug(query, data)
+      const ps = await this.prepare(query)
+      const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
+      if (Array.isArray(data) && Array.isArray(data[0])) return await Promise.all(data.map(exec))
+      else return exec(data)
+    } else return next()
+  }
+
+  /**
+   *  Override in subclasses to detect more statements to be called with ps.all()
+   * @param {string} sql
+   */
+  hasResults(sql) {
+    return /^\s*(SELECT|WITH|CALL|PRAGMA table_info)/i.test(sql)
+  }
+
+  /**
+   * Derives and executes a query to fill in `$count` for given query
+   * @param {import('@sap/cds/apis/cqn').SELECT} query - SELECT CQN
+   * @param {unknown[]} ret - Results of the original query
+   * @returns {Promise<number|string>}
+   */
+  async count(query, ret) {
+    if (ret?.length) {
+      const { one, limit: _ } = query.SELECT,
+        n = ret.length
+      const [max, offset = 0] = one ? [1] : _ ? [_.rows?.val, _.offset?.val] : []
+      if (max === undefined || (n < max && (n || !offset))) return _count_as_string ? `${n + offset}` : n + offset
+    }
+
+    // Keep original query columns when potentially used insde conditions
+    const { having, groupBy } = query.SELECT
+    let columns = []
+    if (having?.length || groupBy?.length) {
+      columns = query.SELECT.columns.filter(c => !c.expand)
+    }
+    if (columns.length === 0) columns.push({ val: 1 })
+    const cq = SELECT.one([_count]).from(
+      cds.ql.clone(query, {
+        columns,
+        localized: false,
+        expand: false,
+        limit: undefined,
+        orderBy: undefined,
+      }),
+    )
+    const { count } = await this.onSELECT({ query: cq })
+    return count
+  }
+
+  /**
+   * Streaming API variant of .run().
+   * @param {import('@sap/cds/apis/cqn').SELECT} query - SELECT CQN
+   * @param {function} callback - Function to be invoked for each row
+   */
+  foreach(query, callback) {
+    return query.foreach(callback)
+  }
+
+  /**
+   * Helper class for results of INSERTs.
+   * Subclasses may override this.
+   */
+  static InsertResults = require('./InsertResults')
+
+  /**
+   * Helper class implementing {@link SQLService#cqn2sql}.
+   * Subclasses commonly override this.
+   */
+  static CQN2SQL = require('./cqn2sql').class
+
+  // REVISIT: There must be a better way!
+  // preserves $count for .map calls on array
+  static _arrayWithCount = function (a, count) {
+    const _map = a.map
+
+    const map = function (..._) {
+      return SQLService._arrayWithCount(_map.call(a, ..._), count)
+    }
+    return Object.defineProperties(a, {
+      $count: { value: count, enumerable: false, configurable: true, writable: true },
+      map: { value: map, enumerable: false, configurable: true, writable: true },
+    })
+  }
+
+  constructor(...args) {
+    super(...args)
+    this.class = new.target // for IntelliSense
+  }
+
+  /**
+   * @param {import('@sap/cds/apis/cqn').Query} query
+   * @returns {typeof SQLService.CQN2SQL}
+   */
+  cqn2sql(query, values) {
+    const cqn2sql = new this.class.CQN2SQL(this)
+    const q = this.cqn4sql(query)
+    const sql = cqn2sql.render(q, values)
+    return sql
+  }
+
+  /**
+   * @param {import('@sap/cds/apis/cqn').Query} q
+   * @returns {import('./infer/cqn').Query}
+   */
+  cqn4sql(q, useTechnicalAlias = true) {
+    if (
+      !cds.env.features.db_strict &&
+      !q.SELECT?.from?.join &&
+      !q.SELECT?.from?.SELECT &&
+      !this.model?.definitions[_target_name4(q)]
+    ) return q
+    else return cqn4sql(q, this.model, useTechnicalAlias)
+  }
+
+  /**
+   * Returns a Promise which resolves to a prepared statement object with
+   * `{run,get,all}` signature as specified in {@link PreparedStatement}.
+   * @abstract
+   * @param {string} sql The SQL String to be prepared
+   * @returns {PreparedStatement}
+   */
+  async prepare(sql) {
+    sql
+    throw '2b overridden by subclass'
+  }
+
+  /**
+   * Used to execute simple SQL statement like BEGIN, COMMIT, ROLLBACK
+   * @param {string} sql
+   * @returns {Promise<unknown>} The result of the query
+   */
+  async exec(sql) {
+    sql
+    throw '2b overridden by subclass'
+  }
+}
+
+/**
+ * Interface of prepared statement objects as returned by {@link SQLService#prepare}
+ * @class
+ * @interface
+ */
+class PreparedStatement {
+  /**
+   * Executes a prepared DML query, i.e., INSERT, UPDATE, DELETE, CREATE, DROP
+   * @abstract
+   * @param {unknown|unknown[]} binding_params
+   */
+  async run(binding_params) {
+    binding_params
+    return 0
+  }
+  /**
+   * Executes a prepared SELECT query and returns a single/first row only
+   * @abstract
+   * @param {unknown|unknown[]} binding_params
+   * @returns {Promise<unknown>}
+   */
+  async get(binding_params) {
+    binding_params
+    return {}
+  }
+  /**
+   * Executes a prepared SELECT query and returns an array of all rows
+   * @abstract
+   * @param {unknown|unknown[]} binding_params
+   * @returns {Promise<unknown[]>}
+   */
+  async all(binding_params) {
+    binding_params
+    return [{}]
+  }
+  /**
+   * Executes a prepared SELECT query and returns a stream of the result
+   * @abstract
+   * @param {unknown|unknown[]} binding_params
+   * @returns {ReadableStream<string|Buffer>} A stream of the result
+   */
+  async stream(binding_params) {
+    binding_params
+  }
+}
+SQLService.prototype.PreparedStatement = PreparedStatement
+
+/** @param {import('@sap/cds').ql.Query} q */
+const _target_name4 = q => {
+  const target = q._subject
+    || q.SELECT?.from
+    || q.INSERT?.into
+    || q.UPSERT?.into
+    || q.UPDATE?.entity
+    || q.DELETE?.from
+    || q.CREATE?.entity
+    || q.DROP?.entity
+  if (target?.SET?.op === 'union') throw new cds.error('UNION-based queries are not supported')
+  if (!target?.ref) return target
+  const [first] = target.ref
+  return first.id || first
+}
+
+
+// Add support for cqn2pql if debug logging for pql is enabled, or if running in the REPL.
+const DEBUG_PQL = cds.log('pql')
+if (DEBUG_PQL._debug || cds.repl) {
+
+  // Add helper method to convert CQN to PQL, used below...
+  SQLService.prototype.cqn2pql = function cqn2pql(query, values) {
+    const CQN2PQL = cqn2pql.renderer ??= require('./cqn2pql')
+    return new CQN2PQL(this).render(query, values)
+  }
+
+  // Add support for logging generated PQL if debug logging for pql is enabled.
+  if (DEBUG_PQL._debug) {
+    const $super = SQLService.prototype.cqn2sql
+    SQLService.prototype.cqn2sql = function (query, values) {
+      const q2 = this.cqn4sql(query, false) // FIXME: calling cqn4sql twice per query is utterly expensive, isn't it ?!?
+      const pql = this.cqn2pql(q2, values)
+      DEBUG_PQL.debug(pql.sql, pql.values ?? '')
+      return $super.call(this, query, values)
+    }
+  }
+
+  // If running in the REPL, extend cds.ql.Query with helpers to inspect queries.
+  if (cds.repl) {
+
+    cds.extend(cds.ql.Query).with(
+      class {
+        forSQL() {
+          const cqn = db.srv.cqn4sql(this)
+          return this.flat(cqn)
+        }
+        forSql() { return this.forSQL() }
+        toSQL() {
+          if (this.SELECT) this.SELECT.expand = 'root' // Enforces using json functions always for top-level SELECTS
+          const { sql, values } = db.srv.cqn2sql(this)
+          return { sql, values } // skipping .cqn property
+        }
+        toSql() {
+          const { sql } = this.toSQL()
+          return sql
+        }
+        toPQL() {
+          const { sql, values } = db.srv.cqn2pql(this)
+          return { sql, values } // skipping .cqn property
+        }
+        toPql() {
+          const { sql } = this.toPQL()
+          return sql
+        }
+      }
+    )
+
+    /**
+     * Dummy SQL service used in extensions to cds.ql above,
+     * if no real SQL service is available yet through cds.db.
+     */
+    class db extends SQLService {
+      /** @returns {SQLService} */
+      static get srv() { return cds.db || (this.singleton ??= new this) }
+      get factory() { return null }
+      get model() { return cds.model }
+    }
+  }
+}
+
+Object.assign(SQLService, { _target_name4 })
+module.exports = SQLService