@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/hana/execute.js

@@ -1,429 +0,0 @@
-const cds = require('../cds')
-const LOG = cds.log('hana|db|sql')
-
-const { HANA_TYPE_CONVERSION_MAP } = require('./conversion')
-const CustomBuilder = require('./customBuilder')
-const { sqlFactory } = require('../db/sql-builder/')
-const { getPostProcessMapper, postProcess } = require('../db/data-conversion/post-processing')
-const { createJoinCQNFromExpanded, hasExpand, rawToExpanded, expandV2 } = require('../db/expand')
-const {
-  hasStreamInsert,
-  hasStreamUpdate,
-  writeStreamWithHanaClient,
-  readStreamWithHanaClient,
-  writeStreamWithHdb,
-  readStreamWithHdb
-} = require('./streaming')
-const { convertStream } = require('../db/utils/stream')
-const { isBase64String } = require('../../common/assert/utils')
-
-function _cqnToSQL(model, query, user, locale, txTimestamp) {
-  return sqlFactory(
-    query,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: 'NOW ()' },
-      locale
-    },
-    model
-  )
-}
-
-const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
-
-const BINARY_TYPES = {
-  12: 'BINARY',
-  13: 'VARBINARY',
-  27: 'BLOB',
-  33: 'BSTRING'
-}
-
-function _getBinaries(stmt) {
-  // hdb vs. @sap/hana-client
-  const parameters = stmt.parameterMetadata || stmt.getParameterInfo()
-  const typeKey = stmt.parameterMetadata ? 'dataType' : 'nativeType'
-  return parameters.reduce((acc, cur, i) => {
-    if (BINARY_TYPES[cur[typeKey]]) acc.push(i)
-    return acc
-  }, [])
-}
-
-function _getProcedureNameAndSchema(sql) {
-  // name delimited with "" allows any character
-  const match = sql
-    .trim()
-    .match(
-      /^call \s*(("(?<schema_delimited>\w+)"\.)?("(?<delimited>.+)")|(?<schema_undelimited>\w+\.)?(?<undelimited>\w+))\s*\(/i
-    )
-  return (
-    match && {
-      name: match.groups.undelimited ?? match.groups.delimited,
-      schema: match.groups.schema_delimited || match.groups.schema_undelimited
-    }
-  )
-}
-
-function _hdbGetResultForProcedure(rows, args, outParameters) {
-  // on hdb, rows already contains results for scalar params
-  const result = rows || {}
-
-  // merge table output params into scalar params
-  if (args && args.length && outParameters) {
-    const params = outParameters.filter(md => !(md.PARAMETER_NAME in rows))
-    for (let i = 0; i < params.length; i++) {
-      result[params[i].PARAMETER_NAME] = args[i]
-    }
-  }
-
-  return result
-}
-
-function _hcGetResultForProcedure(stmt, resultSet, outParameters) {
-  const result = {}
-  // build result from scalar params
-  const paramInfo = stmt.getParameterInfo()
-  if (paramInfo.some(p => p.direction > 1)) {
-    for (let i = 0; i < paramInfo.length; i++) {
-      if (paramInfo[i].direction > 1) {
-        result[paramInfo[i].name] = stmt.getParameterValue(i)
-      }
-    }
-  }
-
-  // merge table output params into scalar params
-  const params = Array.isArray(outParameters) && outParameters.filter(md => !(md.PARAMETER_NAME in result))
-  if (params && params.length) {
-    for (let i = 0; i < params.length; i++) {
-      const parameterName = params[i].PARAMETER_NAME
-      result[parameterName] = []
-      while (resultSet.next()) {
-        result[parameterName].push(resultSet.getValues())
-      }
-      resultSet.nextResult()
-    }
-  }
-
-  return result
-}
-
-function _getProcedureMetadata(dbc, name, schema) {
-  return new Promise((resolve, reject) => {
-    // REVISIT: better?
-    if (dbc._closed) return reject(new Error('Transaction is already closed'))
-    dbc.exec(
-      `SELECT PARAMETER_NAME FROM SYS.PROCEDURE_PARAMETERS WHERE SCHEMA_NAME = ${
-        schema?.toUpperCase?.() === 'SYS' ? `'SYS'` : 'CURRENT_SCHEMA'
-      } AND PROCEDURE_NAME = '${name}' AND PARAMETER_TYPE IN ('OUT', 'INOUT') ORDER BY POSITION`,
-      (err, res) => {
-        if (err) reject(err)
-        else resolve(res)
-      }
-    )
-  })
-}
-
-function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
-  // REVISIT: better?
-  if (dbc._closed) return reject(new Error('Transaction is already closed'))
-
-  dbc.prepare(sql, async function (err, stmt) {
-    if (err) {
-      err.query = sql
-      if (values) err.values = SANITIZE_VALUES ? ['***'] : values
-      return reject(err)
-    }
-
-    // convert binary strings to buffers
-    if (cds.env.hana.base64_to_buffer !== false && _hasValues(values)) {
-      const binaries = _getBinaries(stmt)
-      if (binaries.length) {
-        const vals = Array.isArray(values[0]) ? values : [values]
-        for (const i of binaries) {
-          for (const row of vals) {
-            if (row[i] && isBase64String(row[i])) row[i] = Buffer.from(row[i], 'base64')
-          }
-        }
-      }
-    }
-
-    // procedure call metadata
-    let outParameters
-    const { name: procedureName, schema: procedureSchema } = _getProcedureNameAndSchema(sql) || {}
-    if (procedureName) {
-      try {
-        outParameters = await _getProcedureMetadata(dbc, procedureName, procedureSchema)
-      } catch (e) {
-        LOG._warn && LOG.warn('Unable to fetch procedure metadata due to error:', e)
-      }
-    }
-
-    // REVISIT: better?
-    if (dbc._closed) return reject(new Error('Transaction is already closed'))
-
-    // on @sap/hana-client, we need to use execQuery in case of calling procedures
-    stmt[procedureName && dbc.name !== 'hdb' ? 'execQuery' : 'exec'](values, function (err, rows, ...args) {
-      if (err) {
-        stmt.drop(() => {})
-        err.query = sql
-        if (values) err.values = SANITIZE_VALUES ? ['***'] : values
-        return reject(err)
-      }
-
-      let result
-      if (procedureName) {
-        result =
-          dbc.name === 'hdb'
-            ? _hdbGetResultForProcedure(rows, args, outParameters)
-            : _hcGetResultForProcedure(stmt, rows, outParameters)
-      } else {
-        result = rows
-      }
-
-      stmt.drop(() => {})
-      resolve(result)
-    })
-  })
-}
-
-const _hasValues = values => values && (values.length > 0 || Object.values(values).length > 0)
-
-const regex = /with parameters\s*?\(\s*?'LOCALE'\s*?=\s*?'.*?'\s*?\)/gim
-
-function _executeSimpleSQL(dbc, sql, values) {
-  const res = sql.match(regex)
-  if (res) sql = sql.replace(regex, '') + ' ' + res[0]
-
-  LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
-  return new Promise((resolve, reject) => {
-    // hana-client only accepts arrays
-    if (dbc.name !== 'hdb' && typeof values === 'object') {
-      values = Object.values(values)
-    }
-
-    // ensure that stored procedure with parameters is always executed as prepared
-    if (_hasValues(values) || !!_getProcedureNameAndSchema(sql)) {
-      _executeAsPreparedStatement(dbc, sql, values, reject, resolve)
-    } else {
-      // REVISIT: better?
-      if (dbc._closed) return reject(new Error('Transaction is already closed'))
-
-      dbc.exec(sql, function (err, result) {
-        if (err) {
-          err.query = sql
-          return reject(err)
-        }
-        resolve(result)
-      })
-    }
-  })
-}
-
-function _executeSelectSQL(dbc, sql, values, isOne, postMapper) {
-  return _executeSimpleSQL(dbc, sql, values).then(result => {
-    if (isOne) {
-      result = result.length > 0 ? result[0] : undefined
-    }
-
-    return postProcess(result, postMapper)
-  })
-}
-
-function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
-  const queries = []
-  const expandQueries = createJoinCQNFromExpanded(cqn, model)
-
-  for (const cqn of expandQueries.queries) {
-    cqn._conversionMapper = getPostProcessMapper(HANA_TYPE_CONVERSION_MAP, model, cqn)
-
-    // REVISIT
-    // Why is the post processing in expand different?
-    const { sql, values } = _cqnToSQL(model, cqn, user, locale, txTimestamp)
-
-    queries.push(_executeSelectSQL(dbc, sql, values, false))
-  }
-
-  return rawToExpanded(expandQueries, queries, cqn.SELECT.one, cqn._target)
-}
-
-function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {
-  if (hasExpand(query)) {
-    // expand: '**' or '*3' is handled by new impl
-    if (
-      query.SELECT.columns.some(c => c.expand && typeof c.expand[0] === 'string' && /^\*{1}[\d|*]+/.test(c.expand[0]))
-    ) {
-      return expandV2(model, dbc, query, user, locale, txTimestamp, executeSelectCQN)
-    }
-
-    return _processExpand(model, dbc, query, user, locale, txTimestamp)
-  }
-
-  const { sql, values = [] } = _cqnToSQL(model, query, user, locale, txTimestamp)
-  const postProcessMapper = getPostProcessMapper(HANA_TYPE_CONVERSION_MAP, model, query)
-  return _executeSelectSQL(dbc, sql, values, query.SELECT.one, postProcessMapper)
-}
-
-function _getValuesProxy(values) {
-  return new Proxy(values, {
-    getOwnPropertyDescriptor: (obj, prop) => {
-      if (prop.length > 1 && prop.startsWith(':')) {
-        return Object.getOwnPropertyDescriptor(obj, prop.slice(1))
-      }
-
-      return Object.getOwnPropertyDescriptor(obj, prop)
-    },
-    get: (obj, prop) => {
-      if (prop.length > 1 && prop.startsWith(':')) {
-        return obj[prop.slice(1)]
-      }
-
-      return obj[prop]
-    },
-    ownKeys: target => Reflect.ownKeys(target).map(key => `:${key}`)
-  })
-}
-
-function executePlainSQL(dbc, sql, values) {
-  // Revisit: Keep for Hana?
-  // support named binding parameters
-  if (values && typeof values === 'object' && !Array.isArray(values)) {
-    values = _getValuesProxy(values)
-  }
-
-  return _executeSimpleSQL(dbc, sql, values)
-}
-
-function executeInsertCQN(model, dbc, query, user, locale, txTimestamp) {
-  const { sql, values = [] } = _cqnToSQL(model, query, user, locale, txTimestamp)
-
-  if (hasStreamInsert(query.INSERT, model)) {
-    if (dbc.name === 'hdb') {
-      return writeStreamWithHdb(dbc, sql, values)
-    }
-
-    return writeStreamWithHanaClient(dbc, sql, values)
-  }
-
-  return _executeSimpleSQL(dbc, sql, values).then(affectedRows => {
-    const entriesOrRows = query.INSERT.entries || query.INSERT.rows
-    const affectedRowsCount = Array.isArray(affectedRows)
-      ? affectedRows.reduce((sum, rows) => sum + rows, 0)
-      : affectedRows
-
-    if (entriesOrRows && entriesOrRows.length !== affectedRowsCount) {
-      LOG._warn &&
-        LOG.warn(
-          `INSERT input deviates from affected rows (input: ${entriesOrRows.length}, affectedRows: ${affectedRowsCount})`,
-          {
-            sql,
-            args: values && values.length,
-            values,
-            query
-          }
-        )
-
-      throw new Error('Possible data loss by INSERT into HANA db. Please, update a corresponding HANA driver.')
-    }
-
-    // InsertResult needs an object per row with its values
-    // query.INSERT.values -> one row
-    if (query.INSERT.values) return [{ affectedRows: 1, values: [values] }]
-
-    // query.INSERT.entries or .rows -> multiple rows
-    if (entriesOrRows) return values.map(v => ({ affectedRows: 1, values: v }))
-
-    // INSERT into SELECT
-    return [{ affectedRows }]
-  })
-}
-
-function _writeStream(model, dbc, query, user, locale, txTimestamp, sql, values) {
-  if (dbc.name === 'hdb') return writeStreamWithHdb(dbc, sql, values)
-
-  // @sap/hana-client does not support WHERE EXISTS when writing stream
-  const subselect = query.UPDATE.where?.find(ele => typeof ele === 'object' && ele.SELECT && ele._etagValidation)
-  if (!subselect) return writeStreamWithHanaClient(dbc, sql, values)
-
-  const { sql: s, values: v } = _cqnToSQL(model, subselect, user, locale, txTimestamp)
-  return executePlainSQL(dbc, s, v).then(res => {
-    if (res.length === 0) return 0
-    return writeStreamWithHanaClient(dbc, sql, values)
-  })
-}
-
-function executeUpdateCQN(model, dbc, query, user, locale, txTimestamp) {
-  const { sql, values = [] } = _cqnToSQL(model, query, user, locale, txTimestamp)
-
-  // query can be insert from deep update
-  if (query.UPDATE && hasStreamUpdate(query.UPDATE, model))
-    return _writeStream(model, dbc, query, user, locale, txTimestamp, sql, values)
-
-  return _executeSimpleSQL(dbc, sql, values)
-}
-
-// e. g. DROP, CREATE TABLE, DELETE
-function executeGenericCQN(model, dbc, query, user, locale, txTimestamp) {
-  const { sql, values = [] } = _cqnToSQL(model, query, user, locale, txTimestamp)
-
-  return executePlainSQL(dbc, sql, values)
-}
-
-function _convertNames(rs, columns) {
-  if (!columns) return rs
-
-  const result = {}
-  for (const key in rs) {
-    let key_
-    for (let col of columns) {
-      const name = col.ref?.[col.ref.length - 1]
-      if (name?.toUpperCase() === key) {
-        key_ = col.as || name
-        break
-      }
-    }
-    if (key_) {
-      result[key_] = rs[key]
-    } else {
-      result[key] = rs[key]
-    }
-  }
-
-  return result
-}
-
-async function executeSelectStreamCQN({ model, query, dbc, user, locale, txTimestamp }) {
-  const { sql, values = [] } = _cqnToSQL(model, query, user, locale, txTimestamp)
-  let result
-
-  if (dbc.name === 'hdb') {
-    result = await readStreamWithHdb(dbc, sql, values)
-  } else {
-    result = await readStreamWithHanaClient(dbc, sql, values)
-  }
-
-  if (result.length === 0) return
-
-  if (cds.env.features.stream_compat) {
-    const res = _convertNames(result[0], query.SELECT?.columns)
-    let [key, val] = Object.entries(res)[0]
-    if (val === null) return null
-
-    res.value = val
-    delete res[key]
-
-    return res
-  } else {
-    return dbc.name === 'hdb' ? result[0] : _convertNames(result[0], query.SELECT?.columns)
-  }
-}
-
-module.exports = {
-  delete: executeGenericCQN, // > no extra executeDeleteCQN needed
-  insert: executeInsertCQN,
-  update: executeUpdateCQN,
-  select: executeSelectCQN,
-  stream: executeSelectStreamCQN,
-  convert: convertStream,
-  cqn: executeGenericCQN,
-  sql: executePlainSQL
-}

