@sap/cds 5.8.4 → 5.9.0

package/lib/serve/Service-methods.js

@@ -12,53 +12,42 @@ module.exports = (srv) => {
 
 const add_handler_for = (srv, def) => {
   const event = def.name.match(/\w*$/)[0]
+
+  // Use existing methods as handler implementations
   const method = srv[event]
   if (method) {
-    // use existing method as handler
-    if (method._handled || method.name in srv.__proto__) return
-    srv.on (event, ({data}) => {
+    if (method._is_stub || method.name in srv.__proto__.__proto__) return
+    srv.on (event, function ({params,data}) {
       const args = []; if (def.parent) args.push (def.parent)
+      for (let p in params) args.push(params[p])
       for (let p in data) args.push(data[p])
-      return method.apply (srv,args)
+      return method.apply (this,args)
     })
-    method._handled = true
-  } else {
-    // add method to emit request
-    const method = srv[event] = function (...args) {
-      const [$] = args, target = this.entities [ $ && $.name ? $.name.match(/\w*$/)[0] : $ ]
-      const data = {}
-      if (target) { //> it's a bound action
-        def = target.actions[event]; args.shift()
-        // In case of bound actions, first argument(s) are expected to be the target's primary key,
-        // which we need to fill in to named properties in data
-        // object variant of keys, ensure keys are present in args[0] because of complex param
-        if (typeof args[0] === 'object' && Object.keys(target.keys).every(k => k in args[0])) {
-          const keys = args.shift()
-          for (const p in target.keys)  {
-            data[p] = keys[p]
-          }
-        } else { // positional
-          for (let p in target.keys)  {
-            data[p] = args.shift()
-          }
-        }
-        
-      }
-
-      // object variant of params, ensure at least one param is present in args[0]
-      // REVISIT: still not bullet proof, but parameters might be optional
-      if (def.params) {
-        if (args[0] !== null && typeof args[0] === 'object' && args.length === 1 && Object.keys(def.params).some(p => p in args[0])) {
-          const params = args.shift()
-          for (const p in def.params) data[p] = params[p]
-        } else { // positional
-          for (let p in def.params) data[p] = args.shift()
-        }
-      }
+  }
 
-      // REVISIT: What happens with name clashes of keys and params?
-      return this.send ({ event, target, data })
+  // Add stub methods to send request via typed API
+  const stub = srv[event] = function (...args) {
+    const req = { event, data:{} }, $ = args[0]
+    const target = this.entities [ $ && $.name ? $.name.match(/\w*$/)[0] : $ ]
+    if (target) {                        //> bound action/function?
+      req.target = target; args.shift() // first argument is the target entity name
+      req.params = [ args.shift() ]    // second argument is the target's primary key
     }
-    method._handled = true
+    const {params} = target ? target.actions[event] : def
+    if (params) req.data =  _named(args,params) || _positional(args,params)
+    return this.send (req)
   }
+  stub._is_stub = true
 }
+
+
+const _named = (args, declared) => {
+  if (args.length > 1) return
+  const a = args[0]
+  if (! a || typeof a !== 'object') return
+  if (Object.keys(a).every (k => k in declared)) return a
+}
+
+const _positional = (args, declared) => Object.keys(declared).reduce (
+  (data,k,i) => { data[k] = args[i]; return data }, {}
+)

package/lib/serve/Transaction.js

@@ -1,5 +1,7 @@
 const cds = require('../index'), { cds_tx_protection } = cds.env.features
 const EventContext = require('../req/context')
+class RootContext extends EventContext {}
+
 
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
@@ -28,12 +30,10 @@ module.exports = function tx (ctx,fn) { const srv = this
   // `ctx` is a plain context object or undefined
   if (ctx) { // REVISIT: This is for compatibility with AFC only
     if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
-    else {
-      Object.defineProperty(ctx, '_txed_before', { value: EventContext.for(ctx) }) // > must be non-enumerable
-      return RootTransaction.for (srv, ctx._txed_before)
-    }
+    else Object.defineProperty(ctx, '_txed_before', { value: RootContext.for(ctx) }) // > must be non-enumerable
+    return RootTransaction.for (srv, ctx._txed_before)
   }
-  return RootTransaction.for (srv, EventContext.for(ctx))
+  return RootTransaction.for (srv, RootContext.for(ctx))
 }
 
 
@@ -174,8 +174,11 @@ const _begin = async function (req) {
     return this.ready = this.__proto__.dispatch.call (this,req)
   // Protection against unintended tx.run() after tx.commit/rollback()
   if (typeof this.ready === 'string' || !this.ready && this.context._done) {
-    if (cds_tx_protection) throw Object.assign(new Error (`Transaction is ${this.ready || this.context._done}, no subsequent .run allowed, without prior .begin`), { code: 'TRANSACTION_CLOSED' })
-    else this.ready = this.begin() // compatibiliy to former behavior, which allowed tx.run() after commit/rollback
+    if (!cds_tx_protection) this.ready = this.begin() // compatibiliy to former behavior, which allowed tx.run() after commit/rollback
+    else throw cds.error (
+      `Transaction is ${this.ready || this.context._done}, no subsequent .run allowed, without prior .begin`,
+      { code: 'TRANSACTION_CLOSED' }
+    )
   }
   else if (!this.ready) this.ready = this.begin()
   await this.ready

package/lib/serve/adapters.js

@@ -1,6 +1,7 @@
 const lib = require('../../libx/_runtime')
 const registry = {
-  rest: lib.to.rest,
+  rest: lib.to.old_rest,
+  new_rest: lib.to.new_rest,
   odata: lib.to.odata_v4,
   odata_v2: lib.to.odata_v4,
   odata_v4: lib.to.odata_v4,
@@ -11,6 +12,7 @@ const registry = {
 class ProtocolAdapter {
 
   static at (protocol) {
+    if (protocol === 'rest' && global.cds.env.features.rest_new_adapter) protocol = 'new_rest'
     const factory = registry[protocol]; if (factory) return factory
     else throw new Error (`Service protocol ${protocol} is not supported`)
   }
@@ -30,12 +32,12 @@ class ProtocolAdapter {
   /**
   * Mounts the adapter to an express app.
   */
-  in (app) {
-    const srv = this.service
+  in (app, at) {
+    const srv = this.service, path = at || srv.path
     lib.perf (app)
     lib.auth (srv, app, srv.options)
-    app.use (srv.path+'/webapp/', (_,res)=> res.sendStatus(404))
-    app.use (srv.path, this)
+    app.use (path+'/webapp/', (_,res)=> res.sendStatus(404))
+    app.use (path, this)
     return srv
   }
 

package/lib/serve/index.js

@@ -6,8 +6,14 @@ const _ready = Symbol(), _pending = cds.services._pending || {}
 /** @param som - a service name or a model (name or csn) */
 function cds_serve (som, _options) { // NOSONAR
 
-  if (Array.isArray(som) && som.length === 1) som = som[0]
-  else if (typeof som === 'object' && !is_csn(som)) [som,_options] = [undefined,som]
+  if (som && typeof som === 'object' && !is_csn(som)) {
+    [som,_options] = [undefined,
+      som._is_service_instance ? { service:som, from:'*' } :
+      som._is_service_class    ? { service:som, from:'*' } :
+      som
+    ]
+  }
+  else if (Array.isArray(som) && som.length === 1) som = som[0]
   const o = {..._options} // we must not modify inbound data
 
   // 1) Use fluent API to fill in remaining options...
@@ -40,6 +46,11 @@ function cds_serve (som, _options) { // NOSONAR
   // 4) Pass 1: Construct service provider instances...
   const all=[], provided = loaded.then (csn => { // NOSONAR
 
+    // Shortcut for directly passed service instances
+    if (o.service && o.service._is_service_instance) {
+      return all.push (o.service)
+    }
+
     // Shortcut for directly passed service classes
     if (o.service && o.service._is_service_class) {
       const Service = o.service, d = { name: o.service.name }
@@ -47,19 +58,19 @@ function cds_serve (som, _options) { // NOSONAR
     }
 
     // Get relevant service definitions from model...
-    let {services} = csn = cds.linked (cds.compile.for.odata (csn))
-    let specified = o.service
-    if (specified && specified !== 'all') {
+    let {services} = csn = cds.compile.for.nodejs (csn)
+    const required = cds.requires
+    if (o.service && o.service !== 'all') {
       // skip services not chosen by o.service, if specified
-      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}'`)
+      const specified = o.service.split(/\s*,\s*/).map (s => required[s] && required[s].service || s )
+      services = services.filter (s => specified.some (n => s.name.endsWith(n)))
+      if (!services.length) throw cds.error (`No such service: '${o.service}'`)
     }
     services = services.filter (d => !(
       // skip all services marked to be ignored
       d['@cds.ignore'] || d['@cds.serve.ignore'] ||
       // skip external services, unless asked to mock them and unbound
-      cds.requires[d.name] && (!o.mocked || cds.requires[d.name].credentials)
+      required[d.name] && (!o.mocked || required[d.name].credentials)
     ))
     if (services.length > 1 && o.at) {
       throw cds.error `You cannot specify 'path' for multiple services`
@@ -73,11 +84,12 @@ function cds_serve (som, _options) { // NOSONAR
   // Note: doing that in a second pass guarantees all own services are in
   // cds.services, so they'll be found when they cds.connect to each others.
   let ready = provided.then (()=> Promise.all (all.map (async srv => {
+    if (o.service && o.service._is_service_instance) return srv
     srv.init && await srv.prepend (srv.init)
     srv.options.impl && await srv.prepend (srv.options.impl)
     cds.services[srv.name] = cds.service.paths[srv.path] = srv
     cds.service.providers.push (srv)
-    srv[_ready](srv)
+    if (srv[_ready]) srv[_ready](srv)
     return srv
   })))
 
@@ -93,7 +105,7 @@ function cds_serve (som, _options) { // NOSONAR
 
       for (let each of all) {
         each._edm = edms[each.name]
-        ProtocolAdapter.serve(each).in(app)
+        ProtocolAdapter.serve(each,o.to).in(app)
         if (!o.silent) cds.emit ('serving',each)
       }
     })
@@ -105,7 +117,7 @@ function cds_serve (som, _options) { // NOSONAR
     if (all.length === 0) return resolve()
     let response={}
     for (let each of all) {
-      response[each.name] = !each.definition ? each : ProtocolAdapter.serve(each).asRouter()
+      response[each.name] = !each.definition ? each : ProtocolAdapter.serve(each,o.to).asRouter()
     }
     if (all.length === 1 && all[0].name.endsWith (o.service)) {
       response = Object.assign (all[0], response)

package/lib/utils/data.js

@@ -23,7 +23,7 @@ class DataUtil {
   async reset(db) {
     if (!db)  db = await cds.connect.to('db')
     await this.delete(db)
-    await cds.deploy(db.model).to(db, {ddl:false})
+    await cds.deploy.init(db)
   }
 
   autoReset(enabled) { this._autoReset = enabled; return this }

package/lib/utils/index.js

@@ -1,16 +1,17 @@
 const cwd = process.env._original_cwd || process.cwd()
 const path = require ('path'), { dirname, join, resolve, sep, relative } = path
-const fs = require ('fs'), { lstat, access, rm, rmdir, readdir, unlink } = fs.promises
-const rw = fs.constants.R_OK | fs.constants.W_OK
+const fs = require('fs')
 const cds = global.cds
 
-module.exports = exports = {
-  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) }
+const all = module.exports = exports = { ...fs,
+  get inspect() { return $set (this, 'inspect', require('util').inspect) },
+  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) },
 }
 
-exports.local = (file) => '.' + sep + relative(cwd,file)
+exports.fs = all
 exports.path = path
-exports.fs = fs
+
+exports.local = (file) => '.' + sep + relative(cwd,file)
 
 exports.readdir = async function (x) {
   const d = resolve (cds.root,x)
@@ -54,45 +55,41 @@ exports.read = async function read (file, _encoding) {
 }
 
 exports.write = function write (file, data, o) {
-  if (arguments.length === 1) return {to:f => write(f,file)}
-  if (typeof data === 'object') data = JSON.stringify(data, null, ' '.repeat(o && o.spaces))
+  if (arguments.length === 1) return {to:(...path) => write(join(...path),file)}
+  if (typeof data === 'object' && !Buffer.isBuffer(data))
+    data = JSON.stringify(data, null, ' '.repeat(o && o.spaces))
   const f = resolve (cds.root,file)
-  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data))
+  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
 }
 
-exports.mkdirp = async function mkdirp (dir) {
-  const d = resolve (cds.root,dir)
-  try { await access(d,rw) } catch(_) {
-    await mkdirp (dirname(d))
-    try { await fs.promises.mkdir(d) }
-    catch(e) { if (e.code !== 'EEXIST' /*may still happen with parallel calls*/)  throw e }
-  }
+exports.mkdirp = async function (...path) {
+  const d = resolve (cds.root,...path)
+  await fs.promises.mkdir (d,{recursive:true})
   return d
 }
 
-exports.rm = async function rm (x) {
-  const y = resolve (cds.root,x)
-  return unlink(y)
+exports.rmdir = (...path) => {
+  const d = resolve (cds.root,...path)
+  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true})
+}
+
+exports.rimraf = (...path) => {
+  const d = resolve (cds.root,...path)
+  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true,force:true})
 }
 
-exports.rimraf = async function rimraf (dir) {
-  if (rm) return rm (dir, {recursive:true,force:true}) //> added in Node 14
-  const d = resolve(cds.root,dir)
-  const entries = await readdir(d)
-  await Promise.all (entries.map (async each => {
-    const e = join (d,each)
-    const ls = await lstat(e)
-    return ls.isDirectory() ? rimraf(e) : unlink(e)
-  }))
-  return rmdir(d)
+exports.rm = async function rm (x) {
+  const y = resolve (cds.root,x)
+  return (fs.promises.rm || fs.promises.unlink)(y)
 }
 
 exports.copy = async function copy (x,y) {
   const src = resolve (cds.root,x)
   const dst = resolve (cds.root,y)
+  if (fs.promises.cp) return fs.promises.cp (src,dst,{recursive:true})
   await mkdirp (dirname(dst))
   if (isdir(src)) {
-    const entries = await readdir(src)
+    const entries = await fs.promises.readdir(src)
     return Promise.all (entries.map (async each => {
       const e = join (src,each)
       const f = join (src,each)

package/lib/utils/resources/index.js

@@ -0,0 +1,101 @@
+const fs = require('fs')
+const path = require('path')
+
+const cds = require('../../../libx/_runtime/cds')
+const { packArchive, packArchiveCLI, unpackArchive, unpackArchiveCLI } = require('./tar')
+const { exists } = require('./utils')
+
+// use tar command line interface
+const TAR_CLI = true
+const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
+
+const findCsvFiles = async (folder, deep = false) => {
+  const files = await fs.promises.readdir(folder)
+  const result = []
+
+  for (const file of files) {
+    const filePath = path.join(folder, file)
+    if (deep && (await fs.promises.stat(filePath)).isDirectory()) {
+      const files = await findCsvFiles(filePath)
+      result.push(...files)
+    } else {
+      if (path.extname(file) === '.csv') {
+        result.push(filePath)
+      }
+    }
+  }
+
+  return result
+}
+
+const collectCsvFiles = async sources => {
+  const folders = sources.map(file => path.dirname(file))
+  const uniqueFolders = [...new Set(folders)].filter(folder => !/node_modules/.test(folder))
+  const db = (cds.env.folders && cds.env.folders.db) || 'db/'
+  let dbFolder = path.join(global.cds.root, db)
+  if (dbFolder.endsWith('/') || dbFolder.endsWith('\\')) dbFolder = dbFolder.slice(0, -1)
+  if (!uniqueFolders.includes(dbFolder)) uniqueFolders.push(dbFolder)
+
+  const result = []
+  for (const folder of uniqueFolders) {
+    const dataPath = path.join(folder, 'data')
+    const dataFiles = (await exists(dataPath)) ? await findCsvFiles(dataPath) : []
+    const csvPath = path.join(folder, 'csv')
+    const csvFiles = (await exists(csvPath)) ? await findCsvFiles(csvPath) : []
+    result.push(...dataFiles, ...csvFiles)
+  }
+
+  return result
+}
+
+const packTarArchive = async (files, root, flat = false, cli = true) => {
+  let tgzBuffer, temp
+
+  try {
+    temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
+    if (flat) {
+      const files_ = []
+      for (const file of files) {
+        const destination = path.join(temp, path.basename(file))
+        await fs.promises.copyFile(file, destination)
+        files_.push(destination)
+      }
+      files = files_
+      root = temp
+    }
+
+    const relativeFiles = files.map(file => path.relative(root, file))
+    if (cli) {
+      const output = path.relative(root, path.join(temp, `${cds.utils.uuid()}.tgz`))
+      tgzBuffer = await packArchiveCLI(relativeFiles, root, output)
+    } else {
+      tgzBuffer = await packArchive(relativeFiles, root)
+    }
+  } finally {
+    if (await exists(temp)) {
+      await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+    }
+  }
+
+  return tgzBuffer
+}
+
+const unpackTarArchive = async (buffer, folder, cli = true) => {
+  const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
+  const tgz = path.join(temp, 'resources.tgz')
+  await fs.promises.writeFile(tgz, buffer, 'binary')
+
+  try {
+    cli ? await unpackArchiveCLI(tgz, folder) : await unpackArchive(tgz, folder)
+  } finally {
+    if (await exists(temp)) await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+  }
+}
+
+module.exports = {
+  TAR_CLI,
+  findCsvFiles,
+  collectCsvFiles,
+  packTarArchive,
+  unpackTarArchive
+}

package/lib/utils/resources/tar.js

@@ -0,0 +1,71 @@
+const fs = require('fs')
+const path = require('path')
+const tar = require('tar')
+const exec = require('child_process').exec
+
+const _createArchive = (files, root) => {
+  return tar.c(
+    {
+      gzip: true,
+      preservePaths: false,
+      cwd: root
+    },
+    files
+  )
+}
+
+const _createArchiveCLI = (files, root, output) => {
+  const cmd = 'cd ' + root + ' && tar -czf ' + output + ' ' + files.join(' ')
+
+  return new Promise((resolve, reject) => {
+    exec(cmd, err => {
+      if (err) reject(err)
+      else resolve()
+    })
+  })
+}
+
+const packArchive = (files, root) => {
+  _createArchive(files, root)
+  const stream = _createArchive(files, root)
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    stream.on('data', data => chunks.push(data))
+    stream.on('error', error => reject(error))
+    stream.on('end', () => {
+      resolve(Buffer.concat(chunks))
+    })
+  })
+}
+
+const packArchiveCLI = async (files, root, output) => {
+  await _createArchiveCLI(files, root, output)
+
+  return fs.promises.readFile(path.join(root, output))
+}
+
+const unpackArchive = async (tgz, folder) => {
+  await tar.x({
+    file: tgz,
+    gzip: true,
+    C: folder
+  })
+}
+
+const unpackArchiveCLI = async (tgz, folder) => {
+  const cmd = 'tar -xzf ' + tgz + ' -C ' + folder
+
+  return new Promise((resolve, reject) => {
+    exec(cmd, err => {
+      if (err) reject(err)
+      else resolve()
+    })
+  })
+}
+
+module.exports = {
+  packArchive,
+  packArchiveCLI,
+  unpackArchive,
+  unpackArchiveCLI
+}

package/lib/utils/resources/utils.js

@@ -0,0 +1,11 @@
+const fs = require('fs')
+
+const exists = async fileOrDir => {
+  try {
+    return await fs.promises.stat(fileOrDir)
+  } catch (_) {
+    return false
+  }
+}
+
+module.exports = { exists }

package/libx/_runtime/audit/Service.js

@@ -15,23 +15,23 @@ module.exports = class AuditLogService extends OutboxService {
     // call OutboxService's init, which handles outboxing
     await super.init()
 
-    // register handlers
-    this.on('dataAccessLog', this.dataAccessLog)
-    this.on('dataModificationLog', this.dataModificationLog)
-    this.on('securityLog', this.securityLog)
-    this.on('configChangeLog', this.configChangeLog)
-
     // connect to audit log service
-    // REVISIT for GA: throw error on connect issue instead of warn and this.ready?
     this.alc = await v2utils.connect(this.options.credentials)
-    this.ready = !!this.alc
+
+    // register handlers, if connected
+    if (this.alc) {
+      this.on('dataAccessLog', this._dataAccessLog)
+      this.on('dataModificationLog', this._dataModificationLog)
+      this.on('securityLog', this._securityLog)
+      this.on('configChangeLog', this._configChangeLog)
+    }
   }
 
   async emit(first, second) {
     const { event, data } = typeof first === 'object' ? first : { event: first, data: second }
     if (!this.options.outbox) return this.send(event, data)
 
-    if (this.ready && this[event]) {
+    if (this[event]) {
       try {
         // this will open a new tx -> preserve user
         await super.send(new cds.Request({ method: event, data, user: cds.context.user }))
@@ -45,14 +45,34 @@ module.exports = class AuditLogService extends OutboxService {
   }
 
   async send(event, data) {
-    if (this.ready && this[event]) return super.send(event, data)
+    if (this[event]) return super.send(event, data)
+  }
+
+  /*
+   * api (await AuditLogService.<event>(data))
+   */
+
+  async dataAccessLog(data) {
+    return super.send('dataAccessLog', data)
   }
 
-  async dataAccessLog(arg) {
-    const accesses = arg.accesses || arg.data.accesses
+  async dataModificationLog(data) {
+    return super.send('dataModificationLog', data)
+  }
 
-    if (!this.ready) throw new Error('AuditLogService not connected')
+  async securityLog(data) {
+    return super.send('securityLog', data)
+  }
+
+  async configChangeLog(data) {
+    return super.send('configChangeLog', data)
+  }
 
+  /*
+   * impl
+   */
+
+  async _dataAccessLog({ data: { accesses } }) {
     const { tenant, user } = _getTenantAndUser()
 
     // build the logs
@@ -73,11 +93,7 @@ module.exports = class AuditLogService extends OutboxService {
   }
 
   // REVISIT: modification.action not used in auditlog v2
-  async dataModificationLog(arg) {
-    const modifications = arg.modifications || arg.data.modifications
-
-    if (!this.ready) throw new Error('AuditLogService not connected')
-
+  async _dataModificationLog({ data: { modifications } }) {
     const { tenant, user } = _getTenantAndUser()
 
     // build the logs
@@ -97,15 +113,7 @@ module.exports = class AuditLogService extends OutboxService {
     }
   }
 
-  async securityLog(arg) {
-    let { action, data } = arg
-    if (arg.data && arg.data.action) {
-      action = arg.data.action
-      data = arg.data.data
-    }
-
-    if (!this.ready) throw new Error('AuditLogService not connected')
-
+  async _securityLog({ data: { action, data } }) {
     let { tenant, user } = _getTenantAndUser()
 
     // cds.context may not be proper on auth-related errors -> try to extract from data
@@ -132,18 +140,7 @@ module.exports = class AuditLogService extends OutboxService {
   }
 
   // REVISIT: action and success not used in auditlog v2
-  async configChangeLog(arg) {
-    let { action, success, configurations } = arg
-    if (arg.data) {
-      // eslint-disable-next-line no-unused-vars
-      action = arg.data.action
-      // eslint-disable-next-line no-unused-vars
-      success = arg.data.success
-      configurations = arg.data.configurations
-    }
-
-    if (!this.ready) throw new Error('AuditLogService not connected')
-
+  async _configChangeLog({ data: { action, success, configurations } }) {
     const { tenant, user } = _getTenantAndUser()
 
     // build the logs

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

@@ -13,7 +13,7 @@ const {
   resolveDataSubjectPromises
 } = require('./utils')
 
-let als
+let auditLogService
 
 const _processorFnAccess = (accessLogs, model, req) => {
   return ({ row, key, element, plain }) => {
@@ -70,15 +70,14 @@ const _getDataAccessLogs = (data, req, tx) => {
 }
 
 const auditAccessHandler = async function (data, req) {
-  als = als || (await cds.connect.to('audit-log'))
-  if (!als.ready) return
+  auditLogService = auditLogService || (await cds.connect.to('audit-log'))
 
   const accessLogs = _getDataAccessLogs(data, req, this)
   // REVISIT: a function called resolveDataSubjectPromises should not also convert an object to an array
   let accesses = await resolveDataSubjectPromises(accessLogs)
   accesses = accesses.filter(ele => ele.attributes.length)
 
-  if (accesses.length) await als.emit('dataAccessLog', { accesses })
+  if (accesses.length) await auditLogService.emit('dataAccessLog', { accesses })
 }
 
 module.exports = {