@sap/cds 5.8.4 → 5.9.2

package/lib/serve/factory.js

@@ -1,5 +1,6 @@
-const cds = require('..')
-const { path, isfile } = cds.utils
+const cds = require('..'), { path, isfile } = cds.utils
+const paths = Array.from (new Set ([ cds.root, ...require.resolve.paths('x') ]))
+const DEBUG = cds.debug('srv.factory'); DEBUG && DEBUG ({ 'cds.root':cds.root, paths })
 
 /** @typedef {import('./Service-api')} Service @type { (()=>Service) & (new()=>Service) } */
 const ServiceFactory = function (name, model, options) { //NOSONAR
@@ -8,6 +9,7 @@ const ServiceFactory = function (name, model, options) { //NOSONAR
   const serve = !cds.requires[name] || o.mocked
   const defs = !model ? {[name]:{}} : model.definitions || cds.error (`Invalid argument for 'model': ${model}`)
   const def = !name || name === 'db' ? {} : defs[name] || {}
+  DEBUG && DEBUG ({ name, definition:def, options:o })
 
   let it /* eslint-disable no-cond-assign */
   if (it = o.with)                 return _use (it) // from cds.serve (<options>)
@@ -27,21 +29,24 @@ const ServiceFactory = function (name, model, options) { //NOSONAR
 
   function _required() {
     const kind = o.kind = serve && def['@kind'] || o.kind || 'app-service'
-    if (_required[kind]) return _required[kind]
+    if (_require[kind]) return _require[kind]
     const {impl} = cds.requires[kind] || cds.error (`No configuration found for 'cds.requires.${kind}'`)
-    return _required[kind] = _require (impl || cds.error (`No 'impl' configured for 'cds.requires.${kind}'`))
+    DEBUG && DEBUG ('requires',{kind,impl})
+    return _require[kind] = _require (impl || cds.error (`No 'impl' configured for 'cds.requires.${kind}'`))
   }
 }
 
 const _require = (it,d) => {
-  if (it.startsWith('@sap/cds/')) it = cds.home + it.slice(8)    //> for local tests in @sap/cds dev
-  else if (it.startsWith('./')) it = _relative (d, it.slice(2)) //> relative to <service>.cds
-  else if (it.startsWith('//')) it = path.resolve (cds.root,it.slice(2)) //> relative to cds.root
-  try { var resolved = require.resolve(it) } catch(e) {
+  DEBUG && d && DEBUG ('requires',{ service: d.name, source:_source(d), impl:it })
+  if (it.startsWith('@sap/cds/')) it = cds.home + it.slice(8)  //> for local tests in @sap/cds dev
+  if (it.startsWith('./')) it = _relative (d,it.slice(2))     //> relative to <service>.cds
+  try { var resolved = require.resolve(it,{paths}) } catch(e) {
     try { resolved = require.resolve(it = path.resolve(cds.root,it)) } catch(e) { // for compatibility
+      DEBUG && DEBUG (`Failed loading service implementation from '${it}'`, { 'cds.root':cds.root, paths })
       throw cds.error(`Failed loading service implementation from '${it}'`)
     }
   }
+  DEBUG && DEBUG({resolved})
   return require(resolved)
 }
 
@@ -59,7 +64,7 @@ const sibling = (d) => {
     let found
     if (process.env.CDS_TYPESCRIPT === 'true') found = isfile(path.join(home, each, file + '.ts'))
     if (!found) found = isfile(path.join(home, each, file + '.js'))
-    if (found)  return found
+    if (found)  return found //> equiv to '.'+found.slice(home.length)
   }
 }
 

package/lib/serve/index.js

@@ -1,13 +1,19 @@
-const { ProtocolAdapter } = require('./adapters')
-const { Service } = require('./factory')
 const cds = require ('..')
+const { ProtocolAdapter } = cds.service.adapters
+const { Service } = cds.service.factory
 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,26 +46,32 @@ 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 }
-      return all.push (_new (Service, d,csn,o))
+      const srv = _new (Service, d,csn,o)
+      return all.push (srv)
     }
 
     // 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 +85,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 +106,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 +118,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 = {

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

@@ -14,7 +14,7 @@ const {
   resolveDataSubjectPromises
 } = require('./utils')
 
-let als
+let auditLogService
 
 const attachDiffToContextHandler = async function (req) {
   // store diff in audit data structure at context
@@ -112,15 +112,14 @@ const calcModificationLogsHandler4After = function (_, req) {
 }
 
 const emitModificationHandler = async function (_, req) {
-  als = als || (await cds.connect.to('audit-log'))
-  if (!als.ready) return
+  auditLogService = auditLogService || (await cds.connect.to('audit-log'))
 
   const modificationLogs = req.context._audit.modificationLogs.get(req.query)
   const modifications = Object.keys(modificationLogs)
     .map(k => modificationLogs[k])
     .filter(log => log.attributes.length)
 
-  await als.emit('dataModificationLog', { modifications })
+  await auditLogService.emit('dataModificationLog', { modifications })
 }
 
 module.exports = {

package/libx/_runtime/audit/utils/v2.js

@@ -9,8 +9,7 @@ function connect(credentials) {
     try {
       auditLogging = require('@sap/audit-logging')
     } catch (e) {
-      LOG._warn &&
-        LOG.warn('Unable to require module @sap/audit-logging. Make sure it is installed if audit logging is required.')
+      // not able to require lib -> no audit logging ootb
       return resolve()
     }
     try {