package/libx/_runtime/hana/localized.js

@@ -1,39 +0,0 @@
-const { ensureUnlocalized } = require('../common/utils/draft')
-const { redirect } = require('../db/utils/localized')
-
-const getLocalize = model => name => {
-  if (name.endsWith('_drafts')) return name
-
-  // if we get here via onReadDraft, the target is already localized
-  // because of sub-request using SELECT.from as the new target
-  const target = model.definitions[ensureUnlocalized(name)]
-  const localizedView = target && target['@cds.localized'] !== false && model.definitions[`localized.${name}`]
-  return localizedView ? localizedView.name : name
-}
-
-const localizedHandler = function (req) {
-  const { query } = req
-
-  // do simple checks upfront and exit early
-  if (!query || typeof query === 'string') return
-  if (!query.SELECT) return
-  if (!this.model) return
-  if (!req.locale) return
-
-  // suppress localization by instruction
-  if (query.SELECT.localized === false) return
-
-  // suppress localization for pure counts
-  const columns = query.SELECT.columns
-  if (columns && columns.length === 1 && columns[0].func === 'count') return
-
-  // suppress localization (no redirection to localized view) for queries that
-  // lock the selected record (exclusive and shared locks)
-  if (query.SELECT.forUpdate) return
-  if (query.SELECT.forShareLock) return
-
-  redirect(query, getLocalize(this.model))
-}
-
-localizedHandler._initial = true
-module.exports = localizedHandler

