@sap/cds 5.4.6 → 5.5.0

package/lib/serve/index.js

@@ -42,16 +42,18 @@ function cds_serve (som, _options) { // NOSONAR
 
     // Shortcut for directly passed service classes
     if (o.service && o.service._is_service_class) {
-      const Service = o.service, d = { name: o.service = o.service.name }
+      const Service = o.service, d = { name: o.service.name }
       return all.push (_new (Service, d,csn,o))
     }
 
     // Get relevant service definitions from model...
     let {services} = csn = cds.linked (cds.compile.for.odata (csn))
-    if (o.service && o.service !== 'all') {
+    let specified = o.service
+    if (specified && specified !== 'all') {
       // skip services not chosen by o.service, if specified
-      services = services.filter (s => s.name.endsWith (o.service))
-      if (!services.length) throw cds.error (`No such service: '${o.service}'`)
+      if (cds.requires[specified]) specified = cds.requires[specified].service || specified
+      services = services.filter (s => s.name.endsWith (specified))
+      if (!services.length) throw cds.error (`No such service: '${specified}'`)
     }
     services = services.filter (d => !(
       // skip all services marked to be ignored
@@ -108,13 +110,16 @@ function cds_serve (som, _options) { // NOSONAR
 
 
 function _new (Service, d,m,o) {
-  if (o.service === 'all') o = {...o, service:d.name}
   const srv = new Service (d.name,m,o)
-  if (!srv.path) srv.path = path4(d,o.at)
-  if (o.mocked && d.name in cds.requires) srv.mocked = true
+  const required = cds.requires[d.name]
+  if (required) {
+    if (required.name) srv.name = required.name
+    if (o.mocked) srv.mocked = true
+  }
+  if (!srv.path) srv.path = path4(srv,o.at)
   cds.service.providers.push (srv)
-  _pending[d.name] = new Promise (r => srv[_ready]=r).finally(()=>{
-    delete _pending[d.name]
+  _pending[srv.name] = new Promise (r => srv[_ready]=r).finally(()=>{
+    delete _pending[srv.name]
     delete srv[_ready]
   })
   return srv
@@ -126,10 +131,10 @@ function _new (Service, d,m,o) {
  * Use _path or def[@path] if given with leading '/' prepended if necessary.
  * Otherwise, use the service definition name with stripped 'Service'
  */
-function path4 (def, _path = def['@path']) {
+function path4 (srv, _path = (srv.definition || srv)['@path']) {
 	if (_path)  return _path.replace(/^[^/]/, c => '/'+c)
 	else  return '/' + ( // generate one from the service's name
-		/[^.]+$/.exec(def.name)[0]  //> my.very.CatalogService --> CatalogService
+		/[^.]+$/.exec(srv.name)[0]  //> my.very.CatalogService --> CatalogService
 		.replace(/Service$/,'')     //> CatalogService --> Catalog
 		.replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C.toLowerCase())  //> ODataFooBarX9 --> odata-foo-bar-x9
 		.replace(/_/g,'-')  //> foo_bar_baz --> foo-bar-baz

package/lib/utils/axios.js

@@ -6,26 +6,33 @@ class Axios {
       baseURL: this.url,
     })
   }
-  get    (path,...etc) { return this.axios.get    (_url(path),...etc) .catch(_error) }
-  put    (path,...etc) { return this.axios.put    (_url(path),...etc) .catch(_error) }
-  post   (path,...etc) { return this.axios.post   (_url(path),...etc) .catch(_error) }
-  patch  (path,...etc) { return this.axios.patch  (_url(path),...etc) .catch(_error) }
-  delete (path,...etc) { return this.axios.delete (_url(path),...etc) .catch(_error) }
+  get     (..._) { return this.axios.get     (..._args(_)) .catch(_error) }
+  put     (..._) { return this.axios.put     (..._args(_)) .catch(_error) }
+  post    (..._) { return this.axios.post    (..._args(_)) .catch(_error) }
+  patch   (..._) { return this.axios.patch   (..._args(_)) .catch(_error) }
+  delete  (..._) { return this.axios.delete  (..._args(_)) .catch(_error) }
+  options (..._) { return this.axios.options (..._args(_)) .catch(_error) }
 
-  /** @type typeof _.get    */ get GET()    { return this.get    .bind (this) }
-  /** @type typeof _.put    */ get PUT()    { return this.put    .bind (this) }
-  /** @type typeof _.post   */ get POST()   { return this.post   .bind (this) }
-  /** @type typeof _.patch  */ get PATCH()  { return this.patch  .bind (this) }
-  /** @type typeof _.delete */ get DELETE() { return this.delele .bind (this) }
-  /** @type typeof _.delete */ get DEL()    { return this.delete .bind (this) } //> to avoid conflicts with cds.ql.DELETE
+  /** @type typeof _.get     */ get GET()     { return this.get     .bind (this) }
+  /** @type typeof _.put     */ get PUT()     { return this.put     .bind (this) }
+  /** @type typeof _.post    */ get POST()    { return this.post    .bind (this) }
+  /** @type typeof _.patch   */ get PATCH()   { return this.patch   .bind (this) }
+  /** @type typeof _.delete  */ get DELETE()  { return this.delele  .bind (this) }
+  /** @type typeof _.delete  */ get DEL()     { return this.delete  .bind (this) } //> to avoid conflicts with cds.ql.DELETE
+  /** @type typeof _.options */ get OPTIONS() { return this.options .bind (this) }
 
 }
 
-const _url = (path) => {
-  if (path.raw) path = String.raw(path)
-  if (typeof path !== 'string') throw new Error (`Argument path is expected to be a string but got ${typeof path}`)
-  if (!path.startsWith('/')) throw new Error (`Argument path is expected to start with a /`)
-  return path
+const _args = (args) => {
+  const first = args[0], last = args[args.length-1]
+  if (first.raw) {
+    if (first[first.length-1] === '' && typeof last === 'object')
+      return [ String.raw(...args.slice(0,-1)), last ]
+    return [ String.raw(...args) ]
+  }
+  else if (typeof first !== 'string')
+    throw new Error (`Argument path is expected to be a string but got ${typeof first}`)
+  return args
 }
 
 const _error = (e) => {

package/lib/utils/data.js

@@ -0,0 +1,35 @@
+const cds = require('../index')
+
+class DataUtil {
+
+  async delete(db) {
+    if (!db)  db = await cds.connect.to('db')
+    if (!this._deletes) {
+      this._deletes = []
+      for (const entity of db.model.minified().all('entity')) {
+        if (!entity.query && entity['@cds.persistence.skip'] !== true) {
+          this._deletes.push(cds.ql.DELETE.from(entity))
+        }
+      }
+    }
+    if (this._deletes.length > 0) {
+      const log = cds.log('deploy')
+      if (log._info)  log.info('Deleting all data in', this._deletes)
+      await db.run(this._deletes)
+    }
+  }
+
+  /* delete + new deploy from csv */
+  async reset(db) {
+    if (!db)  db = await cds.connect.to('db')
+    await this.delete(db)
+    await cds.deploy(db.model).to(db, {ddl:false})
+  }
+
+  autoReset(enabled) { this._autoReset = enabled; return this }
+
+}
+
+module.exports = DataUtil
+
+/* eslint no-console: off */

package/lib/utils/tests.js

@@ -1,5 +1,4 @@
 const { resolve, dirname } = require('path')
-const console = global.console
 
 class Test extends require('./axios') {
 
@@ -12,12 +11,12 @@ class Test extends require('./axios') {
    * also acts as an axios lookalike, providing methods to send requests.
    */
   run (cmd, ...args) {
+    initLogging()
 
     // launch cds server...
     global.before (`launching ${cmd} ${args.join(' ')}...`, () => { // NOSONAR
 
       const {cds} = this
-
       if (!/^(serve|run)$/.test(cmd)) try {
         const project = cds.utils.isdir (cmd) || dirname (require.resolve (cmd+'/package.json'))
         cmd='serve'; args.push ('--project', project, '--in-memory?')
@@ -36,6 +35,10 @@ class Test extends require('./axios') {
       catch (e) { if (is_mocha) console.error(e) }
     })
 
+    global.beforeEach (async () => {
+      if (this.data._autoReset)  await this.data.reset()
+    })
+
     // shutdown cds server...
     global.after (done => {
       this.server ? this.server.close (done) : done()
@@ -66,7 +69,8 @@ class Test extends require('./axios') {
    * Switch on/off console log output.
    */
   verbose(v) {
-    process.env.CDS_TEST_VERBOSE = v
+    v === false ? delete process.env.CDS_TEST_VERBOSE : process.env.CDS_TEST_VERBOSE=v
+    initLogging()
     return this
   }
 
@@ -87,10 +91,12 @@ class Test extends require('./axios') {
   get expect(){ return this.chai.expect }
   get assert(){ return this.chai.assert }
   get sleep(){ return require('util').promisify(setTimeout) }
-}
+  get data() { return this._data || (this._data = new (require('./data')))}
 
+}
 
 // harmonizing jest and mocha
+const is_jest = !!global.beforeAll
 const is_mocha = !!global.before
 if (is_mocha) {
   const { format } = require('util')
@@ -101,26 +107,29 @@ if (is_mocha) {
       if (!Array.isArray(each)) each = [each]
       return it (format(title,...each), ()=> fn(...each))
   }))
-} else { // it's jest
+} else if (is_jest) { // it's jest
   global.before = (msg,fn) => global.beforeAll(fn||msg)
   global.after = (msg,fn) => global.afterAll(fn||msg)
+} else { // it's none of both
+  global.before = (_,fn) => fn()
+  global.after = ()=>{}
 }
 
-if (!process.env.CDS_TEST_VERBOSE)  silent()
-
-function silent() {
-  const console = global.console, logs=[]
-  global.console = { __proto__: global.console, logs,
-    time: ()=>{}, timeEnd: (...args)=> logs.push(args),
-    debug: (...args)=> logs.push(args),
-    log: (...args)=> logs.push(args),
-    warn: (...args)=> logs.push(args),
-    error: (...args)=> logs.push(args),
-    dump(){ for (let each of logs) console.log (...each) },
+function initLogging() {
+  const levels = process.env.CDS_TEST_VERBOSE
+    ? { deploy:'info', serve:'info', server:'info',cds:'info' }
+    : { deploy:'warn', serve:'warn', server:'warn',cds:'silent'/*silences provoked request errors */ }
+
+  const env = Reflect.getOwnPropertyDescriptor(global.cds,'env')
+  for (const id of Object.keys(levels)) {
+    if (env && env.value)
+      global.cds.log(id, { level:levels[id] })
+    else // uninitialized cds.env -> set env variables to avoid initializing cds.env eagerly
+      process.env['CDS_LOG_LEVELS_'+id.toUpperCase()] = levels[id]
   }
-  global.after (()=> global.console = console)
 }
 
-
 /** @type Test.run & Test */
 module.exports = Object.setPrototypeOf (Test.run, Test.prototype)
+
+/* eslint no-console: off */

package/libx/_runtime/audit/generic/personal/access.js

@@ -0,0 +1,81 @@
+const cds = require('../../../cds')
+
+const getTemplate = require('../../../common/utils/template')
+const templateProcessor = require('../../../common/utils/templateProcessor')
+
+const {
+  getRootEntity,
+  getPick,
+  createLogEntry,
+  addObjectID,
+  addDataSubject,
+  addDataSubjectForDetailsEntity,
+  resolveDataSubjectPromises
+} = require('./utils')
+
+let als
+
+const _processorFnAccess = (accessLogs, model, req) => {
+  return ({ row, key, element, plain }) => {
+    const entity = getRootEntity(element)
+
+    // create or augment log entry
+    const accessLog = createLogEntry(accessLogs, entity, row)
+
+    // process categories
+    for (const category of plain.categories) {
+      if (category === 'ObjectID') {
+        addObjectID(accessLog, row, key)
+      } else if (category === 'DataSubjectID') {
+        addDataSubject(accessLog, row, key, entity)
+      } else if (category === 'IsPotentiallySensitive') {
+        // add attribute
+        if (!accessLog.attributes.find(ele => ele.name === key)) accessLog.attributes.push({ name: key })
+        // REVISIT: attribute vs. attachment?
+      }
+    }
+
+    // add promise to determine data subject if a DataSubjectDetails entity
+    if (
+      element.parent['@PersonalData.EntitySemantics'] === 'DataSubjectDetails' &&
+      accessLog.dataSubject.id.length === 0 // > id still an array -> promise not yet set
+    ) {
+      addDataSubjectForDetailsEntity(row, accessLog, req, entity, model)
+    }
+  }
+}
+
+const _getDataAccessLogs = (data, req, tx) => {
+  const template = getTemplate(
+    'personal_read',
+    Object.assign({ name: req.target._service.name, model: tx.model }),
+    req.target,
+    { pick: getPick('READ') }
+  )
+
+  const accessLogs = {}
+
+  const processFn = _processorFnAccess(accessLogs, tx.model, req)
+  const data_ = Array.isArray(data) ? data : [data]
+  data_.forEach(row => {
+    templateProcessor({ processFn, row, template })
+  })
+
+  return accessLogs
+}
+
+const auditAccessHandler = async function (data, req) {
+  als = als || (await cds.connect.to('audit-log'))
+  if (!als.ready) return
+
+  const accessLogs = _getDataAccessLogs(data, req, this)
+  const accesses = Object.keys(accessLogs).map(k => accessLogs[k])
+
+  await resolveDataSubjectPromises(accesses)
+
+  if (accesses.length) await als.emit('dataAccessLog', { accesses })
+}
+
+module.exports = {
+  auditAccessHandler
+}

package/libx/_runtime/audit/generic/personal/constants.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ASPECTS: { CREATE: '_auditCreate', READ: '_auditRead', UPDATE: '_auditUpdate', DELETE: '_auditDelete' },
+  WRITE: { CREATE: 1, UPDATE: 1, DELETE: 1 }
+}

package/libx/_runtime/audit/generic/personal/index.js

@@ -0,0 +1,50 @@
+const cds = require('../../../cds')
+
+const {
+  attachDiffToContextHandler,
+  calcModificationLogsHandler4Before,
+  calcModificationLogsHandler4After,
+  emitModificationHandler
+} = require('./modification')
+const { auditAccessHandler } = require('./access')
+
+module.exports = function () {
+  /*
+   * prep context
+   */
+  this.before('*', req => (req.context._audit = req.context._audit || {}))
+
+  /*
+   * data modification
+   */
+  // REVISIT: diff() doesn't work in srv after phase but foreign key propagation has not yet taken place in srv before phase
+  //          -> calc diff in db layer and store in audit data structure at context
+  //          -> REVISIT for GA: clear req._.partialPersistentState?
+  attachDiffToContextHandler._initial = true
+  for (const entity of Object.values(this.entities).filter(e => e._auditCreate)) {
+    cds.db.before('CREATE', entity, attachDiffToContextHandler)
+    // create -> all new -> calcModificationLogsHandler in after phase
+    cds.db.after('CREATE', entity, calcModificationLogsHandler4After)
+    this.after('CREATE', entity, emitModificationHandler)
+  }
+  for (const entity of Object.values(this.entities).filter(e => e._auditUpdate)) {
+    cds.db.before('UPDATE', entity, attachDiffToContextHandler)
+    // update -> mixed (via deep) -> calcModificationLogsHandler in before and after phase
+    cds.db.before('UPDATE', entity, calcModificationLogsHandler4Before)
+    cds.db.after('UPDATE', entity, calcModificationLogsHandler4After)
+    this.after('UPDATE', entity, emitModificationHandler)
+  }
+  for (const entity of Object.values(this.entities).filter(e => e._auditDelete)) {
+    cds.db.before('DELETE', entity, attachDiffToContextHandler)
+    // delete -> all done -> calcModificationLogsHandler in before phase
+    cds.db.before('DELETE', entity, calcModificationLogsHandler4Before)
+    this.after('DELETE', entity, emitModificationHandler)
+  }
+
+  /*
+   * data access
+   */
+  for (const entity of Object.values(this.entities).filter(e => e._auditRead)) {
+    this.after('READ', entity, auditAccessHandler)
+  }
+}

package/libx/_runtime/audit/generic/personal/modification.js

@@ -0,0 +1,138 @@
+const cds = require('../../../cds')
+
+const getTemplate = require('../../../common/utils/template')
+const templateProcessor = require('../../../common/utils/templateProcessor')
+
+const {
+  getMapKeyForCurrentRequest,
+  getRootEntity,
+  getPick,
+  createLogEntry,
+  addObjectID,
+  addDataSubject,
+  addDataSubjectForDetailsEntity,
+  resolveDataSubjectPromises
+} = require('./utils')
+
+let als
+
+const attachDiffToContextHandler = async function (req) {
+  // REVISIT: what does this do?
+  Object.defineProperty(req.query, '_selectAll', {
+    enumerable: false,
+    writable: false,
+    configurable: true,
+    value: true
+  })
+
+  // store diff in audit data structure at context
+  if (!req.context._audit.diffs) req.context._audit.diffs = new Map()
+  req.context._audit.diffs.set(req._.query, await req.diff())
+}
+
+const _getOldAndNew = (action, row, key) => {
+  let oldValue = action === 'Create' ? null : row._old && row._old[key]
+  if (oldValue === undefined) oldValue = null
+  let newValue = action === 'Delete' ? null : row[key]
+  if (newValue === undefined) newValue = null
+  return { oldValue, newValue }
+}
+
+const _addAttribute = (log, action, row, key) => {
+  if (!log.attributes.find(ele => ele.name === key)) {
+    const { oldValue, newValue } = _getOldAndNew(action, row, key)
+    if (oldValue !== newValue) log.attributes.push({ name: key, oldValue, newValue })
+  }
+}
+
+const _processorFnModification = (modificationLogs, model, req, beforeWrite) => processArgs => {
+  if (!processArgs.row._op) return
+
+  const { row, key, element, plain } = processArgs
+
+  // delete in before phase, create and update in after phase
+  if ((row._op === 'delete') !== !!beforeWrite) return
+
+  const entity = getRootEntity(element)
+  const action = row._op[0].toUpperCase() + row._op.slice(1)
+
+  // create or augment log entry
+  const modificationLog = createLogEntry(modificationLogs, entity, row)
+
+  // process categories
+  for (const category of plain.categories) {
+    if (category === 'ObjectID') {
+      addObjectID(modificationLog, row, key)
+    } else if (category === 'DataSubjectID') {
+      addDataSubject(modificationLog, row, key, entity)
+    } else if (category === 'IsPotentiallyPersonal' || category === 'IsPotentiallySensitive') {
+      _addAttribute(modificationLog, action, row, key)
+    }
+  }
+
+  // add promise to determine data subject if a DataSubjectDetails entity
+  if (
+    element.parent['@PersonalData.EntitySemantics'] === 'DataSubjectDetails' &&
+    modificationLog.dataSubject.id.length === 0 // > id still an array -> promise not yet set
+  ) {
+    addDataSubjectForDetailsEntity(row, modificationLog, req, entity, model)
+  }
+}
+
+const _getDataModificationLogs = (req, tx, diff, beforeWrite) => {
+  const template = getTemplate(
+    `personal_${req.event}`.toLowerCase(),
+    Object.assign({ name: req.target._service.name, model: tx.model }),
+    req.target,
+    { pick: getPick(req.event) }
+  )
+
+  const modificationLogs = {}
+  const processFn = _processorFnModification(modificationLogs, tx.model, req, beforeWrite)
+  templateProcessor({ processFn, row: diff, template })
+
+  return modificationLogs
+}
+
+const _calcModificationLogsHandler = async function (req, beforeWrite, that) {
+  const mapKey = getMapKeyForCurrentRequest(req)
+
+  const modificationLogs = _getDataModificationLogs(req, that, req.context._audit.diffs.get(mapKey), beforeWrite)
+
+  // store modificationLogs in audit data structure at context
+  if (!req.context._audit.modificationLogs) req.context._audit.modificationLogs = new Map()
+  const existingLogs = req.context._audit.modificationLogs.get(mapKey) || {}
+  req.context._audit.modificationLogs.set(mapKey, Object.assign(existingLogs, modificationLogs))
+
+  // execute the data subject promises before going along to on phase
+  // guarantees that the reads are executed before the data is modified
+  await Promise.all(Object.keys(modificationLogs).map(k => modificationLogs[k].dataSubject.id))
+}
+
+const calcModificationLogsHandler4Before = function (req) {
+  return _calcModificationLogsHandler(req, true, this)
+}
+
+const calcModificationLogsHandler4After = function (_, req) {
+  return _calcModificationLogsHandler(req, false, this)
+}
+
+const emitModificationHandler = async function (_, req) {
+  als = als || (await cds.connect.to('audit-log'))
+  if (!als.ready) return
+
+  const modificationLogs = req.context._audit.modificationLogs.get(req.query)
+  const modifications = Object.keys(modificationLogs)
+    .map(k => modificationLogs[k])
+    .filter(ele => ele.attributes.length)
+
+  await resolveDataSubjectPromises(modifications)
+  await als.emit('dataModificationLog', { modifications })
+}
+
+module.exports = {
+  attachDiffToContextHandler,
+  calcModificationLogsHandler4Before,
+  calcModificationLogsHandler4After,
+  emitModificationHandler
+}