@cap-js/audit-logging 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -4,11 +4,23 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 0.8.3 - 2025-04-09
+
+- Preperation for `@sap/cds^9`
+
+## Version 0.8.2 - 2024-11-27
+
+### Fixed
+
+- Erroneous modification log for non-updated key properties
+- Error during non-modifying queries on database level
+- Specify charset UTF-8 for requests to SAP Audit Log Service
+
 ## Version 0.8.1 - 2024-09-13
 
 ### Fixed
 
-- Support for @sap/cds^8.2
+- Support for `@sap/cds^8.2`
 - Reduce clutter in error raised for outbound requests
 
 ## Version 0.8.0 - 2024-05-24
@@ -31,7 +43,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Added
 
-- Support for @sap/cds^7.5
+- Support for `@sap/cds^7.5`
 
 ### Fixed
 

package/lib/_relation.js

@@ -0,0 +1,208 @@
+let initializing = false
+
+class Relation {
+  constructor(csn, path = []) {
+    if (!initializing) throw new Error(`Do not new a relation, use 'Relation.to()' instead`)
+    Object.defineProperty(this, 'csn', { get: () => csn })
+    Object.defineProperty(this, 'path', {
+      get: () => path,
+      set: _ => {
+        path = _
+      }
+    })
+    if (csn.target) Object.defineProperty(this, 'target', { get: () => csn.target })
+    initializing = false
+  }
+
+  static to(from, name) {
+    initializing = true
+    if (!name) return new Relation(from)
+    return from._elements[name] && new Relation(from._elements[name], [...from.path, name])
+  }
+
+  _has(prop) {
+    return Reflect.has(this, prop)
+  }
+
+  get _elements() {
+    if (this.csn.elements) return this.csn.elements
+    if (this.csn._target && this.csn._target.elements) return this.csn._target.elements
+    // if (csn.targetAspect) relation.elements = model.definitions[csn.targetAspect].elements
+    // if (csn.kind = 'type') relation.elements = model.definitions[csn.type].element
+    return {}
+  }
+
+  join(fromAlias = '', toAlias = '') {
+    return _getOnCond(this.csn, this.path, { select: fromAlias, join: toAlias })
+  }
+}
+
+const exposeRelation = relation => Object.defineProperty({}, '_', { get: () => relation })
+
+const relationHandler = relation => ({
+  get: (target, name) => {
+    const path = name.split(',')
+    const prop = path.join('_')
+    if (!target[prop]) {
+      if (path.length === 1) {
+        // REVISIT: property 'join' must not be used in CSN to make this working
+        if (relation._has(prop)) return relation[prop]
+        const newRelation = Relation.to(relation, prop)
+        if (newRelation) {
+          target[prop] = new Proxy(exposeRelation(newRelation), relationHandler(newRelation))
+        }
+
+        return target[prop]
+      }
+
+      target[prop] = path.reduce((relation, value) => relation[value] || relation.csn._relations[value], relation)
+      target[prop].path = path
+    }
+
+    return target[prop]
+  }
+})
+
+module.exports = {
+  Relation,
+  exposeRelation,
+  relationHandler
+}
+
+//
+// ----- utils
+//
+
+const _prefixForStruct = element => {
+  const prefixes = []
+  let parent = element.parent
+  while (parent && parent.kind !== 'entity') {
+    prefixes.push(parent.name)
+    parent = parent.parent
+  }
+  return prefixes.length ? prefixes.reverse().join('_') + '_' : ''
+}
+
+const _toRef = (alias, column) => {
+  if (Array.isArray(column)) column = column.join('_')
+  return { ref: alias ? [alias, column] : [column] }
+}
+
+const _adaptRefs = (onCond, path, { select, join }) => {
+  const _adaptEl = el => {
+    const ref = el.ref
+
+    if (ref) {
+      if (ref[0] === path.join('_') && ref[1]) {
+        return _toRef(select, ref.slice(1))
+      }
+
+      // no alias for special $user of canonical localized association
+      if (ref[0] === '$user' && path[0] === 'localized') {
+        return _toRef(undefined, ref.slice(0))
+      }
+
+      return _toRef(join, ref.slice(0))
+    }
+
+    if (el.xpr) return { xpr: el.xpr.map(_adaptEl) }
+    return el
+  }
+
+  return onCond.map(_adaptEl)
+}
+
+const _replace$selfAndAliasOnCond = (xpr, csnElement, aliases, path) => {
+  const selfIndex = xpr.findIndex(({ ref }) => ref?.[0] === '$self')
+  if (selfIndex != -1) {
+    let backLinkIndex
+    if (xpr[selfIndex + 1] && xpr[selfIndex + 1] === '=') backLinkIndex = selfIndex + 2
+    if (xpr[selfIndex - 1] && xpr[selfIndex - 1] === '=') backLinkIndex = selfIndex - 2
+    if (backLinkIndex != null) {
+      const ref = xpr[backLinkIndex].ref
+      const backlinkName = ref[ref.length - 1]
+      const mutOnCond = _newOnConditions(csnElement._backlink, [backlinkName], {
+        select: aliases.join,
+        join: aliases.select
+      })
+
+      xpr.splice(Math.min(backLinkIndex, selfIndex), 3, ...mutOnCond)
+    }
+  }
+
+  for (let i = 0; i < xpr.length; i++) {
+    const element = xpr[i]
+    if (element.xpr) {
+      _replace$selfAndAliasOnCond(element.xpr, csnElement, aliases, path)
+      continue
+    }
+
+    if (element.ref) {
+      if (element.ref[0] === path.join('_') && element.ref[1]) {
+        element.ref = _toRef(aliases.select, element.ref.slice(1)).ref
+        continue
+      }
+
+      // no alias for special $user of canonical localized association
+      if (element.ref[0] === '$user' && path[0] === 'localized') {
+        element.ref = _toRef(undefined, element.ref.slice(0)).ref
+        continue
+      }
+      //no alias for special $now variable
+      if (element.ref[0] === '$now') {
+        continue
+      }
+
+      if (element.ref[0] === aliases.join || element.ref[0] === aliases.select) {
+        // nothing todo here, as already right alias
+        continue
+      }
+
+      element.ref = _toRef(aliases.join, element.ref.slice(0)).ref
+    }
+  }
+}
+
+const _args = (csnElement, path, aliases) => {
+  const onCond = csnElement.on
+  if (!onCond || onCond.length === 0) return []
+  if (onCond.length < 3 && !onCond[0]?.xpr) return onCond
+  if (!csnElement._isSelfManaged) return _adaptRefs(onCond, path, aliases)
+
+  const onCondCopy = JSON.parse(JSON.stringify(onCond))
+  _replace$selfAndAliasOnCond(onCondCopy, csnElement, aliases, path)
+
+  return onCondCopy
+}
+
+// this is only for 2one managed w/o on-conditions, i.e. no static values are possible
+const _foreignToOn = (csnElement, path, { select, join }) => {
+  const on = []
+
+  for (const key of csnElement._foreignKeys) {
+    if (on.length !== 0) {
+      on.push('and')
+    }
+
+    const prefixChild = _prefixForStruct(key.childElement)
+    const ref1 = _toRef(select, prefixChild + key.childElement.name)
+    const structPrefix = path.length > 1 ? path.slice(0, -1) : []
+    const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
+    on.push(ref1, '=', ref2)
+  }
+
+  return on
+}
+
+const _newOnConditions = (csnElement, path, aliases) => {
+  if (csnElement.keys) {
+    return _foreignToOn(csnElement, path, aliases)
+  }
+
+  return _args(csnElement, path, aliases)
+}
+
+const _getOnCond = (csnElement, path = [], aliases = { select: '', join: '' }) => {
+  const onCond = _newOnConditions(csnElement, path, aliases)
+  return [{ xpr: onCond }]
+}

