@sap/cds 8.9.3 → 9.0.2

package/libx/_runtime/hana/search2Contains.js

@@ -1,106 +0,0 @@
-/**
- * Computes a `CONTAINS` CQN expression for a search query.
- *
- * OData search string           | `CONTAINS` search string
- * ----------------------------- | ------------------------
- * `foo`                         | `"%foo%"`
- * `NOT foo`                     | `-"%foo%"` (Currently disabled -> BCP 2180256508)
- * `foo AND bar`                 | `"%foo%" "%bar%"`
- * `foo OR bar`                  | `"%foo%" OR "%bar%"`
- * `foo or bar`                  | `"%foo%" OR "%bar%"`
- * `" foo" OR " bar"`            | `"% foo%" OR "% bar%"`
- * ` foo`                        | `"% foo%"`
- * `foo bar`                     | `"%foo%" "%bar%"`
- *
- * **Some limitations of the `CONTAINS` predicate in SAP HANA:**
- * - The `-` (minus sign) search operator can not be placed directly after `OR`.
- * - Brackets are not supported as search operators.
- * - REVISIT: The `AND` operator in combination with the `OR` operator does not
- * always return the expected result.
- * - Search terms starting with whitespace after a `NOT` operator does not return
- * the expected result. For example: `-%" "foo%` .
- *
- * @param {array} cqnSearchPhrase
- * @param {import("../types/api").ColumnRefs} columns The columns to be searched
- * @returns {import("../types/api").searchContainsExp} The `CONTAINS` CQN expression
- */
-const search2Contains = (cqnSearchPhrase, columns) => {
-  // serialize the CQN search phrase
-  const searchString = cqnSearchPhrase.reduce((searchStringAccumulator, currentValue) => {
-    // Multiple search terms separated by an space are automatically
-    // interpreted as an AND operator. Therefore, it is not mandatory
-    // to explicitly specify the it.
-    if (currentValue === 'and') return (searchStringAccumulator += ' ')
-
-    // the OR keyword is a reserved word and it is case-sensitive
-    if (currentValue === 'or') return (searchStringAccumulator += ' OR ')
-
-    // the - (minus sign) is used to exclude terms from the search
-    if (currentValue === 'not') return (searchStringAccumulator += '-')
-
-    // escape double quotation mark(s) with \\
-    const searchTermEscaped = currentValue.val.replace(/"/g, '\\$&')
-
-    // A search term enclosed with the wildcard character % (percentage sign)
-    // is used to match zero or more characters. In SAP HANA, the % sign is
-    // replaced with an asterisk (*), and a wildcard search is run.
-    // The % sign also prevents ambiguity, as a search input might contain
-    // an 'OR' (uppercase characters), causing semantics issues.
-    return (searchStringAccumulator += `"%${searchTermEscaped}%"`)
-  }, '')
-
-  const expressionArgs = [{ list: columns }, { val: searchString }]
-
-  const expression = {
-    func: 'contains',
-    args: expressionArgs
-  }
-
-  return expression
-}
-
-const isContainsPredicateSupported = (query, entity, columns2Search) => {
-  const cqnSearchPhrase = query.SELECT.search
-
-  if (cqnSearchPhrase?.[0]?.val === ' ') return false
-
-  // REVISIT: In the future, to further optimize search queries, you might
-  // want to remove the following condition(s).
-  if (query._aggregated || /* new parser */ query.SELECT.groupBy) return false
-
-  // REVISIT: search terms starting with whitespace after a `NOT` operator does not
-  // return the expected result on SAP HANA (BCP 2180256508). In addition, double
-  // quotation marks after a `NOT` operator do not return the desired result.
-  // if (cqnSearchPhrase[0] === 'not' && cqnSearchPhrase[1].val[0] === ' ') return false
-
-  // so for now do not optimize for the `NOT` operator
-  if (cqnSearchPhrase[0] === 'not') return false
-
-  // The `AND` operator in combination with the `OR` operator does not
-  // return the expected result
-  const andOR = cqnSearchPhrase.includes('or') && cqnSearchPhrase.includes('and')
-  if (andOR) return false
-
-  // brackets are not supported as search operators in SAP HANA
-  if (cqnSearchPhrase.some(searchXpr => searchXpr.xpr)) return false
-
-  // join not optimized
-  if (entity.query?.SELECT.from.join) return false
-
-  // the CONTAINS function does not interoperate with columns that use the CONCAT function
-  if (_isColumnFunc(columns2Search, entity.query?.SELECT.columns)) return false
-  return true
-}
-
-const _isColumnFunc = (columns2Search, columnsDefs) =>
-  columns2Search.some(column2Search => {
-    if (column2Search.func) return true
-    return columnsDefs?.some(
-      columnDef => (columnDef.func && columnDef.as === column2Search.ref[0]) || columnDef?.xpr?.some(xpr => xpr.func)
-    )
-  })
-
-module.exports = {
-  isContainsPredicateSupported,
-  search2Contains
-}

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,98 +0,0 @@
-const cds = require('../cds')
-const { computeColumnsToBeSearched } = require('../common/utils/columns')
-const searchToLike = require('../common/utils/searchToLike')
-const { isContainsPredicateSupported, search2Contains } = require('./search2Contains')
-const { addAliasToExpression } = require('../db/utils/generateAliases')
-const targetAlias = 'Target'
-const textsAlias = 'Texts'
-
-/**
- * Computes a CQN expression for a search query.
- *
- * For performance reasons, search queries over localized elements use the `CONTAINS` predicate in the `WHERE` clause
- * of a `SELECT` statement instead of the `LIKE` predicate when possible. The `LIKE` predicate might cause a high CPU
- * load on SAP HANA servers because the SAP HANA optimizer cannot push down `LIKE` expressions to the column storage
- * layer. As a result, search queries over large data sets are slow.
- *
- * The `CONTAINS` predicates with exact search option (default behavior) is rendered as `LIKE` by the HANA optimizer.
- * But in contrast to the explicitly written `LIKE ?`, the parameter is already resolved to its concrete value, making
- * it better optimizable by the HANA optimizer.
- *
- * @param {object} query The CQN object
- * @param {import('@sap/cds-compiler/lib/api/main').CSN} entity The target entity for the search query
- * @param {import('../types/api').search2cqnOptions} [options]
- * @returns {object} The modified CQN object
- */
-const search2cqn4sql = (query, entity, options) => {
-  const cqnSearchPhrase = query.SELECT.search
-  if (!cqnSearchPhrase) return query
-  const localizedAssociation = entity.associations?.localized
-
-  let { columns: columns2Search = computeColumnsToBeSearched(query, entity), locale } = options
-  const viewAlias = query.SELECT.from.as ? query.SELECT.from.as : 'LocalizedView'
-
-  if (!query.SELECT.from.as) {
-    _addAliasToQuery(query, viewAlias)
-  }
-
-  const subQuery = cds.ql.SELECT.from(entity.name).columns(1)
-  subQuery.SELECT.from.as = targetAlias
-  const onCondition = _generateKeysWhereCondition(entity, targetAlias, textsAlias)
-  onCondition.push('and', { ref: [textsAlias, 'locale'] }, '=', { val: locale || "SESSION_CONTEXT('LOCALE')" })
-
-  // left outer join the target table with the _texts table (the _texts table contains the translated texts)
-  subQuery.leftJoin(localizedAssociation.target, textsAlias).on(onCondition)
-
-  // add condition for equal keys of target table and localized view
-  subQuery.where(_generateKeysWhereCondition(entity, targetAlias, viewAlias))
-  const containsColumns = _generateContainsColumns(columns2Search, entity)
-
-  let expression
-
-  if (isContainsPredicateSupported(query, entity, columns2Search)) {
-    // generate CQN expression with `CONTAINS` predicate for the columns from the target and text table
-    expression = search2Contains(cqnSearchPhrase, containsColumns)
-    Object.defineProperty(expression, 'searchUsingContains', { value: true, enumerable: true })
-  } else {
-    expression = searchToLike(cqnSearchPhrase, containsColumns)
-  }
-
-  subQuery.where(expression)
-
-  // suppress the localize handler from redirecting the subQuery's target to the localized view
-  subQuery.SELECT.localized = false
-
-  query.where('exists', subQuery)
-
-  return query
-}
-
-const _generateKeysWhereCondition = (entity, alias1, alias2) => {
-  const keys = Object.keys(entity.keys).filter(key => !entity.keys[key].isAssociation && !entity.keys[key].virtual)
-  const where = []
-
-  keys.forEach(key => {
-    if (where.length > 0) where.push('and')
-    where.push({ ref: [alias1, key] }, '=', { ref: [alias2, key] })
-  })
-
-  return where
-}
-
-const _generateContainsColumns = (columns, entity) => {
-  const columnsTarget = addAliasToExpression(columns, targetAlias)
-  const columns2SearchText = columns.filter(col => col.ref && entity.elements[col.ref[col.ref.length - 1]].localized)
-  const columnsText = addAliasToExpression(columns2SearchText, textsAlias)
-  return [...columnsTarget, ...columnsText]
-}
-
-const _addAliasToQuery = (query, alias) => {
-  const SELECT = query.SELECT
-  SELECT.from.as = alias
-  SELECT.columns = addAliasToExpression(SELECT.columns, alias)
-  SELECT.groupBy = addAliasToExpression(SELECT.groupBy, alias)
-  SELECT.orderBy = addAliasToExpression(SELECT.orderBy, alias)
-  SELECT.where = addAliasToExpression(SELECT.where, alias)
-}
-
-module.exports = search2cqn4sql

package/libx/_runtime/hana/streaming.js

@@ -1,248 +0,0 @@
-const cds = require('../cds')
-const LOG = cds.log('hana|db|sql')
-
-const { dynatraceStreamingExtension, isDynatraceEnabled } = require('./dynatrace')
-const { ensureNoDraftsSuffix } = require('../common/utils/draft')
-
-const STREAM_PLACEHOLDER = '[<stream>]'
-
-const _loadStreamExtensionIfNeeded = () => {
-  const hana = require('./driver')
-  if (hana.name !== 'hdb') {
-    const extension = require('@sap/hana-client/extension/Stream.js')
-    return isDynatraceEnabled() ? dynatraceStreamingExtension(extension) : extension
-  }
-}
-
-const streamExtension = _loadStreamExtensionIfNeeded()
-
-function hasStreamInsert(insert, model) {
-  if (!model) return false
-
-  const name = insert.into.ref ? insert.into.ref[0] : insert.into
-  const into = model.definitions[ensureNoDraftsSuffix(name)]
-  if (!into) return false
-
-  if (insert.entries && insert.entries.length > 0) {
-    return Object.keys(insert.entries[0])
-      .map(col => into.elements[col])
-      .some(e => e && e['@Core.MediaType'])
-  }
-  if (insert.columns && insert.columns.length > 0) {
-    return Object.keys(insert.columns)
-      .map(col => into.elements[col])
-      .some(e => e && e['@Core.MediaType'])
-  }
-
-  return false
-}
-
-function hasStreamUpdate(update, model) {
-  if (!model) return false
-
-  const entity = model.definitions[ensureNoDraftsSuffix((update.entity.ref && update.entity.ref[0]) || update.entity)]
-  if (!entity) return false
-
-  const data = Object.assign({}, update.data || {}, update.with || {})
-  return Object.keys(data)
-    .map(col => entity.elements[col])
-    .some(e => e && e['@Core.MediaType'])
-}
-
-function _getColumnInfo(result) {
-  const columnInfo = []
-
-  for (let i = 0, length = result.getColumnCount(); i < length; i++) {
-    columnInfo.push({
-      name: result.getColumnInfo()[i].originalColumnName,
-      lob: result.getColumnInfo()[i].nativeTypeName === 'BLOB'
-    })
-  }
-
-  return columnInfo
-}
-
-function _getResultSetRow(result, columnInfo, stmt) {
-  const res = {}
-
-  for (let i = 0, length = result.getColumnCount(); i < length; i++) {
-    if (columnInfo[i].lob) {
-      if (result.isNull(i)) {
-        res[columnInfo[i].name] = null
-      } else {
-        res[columnInfo[i].name] = streamExtension.createLobStream(result, i, { readSize: 1024000 })
-        res[columnInfo[i].name].on('end', () => {
-          stmt.drop(() => {})
-        })
-        res[columnInfo[i].name].on('error', () => {
-          stmt.drop(() => {})
-        })
-      }
-    } else {
-      res[columnInfo[i].name] = result.getValue(i)
-    }
-  }
-
-  return res
-}
-
-const _writeStreamCb = (resolve, reject, sql, values) => {
-  return (err, stmt) => {
-    if (err) {
-      err.query = sql
-      err.values = values
-      return reject(err)
-    }
-
-    stmt.exec(values, (err, result) => {
-      stmt.drop(() => {})
-      if (err) {
-        err.query = sql
-        err.values = values
-        return reject(err)
-      }
-      resolve(result)
-    })
-  }
-}
-
-// TODO combine with hana client fn?
-function writeStreamWithHdb(dbc, sql, values) {
-  LOG._debug && LOG.debug(`${sql} ${values && values.length ? STREAM_PLACEHOLDER : ''}`)
-  return new Promise((resolve, reject) => {
-    try {
-      dbc.prepare(sql, _writeStreamCb(resolve, reject, sql, values))
-    } catch (err) {
-      // TODO convertErrorCodeToString(err)
-      err.query = sql
-      return reject(err)
-    }
-  })
-}
-
-function writeStreamWithHanaClient(dbc, sql, values) {
-  LOG._debug && LOG.debug(`${sql} ${values && values.length ? STREAM_PLACEHOLDER : ''}`)
-  return new Promise((resolve, reject) => {
-    streamExtension.createStatement(dbc, sql, _writeStreamCb(resolve, reject, sql, values))
-  })
-}
-
-function _getReadObjectHanaClient(result, stmt, resolve, reject) {
-  const resultSet = []
-  const columnInfo = _getColumnInfo(result)
-
-  let next = true
-
-  while (next) {
-    next = result.next((err, ret) => {
-      if (err) {
-        return reject(err)
-      }
-
-      if (ret) {
-        resultSet.push(_getResultSetRow(result, columnInfo, stmt))
-      }
-
-      if (!next) {
-        resolve(resultSet)
-      }
-    })
-  }
-}
-
-function readStreamWithHanaClient(dbc, sql, values) {
-  LOG._debug && LOG.debug(`${sql} ${values && values.length ? STREAM_PLACEHOLDER : ''}`)
-  return new Promise((resolve, reject) => {
-    streamExtension.createStatement(dbc, sql, (err, stmt) => {
-      if (err) {
-        err.query = sql
-        err.values = values
-        return reject(err)
-      }
-
-      stmt.stmt.executeQuery(values, (err, result) => {
-        if (err) {
-          err.query = sql
-          err.values = values
-          return reject(err)
-        }
-
-        // The method createObjectStream does not work in hana-client as expected.
-        // It provides the complete LOBs and not the streams.
-        // The resultset should be constructed like bellow.
-        _getReadObjectHanaClient(result, stmt, resolve, reject)
-      })
-    })
-  })
-}
-
-function _getReadObjectHdb(result, rows, statement) {
-  return () => {
-    const row = result.read()
-
-    if (row) {
-      for (const key in row) {
-        if (typeof row[key] === 'object' && row[key] !== null) {
-          row[key] = row[key].createReadStream()
-          row[key].on('end', () => {
-            statement.drop()
-          })
-          row[key].on('error', () => {
-            statement.drop()
-          })
-        }
-      }
-
-      rows.push(row)
-    }
-  }
-}
-
-function readStreamWithHdb(dbc, sql, values) {
-  LOG._debug && LOG.debug(`${sql} ${values && values.length ? STREAM_PLACEHOLDER : ''}`)
-  return new Promise((resolve, reject) => {
-    const cb = (err, statement) => {
-      if (err) {
-        // TODO convertErrorCodeToString(err)
-        err.query = sql
-
-        return reject(err)
-      }
-
-      statement.execute(values, (err, result) => {
-        if (err) {
-          // TODO convertErrorCodeToString(err)
-          err.query = this.sql
-          statement.drop()
-
-          return reject(err)
-        }
-
-        const rows = []
-        const objStream = result.createObjectStream()
-
-        objStream
-          .on('readable', _getReadObjectHdb(objStream, rows, statement))
-          .once('error', err => reject(err))
-          .once('end', () => resolve(rows))
-      })
-    }
-
-    try {
-      dbc.prepare(sql, cb)
-    } catch (err) {
-      //  TODO convertErrorCodeToString(err)
-      err.query = sql
-      return reject(err)
-    }
-  })
-}
-
-module.exports = {
-  hasStreamInsert,
-  hasStreamUpdate,
-  writeStreamWithHanaClient,
-  readStreamWithHanaClient,
-  writeStreamWithHdb,
-  readStreamWithHdb
-}

package/libx/_runtime/messaging/Outbox.js

@@ -1,15 +0,0 @@
-const cds = require('../cds')
-
-class Outbox extends cds.Service {
-  constructor(...args) {
-    super(...args)
-
-    if (this.options.outbox) return cds.outboxed(this)
-  }
-}
-
-module.exports = cds.utils.deprecated(() => Outbox, {
-  kind: 'Class',
-  old: 'Outbox',
-  use: 'config or cds.outboxed() to outbox your service'
-})()

package/libx/_runtime/sqlite/Service.js

@@ -1,153 +0,0 @@
-const cds = require('../cds')
-
-const DatabaseService = require('../db/Service')
-
-let _sqlite
-
-/*
- * sqlite-specific handlers
- */
-const localized = require('./localized')
-const convertAssocToOneManaged = require('./convertAssocToOneManaged')
-const convertDraftAdminPathExpression = require('./convertDraftAdminPathExpression')
-
-/*
- * sqlite-specific execution
- */
-const execute = require('./execute')
-
-const _new = url => {
-  if (url && url !== ':memory:') url = cds.utils.path.resolve(cds.root, url)
-  if (!_sqlite) _sqlite = require('sqlite3')
-  return new Promise((resolve, reject) => {
-    const dbc = new _sqlite.Database(url, err => {
-      err ? reject(err) : resolve(dbc)
-    })
-  })
-}
-
-/*
- * the service
- */
-module.exports = class SQLiteDatabase extends DatabaseService {
-  constructor(...args) {
-    super(...args)
-
-    // REVISIT: official db api
-    this._execute = execute
-
-    // REVISIT: official db api
-    this._insert = this._queries.insert(execute.insert)
-    this._read = this._queries.read(execute.select, execute.stream, execute.convert)
-    this._update = this._queries.update(execute.update, execute.select)
-    this._delete = this._queries.delete(execute.delete, execute.update)
-    this._run = this._queries.run(this._insert, this._read, this._update, this._delete, execute.cqn, execute.sql)
-
-    this.dbcs = new Map()
-  }
-
-  init() {
-    this._registerBeforeHandlers()
-    this._registerOnHandlers()
-    this._registerAfterHandlers()
-
-    /*
-     * tx
-     */
-    this.on(['BEGIN', 'COMMIT', 'ROLLBACK'], function (req) {
-      // REVISIT: better?
-      this.dbc._closed = req.event !== 'BEGIN'
-
-      return this._run(this.model, this.dbc, req.event)
-    })
-
-    /*
-     * generic
-     */
-    // all others, i.e. CREATE, DROP table, ...
-    this.on('*', function (req) {
-      return this._run(this.model, this.dbc, req.query || req.event, req, req.data)
-    })
-  }
-
-  _registerBeforeHandlers() {
-    this.before(['CREATE', 'UPDATE', 'UPSERT'], '*', this._input) // > has to run before rewrite
-    this.before(['CREATE', 'READ', 'UPDATE', 'DELETE', 'UPSERT'], '*', this._rewrite)
-
-    if (!cds.db?.cqn2sql) this.before('READ', '*', convertDraftAdminPathExpression)
-    this.before('READ', '*', convertAssocToOneManaged)
-    this.before('READ', '*', localized) // > has to run after rewrite
-    this.before('READ', '*', this._virtual)
-  }
-
-  _registerOnHandlers() {
-    this.on('CREATE', '*', this._CREATE)
-    this.on('READ', '*', this._READ)
-    this.on('UPDATE', '*', this._UPDATE)
-    this.on('DELETE', '*', this._DELETE)
-  }
-
-  _registerAfterHandlers() {
-    // REVISIT: after phase runs in parallel -> side effects possible!
-    const { effective, features } = cds.env
-
-    if (effective.odata.structs && !features.ucsn_struct_conversion) {
-      // REVISIT: only register for entities that contain structured or navigation to it
-      this.after(['READ'], '*', this._structured)
-    }
-  }
-
-  url4(tenant) {
-    const credentials = this.options.credentials || this.options || {}
-    let dbUrl = credentials.database || credentials.url || credentials.host || ':memory:'
-
-    if (tenant && dbUrl !== ':memory:') {
-      dbUrl = dbUrl.replace(/\.(db|sqlite)$/, `-${tenant}.$1`)
-    }
-    return dbUrl
-  }
-
-  /*
-   * connection
-   */
-  async acquire(arg) {
-    // in non-multi-tenant scenarios, the default db should be returned regardless of arg
-    const isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
-    // REVISIT: there should already be compat for the multitenancy flag, why is it not working here?
-    // REVISIT: remove fallback arg.user.tenant with cds^6
-    const tenant = isMultitenant && arg && (typeof arg === 'string' ? arg : arg.tenant || (arg.user && arg.user.tenant))
-    let dbc = this.dbcs.get(tenant)
-    if (!dbc) {
-      const dbUrl = this.url4(tenant)
-
-      dbc = await _new(dbUrl)
-
-      dbc._queued = []
-
-      if (cds.env.features.assert_integrity === 'db') {
-        await new Promise((resolve, reject) => {
-          dbc.exec('PRAGMA foreign_keys = ON', err => {
-            if (err) reject(err)
-            resolve()
-          })
-        })
-      }
-
-      this.dbcs.set(tenant, dbc)
-    }
-
-    if (dbc._busy) await new Promise(resolve => dbc._queued.push(resolve))
-    else dbc._busy = true
-
-    return dbc
-  }
-
-  release(dbc) {
-    if (dbc._queued.length) dbc._queued.shift()()
-    else dbc._busy = false
-  }
-
-  async disconnect(tenant) {
-    this.dbcs.delete(tenant)
-  }
-}

package/libx/_runtime/sqlite/conversion.js

@@ -1,47 +0,0 @@
-const normalizeTimestamp = require('../common/utils/normalizeTimestamp')
-
-const convertToBoolean = boolean => {
-  if (boolean === null) return null
-
-  return Boolean(boolean)
-}
-
-const convertToDateString = value => {
-  if (!value) return null
-
-  return value
-}
-
-const convertInt64ToString = int64 => {
-  if (int64 === null) return null
-
-  return String(int64)
-}
-
-const convertToISOTime = value => {
-  if (value === null) return value
-
-  if (!value) return normalizeTimestamp(new Date(0))
-
-  return normalizeTimestamp(value)
-}
-
-const convertToISONoMillis = element => {
-  if (element) {
-    const dateTime = new Date(element).toISOString()
-    return dateTime.slice(0, 19) + dateTime.slice(23)
-  }
-
-  return null
-}
-
-const SQLITE_TYPE_CONVERSION_MAP = new Map([
-  ['cds.Boolean', convertToBoolean],
-  ['cds.Date', convertToDateString],
-  ['cds.Integer64', convertInt64ToString],
-  ['cds.Int64', convertInt64ToString],
-  ['cds.DateTime', convertToISONoMillis],
-  ['cds.Timestamp', convertToISOTime]
-])
-
-module.exports = { SQLITE_TYPE_CONVERSION_MAP }