@sap/cds 6.0.4 → 6.1.2

package/lib/utils/jest.js

@@ -0,0 +1,43 @@
+let vm = require('vm')
+if (!vm.__caching__) {
+  vm.__caching__ = true
+  const scriptCache = {}
+  vm._Script = vm._Script || vm.Script
+  class CachedScript extends vm._Script {
+    constructor(src, options) {
+      const cached = scriptCache[options.filename]
+      if (cached) {
+        return cached
+      }
+      super(src, options)
+      // Assume that .test.js files are only loaded once
+      if (!options.filename.endsWith('.test.js')) {
+        scriptCache[options.filename] = this
+      }
+    }
+  }
+
+  vm.Script = CachedScript
+}
+vm = undefined
+
+let asyncHooks = require('async_hooks')
+if (!asyncHooks._AsyncLocalStorage) {
+  asyncHooks._AsyncLocalStorage = asyncHooks.AsyncLocalStorage
+  class TmpAsyncLocalStorage extends asyncHooks._AsyncLocalStorage {
+    disable() {
+      if (this._timer) clearTimeout(this._timer)
+      return super.disable()
+    }
+
+    _enable() {
+      if (this._timer) clearTimeout(this._timer)
+      this._timer = setTimeout(() => this.disable(), 60 * 1000)
+      this._timer.unref()
+      return super._enable()
+    }
+  }
+
+  asyncHooks.AsyncLocalStorage = TmpAsyncLocalStorage
+}
+asyncHooks = null

package/lib/utils/resources/index.js

@@ -1,54 +1,44 @@
 const fs = require('fs')
 const path = require('path')
 
-const cds = require('../../../libx/_runtime/cds')
-const { packArchive, packArchiveCLI, unpackArchive, unpackArchiveCLI } = require('./tar')
+const { packArchiveCLI, unpackArchiveCLI } = require('./tar')
 const { exists } = require('./utils')
 
-// use tar command line interface
 const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
 
-const packTarArchive = async (files, root, flat = false, cli = true) => {
-  let tgzBuffer, temp
+const packTarArchive = async (files, root, flat = false) => {
+  if (typeof files === 'string') return await packArchiveCLI(files)
 
+  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
+    for (const file of files) {
+      const fname = flat ? path.basename(file) : path.relative(root, file)
+      const destination = path.join(temp, fname)
+      const dirname = path.dirname(destination)
+      if (!await exists(dirname)) await fs.promises.mkdir(dirname, { recursive: true })
+      await fs.promises.copyFile(file, destination)
     }
 
-    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)
-    }
+    tgzBuffer = await packArchiveCLI(temp)
   } finally {
     if (await exists(temp)) {
-      await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+      await fs.promises.rm(temp, { recursive: true, force: true })
     }
   }
 
   return tgzBuffer
 }
 