package/lib/modification.js

@@ -76,7 +76,7 @@ const addDiffToCtx = async function (req) {
   if (!_audit.diffs) _audit.diffs = new Map()
 
   // get diff
-  let diff = await req.diff()
+  let diff = (await req.diff()) || {}
   diff = _getDataWithAppliedTransitions(diff, req)
 
   // add keys, if necessary
@@ -88,9 +88,9 @@ const addDiffToCtx = async function (req) {
 }
 addDiffToCtx._initial = true
 
-const _getOldAndNew = (action, row, key) => {
+const _getOldAndNew = (action, row, key, entity) => {
   let oldValue = action === 'Create' ? null : row._old && row._old[key]
-  if (oldValue === undefined) oldValue = null
+  if (oldValue === undefined) oldValue = action === 'Update' && key in entity.keys ? row[key] : null
   else if (Array.isArray(oldValue)) oldValue = JSON.stringify(oldValue)
   let newValue = action === 'Delete' ? null : row[key]
   if (newValue === undefined) newValue = null
@@ -98,9 +98,9 @@ const _getOldAndNew = (action, row, key) => {
   return { oldValue, newValue }
 }
 
-const _addAttribute = (log, action, row, key) => {
+const _addAttribute = (log, action, row, key, entity) => {
   if (!log.attributes.find(ele => ele.name === key)) {
-    const { oldValue, newValue } = _getOldAndNew(action, row, key)
+    const { oldValue, newValue } = _getOldAndNew(action, row, key, entity)
     if (oldValue !== newValue) {
       const attr = { name: key }
       if (action !== 'Create') attr.old = oldValue
@@ -139,7 +139,7 @@ const _processorFnModification = (modificationLogs, model, req, beforeWrite) =>
     } else if (category === 'DataSubjectID') {
       addDataSubject(modificationLog, row, key, entity)
     } else if (category === 'IsPotentiallyPersonal' || category === 'IsPotentiallySensitive') {
-      _addAttribute(modificationLog, action, row, key)
+      _addAttribute(modificationLog, action, row, key, entity)
       // do not log the value of a sensitive attribute
       if (element['@PersonalData.IsPotentiallySensitive']) _maskAttribute(modificationLog.attributes, key)
     }

package/lib/utils.js

@@ -1,5 +1,7 @@
 const cds = require('@sap/cds')
 
+const { Relation, exposeRelation, relationHandler } = require('./_relation')
+
 const WRITE = { CREATE: 1, UPDATE: 1, DELETE: 1 }
 
 const $hasPersonalData = Symbol('@cap-js/audit-logging:hasPersonalData')
@@ -9,7 +11,7 @@ const $visitedUp = Symbol('@cap-js/audit-logging:visitedUp')
 const $visitedDown = Symbol('@cap-js/audit-logging:visitedDown')
 
 const hasPersonalData = entity => {
-  if (!entity.own($hasPersonalData)) {
+  if (entity.own($hasPersonalData) == null) {
     if (!entity['@PersonalData.EntitySemantics']) entity.set($hasPersonalData, false)
     else {
       // default role to entity name
@@ -121,7 +123,22 @@ const _buildSubSelect = (model, { entity, relative, element, next }, row, previo
   const targetAlias = _alias(element._target)
   const relativeAlias = _alias(relative)
 
-  childCqn.where(relative._relations[element.name].join(targetAlias, relativeAlias))
+  if (!('_relations' in relative)) {
+    const newRelation = Relation.to(relative)
+    relative._relations = new Proxy(exposeRelation(newRelation), relationHandler(newRelation))
+  }
+
+  let w = relative._relations[element.name].join(targetAlias, relativeAlias)
+
+  // REVISIT: rewrite to path expression, if alias for relative is already used in subselect to avoid sql error
+  if (previousCqn?._aliases.has(relativeAlias)) {
+    let t
+    for (const a in entity.associations) if (entity.associations[a].target === relative.name) t = entity.associations[a]
+    if (t && w[0]?.xpr) for (const ele of w[0].xpr) if (ele.ref?.[0] === relativeAlias) ele.ref.splice(0, 1, as, t.name)
+  }
+  childCqn._aliases = new Set(previousCqn ? [...previousCqn._aliases.values(), as] : [as])
+
+  childCqn.where(w)
 
   if (previousCqn) childCqn.where('exists', previousCqn)
   else childCqn.where(_addKeysToWhere(keys, row, as))
@@ -147,22 +164,24 @@ const _getDataSubjectIdQuery = ({ dataSubjectEntity, subs }, row, model) => {
 }
 
 const _getUps = (entity, model) => {
-  if (entity.own($parents)) return entity[$parents]
-  const ups = []
-  for (const def of Object.values(model.definitions)) {
-    if (def.kind !== 'entity' || !def.associations) continue
-    for (const element of Object.values(def.associations)) {
-      if (element.target !== entity.name || element._isBacklink || element.name === 'SiblingEntity') continue
-      ups.push(element)
+  if (entity.own($parents) == null) {
+    const ups = []
+    for (const def of Object.values(model.definitions)) {
+      if (def.kind !== 'entity' || !def.associations) continue
+      for (const element of Object.values(def.associations)) {
+        if (element.target !== entity.name || element._isBacklink || element.name === 'SiblingEntity') continue
+        ups.push(element)
+      }
     }
+    entity.set($parents, ups)
   }
-  return entity.set($parents, ups)
+  return entity.own($parents)
 }
 
 const _getDataSubjectUp = (root, model, entity, prev, next, result) => {
   for (const element of _getUps(entity, model)) {
     // cycle detection
-    if (!element.own($visitedUp)) element.set($visitedUp, new Set())
+    if (element.own($visitedUp) == null) element.set($visitedUp, new Set())
     if (element.own($visitedUp).has(root)) continue
     element.own($visitedUp).add(root)
 
@@ -192,7 +211,7 @@ const _getDataSubjectDown = (root, entity, prev, next) => {
   }
   for (const element of associations) {
     // cycle detection
-    if (!element.own($visitedDown)) element.set($visitedDown, new Set())
+    if (element.own($visitedDown) == null) element.set($visitedDown, new Set())
     if (element.own($visitedDown).has(root)) continue
     element.own($visitedDown).add(root)
 
@@ -204,12 +223,14 @@ const _getDataSubjectDown = (root, entity, prev, next) => {
 }
 
 const getDataSubject = (entity, model) => {
-  if (entity.own($dataSubject)) return entity[$dataSubject]
-  // entities with EntitySemantics 'DataSubjectDetails' or 'Other' must not necessarily
-  // be always below or always above 'DataSubject' entity in CSN tree
-  let dataSubjectInfo = _getDataSubjectUp(entity.name, model, entity)
-  if (!dataSubjectInfo) dataSubjectInfo = _getDataSubjectDown(entity.name, entity)
-  return entity.set($dataSubject, dataSubjectInfo)
+  if (entity.own($dataSubject) == null) {
+    // entities with EntitySemantics 'DataSubjectDetails' or 'Other' must not necessarily
+    // be always below or always above 'DataSubject' entity in CSN tree
+    let dataSubjectInfo = _getDataSubjectUp(entity.name, model, entity)
+    if (!dataSubjectInfo) dataSubjectInfo = _getDataSubjectDown(entity.name, entity)
+    entity.set($dataSubject, dataSubjectInfo)
+  }
+  return entity.own($dataSubject)
 }
 
 const _getDataSubjectsMap = req => {
@@ -235,20 +256,29 @@ const addDataSubjectForDetailsEntity = (row, log, req, entity, model) => {
   else map.set(role, _getDataSubjectIdQuery(dataSubjectInfo, row, model))
 }
 
-const resolveDataSubjects = async (logs, req) => {
+const resolveDataSubjects = (logs, req) => {
+  const ps = []
+
   const map = _getDataSubjectsMap(req)
+
   for (const each of Object.values(logs)) {
     if (each.data_subject.id instanceof cds.ql.Query) {
       const q = each.data_subject.id
-      if (map.has(q)) {
-        each.data_subject.id = map.get(q)
-      } else {
-        const res = await q
-        map.set(q, res)
-        each.data_subject.id = res
+      if (!map.has(q)) {
+        const p = cds.run(q).then(res => map.set(q, res))
+        map.set(q, p)
+        ps.push(p)
       }
     }
   }
+
+  return Promise.all(ps).then(() => {
+    for (const each of Object.values(logs)) {
+      if (each.data_subject.id instanceof cds.ql.Query) {
+        each.data_subject.id = map.get(each.data_subject.id)
+      }
+    }
+  })
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/audit-logging",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "CDS plugin providing integration to the SAP Audit Log service as well as out-of-the-box personal data-related audit logging based on annotations.",
   "repository": "cap-js/audit-logging",
   "author": "SAP SE (https://www.sap.com)",

package/srv/log2restv2.js

@@ -80,7 +80,7 @@ module.exports = class AuditLog2RESTv2 extends AuditLogService {
   }
 
   async _send(data, path) {
-    const headers = { 'content-type': 'application/json' }
+    const headers = { 'content-type': 'application/json;charset=utf-8' }
     if (this._vcap) {
       headers.XS_AUDIT_ORG = this._vcap.organization_name
       headers.XS_AUDIT_SPACE = this._vcap.space_name