@sap/cds 5.5.5 → 5.6.0

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,7 +1,6 @@
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, searchToContains } = require('./searchToContains')
-const { getOnCond } = require('../common/utils/generateOnCond')
 
 /**
  * Computes a CQN expression for a search query.
@@ -15,30 +14,27 @@ const { getOnCond } = require('../common/utils/generateOnCond')
  * 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} cqn The CQN object
+ * @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 = (cqn, entity, options) => {
-  const cqnSearchPhrase = cqn.SELECT.search
-  if (!cqnSearchPhrase) return cqn
+const search2cqn4sql = (query, entity, options) => {
+  const cqnSearchPhrase = query.SELECT.search
+  if (!cqnSearchPhrase) return query
 
-  let { columns = computeColumnsToBeSearched(cqn, entity), locale } = options
+  let { columns: columnsToBeSearched = computeColumnsToBeSearched(query, entity), locale } = options
   const localizedAssociation = _getLocalizedAssociation(entity)
 
   // If the localized association is defined for the target entity,
   // there should be at least one localized element.
   const resolveLocalizedTextsAtRuntime = !!localizedAssociation
 
-  if (resolveLocalizedTextsAtRuntime) {
-    // suppress the localize handler from modifying the from target
-    // The `_suppressLocalization` property is:
-    // enumerable: false (default), writable: false (default)
-    Object.defineProperty(cqn, '_suppressLocalization', { value: true })
+  // suppress the localize handler from redirecting the query's target to the localized view
+  Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-    const onConditionOptions = _getOnConditionOptions(entity, localizedAssociation)
-    const onCondition = getOnCond(localizedAssociation, onConditionOptions)
+  if (resolveLocalizedTextsAtRuntime) {
+    const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
     onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
@@ -46,31 +42,26 @@ const search2cqn4sql = (cqn, entity, options) => {
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)
     const localizedEntityName = localizedAssociation.target
-    cqn.join(localizedEntityName).on(onCondition)
-
-    // The inner join modifies the original SELECT ... FROM query and adds ambiguity,
-    // therefore add the table/entity name (as a preceding element) to the columns ref
-    // to prevent a SQL ambiguity error. E.g., SqlError message: column ambiguously
-    // defined.
-    cqn.SELECT.columns = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.columns)
-    columns = _unshiftEntityNameToColumnRef(entity, columns)
-    if (cqn.SELECT.groupBy) cqn.SELECT.groupBy = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.groupBy)
+    query.join(localizedEntityName).on(onCondition)
+
+    // prevent SQL ambiguity error for columns with the same name
+    columnsToBeSearched = _addAliasToColumns(query, entity, columnsToBeSearched)
   } // else --> resolve localized texts via localized view (default)
 
-  const useContains = resolveLocalizedTextsAtRuntime && isContainsPredicateSupported(cqn)
+  const useContains = isContainsPredicateSupported(query)
   let expression
 
   if (useContains) {
-    expression = searchToContains(cqnSearchPhrase, columns)
+    expression = searchToContains(cqnSearchPhrase, columnsToBeSearched)
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.
-    expression = searchToLike(cqnSearchPhrase, columns)
+    expression = searchToLike(cqnSearchPhrase, columnsToBeSearched)
   }
 
   // REVISIT: find out here if where or having must be used
-  cqn._aggregated ? cqn.having(expression) : cqn.where(expression)
-  return cqn
+  query._aggregated ? query.having(expression) : query.where(expression)
+  return query
 }
 
 const _getLocalizedAssociation = entity => {
@@ -78,28 +69,28 @@ const _getLocalizedAssociation = entity => {
   return associations && associations.localized
 }
 
-const _getOnConditionOptions = (entity, localizedAssociation) => {
-  return {
-    associationNames: [localizedAssociation.name],
-    aliases: {
-      select: localizedAssociation.target,
-      join: entity.name
-    }
-  }
-}
-
-const _unshiftEntityNameToColumnRef = (entity, columns) => {
+// The inner join modifies the original SELECT ... FROM query and adds ambiguity,
+// therefore add the table/entity name (as a preceding element) to the columns ref
+// to prevent a SQL ambiguity error.
+const _addAliasToColumns = (query, entity, columnsToBeSearched) => {
   const localizedEntityName = _getLocalizedAssociation(entity).target
   const elements = entity.elements
-
-  columns = columns.map(column => {
+  const entityName = entity.name
+  const _addAliasToColumn = (entityName, localizedEntityName, elements) => column => {
     const columnRef = column.ref
     if (!columnRef) return column
     const columnName = columnRef[0]
     const localizedElement = elements[columnName].localized
-    const entityName = localizedElement ? localizedEntityName : entity.name
-    return { ref: [entityName, columnName] }
-  })
+    const targetEntityName = localizedElement ? localizedEntityName : entityName
+    return { ref: [targetEntityName, columnName] }
+  }
+
+  query.SELECT.columns = query.SELECT.columns.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  const columns = columnsToBeSearched.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+
+  if (query.SELECT.groupBy) {
+    query.SELECT.groupBy = query.SELECT.groupBy.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  }
 
   return columns
 }

package/libx/_runtime/hana/searchToContains.js

@@ -64,12 +64,12 @@ const searchToContains = (cqnSearchPhrase, columns) => {
   return expression
 }
 
-const isContainsPredicateSupported = cqn => {
-  const cqnSearchPhrase = cqn.SELECT.search
+const isContainsPredicateSupported = query => {
+  const cqnSearchPhrase = query.SELECT.search
 
   // REVISIT: In the future, to further optimize search queries, you might
   // want to remove the following condition(s).
-  if (cqn._aggregated) return false
+  if (query._aggregated) 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

package/libx/_runtime/index.js

@@ -5,9 +5,12 @@ module.exports = {
       return this._odatav4 || (this._odatav4 = require('./cds-services/adapter/odata-v4/to'))
     },
 
-    /** @type {import('./cds-services/adapter/rest/to')} */
     get rest() {
-      return this._rest || (this._rest = require('./cds-services/adapter/rest/to'))
+      if (!this._rest) {
+        if (global.cds.env.features.rest_new_adapter) this._rest = require('../rest')
+        else this._rest = require('./cds-services/adapter/rest/to')
+      }
+      return this._rest
     }
   },
 

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -37,7 +37,7 @@ class AMQPWebhookMessaging extends MessagingService {
         // Some messaging systems don't adhere to the standard that the payload has a `data` property.
         // For these cases, we interpret the whole payload as `data`.
         let data, headers
-        if ('data' in _payload) {
+        if (typeof _payload === 'object' && 'data' in _payload) {
           data = _payload.data
           headers = { ..._payload }
           delete headers.data

package/libx/_runtime/messaging/common-utils/AMQPClient.js

@@ -3,6 +3,14 @@ const LOG = cds.log('messaging')
 const ClientAmqp = require('@sap/xb-msg-amqp-v100').Client
 const { connect, disconnect } = require('./connections')
 
+const _JSONorString = string => {
+  try {
+    return JSON.parse(string)
+  } catch (e) {
+    return string
+  }
+}
+
 const addDataListener = (client, queue, prefix, cb) =>
   new Promise((resolve, reject) => {
     const source = `${prefix}${queue}`
@@ -11,7 +19,7 @@ const addDataListener = (client, queue, prefix, cb) =>
       .attach(source)
       .on('data', async raw => {
         const buffer = Buffer.concat(raw.payload.chunks)
-        const payload = JSON.parse(buffer.toString())
+        const payload = _JSONorString(buffer.toString())
         const topic = raw.source.properties.to.replace(/^topic:\/*/, '')
         await cb(topic, payload, null, { done: raw.done, failed: raw.failed })
       })

package/libx/_runtime/messaging/common-utils/connections.js

@@ -1,17 +1,15 @@
 const cds = require('../../cds')
 const LOG = cds.log('messaging')
 
-const MAX_NUMBER_RECONNECTS = 1000
 const MAX_WAITING_TIME = 1480000
 
 const _waitingTime = x => (x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000)
 
-const _periodicallyReconnect = (client, x, n) => {
+const _connectUntilConnected = (client, x) => {
   setTimeout(() => {
     connect(client, true).catch(e => {
-      LOG._warn && LOG.warn(`Connection to Enterprise Messaging Client lost: Unsuccessful attempt to reconnect (${n}).`)
-      /* istanbul ignore else */
-      if (n < MAX_NUMBER_RECONNECTS) _periodicallyReconnect(client, x + 1, n + 1)
+      LOG._warn && LOG.warn(`Connection to Enterprise Messaging Client lost: Unsuccessful attempt to reconnect (${x}).`)
+      _connectUntilConnected(client, x + 1)
     })
   }, _waitingTime(x))
 }
@@ -30,22 +28,21 @@ const connect = (client, keepAlive) => {
           client.disconnect()
         })
 
+        if (keepAlive) {
+          client.once('disconnected', () => {
+            client.removeAllListeners('error')
+            client.removeAllListeners('connected')
+            _connectUntilConnected(client, 0)
+          })
+        }
+
         resolve(this)
       })
       .once('error', err => {
-        client.removeAllListeners('disconnected')
         client.removeAllListeners('connected')
         reject(err)
       })
 
