@sap/cds 9.0.4 → 9.2.0

package/lib/utils/tar.js

@@ -1,3 +1,4 @@
+const { PassThrough } = require('stream')
 const child_process = require('child_process')
 const spawn = /\btar\b/.test(process.env.DEBUG) ? (cmd, args, options) => {
   Error.captureStackTrace(spawn,spawn)
@@ -8,26 +9,36 @@ const spawn = /\btar\b/.test(process.env.DEBUG) ? (cmd, args, options) => {
 const cds = require('../index'), { fs, path, mkdirp, exists, rimraf } = cds.utils
 const _resolve = (...x) => path.resolve (cds.root,...x)
 
-// tar does not work properly on Windows (by npm/jest tests) w/o this change
+// ======= ONLY_FOR_WINDOWS ======
+// This section contains logic relevant for Windows OS.
+
+// tar does not work properly on Windows w/o this change
 const win = path => {
   if (!path) return path
   if (typeof path === 'string') return path.replace('C:', '//localhost/c$').replace(/\\+/g, '/')
   if (Array.isArray(path)) return path.map(el => win(el))
 }
 
-async function copyDir(src, dest) {
+// spawn tar on Windows, using the cli version
+const winSpawnDir = (dir, args) => {
+  if (args.some(arg => arg === '-f')) return spawn ('tar', ['c', '-C', win(dir), ...win(args)])
+  else return spawn ('tar', ['cf', '-', '-C', win(dir), ...win(args)])
+}
+
+// copy a directory recursively on Windows, using fs.promises
+async function winCopyDir(src, dest) {
   if ((await fs.promises.stat(src)).isDirectory()) {
     const entries = await fs.promises.readdir(src)
-    return Promise.all(entries.map(async each => copyDir(path.join(src, each), path.join(dest, each))))
+    return Promise.all(entries.map(async each => winCopyDir(path.join(src, each), path.join(dest, each))))
   } else {
     await fs.promises.mkdir(path.dirname(dest), { recursive: true })
     return fs.promises.copyFile(src, dest)
   }
 }
 
-// Copy resources containing files and folders to temp dir on Windows and pack temp dir.
-// cli tar has a size limit on Windows.
-const createTemp = async (root, resources) => {
+// copy resources containing files and folders to temp dir on Windows 
+// cli tar has a size limit on Windows
+const winCreateTemp = async (root, resources) => {
   // Asynchronously copies the entire content from src to dest.
   const temp = await fs.promises.mkdtemp(`${fs.realpathSync(require('os').tmpdir())}${path.sep}tar-`)
   for (let resource of resources) {
@@ -43,7 +54,7 @@ const createTemp = async (root, resources) => {
         await fs.promises.cp(resource, destination, { recursive: true })
       } else {
         // node < 16
-        await copyDir(resource, destination)
+        await winCopyDir(resource, destination)
       }
     }
   }
@@ -51,6 +62,43 @@ const createTemp = async (root, resources) => {
   return temp
 }
 
+// spawn tar on Windows, using a temp dir, which is copied from the original dir
+// cli tar has a size limit on Windows
+const winSpawnTempDir = (dir, args) => {
+  // Synchronous trick: use a PassThrough as placeholder
+  const stdout = new PassThrough()
+  const stderr = new PassThrough()
+  const c = {
+    stdout,
+    stderr,
+    on: (...a) => { stdout.on(...a); stderr.on(...a); return c },
+    once: (...a) => { stdout.once(...a); stderr.once(...a); return c },
+    kill: () => {},
+  }
+  
+  // async copy, then swap streams/events
+  winCreateTemp(dir, args.shift()).then(tempPath => {
+    const real = winSpawnDir(tempPath, args)
+    real.stdout.pipe(stdout)
+    real.stderr && real.stderr.pipe(stderr)
+    const cleanup = () => exists(tempPath) && rimraf(tempPath)
+    real.on('close', (...ev) => { 
+      stdout.emit('close', ...ev)
+      stderr.emit('close', ...ev)
+      cleanup()
+    })
+    real.on('error', (...ev) => { 
+      stdout.emit('error', ...ev)
+      stderr.emit('error', ...ev) 
+      cleanup()
+    })
+    c.kill = (...ev) => real.kill(...ev)
+  })
+  return c
+}
+
+// ====== END ONLY_FOR_WINDOWS ======
+
 const tarInfo = async (info) => {
   let cmd, param
   if (info === 'version') {
@@ -118,19 +166,12 @@ exports.create = (dir='.', ...args) => {
   if (typeof dir === 'string') dir = _resolve(dir)
   if (Array.isArray(dir)) [ dir, ...args ] = [ cds.root, dir, ...args ]
 
-  let c, temp
+  let c
   args = args.filter(el => el)
-  if (process.platform === 'win32') {
-    const spawnDir = (dir, args) => {
-      if (args.some(arg => arg === '-f')) return spawn ('tar', ['c', '-C', win(dir), ...win(args)])
-      else return spawn ('tar', ['cf', '-', '-C', win(dir), ...win(args)])
-    }
+  if (process.platform === 'win32') {    
     args.push('.')
-    if (Array.isArray(args[0])) {
-      c = createTemp(dir, args.shift()) .then (t => spawnDir(t,args))
-    } else {
-      c = spawnDir(dir, args)
-    }
+    if (Array.isArray(args[0])) c = winSpawnTempDir(dir, args)
+    else c = winSpawnDir(dir, args)
   } else {
     if (Array.isArray(args[0])) {
       args.push (...args.shift().map (f => path.isAbsolute(f) ? path.relative(dir,f) : f))
@@ -153,11 +194,7 @@ exports.create = (dir='.', ...args) => {
       c.stdout.on('data', d => data.push(d))
       c.stderr.on('data', d => stderr += d)
       c.on('close', code => code ? reject(new Error(stderr)) : resolve(Buffer.concat(data)))
-      c.on('error', reject)
-      if (process.platform === 'win32') {
-        c.on('close', () => temp && exists(temp) && rimraf(temp))
-        c.on('error', () => temp && exists(temp) && rimraf(temp))
-      }
+      c.on('error', reject)      
     },
 
     /**

package/lib/utils/version.js

@@ -0,0 +1,18 @@
+const semver = exports = module.exports = (x,y,z) => {
+  if (typeof x === 'string') [ x,y,z ] = String(x).split('.')
+  return 1e6 * (x||0) + 1e3 * (y||0) + +(z||0)
+}
+
+exports.checkNodeVersion = (cds = require ('../../package.json')) => {
+  let required = cds.engines?.node?.slice(2) //> e.g. >=22
+  let current = process.version.slice(1)    //> e.g. v24.4.1
+  if (semver(current) >= semver(required)) return; else process.stderr.write (`
+    Node.js version ${required} or higher is required for @sap/cds v${cds.version}.
+    Current version ${current} does not satisfy this. \n\n`)
+  return process.exit(1)
+}
+
+exports.check = (x, min, max) => {
+  let v = semver(x)
+  return (!min || semver(min) <= v) && (!max || v <= semver(max))
+}

package/libx/_runtime/cds.js

@@ -16,7 +16,7 @@ cds.extend(service).with(require('./common/aspects/service'))
  */
 cds.Service.prototype._requires_resolving = function (req) {
   if (req._resolved) return false
-  if (!this.model) return false
+  if (!this.definition) return false
   if (!req.query || typeof req.query !== 'object') return false
   if (Array.isArray(req.query)) return false
   if (Object.keys(req.query).length === 0) return false

package/libx/_runtime/common/aspects/any.js

@@ -1,20 +1,10 @@
-const { foreignKey4 } = require('../../common/utils/foreignKeyPropagations')
+const { foreignKey4 } = require('../utils/foreignKeyPropagations')
 
 const _getCommonFieldControl = e => {
   const cfr = e['@Common.FieldControl']
   return cfr && cfr['#']
 }
 
-const _isMandatory = e => {
-  return (
-    e['@assert.mandatory'] !== false &&
-    (e['@mandatory'] ||
-      e['@Common.FieldControl.Mandatory'] ||
-      e['@FieldControl.Mandatory'] ||
-      _getCommonFieldControl(e) === 'Mandatory')
-  )
-}
-
 const _isReadOnly = e => {
   return (
     e['@readonly'] ||
@@ -34,22 +24,10 @@ module.exports = class {
     return this.own('__isStructured', () => !!this.elements && this.kind !== 'entity')
   }
 
-  get _isMandatory() {
-    return this.own('__isMandatory', () => !this.isAssociation && _isMandatory(this))
-  }
-
   get _isReadOnly() {
     return this.own('__isReadOnly', () => !this.key && _isReadOnly(this))
   }
 
-  get _mandatories() {
-    return this.own(
-      '__mandatories',
-      // eslint-disable-next-line no-unused-vars
-      () => this.elements && Object.entries(this.elements).filter(([_, v]) => v._isMandatory)
-    )
-  }
-
   get _foreignKey4() {
     return this.own('__foreignKey4', () => foreignKey4(this))
   }

package/libx/_runtime/common/generic/crud.js

@@ -78,9 +78,7 @@ module.exports = cds.service.impl(function () {
       if (await _targetEntityDoesNotExist(req)) req.reject(404) // REVISIT: add a reasonable error message
     }
 
-    // flag to trigger read after write in legacy odata adapter
-    if (req.constructor.name in { ODataRequest: 1 }) req._.readAfterWrite = true
-    if (req.protocol?.match(/odata/)) req._.readAfterWrite = true //> REVISIT for noah
+    if (req.protocol?.match(/odata/)) req._.readAfterWrite = true
 
     return req.data
   })

package/libx/_runtime/common/generic/input.js

@@ -13,11 +13,11 @@ const LOG = cds.log('app')
 const { Readable } = require('node:stream')
 
 const { enrichDataWithKeysFromWhere } = require('../utils/keys')
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
 const propagateForeignKeys = require('../utils/propagateForeignKeys')
-const { checkInputConstraints, assertTargets } = require('../../cds-services/util/assert')
 const getTemplate = require('../utils/template')
 const getRowUUIDGeneratorFn = require('../utils/rowUUIDGenerator')
+const templatePathSerializer = require('../utils/templateProcessorPathSerializer')
 
 const _shouldSuppressErrorPropagation = (event, value) => {
   return (
@@ -96,6 +96,113 @@ const _preProcessAssertTarget = (assocInfo, assertMap) => {
   })
 }
 
+const _enumValues = element => {
+  return Object.keys(element).map(enumKey => {
+    const enum_ = element[enumKey]
+    const enumValue = enum_ && enum_.val
+
+    if (enumValue !== undefined) {
+      if (enumValue['=']) return enumValue['=']
+      if (enum_ && enum_.literal && enum_.literal === 'number') return Number(enumValue)
+      return enumValue
+    }
+
+    return enumKey
+  })
+}
+
+// REVISIT: this needs a cleanup!
+const _assertError = (code, element, value, key, path) => {
+  let args
+
+  if (typeof code === 'object') {
+    args = code.args
+    code = code.code
+  }
+
+  const { name, type, precision, scale } = element
+  const error = new Error()
+  const errorEntry = {
+    code,
+    message: code,
+    target: path ?? element.name ?? key,
+    args: args ?? [name ?? key]
+  }
+
+  const assertError = Object.assign(error, errorEntry)
+  Object.assign(assertError, {
+    entity: element.parent && element.parent.name,
+    element: name, // > REVISIT: when is error.element needed?
+    type: element.items ? element.items._type : type,
+    status: 400,
+    value
+  })
+
+  if (element.enum) assertError.enum = _enumValues(element)
+  if (precision) assertError.precision = precision
+  if (scale) assertError.scale = scale
+
+  if (element.target) {
+    // REVISIT: when does this case apply?
+    assertError.target = element.target
+  }
+
+  return assertError
+}
+
+/**
+ * Check whether the target entity referenced by the association (the reference's target) exists and assert an error if
+ * the the reference's target doesn't exist.
+ *
+ * In other words, use this annotation to check whether a non-null foreign key input in a table has a corresponding
+ * primary key (also known as a parent key) in the associated/referenced target table (also known as a parent table).
+ *
+ * @param {object} assertMap - Map containing the targets to assert.
+ * @param {array} errors - Array to collect errors.
+ * @see {@link https://cap.cloud.sap/docs/guides/providing-services#assert-target @assert.target} for further information.
+ */
+const _assertTargets = async (assertMap, errors) => {
+  const { targets: targetsMap, allTargets } = assertMap
+  if (targetsMap.size === 0) return
+
+  const targets = Array.from(targetsMap.values())
+  const transactions = targets.map(({ keys, entity }) => {
+    const where = Object.assign({}, ...keys)
+    return cds.db.exists(entity, where).forShareLock()
+  })
+  const targetsExistsResults = await Promise.allSettled(transactions)
+
+  targetsExistsResults.forEach((txPromise, index) => {
+    const isPromiseRejected = txPromise.status === 'rejected'
+    const shouldAssertError = (txPromise.status === 'fulfilled' && txPromise.value == null) || isPromiseRejected
+    if (!shouldAssertError) return
+
+    const target = targets[index]
+    const { element } = target.assocInfo
+
+    if (isPromiseRejected) {
+      LOG._debug &&
+        LOG.debug(
+          `The transaction to check the @assert.target constraint for foreign key "${element.name}" failed`,
+          txPromise.reason
+        )
+
+      throw new Error(txPromise.reason.message)
+    }
+
+    allTargets
+      .filter(t => t.key === target.key)
+      .forEach(target => {
+        const { row, pathSegmentsInfo } = target.assocInfo
+        const key = target.foreignKey.name
+        let path
+        if (pathSegmentsInfo?.length) path = templatePathSerializer(key, pathSegmentsInfo)
+        const error = _assertError('ASSERT_TARGET', target.foreignKey, row[key], key, path)
+        errors.push(error)
+      })
+  })
+}
+
 const _processCategory = (req, category, value, elementInfo, assertMap) => {
   const { row, key, element, isRoot } = elementInfo
   category = _getSimpleCategory(category)
@@ -166,7 +273,7 @@ const _getProcessorFn = (req, errors, assertMap) => {
   const event = req.event
 
   return elementInfo => {
-    const { row, key, element, plain, pathSegmentsInfo } = elementInfo
+    const { row, key, plain } = elementInfo
     // ugly pointer passing for sonar
     const value = { mandatory: false, val: row && row[key] }
 
@@ -175,9 +282,6 @@ const _getProcessorFn = (req, errors, assertMap) => {
     }
 
     if (_shouldSuppressErrorPropagation(event, value)) return
-
-    // REVISIT: Convert checkInputConstraints to template mechanism
-    checkInputConstraints({ element, value: value.val, errors, pathSegmentsInfo, event })
   }
 }
 
@@ -251,7 +355,7 @@ async function validate_input(req) {
   }
 
   const errs = cds.validate(req.data, req.target, assertOptions)
-  if (errs) return req._errors.push(...errs)
+  if (errs) return errs.forEach(err => req.error(err))
 
   // -------------------------------------------------
   // REVISIT: is the below still needed?
@@ -276,49 +380,12 @@ async function validate_input(req) {
     pathSegmentsInfo: []
   })
   if (assertMap.targets.size > 0) {
-    await assertTargets(assertMap, errors)
+    await _assertTargets(assertMap, errors)
   }
 
   if (errors.length) for (const error of errors) req.error(error)
 }
 
-const _getProcessorFnForActionsFunctions =
-  (errors, opName) =>
-  ({ row, key, element }) => {
-    const value = row && row[key]
-
-    // REVISIT: Convert checkInputConstraints to template mechanism
-    checkInputConstraints({ element, value, errors, key: opName })
-  }
-
-const _processActionFunctionRow = (row, param, key, errors, event, service) => {
-  const values = Array.isArray(row[key]) ? row[key] : [row[key]]
-
-  // unstructured
-  for (const value of values) {
-    checkInputConstraints({ element: param, value, errors, key })
-  }
-
-  // structured
-  const template = getTemplate('app-input-operation', service, param, {
-    pick: _pick,
-    ignore: element => element._isAssociationStrict
-  })
-
-  template.process(values, _getProcessorFnForActionsFunctions(errors, key))
-}
-
-const _processActionFunction = (row, eventParams, errors, event, service) => {
-  for (const key in eventParams) {
-    let param = eventParams[key]
-
-    // .type of action/function behaves different to .type of other csn elements
-    const _type = param.type
-    if (!_type && param.items) param = param.items
-    _processActionFunctionRow(row, param, key, errors, event, service)
-  }
-}
-
 function validate_action(req) {
   const operation = this.actions?.[req.event] || req.target?.actions?.[req.event]
   if (!operation) return
@@ -332,13 +399,7 @@ function validate_action(req) {
     protocol: req.protocol
   }
   let errs = cds.validate(data, operation, assertOptions)
-  if (errs) return req._errors.push(...errs)
-
-  // REVISIT: we still need the following because cds.validate doesn't check for @mandatory params (both flat and nested)
-  const errors = []
-  const arrayData = Array.isArray(data) ? data : [data]
-  for (const row of arrayData) _processActionFunction(row, operation.params, errors, req.event, this)
-  if (errors.length) for (const error of errors) req.error(error)
+  if (errs) return errs.forEach(err => req.error(err))
 
   // convert binaries
   operation.params &&

package/libx/_runtime/common/generic/sorting.js

@@ -1,5 +1,5 @@
 const cds = require('../../cds')
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
 
 const _getStaticOrders = req => {
   const { target: entity, query } = req

package/libx/_runtime/common/generic/temporal.js

@@ -76,12 +76,6 @@ function handle_temporal_data(req) {
       _getDateFromQueryOptions(_queryOptions['sap-valid-to'] ?? normalizeTimestamp('9999-12-31T23:59:59.9999999Z'))
     )
   }
-
-  // REVISIT: needed without okra
-  if (req.constructor.name !== 'ODataRequest') {
-    req._['VALID-FROM'] = _['VALID-FROM']
-    req._['VALID-TO'] = _['VALID-TO']
-  }
 }
 handle_temporal_data._initial = true
 

package/libx/_runtime/common/utils/draft.js

@@ -1,5 +1,5 @@
 const cds = require('../../../../lib')
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
 
 const _4sqlite = cds.env.i18n && Array.isArray(cds.env.i18n.for_sqlite) ? cds.env.i18n.for_sqlite : []
 // compiler reserves 'localized' and raises a corresponding exception if used in models

package/libx/_runtime/common/utils/entityFromCqn.js

@@ -1,4 +1,4 @@
-const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { ensureNoDraftsSuffix } = require('./draft')
 
 const traverseFroms = (cqn, cb, aliasForSet) => {
   while (cqn.SELECT) cqn = cqn.SELECT.from

package/libx/_runtime/common/utils/propagateForeignKeys.js

@@ -1,6 +1,6 @@
 const cds = require('../../cds')
 
-const { prefixForStruct } = require('../../common/utils/csn')
+const { prefixForStruct } = require('./csn')
 
 const _autoGenerate = e => e && e.isUUID && e.key
 

package/libx/_runtime/common/utils/resolveView.js

@@ -1,7 +1,7 @@
 const cds = require('../../../../lib')
 let LOG = cds.log('app')
 
-const { rewriteAsterisks } = require('../../common/utils/rewriteAsterisks')
+const { rewriteAsterisks } = require('./rewriteAsterisks')
 
 const _setInverseTransition = (mapping, ref, mapped) => {
   const existing = mapping.get(ref)
@@ -531,7 +531,7 @@ const _mappedValue = (col, alias) => {
 const getDBTable = target => cds.ql.resolve.table(target)
 
 const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
-  const el = target.elements[as] || target.query._target.elements[ref.at(-1)]
+  const el = target.elements[as] || target.query._target?.elements[ref.at(-1)]
 
   if (el && el.isAssociation && el.keys) {
     for (const key of el.keys) {

package/libx/_runtime/common/utils/structured.js

@@ -1,6 +1,6 @@
 const resolveStructured = require('./resolveStructured')
-const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
-const { traverseFroms } = require('../../common/utils/entityFromCqn')
+const { ensureNoDraftsSuffix } = require('./draft')
+const { traverseFroms } = require('./entityFromCqn')
 
 const OPERATIONS_MAP = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in'].reduce((acc, cur) => {
   acc[cur] = 1

package/libx/_runtime/common/utils/templateProcessor.js

@@ -6,7 +6,6 @@ const _processElement = (processFn, row, key, target, picked = {}, isRoot, pathS
 
   if (!plain) return
 
-  /** @type import('../../types/api').templateElementInfo */
   const elementInfo = { row, key, element, target, plain, isRoot, pathSegmentsInfo }
 
   if (!element && target._flat2struct?.[key] && elementInfo.pathSegmentsInfo) {
@@ -53,7 +52,6 @@ const _processComplex = (processFn, row, template, key, pathOptions) => {
     let pathSegmentInfo
     if (pathOptions.includeKeyValues) {
       pathOptions.rowUUIDGenerator?.(keyNames, row, template)
-      /** @type import('../../types/api').pathSegmentInfo */
       pathSegmentInfo = { key, keyNames, row, elements: template.target.elements, draftKeys: pathOptions.draftKeys }
     }
 
@@ -63,9 +61,6 @@ const _processComplex = (processFn, row, template, key, pathOptions) => {
   }
 }
 
-/**
- * @param {import("../../types/api").TemplateProcessor} args
- */
 const templateProcessor = ({ processFn, data, template, isRoot = true, pathOptions = {} }) => {
   if (!template || !template.elements.size || !data || typeof data !== 'object') return
   const dataArr = Array.isArray(data) ? data : [data]

package/libx/_runtime/common/utils/vcap.js

@@ -1,4 +1,4 @@
-const cds = require('../../../../libx/_runtime/cds')
+const cds = require('../../cds')
 
 const getAppMetadata = () => {
   const appMetadata = cds.env.app