@sap/cds 7.2.0 → 7.3.0

package/libx/_runtime/remote/Service.js

@@ -34,6 +34,7 @@ const _setHeaders = (defaultHeaders, req) => {
 }
 
 const _setCorrectValue = (el, data, params, kind) => {
+  if (data[el] === undefined) return "'undefined'"
   return typeof data[el] === 'object' && kind !== 'odata-v2'
     ? JSON.stringify(data[el])
     : formatVal(data[el], el, { elements: params }, kind)
@@ -109,8 +110,9 @@ const _handleUnboundActionFunction = (srv, def, req, event) => {
       def &&
       def.returns &&
       (def.returns.type === 'cds.LargeBinary' || def.returns.type === 'cds.Binary')
+    const { headers, data } = req
 
-    return srv.send({ method: 'POST', path: `/${event}`, data: req.data, _binary: isBinary })
+    return srv.send({ method: 'POST', path: `/${event}`, headers, data, _binary: isBinary })
   }
 
   const url =
@@ -118,16 +120,17 @@ const _handleUnboundActionFunction = (srv, def, req, event) => {
   return srv.get(url)
 }
 
-const _sendV2RequestActionFunction = (srv, def, url) => {
+const _sendV2RequestActionFunction = (srv, def, req, url) => {
+  const { headers } = req
   return def.kind === 'function'
-    ? srv.send({ method: 'GET', path: url, _returnType: def.returns })
-    : srv.send({ method: 'POST', path: url, data: {}, _returnType: def.returns })
+    ? srv.send({ method: 'GET', path: url, headers, _returnType: def.returns })
+    : srv.send({ method: 'POST', path: url, headers, data: {}, _returnType: def.returns })
 }
 
 const _handleV2ActionFunction = (srv, def, req, event, kind) => {
   const url =
     Object.keys(req.data).length > 0 ? _buildPartialUrlFunctions(`/${event}`, req.data, def.params, kind) : `/${event}`
-  return _sendV2RequestActionFunction(srv, def, url)
+  return _sendV2RequestActionFunction(srv, def, req, url)
 }
 
 const _handleV2BoundActionFunction = (srv, def, req, event, kind) => {
@@ -147,7 +150,7 @@ const _handleV2BoundActionFunction = (srv, def, req, event, kind) => {
   }
 
   const url = `${`/${event}`}?${params.join('&')}`
-  return _sendV2RequestActionFunction(srv, def, url)
+  return _sendV2RequestActionFunction(srv, def, req, url)
 }
 
 const _addHandlerActionFunction = (srv, def, target) => {
@@ -178,7 +181,6 @@ const resolvedTargetOfQuery = q => {
 }
 
 let logged
-let sdkLoggerDisabled
 
 const _resolveSelectionStrategy = options => {
   if (typeof options?.selectionStrategy !== 'string') return
@@ -226,22 +228,6 @@ class RemoteService extends cds.Service {
             'Configuration option "cds.env.features.fetch_csrf" is deprecated.\n Please use "csrf"/"csrfInBatch" as described in https://cap.cloud.sap/docs/node.js/remote-services'
           )
       }
-
-      // REVISIT: use cds.log's logger in cloud sdk
-
-      // disable sdk logger if not in debug mode
-      if (!LOG._debug && !sdkLoggerDisabled) {
-        try {
-          // eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
-          const sdkUtils = require('@sap-cloud-sdk/util')
-          sdkUtils.setGlobalLogLevel('error')
-
-          // disable sdk logger once
-          sdkLoggerDisabled = true
-        } catch (err) {
-          /* might fail in cds repl due to winston's exception handler, see cap/issues#10134 */
-        }
-      }
     } else if ([...this.entities].length || [...this.operations].length) {
       throw new Error(`No credentials configured for "${this.name}".`)
     }
@@ -262,6 +248,8 @@ class RemoteService extends cds.Service {
     }
 
     this.on('*', async (req, next) => {
+      const { query } = req
+      if (!query && !(typeof req.path === 'string')) return next()
       // early validation on first request for use case without remote API
       // ideally, that's done on bootstrap of the remote service
       if (typeof this.destination === 'object' && !this.destination.url)
@@ -269,9 +257,6 @@ class RemoteService extends cds.Service {
       if (this._resilienceMiddlewares && !this._resilienceMiddlewares.timeout)
         this._resilienceMiddlewares.timeout = cloudSdkResilience().timeout(this.requestTimeout)
 
-      const { query } = req
-      if (!query && !(typeof req.path === 'string')) return next()
-
       const resolvedTarget = resolvedTargetOfQuery(query) || getTransition(req.target, this).target
       const reqOptions = getReqOptions(req, query, this)
       reqOptions.headers = _setHeaders(reqOptions.headers, req)

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

@@ -427,12 +427,13 @@ const _stringToReqOptions = (query, data, target) => {
   return reqOptions
 }
 
-const _pathToReqOptions = (method, path, data, target) => {
+const _pathToReqOptions = (method, path, data, target, srvName) => {
   let url = path
   if (!url.startsWith('/')) {
     // extract entity name and instance identifier (either in "()" or after "/") from fully qualified path
     const parts = path.match(/([\w.]*)([\W.]*)(.*)/)
     if (!parts) url = '/' + path.match(/\w*$/)[0]
+    else if (url.startsWith(srvName)) url = '/' + parts[1].replace(srvName + '.', '') + parts[2] + parts[3]
     else url = '/' + parts[1].match(/\w*$/)[0] + parts[2] + parts[3]
 
     // normalize in case parts[2] already starts with /
@@ -459,7 +460,7 @@ const getReqOptions = (req, query, service) => {
       ? _cqnToReqOptions(query, service, req)
       : typeof query === 'string'
       ? _stringToReqOptions(query, req.data, req.target)
-      : _pathToReqOptions(req.method, req.path, req.data, req.target)
+      : _pathToReqOptions(req.method, req.path, req.data, req.target, service.name)
 
   if (service.kind === 'odata-v2' && req.event === 'READ' && reqOptions.url?.match(/(\/any\()|(\/all\()/)) {
     req.reject(501, 'Lambda expressions are not supported in OData v2')

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

@@ -66,12 +66,9 @@ const _convertActionFuncResponse = (returnType, convertValueFn) => data => {
 
 // eslint-disable-next-line complexity
 const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, element) => {
-  if (value == null) {
-    return value
-  }
+  if (value == null) return value
 
   const type = _elementType(element)
-
   if (type === 'cds.Boolean') {
     if (value === 'true') {
       value = true
@@ -119,18 +116,19 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
 
   return value
 }
+
 const _PT = ([hh, mm, ss]) => `PT${hh}H${mm}M${ss}S`
 
 const _convertPayloadValue = (value, element) => {
-  const type = _elementType(element)
+  if (value == null) return value
 
   // see https://www.odata.org/documentation/odata-version-2-0/json-format/
-  if (value == null) return value
+  const type = _elementType(element)
   switch (type) {
     case 'cds.Time':
       return value.match(/^(PT)([H,M,S,0-9])*$/) ? value : _PT(value.split(':'))
     case 'cds.Decimal':
-      return typeof value === 'string' ? value : new String(value)
+      return typeof value === 'string' ? value : `${value}`
     case 'cds.Date':
     case 'cds.DateTime':
       return `/Date(${new Date(value).getTime()})/`

package/libx/odata/{grammar.pegjs → grammar.peggy}

@@ -33,7 +33,7 @@
     const stack = []
     let SELECT, count
     const TECHNICAL_OPTS = ['$value'] // odata parts to be handled somewhere else
-    // we keep that here to allow for usage in https://pegjs.org/online
+    // we keep that here to allow for usage in https://peggyjs.org/online
     const safeNumber =
       options.safeNumber ||
       function (str) {

package/libx/odata/metadata.js

@@ -0,0 +1,121 @@
+const cds = require('../../lib')
+const LOG = cds.log('odata')
+const crypto = require('crypto')
+
+const _requestedFormat = (queryOption, header) => {
+  if (queryOption) return queryOption.match(/json/i) ? 'json' : 'xml'
+  if (header) {
+    const jsonIndex = header.indexOf('application/json')
+    if (jsonIndex === -1) return 'xml'
+    const xmlIndex = header.indexOf('application/xml')
+    if (xmlIndex === -1) return 'json'
+    return jsonIndex < xmlIndex ? 'json' : 'xml'
+  }
+  return 'xml'
+}
+
+const _metadataFromFile = async srv => {
+  const fs = require('fs')
+  const filePath = cds.root + `/srv/odata/v4/${srv.name}.xml`
+  let exists
+  try {
+    exists = !(await fs.promises.access(filePath, fs.constants.F_OK))
+  } catch (e) {
+    LOG._debug && LOG.debug(`No metadata file found for service ${srv.name} at ${filePath}`)
+  }
+  if (exists) {
+    const file = await fs.promises.readFile(filePath)
+    return file.toString()
+  }
+}
+
+const normalize_header = value => {
+  return value.split(',').map(str => str.trim())
+}
+
+const validate_etag = (ifNoneMatch, etag) => {
+  const ifNoneMatchEtags = normalize_header(ifNoneMatch)
+  return ifNoneMatchEtags.includes(etag) || ifNoneMatchEtags.includes('*')
+}
+
+const generateEtag = s => {
+  return `W/"${crypto.createHash('sha256').update(s).digest('base64')}"`
+}
+
+const odata_error = (code, message) => ({ error: { code, message } })
+
+module.exports = srv =>
+  async function metadata(req, res, next) {
+    if (req.path === '/$metadata') {
+      if (req.method !== 'GET')
+        return res
+          .status(405)
+          .json(odata_error('METHOD_NOT_ALLOWED', `Method ${req.method} not allowed for $metadata.`))
+
+      const tenant = cds.context.tenant
+      const locale = cds.context.locale
+      const format = _requestedFormat(req.query['$format'], req.headers['accept'])
+
+      // REVISIT: edm(x) and etag cache is only evicted with model
+      const csnService = (cds.context.model || cds.model).definitions[srv.name]
+      const metadataCache = (csnService.metadataCache = csnService.metadataCache || { jsonEtag: {}, xmlEtag: {} })
+
+      const etag = format === 'json' ? metadataCache.jsonEtag?.[locale] : metadataCache.xmlEtag?.[locale]
+
+      if (req.headers['if-none-match']) {
+        if (etag) {
+          const unchanged = validate_etag(req.headers['if-none-match'], etag)
+          if (unchanged) {
+            res.set('Etag', etag)
+            return res.status(304).end()
+          }
+        }
+      }
+
+      const { 'cds.xt.ModelProviderService': mps } = cds.services
+      if (mps) {
+        if (format === 'json')
+          res
+            .status(400)
+            .json(
+              odata_error(
+                'UNSUPPORTED_METADATA_TYPE',
+                'JSON metadata is not supported if cds.requires.extensibilty: true.'
+              )
+            )
+
+        try {
+          const edmx = await mps.getEdmx({ tenant, model: srv.model, service: srv.definition.name, locale })
+          metadataCache.xmlEtag[locale] = generateEtag(edmx)
+          res.set('Content-Type', 'application/xml')
+          res.send(edmx)
+        } catch (e) {
+          if (LOG._error) {
+            e.message = 'Unable to get EDMX for tenant ' + tenant + ' due to error: ' + e.message
+            LOG.error(e)
+          }
+
+          return res.status(503).json(odata_error('SERVICE_UNAVAILABLE', 'Service unavailable'))
+        }
+      }
+
+      if (format === 'json') {
+        const edm =
+          metadataCache.edm || (metadataCache.edm = cds.compile.to.edm(srv.model, { service: srv.definition.name }))
+        const localized = cds.localize(srv.model, locale, edm)
+        metadataCache.jsonEtag[locale] = generateEtag(localized)
+        return res.json(JSON.parse(localized))
+      }
+
+      const edmx =
+        metadataCache.edmx ||
+        (await _metadataFromFile(srv)) ||
+        (metadataCache.edmx = cds.compile.to.edmx(srv.model, { service: srv.definition.name }))
+      const localized = cds.localize(srv.model, locale, edmx)
+      metadataCache.xmlEtag[locale] = generateEtag(localized)
+      res.set('Etag', metadataCache.xmlEtag[locale])
+      res.set('Content-Type', 'application/xml')
+      return res.send(localized)
+    }
+    return next()
+  }