-    if (keepAlive) {
-      client.once('disconnected', () => {
-        client.removeAllListeners('error')
-        client.removeAllListeners('connected')
-        _periodicallyReconnect(client, 0, 0)
-      })
-    }
-
     client.connect()
   })
 }

package/libx/_runtime/messaging/common-utils/naming-conventions.js

@@ -6,7 +6,7 @@ const _queueName = ({ appName, appID, ownNamespace }) => {
 const queueName = (options, optionsApp = {}) => {
   const namespace = options.credentials && options.credentials.namespace
   if (options.queue && options.queue.name) {
-    if (options.credentials.namespace) return options.queue.name.replace(/\$namespace/g, options.credentials.namespace)
+    if (namespace) return options.queue.name.replace(/\$namespace/g, namespace)
     return options.queue.name
   }
   const ownNamespace = namespace

package/libx/_runtime/messaging/enterprise-messaging-utils/registerEndpoints.js

@@ -65,7 +65,8 @@ class EndpointRegistry {
         const other = authInfo
           ? {
               _: { req: { authInfo, headers: {}, query: {} } }, // for messaging to retrieve subdomain
-              user: new cds.User.Privileged({ tenant: tenantId }) // usual tenant identification
+              user: new cds.User.Privileged(),
+              tenant: tenantId
             }
           : {}
         if (!cb) return res.sendStatus(200)

package/libx/_runtime/messaging/message-queuing.js

@@ -29,6 +29,20 @@ class MQManagement {
     return res.body
   }
 
+  async getQueues() {
+    const res = await authorizedRequest({
+      method: 'GET',
+      uri: this.options.url,
+      path: `/v1/management/queues`,
+      oa2: this.options.auth.oauth2,
+      attemptInfo: () => LOG._info && LOG.info('Get queues'),
+      errMsg: `Queues could not be retrieved`,
+      target: { kind: 'QUEUE' },
+      tokenStore: this
+    })
+    return res.body && res.body.results
+  }
+
   createQueue(queueName = this.queueName) {
     return authorizedRequest({
       method: 'PUT',
@@ -121,6 +135,10 @@ class MQManagement {
     }
     await Promise.all([...this.subscribedTopics].map(kv => kv[0]).map(t => this.createSubscription(t)))
   }
+
+  waitUntilReady() {
+    return this
+  }
 }
 
 class MessageQueuing extends AMQPWebhookMessaging {

package/libx/_runtime/remote/Service.js

@@ -12,7 +12,7 @@ if (!LOG._debug) {
 const { resolveView, getTransition, restoreLink, findQueryTarget } = require('../common/utils/resolveView')
 const { postProcess } = require('../common/utils/postProcessing')
 const { getKind, run, getDestination, getAdditionalOptions, getReqOptions } = require('./utils/client')
-const { formatVal } = require('../odata/cqn2odata')
+const { formatVal } = require('../../odata/utils')
 
 const _isSimpleCqnQuery = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0
 
@@ -125,6 +125,7 @@ class RemoteService extends cds.Service {
     }
 
     this.datasource = this.options.datasource
+    this.destinationOptions = this.options.destinationOptions
     this.destination =
       this.options.credentials.destination ||
       getDestination((this.definition && this.definition.name) || this.datasource, this.options.credentials)
@@ -133,6 +134,11 @@ class RemoteService extends cds.Service {
     this.path = this.options.credentials.path
     this.kind = getKind(this.options) // TODO: Simplify
 
+    const clearKeysFromData = function (req) {
+      if (req.target && req.target.keys) for (const k of Object.keys(req.target.keys)) delete req.data[k]
+    }
+    this.before('UPDATE', '*', Object.assign(clearKeysFromData, { _initial: true }))
+
     for (const each of this.entities) {
       for (const a in each.actions) {
         _addHandlerActionFunction(this, each.actions[a], each)
@@ -153,7 +159,13 @@ class RemoteService extends cds.Service {
       const resolvedTarget = resolvedTargetOfQuery(query) || getTransition(req.target, this).target
       const reqOptions = getReqOptions(req, query, this)
       reqOptions.headers = _setHeaders(reqOptions.headers, req)
-      const additionalOptions = getAdditionalOptions(req, this.destination, this.kind, resolvedTarget)
+      const additionalOptions = getAdditionalOptions(
+        req,
+        this.destination,
+        this.kind,
+        resolvedTarget,
+        this.destinationOptions
+      )
 
       // hidden compat flag in order to suppress logging response body of failed request
       if (req._suppressRemoteResponseBody) {

package/libx/_runtime/remote/utils/client-types.d.ts

@@ -0,0 +1,7 @@
+import sdkCore from '@sap-cloud-sdk/core'
+export interface DestinationOptions extends Omit<sdkCore.DestinationOptions, 'selectionStrategy'> {
+  /*
+   * @see https://sap.github.io/cloud-sdk/api/1.50.0/modules/sap_cloud_sdk_core#DestinationSelectionStrategies
+   */
+  selectionStrategy?: 'alwaysProvider' | 'alwaysSubscriber' | 'subscriberFirst'
+}

package/libx/_runtime/remote/utils/client.js

@@ -1,8 +1,8 @@
 const cds = require('../../cds')
 const LOG = cds.log('remote')
-const cdsLocale = require('../../../../lib/req/locale.js')
 
-const generateQuery = require('../cqn2odata')
+const cdsLocale = require('../../../../lib/req/locale')
+
 const { convertV2ResponseData } = require('./dataConversion')
 
 let _cloudSdkCore
@@ -14,16 +14,38 @@ const PPPD = {
   DELETE: 1
 }
 
-const _executeHttpRequest = (...args) => {
-  if (!_cloudSdkCore) _cloudSdkCore = require('@sap-cloud-sdk/core')
+const KINDS_SUPPORTING_BATCH = { odata: 1, 'odata-v2': 1, 'odata-v4': 1 }
+
+const _executeHttpRequest = async ({ requestConfig, destination, destinationOptions, jwt }) => {
+  const { getDestination, executeHttpRequest } = cloudSdkCore()
 
-  const opts = args[1]
-  if (PPPD[opts.method] && cds.env.features.fetch_csrf) {
-    if (args.length === 3) args[2].fetchCsrfToken = true
-    else args.push({ fetchCsrfToken: true })
+  const destinationName = typeof destination === 'string' && destination
+  if (destinationName) {
+    destination = await getDestination(destinationName, resolveDestinationOptions(destinationOptions, jwt))
+  } else if (destination.forwardAuthToken) {
+    destination = {
+      ...destination,
+      headers: destination.headers ? { ...destination.headers } : {},
+      authentication: 'NoAuthentication'
+    }
+    delete destination.forwardAuthToken
+    if (jwt) {
+      destination.headers.authorization = `Bearer ${jwt}`
+    } else {
+      LOG._warn && LOG.warn('Missing JWT token for forwardAuthToken')
+    }
   }
 
-  return _cloudSdkCore.executeHttpRequest(...args)
+  let requestOptions
+  if (PPPD[requestConfig.method] && cds.env.features.fetch_csrf) {
+    requestOptions = { fetchCsrfToken: true }
+  }
+
+  return executeHttpRequest(destination, requestConfig, requestOptions)
+}
+
+const cloudSdkCore = function () {
+  return _cloudSdkCore || (_cloudSdkCore = require('@sap-cloud-sdk/core'))
 }
 
 const getDestination = (name, credentials) => {
@@ -34,6 +56,26 @@ const getDestination = (name, credentials) => {
   return { name, ...credentials }
 }
 
+/**
+ * @param {import('./client-types').DestinationOptions} [options]
+ * @param {string} [jwt]
+ * @returns {import('@sap-cloud-sdk/core').DestinationOptions}
+ */
+const resolveDestinationOptions = function (options, jwt) {
+  if (!options && !jwt) return undefined
+
+  const resolvedOptions = Object.assign({}, options || {})
+  resolvedOptions.userJwt = jwt
+
+  if (options && options.selectionStrategy) {
+    resolvedOptions.selectionStrategy = cloudSdkCore().DestinationSelectionStrategies[options.selectionStrategy]
+    if (!resolvedOptions.selectionStrategy)
+      throw new Error(`Unsupported destination selection strategy "${options.selectionStrategy}".`)
+  }
+
+  return resolvedOptions
+}
+
 const getKind = options => {
   const kind = (options.credentials && options.credentials.kind) || options.kind
   if (typeof kind === 'object') {
@@ -175,17 +217,19 @@ const _getSanitizedError = (e, reqOptions, suppressRemoteResponseBody) => {
   return e
 }
 
-const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppressRemoteResponseBody }) => {
-  const dest = typeof destination === 'string' ? { destinationName: destination, jwt } : destination
-
+// eslint-disable-next-line complexity
+const run = async (
+  requestConfig,
+  { destination, jwt, kind, resolvedTarget, suppressRemoteResponseBody, destinationOptions }
+) => {
   let response
   try {
-    response = await _executeHttpRequest(dest, reqOptions)
+    response = await _executeHttpRequest({ requestConfig, destination, destinationOptions, jwt })
   } catch (e) {
     // > axios received status >= 400 -> gateway error
     e.message = e.message ? 'Error during request to remote service: ' + e.message : 'Request to remote service failed.'
 
-    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
+    const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -198,15 +242,15 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppres
     response.headers['content-type'] &&
     response.headers['content-type'].includes('text/html') &&
     !(
-      reqOptions.headers.accept.includes('text/html') ||
-      reqOptions.headers.accept.includes('text/*') ||
-      reqOptions.headers.accept.includes('*/*')
+      requestConfig.headers.accept.includes('text/html') ||
+      requestConfig.headers.accept.includes('text/*') ||
+      requestConfig.headers.accept.includes('*/*')
     )
   ) {
     const e = new Error("Received content-type 'text/html' which is not part of accepted content types")
     e.response = response
 
-    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
+    const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -216,13 +260,38 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppres
     })
   }
 
+  // get result of $batch
+  // does only support read requests as of now
+  if (requestConfig._autoBatch) {
+    // response data splitted by empty lines
+    // 1. entry contains batch id and batch headers
+    // 2. entry contains request status code and request headers
+    // 3. entry contains data or error
+    const responseDataSplitted = response.data.split('\r\n\r\n')
+    // remove closing batch id
+    const [content] = responseDataSplitted[2].split('\r\n')
+    const contentJSON = JSON.parse(content)
+
+    if (responseDataSplitted[1].startsWith('HTTP/1.1 2')) {
+      response.data = contentJSON
+    }
+    if (responseDataSplitted[1].startsWith('HTTP/1.1 4') || responseDataSplitted[1].startsWith('HTTP/1.1 5')) {
+      contentJSON.message = contentJSON.message
+        ? 'Error during request to remote service: ' + contentJSON.message
+        : 'Request to remote service failed.'
+      const sanitizedError = _getSanitizedError(contentJSON, requestConfig)
+      LOG._warn && LOG.warn(sanitizedError)
+      throw Object.assign(new Error(contentJSON.message), { statusCode: 502, innererror: sanitizedError })
+    }
+  }
+
   if (kind === 'odata-v4') return _purgeODataV4(response.data)
-  if (kind === 'odata-v2') return _purgeODataV2(response.data, resolvedTarget, reqOptions.headers)
+  if (kind === 'odata-v2') return _purgeODataV2(response.data, resolvedTarget, requestConfig.headers)
   if (kind === 'odata') {
     if (typeof response.data !== 'object') return response.data
     // try to guess if we need to purge v2 or v4
     if (response.data.d) {
-      return _purgeODataV2(response.data, resolvedTarget, reqOptions.headers)
+      return _purgeODataV2(response.data, resolvedTarget, requestConfig.headers)
     }
     return _purgeODataV4(response.data)
   }
@@ -241,7 +310,7 @@ const getJwt = req => {
 }
 
 const _cqnToReqOptions = (query, kind, model) => {
-  const queryObject = generateQuery(query, kind, model)
+  const queryObject = cds.odata.urlify(query, { kind, model })
   return {
     method: queryObject.method,
     url: encodeURI(
@@ -312,14 +381,39 @@ const getReqOptions = (req, query, service) => {
   }
   reqOptions.url = formatPath(reqOptions.url)
 
+  // batch envelope if needed
+  if (
+    KINDS_SUPPORTING_BATCH[service.kind] &&
+    reqOptions.method === 'GET' &&
+    reqOptions.url.length > ((cds.env.remote && cds.env.remote.max_get_url_length) || 1028)
+  ) {
+    reqOptions._autoBatch = true
+    reqOptions.data = [
+      '--batch1',
+      'Content-Type: application/http',
+      'Content-Transfer-Encoding: binary',
+      '',
+      `${reqOptions.method} ${reqOptions.url.replace(/^\//, '')} HTTP/1.1`,
+      ...Object.keys(reqOptions.headers).map(k => `${k}: ${reqOptions.headers[k]}`),
+      '',
+      '',
+      '--batch1--',
+      ''
+    ].join('\r\n')
+    reqOptions.method = 'POST'
+    reqOptions.headers.accept = 'multipart/mixed'
+    reqOptions.headers['content-type'] = 'multipart/mixed; boundary=batch1'
+    reqOptions.url = '/$batch'
+  }
+
   if (service.path) reqOptions.url = `${encodeURI(service.path)}${reqOptions.url}`
 
   return reqOptions
 }
 
-const getAdditionalOptions = (req, destination, kind, resolvedTarget) => {
+const getAdditionalOptions = (req, destination, kind, resolvedTarget, destinationOptions) => {
   const jwt = getJwt(req)
-  const additionalOptions = { destination, kind, resolvedTarget }
+  const additionalOptions = { destination, kind, resolvedTarget, destinationOptions }
   if (jwt) additionalOptions.jwt = jwt
   return additionalOptions
 }

package/libx/_runtime/sqlite/Service.js

@@ -71,7 +71,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
      */
     // all others, i.e. CREATE, DROP table, ...
     this.on('*', function (req) {
-      return this._run(this.model, this.dbc, req.query || req.event, req)
+      return this._run(this.model, this.dbc, req.query || req.event, req, req.data)
     })
   }
 
@@ -189,7 +189,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
         log('DROP TABLE IF EXISTS ' + entity + ';')
       }
       log()
-      for (const each of createEntities) log(each + ';\n')
+      for (const each of createEntities) log(each + '\n')
       return
     }
 

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -1,10 +1,8 @@
-const { foreignKeyPropagations } = require('../common/utils/foreignKeyPropagations')
 const getError = require('../common/error')
 
 function _convertRefForAssocToOneManaged(element, refEntry) {
   const maybeManagedKey = refEntry.ref.join('_')
-  const _foreignKeyPropagations = foreignKeyPropagations(element)
-  if (_foreignKeyPropagations.filter(key => key.parentFieldName === maybeManagedKey)[0]) {
+  if (element._foreignKeys.find(key => key.parentElement && key.parentElement.name === maybeManagedKey)) {
     refEntry.ref = [maybeManagedKey]
   } else {
     throw getError(501, 'Path expressions in query options are not supported on SQLite')

package/libx/gql/GraphQLAdapter.js

@@ -0,0 +1,33 @@
+const cds = require('../_runtime/cds')
+
+const express = require('express')
+const { graphqlHTTP } = require('express-graphql')
+const { makeExecutableSchema } = require('@graphql-tools/schema')
+
+const { generate } = require('./schema')
+const { fieldResolver, createRootResolvers } = require('./resolvers')
+
+class GraphQLAdapter extends express.Router {
+  constructor(services, options) {
+    super()
+    const mergedOptions = { ...defaultOptions, ...options }
+
+    const path = mergedOptions.path
+    delete mergedOptions.path
+
+    const applicationServices = Object.values(services).filter(service => service instanceof cds.ApplicationService)
+
+    const typeDefs = generate(applicationServices)
+    const resolvers = createRootResolvers(applicationServices)
+
+    const schema = makeExecutableSchema({ typeDefs, resolvers })
+
+    this.use(path, graphqlHTTP({ fieldResolver, schema, ...mergedOptions }))
+  }
+}
+
+const defaultOptions = {
+  path: '/graphql'
+}
+
+module.exports = GraphQLAdapter