package/libx/_runtime/hana/pool.js

@@ -1,186 +0,0 @@
-const cds = require('../cds')
-const LOG = cds.log('pool|db')
-
-const { pool } = cds.utils
-const hana = require('./driver')
-const getError = require('../common/error')
-
-const _getMassagedCreds = function (creds) {
-  if (!('ca' in creds) && creds.certificate) creds.ca = creds.certificate
-  if ('encrypt' in creds && !('useTLS' in creds)) creds.useTLS = creds.encrypt
-  if ('hostname_in_certificate' in creds && !('sslHostNameInCertificate' in creds))
-    creds.sslHostNameInCertificate = creds.hostname_in_certificate
-  if ('validate_certificate' in creds && !('sslValidateCertificate' in creds))
-    creds.sslValidateCertificate = creds.validate_certificate
-  return creds
-}
-
-// `disableCache: true` means to force fetch credentials from service manager
-async function credentials4(tenant, db) {
-  const { disableCache = false, options } = db
-  const credentials = options?.credentials ?? cds.env.requires.db?.credentials
-  if (!credentials) throw new Error('No database credentials provided')
-
-  if (cds.requires.multitenancy) {
-    const res = await require('@sap/cds-mtxs/lib').xt.serviceManager.get(tenant, { disableCache })
-    return _getMassagedCreds(res.credentials)
-  }
-
-  if (typeof credentials !== 'object' || !credentials.host) throw new Error('Malformed database credentials provided')
-  return _getMassagedCreds(credentials)
-}
-
-function factory4(creds, tenant) {
-  return {
-    create: () => {
-      return hana.__connect(creds, tenant).catch(e => {
-        if (!cds.requires.multitenancy || !e?.message.match(/authentication failed/i)) throw e
-
-        LOG._warn &&
-          LOG.warn(
-            `Possibly stale credentials for tenant ${tenant}, re-trying with fresh credentials from BTP Service Manager`
-          )
-        return credentials4(tenant, { disableCache: true }).then(_creds => {
-          // update creds in closure
-          creds = _creds
-          return hana.__connect(creds, tenant)
-        })
-      })
-    },
-    destroy: client => hana.__disconnect(client),
-    validate: client => hana.__isConnected(client)
-  }
-}
-
-/*
- * default generic-pool config
- */
-const defaultConfig = { min: 0, max: 100, testOnBorrow: true, fifo: false }
-
-const _getPoolConfig = function () {
-  const { pool: poolConfig } = cds.env.requires.db
-  const mergedConfig = Object.assign({}, defaultConfig, poolConfig)
-
-  // without an acquire timeout, the acquire call _never_ rejects -> blocks the request forever
-  mergedConfig.acquireTimeoutMillis ??= process.env.NODE_ENV === 'production' ? 1000 : 10 * 1000
-
-  // defaults
-  if (!poolConfig) {
-    mergedConfig.softIdleTimeoutMillis = 30 * 1000
-    mergedConfig.idleTimeoutMillis = 30 * 1000
-  }
-
-  // if evictionRunIntervalMillis is not set specifically, set to 2x of idleTimeoutMillis or softIdleTimeoutMillis
-  if (!('evictionRunIntervalMillis' in mergedConfig)) {
-    mergedConfig.evictionRunIntervalMillis =
-      2 * (mergedConfig.idleTimeoutMillis || mergedConfig.softIdleTimeoutMillis || 30 * 1000)
-  }
-
-  // if numTestsPerEvictionRun is not set specifically, set to ~30% of min-max delta
-  if (!('numTestsPerEvictionRun' in mergedConfig) && mergedConfig.max - mergedConfig.min > 0) {
-    mergedConfig.numTestsPerEvictionRun = Math.ceil((mergedConfig.max - mergedConfig.min) / 3)
-  }
-
-  return mergedConfig
-}
-
-const pools = new Map()
-
-async function pool4(tenant, db) {
-  if (!pools.get(tenant)) {
-    const poolPromise = new Promise((resolve, reject) => {
-      credentials4(tenant, db)
-        .then(creds => {
-          const config = _getPoolConfig()
-          LOG._info && LOG.info('effective pool configuration:', config)
-          const p = pool.createPool(factory4(creds, tenant), config)
-          const INVALID_CREDENTIALS_WARNING = `Could not establish connection for tenant "${tenant}". Existing pool will be drained.`
-          const INVALID_CREDENTIALS_ERROR = `Create is blocked for tenant "${tenant}" due to invalid credentials.`
-          const _create = () =>
-            new Promise((_, reject) =>
-              setTimeout(() => reject(new Error(INVALID_CREDENTIALS_ERROR)), config.acquireTimeoutMillis)
-            )
-
-          // The error listener for `factoryCreateError` is registered to detect failed connection attempts.
-          // If it fails due to invalid credentials, we delete the current pool from the pools map and overwrite the pool factory create function.
-          // The background is that the generic pool will keep trying to establish a connection by invoking the factory create function until the `acquireTimeoutMillis` is reached.
-          // This leads to numerous connection attempts for a single request, even when the credentials are invalid.
-          // Due to the deletion in the map, subsequent requests will retrieve the credentials again.
-          p.on('factoryCreateError', function (err) {
-            if (err._connectError) {
-              LOG._warn && LOG.warn(INVALID_CREDENTIALS_WARNING)
-              pools.delete(tenant)
-              if (p._factory?.create) p._factory.create = _create
-              // shutdown
-              p.drain().then(p.clear.bind(p)) //> no need to await
-            }
-          })
-
-          resolve(p)
-        })
-        .catch(e => {
-          // delete pools entry if fetching credentials failed
-          pools.delete(tenant)
-          reject(e)
-        })
-    })
-
-    pools.set(tenant, poolPromise)
-  }
-
-  if ('then' in pools.get(tenant)) {
-    pools.set(tenant, await pools.get(tenant))
-  }
-
-  return pools.get(tenant)
-}
-
-async function resilientAcquire(pool, attempts = 1) {
-  // max 3 attempts
-  attempts = Math.min(attempts, 3)
-  let client,
-    err,
-    attempt = 0
-
-  while (!client && attempt < attempts) {
-    try {
-      client = await pool.acquire()
-    } catch (e) {
-      if (e.name !== 'TimeoutError') throw e
-      err = e
-      attempt++
-    }
-  }
-
-  if (client) return client
-
-  const { borrowed, pending, size, available, max } = pool
-  const message =
-    'Acquiring client from pool timed out. Please review your system setup, transaction handling, and pool configuration. ' +
-    `Pool State: borrowed: ${borrowed}, pending: ${pending}, size: ${size}, available: ${available}, max: ${max}`
-  err = getError(Object.assign(err, { statusCode: 503, message }))
-  err._attempts = attempt
-  LOG._debug && LOG.debug(err)
-  throw err
-}
-
-module.exports = {
-  acquire: async (tenant, db) => {
-    const pool = await pool4(tenant, db)
-    const _attempts = cds.env.requires.db.connection_attempts
-    const attempts = _attempts && !isNaN(_attempts) && parseInt(_attempts)
-    const client = await resilientAcquire(pool, attempts)
-    client._pool = pool
-    return client
-  },
-
-  release: client => client._pool.release(client),
-
-  drain: async tenant => {
-    const pool = pools.get(tenant)
-    if (!pool) return
-    pools.delete(tenant)
-    await pool.drain()
-    await pool.clear()
-  }
-}

package/libx/_runtime/hana/search.js

@@ -1,20 +0,0 @@
-const cds = require('../cds')
-const search2cqn4sql = require('./search2cqn4sql')
-
-const _setSearchOptions = (query, _searchOptions) => {
-  if (!(query && query.SELECT)) return
-  if (query.SELECT.search) Object.defineProperty(query, '_searchOptions', { value: _searchOptions })
-  if (query.SELECT.from.SELECT) _setSearchOptions(query.SELECT.from, _searchOptions)
-}
-
-function searchHandler(req) {
-  // REVISIT: remove feature toggle optimized_search after grace period
-  // inject the search2cqn4sql module into the rewrite handler only when
-  // the optimized search feature toggle is turned on
-  if (cds.env.features.optimized_search === false) return
-  _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
-}
-
-// handlers marked with `._initial = true` run in sequence
-searchHandler._initial = true
-module.exports = searchHandler