@sap/cds 8.9.4 → 9.0.2

package/libx/rest/middleware/parse.js

@@ -1,147 +1,131 @@
-const cds = require('../../_runtime/cds')
-const { INSERT, SELECT, UPDATE, DELETE } = cds.ql
+module.exports = exports = adapter => exports.parse.bind(adapter)
 
-const { getKeysAndParamsFromPath } = require('../../common/utils/path')
-
-const { preProcessData } = require('../pre-processing')
-const { convertStructured } = require('../../_runtime/common/utils/ucsn')
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.parse = function (req, res, next) {
+  const { service } = this
 
+  // REVISIT: Once we don't display the error message location in terms of an offset, but instead a copy of the
+  // original request including a marker, we don't need to provide the baseUrl here.
+  let query = cds.odata.parse(req.url, { service, baseUrl: req.baseUrl, protocol: 'rest' })
 
-const _cache = req => `rest-input;skip-key-validation:${req.method !== 'POST'}`
+  // parser always produces selects
+  const _target = (req._target = query.SELECT && query.SELECT.from)
+  if (!_target) return next()
 
-module.exports = adapter => {
-  const { service } = adapter
-
-  return function parse(req, res, next) {
-    // REVISIT: Once we don't display the error message location in terms of an offset, but instead a copy of the
-    // original request including a marker, we don't need to provide the baseUrl here.
-    let query = cds.odata.parse(req.url, { service, baseUrl: req.baseUrl, protocol: 'rest' })
-
-    // parser always produces selects
-    const _target = (req._target = query.SELECT && query.SELECT.from)
-    if (!_target) return next()
-
-    // REVISIT: __target is the csn target definition
-    let {
-      __target: definition,
-      SELECT: { from, one }
-    } = query
-    if (typeof definition === 'string') {
-      definition =
-        service.model.definitions[definition] ||
-        service.model.definitions[definition.split(':$:')[0]].actions[definition.split(':$:')[1]]
-    }
-    delete query.__target
+  // REVISIT: __target is the csn target definition
+  let {
+    __target: definition,
+    SELECT: { from, one }
+  } = query
+  if (typeof definition === 'string') {
+    definition =
+      service.model.definitions[definition] ||
+      service.model.definitions[definition.split(':$:')[0]].actions[definition.split(':$:')[1]]
+  }
+  delete query.__target
 
-    // req.__proto__.method is set in case of upsert
-    const isUpsert = req.__proto__.method in { PUT: 1, PATCH: 1 }
+  // req.__proto__.method is set in case of upsert
+  const isUpsert = req.__proto__.method in { PUT: 1, PATCH: 1 }
 
-    // REVISIT: hack for actions and functions
-    let operation, args
-    const last = _target.ref[_target.ref.length - 1]
-    if (last.operation) {
-      operation = last.operation
-      if (last.args) args = last.args
-      _target.ref.pop()
-    }
+  // REVISIT: hack for actions and functions
+  let operation, args
+  const last = _target.ref[_target.ref.length - 1]
+  if (last.operation) {
+    operation = last.operation
+    if (last.args) args = last.args
+    _target.ref.pop()
+  }
 
-    const unbound = _target.ref.length === 0
+  const unbound = _target.ref.length === 0
 
-    // query based on method
-    switch (req.method) {
-      case 'HEAD':
-      case 'GET':
-        if (operation) {
-          req._operation = operation = definition
-          if (operation.kind === 'action') cds.error('Action must be called by POST', { code: 400 })
-          if (!unbound) query = one ? SELECT.one(_target) : SELECT.from(_target)
-          else query = undefined
+  // query based on method
+  switch (req.method) {
+    case 'HEAD':
+    case 'GET':
+      if (operation) {
+        req._operation = operation = definition
+        if (operation.kind === 'action') cds.error('Action must be called by POST', { code: 400 })
+        if (!unbound) query = one ? SELECT.one(_target) : SELECT.from(_target)
+        else query = undefined
+      } else {
+        // read (nothing to do)
+      }
+      break
+    case 'POST':
+      if (operation) {
+        req._operation = operation = definition
+        if (operation.kind === 'function') cds.error('Function must be called by GET', { code: 400 })
+        if (!unbound) query = one ? SELECT.one(_target) : SELECT.from(_target)
+        else query = undefined
+      } else {
+        // create
+        if (one && !isUpsert) cds.error('POST not allowed on entity', { code: 400 })
+        query = INSERT.into(_target)
+      }
+      break
+    case 'PUT':
+    case 'PATCH':
+      if (operation) {
+        let errorMsg
+        if (definition) {
+          errorMsg = `${definition.kind.charAt(0).toUpperCase() + definition.kind.slice(1)} must be called by ${
+            definition.kind === 'action' ? 'POST' : 'GET'
+          }`
         } else {
-          // read (nothing to do)
+          errorMsg = `That action/function must be called by POST/GET`
         }
-        break
-      case 'POST':
-        if (operation) {
-          req._operation = operation = definition
-          if (operation.kind === 'function') cds.error('Function must be called by GET', { code: 400 })
-          if (!unbound) query = one ? SELECT.one(_target) : SELECT.from(_target)
-          else query = undefined
+        cds.error(errorMsg, { code: 400 })
+      }
+      if (!one) throw { statusCode: 400, code: '400', message: `INVALID_${req.method}` }
+      query = UPDATE(_target)
+      break
+    case 'DELETE':
+      if (operation) {
+        let errorMsg
+        if (definition) {
+          errorMsg = `${definition.kind.charAt(0).toUpperCase() + definition.kind.slice(1)} must be called by ${
+            definition.kind === 'action' ? 'POST' : 'GET'
+          }`
         } else {
-          // create
-          if (one && !isUpsert) cds.error('POST not allowed on entity', { code: 400 })
-          query = INSERT.into(_target)
-        }
-        break
-      case 'PUT':
-      case 'PATCH':
-        if (operation) {
-          let errorMsg
-          if (definition) {
-            errorMsg = `${definition.kind.charAt(0).toUpperCase() + definition.kind.slice(1)} must be called by ${
-              definition.kind === 'action' ? 'POST' : 'GET'
-            }`
-          } else {
-            errorMsg = `That action/function must be called by POST/GET`
-          }
-          cds.error(errorMsg, { code: 400 })
+          errorMsg = `That action/function must be called by POST/GET`
         }
-        if (!one) throw { statusCode: 400, code: '400', message: `INVALID_${req.method}` }
-        query = UPDATE(_target)
-        break
-      case 'DELETE':
-        if (operation) {
-          let errorMsg
-          if (definition) {
-            errorMsg = `${definition.kind.charAt(0).toUpperCase() + definition.kind.slice(1)} must be called by ${
-              definition.kind === 'action' ? 'POST' : 'GET'
-            }`
-          } else {
-            errorMsg = `That action/function must be called by POST/GET`
-          }
-          cds.error(errorMsg, { code: 400 })
-        }
-        if (!one) cds.error('DELETE not allowed on collection', { code: 400 })
-        query = DELETE.from(_target)
-        break
-      default:
-      // anything to do?
-    }
-    req._query = query // REVISIT: req._query should not be a standard API
-    if (query && definition) req._query.__target = definition.name
-    if (!definition) return next()
+        cds.error(errorMsg, { code: 400 })
+      }
+      if (!one) cds.error('DELETE not allowed on collection', { code: 400 })
+      query = DELETE.from(_target)
+      break
+    default:
+    // anything to do?
+  }
+  req._query = query // REVISIT: req._query should not be a standard API
 
-    const { keys, params } = getKeysAndParamsFromPath(from, service)
-    req._data = operation?.kind === 'function' ? {} : keys
-    if (params) req._params = params
+  if (!definition) return next()
 
-    // REVISIT: query._data hack
-    if (
-      (query && (query.INSERT || query.UPDATE || query.DELETE)) ||
-      (operation && operation.kind === 'action') ||
-      args
-    ) {
-      if (operation && (operation.kind === 'action' || operation.kind === 'function') && !operation.params) {
-        req._data = {}
-      } else {
-        const payload = args || req.body
-        if (!operation) Object.assign(payload, keys)
-        if (!cds.env.features.cds_validate) {
-          const errs = []
-          convertStructured(service, operation || definition, payload, {
-            cleanupStruct: cds.env.features.rest_struct_data
-          })
-          preProcessData(payload, service, definition, _cache, errs)
-          if (errs.length) {
-            if (errs.length === 1) throw errs[0]
-            throw Object.assign(new Error('MULTIPLE_ERRORS'), { statusCode: 400, details: errs })
-          }
-        } else {
-          preProcessData(payload, service, definition)
-        }
-        req._data = payload
-      }
-    }
+  const { keys, params } = getKeysAndParamsFromPath(from, service)
+  req._data = operation?.kind === 'function' ? {} : keys
+  if (params) req._params = params
 
-    next()
+  // REVISIT: query._data hack
+  if ((query && (query.INSERT || query.UPDATE || query.DELETE)) || (operation && operation.kind === 'action') || args) {
+    if (operation && (operation.kind === 'action' || operation.kind === 'function') && !operation.params) {
+      req._data = {}
+    } else {
+      const payload = args || req.body
+      if (!operation) Object.assign(payload, keys)
+      preProcessData(payload, service, definition)
+      req._data = payload
+    }
   }
+
+  next()
 }
+
+const cds = require('../../_runtime/cds')
+const { INSERT, SELECT, UPDATE, DELETE } = cds.ql
+
+const { getKeysAndParamsFromPath } = require('../../common/utils/path')
+
+const { preProcessData } = require('../pre-processing')

package/libx/rest/middleware/read.js

@@ -1,28 +1,30 @@
-module.exports = adapter => {
-  const { service } = adapter
+module.exports = exports = adapter => exports.read.bind(adapter)
 
-  return async function read(req, res) {
-    const { _query: query, _target: target, _data: data, _params: params } = req
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.read = async function (req, res) {
+  const { _query: query, _target: target, _data: data, _params: params } = req
 
-    let result,
-      status = 200
+  let result,
+    status = 200
 
-    result = await service.dispatch(adapter.request4({ query, data, params, req, res }))
+  result = await this.service.dispatch(this.request4({ query, data, params, req, res }))
 
-    // 204 or 404?
-    if (result == null && query.SELECT.one) {
-      if (target.ref.length > 1) status = 204
-      else throw { code: 404 }
-    }
-
-    // REVISIT: Still needed with cds-mtxs?
-    // compat for mtx returning strings instead of objects
-    if (typeof result === 'object' && result !== null && '$count' in result) {
-      result = { count: result.$count, value: result }
-    } else if (typeof result === 'number') {
-      result = result.toString()
-    }
+  // 204 or 404?
+  if (result == null && query.SELECT.one) {
+    if (target.ref.length > 1) status = 204
+    else throw { code: 404 }
+  }
 
-    return { result, status }
+  // REVISIT: Still needed with cds-mtxs?
+  // compat for mtx returning strings instead of objects
+  if (typeof result === 'object' && result !== null && '$count' in result) {
+    result = { count: result.$count, value: result }
+  } else if (typeof result === 'number') {
+    result = result.toString()
   }
+
+  return { result, status }
 }

package/libx/rest/middleware/update.js

@@ -1,35 +1,23 @@
-const cds = require('../../_runtime/cds')
-
-const UPSERT_ALLOWED = !(cds.env.runtime && cds.env.runtime.allow_upsert === false)
-
-module.exports = adapter => {
-  const { router, service } = adapter
-
-  return async function update(req, res, next) {
-    let { _query: query, _data: data, _params: params } = req
+module.exports = exports = adapter => exports.update.bind(adapter)
 
-    let result,
-      status = 200
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+// prettier-ignore
+exports.update = async function (req, res) {
+  // add default values for unprovided properties
+  if (req.method === 'PUT') prepare_put_requests(this.service, cds.infer.target(req._query), req._data)
 
-    // if upsert it allowed, we need to catch 404 and retry with create
-    try {
-      query.data(data)
-      // REVISIT: if PUT, req.method should be PUT -> Crud2Http maps UPSERT to PUT
-      result = await service.dispatch(adapter.request4({ query, method: req.method, params, req, res }))
-    } catch (e) {
-      const is404 = e.code === 404 || e.status === 404 || e.statusCode === 404
-      const isForcedInsert =
-        (e.code === 412 || e.status === 412 || e.statusCode === 412) && req.headers['if-none-match'] === '*'
-      if ((is404 || isForcedInsert) && UPSERT_ALLOWED) {
-        // -> redirect to POST
-        const _body = JSON.parse(req._raw)
-        const _req = Object.assign(Object.create(req), { method: 'POST', body: _body })
-        return router.handle(_req, res, next)
-      }
-
-      throw e
-    }
-
-    return { result, status }
-  }
+  const request = this.request4({
+    req, res,                         // REVISIT: should go into cds.Request
+    method: req.method,               // REVISIT: should go into cds.Request
+    params: req._params,              // REVISIT: eliminate req._params
+    query: req._query.data(req._data) // REVISIT: eliminate req._query, req._data
+  })
+  const result = await this.service.send(request)
+  return { result }
 }
+
+const cds = require('../../_runtime/cds')
+const prepare_put_requests = require('../../http/put')

package/libx/rest/middleware/upsert.js

@@ -0,0 +1,31 @@
+module.exports = exports = adapter => exports.upsert.bind(adapter)
+
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+// prettier-ignore
+exports.upsert = function (req, res) {
+  return update.call(this, req, res)
+    .catch(e => {
+      if (!retry(e, req)) throw e
+
+      req.method = 'POST'
+      const { entity } = req._query.UPDATE
+      const { keys } = getKeysAndParamsFromPath(entity, { model: this.service.model })
+      const data = (req.body = JSON.parse(req._raw)) // REVISIT: eliminate req._raw
+      req._data = Object.assign(data, keys)          // REVISIT: eliminate req._data
+      req._query = INSERT.into(entity)               // REVISIT: eliminate req._query
+      return create.call(this, req, res)             // REVISIT: Changed from calling router.handle() which is undocumented!
+    })
+}
+
+const { update } = require('./update')
+const { create } = require('./create')
+
+const { getKeysAndParamsFromPath } = require('../../common/utils/path')
+
+// REVISIT: we really need to eliminate this code || status || statusCode mess w/ cds9!
+const retry = (e, req) => is404(e) || (is412(e) && req.get('if-none-match') === '*')
+const is404 = e => e.code === 404 || e.status === 404 || e.statusCode === 404
+const is412 = e => e.code === 412 || e.status === 412 || e.statusCode === 412

package/libx/rest/pre-processing.js

@@ -1,36 +1,26 @@
 const getTemplate = require('../_runtime/common/utils/template')
-const { checkStaticElementByKey } = require('../_runtime/cds-services/util/assert')
+
 const _picker = element => {
   const categories = []
   if (Array.isArray(element)) return
   if (element.type === 'cds.Binary' || element.type === 'cds.LargeBinary') categories.push('convert_binary')
-  if (!(element._isStructured || element.isAssociation || element.items)) categories.push('static_validation')
   if (categories.length) return { categories }
 }
 
-const _processorFn = errors => elementInfo => {
-  const { row, key, plain, target } = elementInfo
+const _processorFn = () => elementInfo => {
+  const { row, key, plain } = elementInfo
   if (typeof row !== 'object') return
   if (row[key] == null) return
   for (const category of plain.categories) {
-    switch (category) {
-      case 'convert_binary':
-        if (typeof row[key] === 'string') row[key] = Buffer.from(row[key], 'base64')
-        break
-      case 'static_validation':
-        if (errors) { //> errors collector is only provided in case of !cds.env.features.cds_validate
-          // REVISIT move validation to generic asserter => see PR 717
-          const validations = checkStaticElementByKey(target, key, row[key])
-          errors.push(...validations)
-        }
-        break
+    if (category === 'convert_binary') {
+      if (typeof row[key] === 'string') row[key] = Buffer.from(row[key], 'base64')
     }
   }
 }
 
-const preProcessData = (data, srv, definition, usecase = 'rest-pre-process', errors) => {
-  const template = getTemplate(usecase, srv, definition, { pick: _picker })
-  template.process(data, _processorFn(errors))
+const preProcessData = (data, srv, definition) => {
+  const template = getTemplate('rest-pre-processing', srv, definition, { pick: _picker })
+  template.process(data, _processorFn())
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "8.9.4",
+  "version": "9.0.2",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -12,8 +12,7 @@
   "main": "lib/index.js",
   "bin": {
     "cds-deploy": "lib/dbs/cds-deploy.js",
-    "cds-serve": "bin/serve.js",
-    "cds-test": "bin/test.js"
+    "cds-serve": "bin/serve.js"
   },
   "files": [
     "_i18n/",
@@ -30,12 +29,12 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
-    "@sap/cds-compiler": "^5",
-    "@sap/cds-fiori": "^1",
-    "@sap/cds-foss": "^5.0.0"
+    "@sap/cds-compiler": "^6",
+    "@sap/cds-fiori": "^2",
+    "js-yaml": "^4.1.0"
   },
   "peerDependencies": {
     "@eslint/js": "^9",

package/srv/outbox.cds

@@ -9,4 +9,5 @@ entity Messages {
       partition            : Integer default 0;
       lastError            : LargeString;
       lastAttemptTimestamp : Timestamp @cds.on.update: $now;
+      status               : String(23);
 }

package/bin/test.js

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable no-console */
-
-const options = {
-  'timeout':  { type:'string',  short:'t' },
-  'verbose':  { type:'boolean', short:'v' },
-  'unmute':   { type:'boolean', short:'u' },
-  'silent':   { type:'boolean', short:'s' },
-  'quiet':    { type:'boolean', short:'q' },
-  'list':     { type:'boolean', short:'l' },
-  'recent':   { type:'boolean' },
-  'passed':   { type:'boolean' },
-  'failed':   { type:'boolean' },
-  'match':    { type:'string', default: '(.test.js|.spec.js)$' },
-  'skip':     { type:'string', default: '^(gen,*.tmp)$' },
-  'only':     { type:'string'},
-  'help':     { type:'boolean', short:'h' },
-  'workers':  { type:'string', short:'w' },
-}
-
-const USAGE = `
-Usage:
-
-  cds test [ options ] [ patterns ]
-
-Options:
-
-  -l, --list     List found test files
-  -q, --quiet    No output at all
-  -s, --silent   No output
-  -t, --timeout  in milliseconds
-  -u, --unmute   Unmute output
-  -v, --verbose  Increase verbosity
-  -w, --workers  Specify number of workers
-  -?, --help     Displays this usage info
-
-  --match        Pick matching files, default: ${options.match.default}
-  --skip         Skip matching files, default: ${options.skip.default}
-  --only         Run only the matching tests
-  --failed       Repeat recently failed test suite(s)
-  --passed       Repeat recently passed test suite(s)
-  --recent       Repeat recently run test suite(s)
-`
-
-const { DIMMED, YELLOW, GRAY, RESET } = require('./colors')
-const regex4 = s => !s ? null : RegExp (s.replace(/[,.*]/g, s => ({ ',': '|', '.': '\\.', '*': '.*' })[s]))
-const recent = () => {try { return require(home+'/.cds-test-recent.json') } catch {/* egal */}}
-const os = require('os'), home = os.userInfo().homedir
-
-async function test (argv,o) {
-  if (o.help || argv == '?') return console.log (USAGE)
-  if (o.recent) o = { ...o, ...recent().options }
-  if (o.passed) o.files = recent().passed
-  if (o.failed) o.files = recent().failed
-  if (!o.files) o.files = await fetch (argv,o)
-  if (o.list) return list (o.files)
-  if (o.skip) process.env._chest_skip = o.skip
-  if (o.files.length > 1) console.log (DIMMED,`\nRunning ${o.files.length} test suites...`, RESET)
-  const test = require('node:test').run({ ...o,
-    execArgv: [ '--require', require.resolve('../lib/fixtures/node-test.js') ],
-    timeout: +o.timeout || undefined,
-    concurrency: +o.workers || true,
-    testNamePatterns: regex4 (o.only), only: false,
-  })
-  require('./reporter')(test, test.options = o)
-}
-
-async function fetch (argv,o) {
-  const patterns = regex4 (argv.join('|')) || { test: ()=> true }
-  const tests = regex4 (o.match || options.match.default) || { test: ()=> true }
-  const skip = regex4 (o.skip || options.skip.default) || { test: ()=> false }
-  const ignore = /^(\..*|node_modules|_out)$/
-  const files = []
-  const fs = require('node:fs'), path = require('node:path')
-  const _read = fs.promises.readdir
-  const _isdir = x => fs.statSync(x).isDirectory()
-  await async function _visit (dir) {
-    const entries = await _read (dir)
-    return Promise.all (entries.map (each => {
-      if (ignore.test(each) || skip.test(each = path.join (dir,each))) return
-      if (tests.test(each)) return patterns.test(each) && files.push(each)
-      if (_isdir(each)) return _visit (each)
-    }))
-  } (process.cwd())
-  if (!files.length) throw YELLOW+`\n No matching test files found. \n`+RESET
-  return files
-}
-
-function list (files) {
-  const { relative } = require('node:path'), cwd = process.cwd()
-  const time = (performance.now() / 1000).toFixed(3)
-  console.log()
-  console.log(`Found these matching test files:`, DIMMED, '\n')
-  for (let f of files) console.log('  ', relative(cwd, f))
-  console.log(RESET+'\n', files.length, 'total')
-  console.log(GRAY, time+'s', RESET, '\n')
-}
-
-
-if (!module.parent) {
-  const { positionals, values } = require('node:util').parseArgs ({ options, allowPositionals: true })
-  test (positionals, values) .catch (e => console.error(e), process.exitCode = 1)
-}
-
-else module.exports = Object.assign ( test, {
-  options: [
-    '--files',
-    '--match',
-    '--skip',
-    '--timeout',
-    '--workers',
-  ],
-  flags: [
-    '--verbose',
-    '--unmute',
-    '--silent',
-    '--quiet',
-    '--list',
-    '--recent',
-    '--passed',
-    '--failed',
-  ],
-  shortcuts: [ '-f', null, null, '-t', '-w', '-v', '-u', '-s', '-q', '-l' ],
-  help: USAGE
-})

package/lib/env/plugins.js

@@ -1,18 +0,0 @@
-// REVISIT: we should have a real modular plugin technique for cds.env
-module.exports = function add_mtx_env (env) {
-
-  const mtx_env = require('@sap/cds-mtxs/env')
-  if (mtx_env) {
-    const {requires} = env, {kinds} = requires
-    Object.assign (env, mtx_env, {requires})
-    Object.assign (requires, mtx_env.requires, {kinds})
-    Object.assign (kinds, mtx_env.requires?.kinds)
-  }
-
-  function require (id) {
-    try { return module.require(id) }
-    catch(e) { if (e.code !== 'MODULE_NOT_FOUND') throw e }
-  }
-
-  return env
-}