-const unpackTarArchive = async (buffer, folder, cli = true) => {
+const unpackTarArchive = async (buffer, folder) => {
   const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
   const tgz = path.join(temp, 'resources.tgz')
   await fs.promises.writeFile(tgz, Buffer.from(buffer), 'binary')
 
   try {
-    cli ? await unpackArchiveCLI(tgz, folder) : await unpackArchive(tgz, folder)
+    await unpackArchiveCLI(tgz, folder)
   } finally {
-    if (await exists(temp)) await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+    if (await exists(temp)) await fs.promises.rm(temp, { recursive: true, force: true })
   }
 }
 

package/lib/utils/resources/tar.js

@@ -1,21 +1,13 @@
 const fs = require('fs')
 const path = require('path')
 const exec = require('child_process').exec
+const cds = require('../../../libx/_runtime/cds')
+const { exists } = require('./utils')
 
-const _createArchive = (files, root) => {
-  const tar = require('tar')
-  return tar.c(
-    {
-      gzip: true,
-      preservePaths: false,
-      cwd: root
-    },
-    files
-  )
-}
+const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
 
-const _createArchiveCLI = (files, root, output) => {
-  const cmd = 'cd ' + root + ' && tar -czf ' + output + ' ' + files.join(' ')
+const _createArchiveCLI = (root, output) => {
+  const cmd = 'tar -zcvf ' + output + ' -C ' + root + '  .'
 
   return new Promise((resolve, reject) => {
     exec(cmd, err => {
@@ -25,32 +17,19 @@ const _createArchiveCLI = (files, root, output) => {
   })
 }
 
-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) => {
-  const tar = require('tar')
-  await tar.x({
-    file: tgz,
-    gzip: true,
-    C: folder
-  })
+const packArchiveCLI = async (root) => {
+  const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
+  const output = path.join(temp, `${cds.utils.uuid()}.tgz`)
+  try {
+    await _createArchiveCLI(root, output)
+
+    return fs.promises.readFile(output)
+  }
+  finally {
+    if (await exists(temp)) {
+      await fs.promises.rm(temp, { recursive: true, force: true })
+    }
+  }
 }
 
 const unpackArchiveCLI = async (tgz, folder) => {
@@ -65,8 +44,6 @@ const unpackArchiveCLI = async (tgz, folder) => {
 }
 
 module.exports = {
-  packArchive,
   packArchiveCLI,
-  unpackArchive,
   unpackArchiveCLI
 }

package/libx/_runtime/auth/index.js

@@ -57,7 +57,7 @@ const _log = (req, challenges) => {
   LOG.debug(`User "${req.user.id}" request URL`, req.url, '\n', ...challengesLog)
 }
 
-const _authCallback = (req, res, next, internalError, user, challenges) => {
+const cap_auth_callback = (req, res, next, internalError, user, challenges) => {
   // An internal error occurs during the authentication process
   if (internalError) {
     // REVISIT: What to do? Security log?
@@ -83,7 +83,7 @@ const _authCallback = (req, res, next, internalError, user, challenges) => {
 
 const _mountCustomAuth = (srv, app, config) => {
   const impl = cds.resolve(config.impl)
-  app.use(srv.path, _require(impl))
+  app.use(_require(impl))
 }
 
 const _mountMockAuth = (srv, app, strategy, config) => {
@@ -92,12 +92,12 @@ const _mountMockAuth = (srv, app, strategy, config) => {
       ? new (require('./strategies/dummy'))()
       : new (require('./strategies/mock'))(config, `mock_${srv.name}`)
 
-  app.use(srv.path, (req, res, next) => {
+  app.use(function cap_auth(req, res, next) {
     let user, challenge
     impl.success = arg => (user = arg)
     impl.fail = arg => (challenge = arg)
     impl.authenticate(req)
-    _authCallback(req, res, next, undefined, user, [challenge])
+    cap_auth_callback(req, res, next, undefined, user, [challenge])
   })
 }
 
@@ -119,10 +119,10 @@ const _mountPassportAuth = (srv, app, strategy, config) => {
   }
 
   // authenticate
-  app.use(srv.path, passport.initialize())
-  app.use(srv.path, (req, res, next) => {
+  app.use(passport.initialize())
+  app.use((req, res, next) => {
     const options = { session: false, failWithError: true }
-    const callback = _authCallback.bind(undefined, req, res, next)
+    const callback = cap_auth_callback.bind(undefined, req, res, next)
     passport.authenticate(strategy === 'jwt' ? 'JWT' : strategy, options, callback)(req, res, next)
   })
 }
@@ -131,7 +131,9 @@ const _mountPassportAuth = (srv, app, strategy, config) => {
  * export authentication middleware
  */
 // eslint-disable-next-line complexity
-module.exports = (srv, app, options) => {
+module.exports = (srv, options = srv.options) => {
+  const handlers = [],
+    app = { use: h => handlers.push(h) }
   // NOTE: options.auth is not an official API
   let config = 'auth' in options ? options.auth : cds.env.requires.auth
   if (!config) {
@@ -147,7 +149,7 @@ module.exports = (srv, app, options) => {
       LOG._warn && LOG.warn(`No authentication configured. This is not recommended in production.`)
     }
     // no auth wanted > return
-    return
+    return handlers
   }
 
   // cds.env.requires.auth = { kind: 'xsuaa-auth' } was briefly documented on capire -> also support
@@ -181,11 +183,12 @@ module.exports = (srv, app, options) => {
     (process.env.NODE_ENV === 'production' && config.credentials && config.restrict_all_services)
   ) {
     if (!logged) LOG._debug && LOG.debug(`Enforcing authenticated users for all services`)
-    app.use(srv.path, _enforce_authenticated_user)
+    app.use(cap_enforce_login)
   }
 
   // so we don't log the same stuff multiple times
   logged = true
+  return handlers
 }
 
 const _strategy4 = config => {
@@ -196,7 +199,7 @@ const _strategy4 = config => {
   throw new Error(`Authentication kind "${config.kind}" is not supported`)
 }
 
-const _enforce_authenticated_user = (req, res, next) => {
+const cap_enforce_login = (req, res, next) => {
   if (req.user && req.user.is('authenticated-user')) return next() // pass if user is authenticated
   if (!req.user || req.user._is_anonymous) {
     if (req.user && req.user._challenges) res.set('WWW-Authenticate', req.user._challenges.join(';'))

package/libx/_runtime/cds-services/adapter/odata-v4/OData.js

@@ -107,8 +107,7 @@ class OData {
   constructor(edm, csn, options = {}) {
     this._validateEdm(edm)
     this._options = options
-    this._csn = csn
-    this._createOdataService(edm)
+    this._createOdataService(edm, csn)
   }
 
   _validateEdm(edm) {
@@ -118,7 +117,7 @@ class OData {
     }
   }
 
-  _createOdataService(edm) {
+  _createOdataService(edm, csn) {
     const ServiceFactory = require('./okra/odata-server').ServiceFactory
 
     // skip okra's validation in production or implicitly for w4 and x4
@@ -133,7 +132,7 @@ class OData {
       effective.odata.proxies ||
       effective.odata.xrefs
 
-    this._odataService = ServiceFactory.createService(edm, _config(edm, this._csn, this._options)).trust(isTrusted)
+    this._odataService = ServiceFactory.createService(edm, _config(edm, csn, this._options)).trust(isTrusted)
 
     // will be added to express app like app.use('/base/path/', service) and odata-v4 wants app.use('/', service) if basePath is set
     this._odataService.setBasePath('/')
@@ -165,8 +164,7 @@ class OData {
         req,
         res
       } = data
-      // REVISIT: _model should not be necessary
-      const tx = (txs[odataContext.id] = cdsService.tx({ user, req, res, _model: cdsService.model }))
+      const tx = (txs[odataContext.id] = cdsService.tx({ user, req, res }))
       cds.context = tx.context
       // for collecting results and errors
       data.results = data.results || {}
@@ -183,19 +181,8 @@ class OData {
       if (errors) {
         // rollback without errors to not trigger srv.on('error') with array
         await tx.rollback()
-        // invoke srv.on('error') for each error and build failedRequests that reflects error modifications
-        errors = odataContext.applicationData.errors[odataContext.id]
-        const failedRequests = {}
-
-        for (const e of errors) {
-          const { error: err, req } = e
-          for (const each of cdsService._handlers._error) each.handler.call(cdsService, err, req)
-          const requestId = req._.odataReq.getOdataRequestId()
-          const { error, statusCode } = normalizeError(err, req)
-          failedRequests[requestId] = Object.assign(error, { statusCode })
-        }
-
-        done(new Error(`Atomicity group "${odataContext.id}" failed`), { failedRequests })
+
+        done()
         return
       }
 
@@ -226,6 +213,7 @@ class OData {
     this._odataService.use(DATA_DELETE_HANDLER, _delete(cdsService))
 
     this._odataService.use(ACTION_EXECUTE_HANDLER, _action(cdsService))
+    return this
   }
 
   /**

package/libx/_runtime/cds-services/adapter/odata-v4/ODataRequest.js

@@ -163,12 +163,9 @@ class ODataRequest extends cds.Request {
        */
       const { user } = req
 
-      // REVISIT: _model should not be necessary
-      const _model = service.model
-
       // REVISIT: public API for query options (express style req.query already in use)?
       const _queryOptions = odataReq.getQueryOptions()
-      super({ event, target, data, query, user, method, headers, req, res, _model, _queryOptions })
+      super({ event, target, data, query, user, method, headers, req, res, _queryOptions })
     }
 
     /*

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/action.js

@@ -77,10 +77,7 @@ const action = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/create.js

@@ -63,10 +63,7 @@ const create = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/delete.js

@@ -44,10 +44,7 @@ const del = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/error.js

@@ -114,13 +114,13 @@ const getErrorHandler = (crashOnError = true, srv) => {
 
     // invoke srv.on('error', function (err, req) { ... }) here in special situations
     // REVISIT: if for compat reasons, remove once cds^5.1
-    if (srv._handlers._error) {
+    if (srv._handlers._error.length) {
       let ctx = cds.context
       if (!ctx) {
         // > error before req was dispatched
         ctx = new cds.Request({ req, res: req.res, user: req.user || new cds.User.Anonymous() })
         for (const each of srv._handlers._error) each.handler.call(srv, err, ctx)
-      } else if (err.getRootCause) {
+      } else {
         // > error after req was dispatched, e.g., serialization error in okra
         for (const each of srv._handlers._error) each.handler.call(srv, err, ctx)
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/metadata.js

@@ -5,10 +5,6 @@ const { toODataResult } = require('../utils/result')
 const { normalizeError } = require('../../../../common/error/frontend')
 const getError = require('../../../../common/error')
 
-const _getMetadata4Tenant = async (tenant, locale, service) => {
-  return await cds.mtx.getEdmx(tenant, service.name, locale)
-}
-
 /**
  * Provide localized metadata handler.
  *
@@ -23,21 +19,12 @@ const metadata = service => {
     const locale = odataRes.getContract().getLocale()
 
     try {
-      let edmx
-
-      if (cds.mtx && service._isExtended) {
-        edmx = await _getMetadata4Tenant(tenant, locale, service)
-      }
-
-      if (!edmx) {
-        edmx = cds.localize(
-          service.model,
-          locale,
-          // REVISIT: we could cache this in a weak map
-          cds.compile.to.edmx(service.model, { service: service.definition.name })
-        )
-      }
-
+      let edmx = cds.localize(
+        service.model,
+        locale,
+        // REVISIT: we could cache this in model._cached
+        cds.compile.to.edmx(service.model, { service: service.definition.name })
+      )
       return next(null, toODataResult(edmx))
     } catch (e) {
       if (LOG._error) {

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/read.js

@@ -81,7 +81,8 @@ const _getCount = async (tx, readReq) => {
     // REVISIT: this process appears to be rather clumsy
     // Copy CQN including from, where and search + changing columns
     const select = SELECT.from(readReq.query.SELECT.from)
-    select.SELECT.columns = [{ func: 'count', args: [{ val: '1' }], as: '$count' }]
+    // { val: 1 } is used on purpose, as "numbers" are not used as param in prepared stmt
+    select.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '$count' }]
 
     if (readReq.query.SELECT.where) select.SELECT.where = readReq.query.SELECT.where
     if (readReq.query.SELECT.search) select.SELECT.search = readReq.query.SELECT.search
@@ -484,10 +485,7 @@ const read = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/request.js

@@ -6,7 +6,7 @@ module.exports = srv => {
   const requires = getRequiresAsArray(srv.definition)
   const restricted = isRestricted(srv)
 
-  return (odataReq, odataRes, next) => {
+  return function ODataRequestHandler(odataReq, odataRes, next) {
     const req = odataReq.getBatchApplicationData()
       ? odataReq.getBatchApplicationData().req
       : odataReq.getIncomingRequest()

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/update.js

@@ -174,10 +174,7 @@ const update = service => {
     } catch (e) {
       err = e
 
-      if (changeset) {
-        // for passing into rollback
-        odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
-      } else {
+      if (!changeset) {
         // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
         await tx.rollback(e).catch(() => {})
       }

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/utils/PrimitiveValueDecoder.js

@@ -68,8 +68,6 @@ const MULTI_LINE_STRING_VALIDATION = new RegExp('^' + SRID + 'MultiLineString\\(
 const MULTI_POLYGON_VALIDATION = new RegExp('^' + SRID + 'MultiPolygon\\((' + MULTI_POLYGON + ')\\)$', 'i')
 const COLLECTION_VALIDATION = new RegExp('^' + SRID + 'Collection\\((' + MULTI_GEO_LITERAL + ')\\)$', 'i')
 
-const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}={2})$/
-
 function _getBase64(val) {
   if (isInvalidBase64string(val)) return
   // convert url-safe to standard base64

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/DeserializerFactory.js

@@ -40,8 +40,10 @@ class DeserializerFactory {
         let additionalInformation = { hasDelta: false }
         const deserializer = new ResourceJsonDeserializer(edm, jsonContentTypeInfo)
         return (edmObject, value) => {
+          const body = deserializer[name](edmObject, value, expand, additionalInformation)
+
           return {
-            body: deserializer[name](edmObject, value, expand, additionalInformation),
+            body,
             expand,
             additionalInformation
           }

package/libx/_runtime/cds-services/adapter/odata-v4/to.js

@@ -1,7 +1,41 @@
-const Dispatcher = require('./Dispatcher')
+const { alias2ref } = require('../../../common/utils/csn') // REVISIT: eliminate that
+const cds = require('../../../cds')
+const OData = require('./OData')
 
-const to = service => {
-  return new Dispatcher(service).getService()
+/**
+ * This is the express handler for a specific OData endpoint.
+ * Note: the same service can be served at different endpoints.
+ */
+module.exports = srv => {
+  const okra = new OkraAdapter(srv)
+  return okra.process.bind(okra)
 }
 
-module.exports = to
+function OkraAdapter(srv, model = srv.model) {
+  const edm = cds.compile.to.edm(model, { service: srv.definition?.name || srv.name })
+  alias2ref(srv, edm) // REVISIT: eliminate that -> done again and again -> search for _alias2ref
+  return new OData(edm, model, srv.options).addCDSServiceToChannel(srv)
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  REVISIT: Move to ExtensibilityService
+//
+if (cds.mtx || cds.requires.extensibility || cds.requires.toggles)
+  module.exports = srv => {
+    const id = `${++unique} - ${srv.path}` // REVISIT: this is to allow running multiple express apps serving same endpoints, as done by some questionable tests
+    return function ODataAdapter(req, res) {
+      const model = cds.context?.model || srv.model
+      if (!model._cached) Object.defineProperty(model, '_cached', { value: {} })
+
+      // Note: cache is attached to model cache so they get disposed when models are evicted from cache
+      let adapters = model._cached._odata_adapters || (model._cached._odata_adapters = {})
+      let okra = adapters[id]
+      if (!okra) {
+        const _srv = { __proto__: srv, _real_srv: srv, model } // REVISIT: we need to do that better in new adapters
+        okra = adapters[id] = new OkraAdapter(_srv, model)
+      }
+      return okra.process(req, res)
+    }
+  }
+let unique = 0

package/libx/_runtime/cds-services/adapter/odata-v4/utils/readAfterWrite.js

@@ -22,10 +22,8 @@ const _isNoAccessError = e => Number(e.code) === 403 || Number(e.code) === 401
 const _isNotFoundError = e => Number(e.code) === 404
 const _isEntityNotReadableError = e => Number(e.code) === 405
 
-const _handleReadError = (err, req) => {
+const _handleReadError = err => {
   if (!(_isNoAccessError(err) || _isEntityNotReadableError(err) || _isNotFoundError(err))) throw err
-  const log = Object.assign(err, { level: 'ERROR', message: normalizeError(err, req).error.message })
-  process.env.NODE_ENV !== 'production' && LOG._warn && LOG.warn(log)
 }
 
 const _getOperationQueryColumns = urlQueryOptions => {

package/libx/_runtime/cds-services/services/utils/differ.js

@@ -18,6 +18,10 @@ module.exports = class Differ {
   _createSelectColumnsForDelete(entity) {
     const columns = []
     for (const element of Object.values(entity.elements)) {
+      // Don't take into account virtual or computed properties to make the diff result
+      // consistent with the ones for UPDATE/CREATE (where we don't have access to that
+      // information).
+      if (!element.key && (element.virtual || element['@Core.Computed'])) continue
       if (element.isComposition) {
         if (element._target._hasPersistenceSkip) continue
         columns.push({

package/libx/_runtime/cds-services/util/errors.js

@@ -9,35 +9,7 @@ const getFeatureNotSupportedError = message => {
   return getError(501, `Feature is not supported: ${message}`)
 }
 
-const getAuditLogNotWrittenError = (rootCauseError, phase, event) => {
-  const errorMessage =
-    !phase || event === 'READ' ? 'Audit log could not be written' : `Audit log could not be written ${phase}`
-  const error = new Error(errorMessage)
-  error.rootCause = rootCauseError
-  return error
-}
-
-const hasBeenCalledError = (method, query) => {
-  return new Error(`Method ${method} has been called before. Invalid CQN: ${JSON.stringify(query)}`)
-}
-
-const unexpectedFunctionCallError = (functionName, expectedFunction) => {
-  return new Error(`Cannot build CQN object. Invalid call of "${functionName}" before "${expectedFunction}"`)
-}
-
-const invalidFunctionArgumentError = (statement, arg) => {
-  const details = JSON.stringify(arg, (key, value) => (value === undefined ? '__undefined__' : value)).replace(
-    /"__undefined__"/g,
-    'undefined'
-  )
-  return new Error(`Cannot build ${statement} statement. Invalid data provided: ${details}`)
-}
-
 module.exports = {
   getModelNotDefinedError,
-  getFeatureNotSupportedError,
-  getAuditLogNotWrittenError,
-  hasBeenCalledError,
-  unexpectedFunctionCallError,
-  invalidFunctionArgumentError
+  getFeatureNotSupportedError
 }

package/libx/_runtime/common/i18n/messages.properties

@@ -74,8 +74,9 @@ ENTITY_IS_NOT_CRUD=Entity "{0}" is not {1}
 ENTITY_IS_NOT_CRUD_VIA_NAVIGATION=Entity "{0}" is not {1} via navigation "{2}"
 ENTITY_IS_AUTOEXPOSED=Entity "{0}" is not explicitly exposed as part of the service
 EXPAND_IS_RESTRICTED=Navigation property "{0}" is not allowed for expand operation
-EXPAND_COUNT_UNSUPPORTED="$count" is not supported for expand operation
+EXPAND_COUNT_UNSUPPORTED="/$count" is not supported for expand operation
 ORDERBY_LAMBDA_UNSUPPORTED="$orderby" does not support lambda
+EXPAND_APPLY_UNSUPPORTED="$apply" is not supported for expand operation
 
 # rest protocol adapter
 INVALID_RESOURCE="{0}" is not a valid resource