@cap-js/audit-logging 0.8.2 → 0.9.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.9.0 - 2025-06-05
+
+### Added
+
+- Support for `@sap/cds^9`
+
+## Version 0.8.3 - 2025-04-09
+
+### Fixed
+
+- Preperation for `@sap/cds^9`
+
 ## Version 0.8.2 - 2024-11-27
 
 ### Fixed
@@ -16,7 +28,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### 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
@@ -39,7 +51,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/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')
@@ -121,6 +123,12 @@ const _buildSubSelect = (model, { entity, relative, element, next }, row, previo
   const targetAlias = _alias(element._target)
   const relativeAlias = _alias(relative)
 
+  // REVISIT: there seems to be a caching issue in cds^9 when elemets are renamed
+  if (!('_relations' in relative) || !relative._relations[element.name]) {
+    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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cap-js/audit-logging",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "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)",
   "homepage": "https://cap.cloud.sap/",
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "Apache-2.0",
   "main": "cds-plugin.js",
   "files": [
     "lib",
@@ -14,21 +14,19 @@
   ],
   "scripts": {
     "lint": "npx eslint .",
-    "test": "npm run test-new-db && npm run test-old-db",
-    "test-new-db": "CDS_ENV='better-sqlite' npx jest --silent",
-    "test-old-db": "CDS_ENV='legacy-sqlite' npx jest --silent"
+    "test": "npx jest --silent"
   },
   "peerDependencies": {
-    "@sap/cds": ">=7"
+    "@sap/cds": ">=8"
   },
   "devDependencies": {
     "@cap-js/audit-logging": "file:.",
-    "@cap-js/sqlite": "^1",
+    "@cap-js/cds-test": ">=0",
+    "@cap-js/sqlite": ">=1",
     "axios": "^1",
     "eslint": "^9",
     "express": "^4",
-    "jest": "^29",
-    "sqlite3": "^5.1.6"
+    "jest": "^29"
   },
   "cds": {
     "requires": {

package/srv/service.js

@@ -1,8 +1,6 @@
 const cds = require('@sap/cds')
 
-const Base = cds.outboxed ? cds.Service : require('@sap/cds/libx/_runtime/messaging/Outbox')
-
-module.exports = class AuditLogService extends Base {
+module.exports = class AuditLogService extends cds.Service {
   async init() {
     // add common audit log entry fields
     this.before('*', req => {