@sap/cds 8.9.4 → 9.0.2

package/lib/req/cds-context.js

@@ -1,52 +0,0 @@
-const { AsyncLocalStorage } = require ('async_hooks')
-const { EventEmitter } = require('events')
-const { isStandardError } = require('../../libx/_runtime/common/error/standardError')
-const EventContext = require('./context'), ec4 = v => {
-  if (v instanceof EventContext || typeof v !== 'object') return v
-  if (v.context) return v.context
-  else return EventContext.for(v)
-}
-
-module.exports = new class extends AsyncLocalStorage {
-
-  run(v,fn,...args) { return super.run (ec4(v),fn,...args) }
-  enterWith(v) { return super.enterWith (ec4(v)) }
-
-  spawn (o,fn, /** @type {import('../index')} cds */ cds=this) {
-    if (typeof o === 'function') [fn,o] = [o,fn] //> for compatibility
-    if (o instanceof EventContext) throw cds.error `The passed options must not be an instance of cds.EventContext.`
-    const fx = ()=>{
-      const tx = cds.tx({...o}) // create a new detached transaction for each run of the background job
-      return cds._context.run (tx, async ()=> {
-        // REVISIT: The model must be set _after_ run to make sure that cds.context.tenant is correctly set.
-        //          Otherwise, `model4` could query the wrong database to check for extensions.
-        if (cds.model && (cds.env.requires.extensibility || cds.env.requires.toggles)) {
-          const ctx = cds.context
-          const ExtendedModels = require('../srv/srv-models') // the sentinel is automatically started when required
-          cds.context.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
-          tx.model = cds.context.model
-        }
-        return Promise.resolve(fn(tx))
-        .then (tx.commit, e => {
-          cds.log().error(`ERROR occurred in background job:`, e)
-          return tx.rollback(e)
-        })
-        .then (res => Promise.all(em.listeners('succeeded').map(each => each(res))))
-        .catch (err => Promise.all(em.listeners('failed').map(each => each(err))))
-        .finally (() => Promise.all(em.listeners('done').map(each => each())))
-      })
-    }
-    const em = new EventEmitter
-    if (o?.every) {
-      em.timer = setInterval(fx, o.every)
-      em.on('failed', e => { if (isStandardError(e) && cds.env.server.shutdown_on_uncaught_errors) {
-        cds.log().error('❗️Uncaught', e)
-        return cds.shutdown(e)} 
-      })
-      cds.on('shutdown', () => clearInterval(em.timer))
-    } else {
-      em.timer = (o?.after ? setTimeout(fx, o.after) : setImmediate(fx)).unref()
-    }
-    return em
-  }
-}

package/lib/req/locale.js

@@ -1,35 +0,0 @@
-const {i18n} = require('../index').env
-
-function normalized_locale_from (req) {
-  const header = original_locale_from (req); if (!header) return i18n.default_language
-  const locale = header .match (/^[^,; ]*/)[0] .replace (/-/g,'_')
-  return SPECIAL[locale] //> keeps language and region for those in i18n.preserved_locales
-  || locale.match(/[A-Za-z]+/)?.[0].toLowerCase() //> keeps language only
-  || i18n.default_language
-}
-
-function original_locale_from (req) {
-  return !req ? undefined :
-    req.query['sap-locale'] || SAP_LANGUAGES[req.query['sap-language']] ||
-    req.headers['x-sap-request-language'] ||
-    req.headers['accept-language']
-}
-
-const SAP_LANGUAGES = {
-  '1Q': 'en_US_x_saptrc',
-  '2Q': 'en_US_x_sappsd',
-  '3Q': 'en_US_x_saprigi'
-}
-
-const SPECIAL = {
-  ...Object.fromEntries (i18n.preserved_locales.map(l=>[l.toUpperCase(),l])), // REVISIT: why uppercase?
-  ...Object.fromEntries (i18n.preserved_locales.map(l=>[l,l])),
-  en_US_x_saptrc: 'en_US_saptrc',
-  en_US_x_sappsd: 'en_US_sappsd',
-  en_US_x_saprigi: 'en_US_saprigi',
-}
-
-module.exports = Object.assign (normalized_locale_from, {
-  from: normalized_locale_from,
-  raw: original_locale_from
-})

package/lib/srv/cds.ServiceClient.js

@@ -1,96 +0,0 @@
-//////////////////////////////////////////////////////////////
-//
-//  PLEASE DO NOT RUN prettier ON THIS FILE
-//
-//////////////////////////////////////////////////////////////
-
-const cds = require('../index'), { Event, Request } = cds
-const Service = require('./cds.Service')
-
-const is_rest = x => x && typeof x === 'string' && x[0] === '/'
-const is_query = x => x && x.bind || is_array(x) && !x.raw
-const is_array = (x) => Array.isArray(x) && !x.raw
-const is_object = (x) => typeof x === 'object'
-
-class ServiceClient extends Service {
-
-  constructor (...args) {
-    super(...args)
-    this.decorate()
-  }
-
-  /**
-   * Messaging API to emit asynchronous event messages, i.e. instances of `cds.Event`.
-   */
-  emit (event, data, headers) {
-    const eve = event instanceof Event ? event : new Event (
-      is_object(event) ? event
-      : { event, data, headers }
-    )
-    return this.dispatch (eve)
-  }
-
-  /**
-   * REST-style API to send synchronous requests...
-   */
-  send (method, path, data, headers) {
-    const req = method instanceof Request ? method : new Request (
-      is_object(method) ? method :
-      is_object(path) ? path.is_linked ? { method, entity:path, data, headers } : { method, data:path, headers:data }
-      : { method, path, data, headers }
-    )
-    return this.dispatch (req)
-  }
-  get    (...args) { return is_rest(args[0]) ? this.send('GET',   ...args) : this.read   (...args) }
-  put    (...args) { return is_rest(args[0]) ? this.send('PUT',   ...args) : this.update (...args) }
-  post   (...args) { return is_rest(args[0]) ? this.send('POST',  ...args) : this.create (...args) }
-  patch  (...args) { return is_rest(args[0]) ? this.send('PATCH', ...args) : this.update (...args) }
-  delete (...args) { return is_rest(args[0]) ? this.send('DELETE',...args) : DELETE.from (...args).bind(this) }
-
-  /**
-   * Querying API to send synchronous requests...
-   */
-  run (query, data) {
-    if (query.raw) [ query, data ] = [ cds.ql (...arguments) ]
-    else if (typeof query === 'function') {
-      const fn = query; if (this.context) return fn(this)     // if this is a tx -> run fn with this
-      const ctx = cds.context, tx = ctx?.tx                   // is there an (open) outer tx? ...
-      if (!tx || tx._done === 'committed') return this.tx(fn) // no -> run fn with root tx
-      if (tx._done !== 'rolled back') return fn(this.tx(ctx)) // yes -> run fn with nested tx
-      else throw this.tx._is_done (tx._done)                  // throw if outer tx was rolled back
-    }
-    const req = new Request ({ query, data })
-    return this.dispatch (req)
-  }
-  read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT.read(...args).bind(this) }
-  insert (...args) { return INSERT(...args).bind(this) }
-  create (...args) { return INSERT.into(...args).bind(this) }
-  update (...args) { return UPDATE.entity(...args).bind(this) }
-  upsert (...args) { return UPSERT(...args).bind(this) }
-  exists (...args) { return SELECT.one([1]).from(...args).bind(this) }
-
-  /**
-   * Streaming API variant of .run(). Subclasses should override this to support real streaming.
-   * The default implementation doesn't stream, but simply invokes the callback on each row.
-   * The callback function is invoked with (row, index).
-   */
-  foreach (query, data, callback) {
-    if (!callback)  [ data, callback ] = [ undefined, data ]
-    return this.run (query, data) .then (rows => rows.forEach(callback) || rows)
-  }
-
-  /**
-   * Subclasses may override this to free resources when
-   * tenants offboard or the service is disposed.
-   */
-  disconnect (tenant) { // eslint-disable-line no-unused-vars
-    // if (this === cds.db) { //> REVISIT: should go into DatabaseService
-    //   if (!tenant) cds.db = undefined
-    //   else if (this.dbcs) this.dbcs.delete[tenant] // This code is obviously wrong and never tested -> is that required ?!?
-    // }
-    // delete cds.services[this.name] // REVISIT: this is in contrast to some tests
-  }
-}
-ServiceClient.prototype.decorate = require('./srv-methods')
-
-module.exports = ServiceClient

package/lib/srv/cds.ServiceProvider.js

@@ -1,20 +0,0 @@
-//////////////////////////////////////////////////////////////
-//
-//  PLEASE DO NOT RUN prettier ON THIS FILE
-//
-//////////////////////////////////////////////////////////////
-
-const ServiceClient = require('./cds.ServiceClient')
-const cds = require('../index')
-
-
-class ServiceProvider extends ServiceClient {
-
-  get endpoints() { return super.endpoints = cds.service.protocols.endpoints4(this) }
-  set endpoints(p) { super.endpoints = p }
-  get path() { return super.path = cds.service.protocols.path4(this) }
-  set path(p) { super.path = p }
-
-}
-
-module.exports = ServiceProvider

package/lib/srv/protocols/okra.js

@@ -1,22 +0,0 @@
-const cds = require('../../index'), { decodeURI } = cds.utils
-cds.log().info('using legacy OData adapter')
-
-const legacy_adapter4 = require('../../../libx/_runtime/cds-services/adapter/odata-v4/to')
-const LOG = cds.log('okra')
-
-module.exports = function ODataAdapter(srv) {
-  const router = require('express').Router()
-
-  router.use(function odata_log(req, _, next) {
-    let url = decodeURI(req.originalUrl)
-    LOG && LOG(req.method, url, req.body || '')
-    if (/\$batch/.test(req.url)) req._okra_logger = req => {
-      let path = decodeURI(req._.odataReq?._rawODataPath || '')
-      LOG && LOG('>', req.event, path, req._queryOptions || '')
-      if (LOG._debug && req.query) LOG.debug(req.query) //> why only for batch subrequests?
-    }
-    next()
-  })
-  router.use(legacy_adapter4(srv))
-  return router
-}

package/lib/test/axios.js

@@ -1,63 +0,0 @@
-const http = require('http')
-class Axios {
-  get axios() {
-    const axios = require('axios').create ({
-      headers: { 'Content-Type': 'application/json' },
-      httpAgent: new http.Agent({ keepAlive: false}),
-      baseURL: this.url,
-    })
-    // fill in baseURL on subsequent this.url = url, after server has started
-    Reflect.defineProperty (this, 'url', { configurable: true, set: url => {
-      Reflect.defineProperty (this, 'url', { value: url })
-      axios.defaults.baseURL = url
-    }})
-    return super.axios = axios
-  }
-  get     (..._) { return this.axios.get     (..._args(_)) .catch(_error) }
-  put     (..._) { return this.axios.put     (..._args(_)) .catch(_error) }
-  post    (..._) { return this.axios.post    (..._args(_)) .catch(_error) }
-  patch   (..._) { return this.axios.patch   (..._args(_)) .catch(_error) }
-  delete  (..._) { return this.axios.delete  (..._args(_)) .catch(_error) }
-  options (..._) { return this.axios.options (..._args(_)) .catch(_error) }
-
-  /** @type typeof _.get     */ get GET()     { return this.get     .bind (this) }
-  /** @type typeof _.put     */ get PUT()     { return this.put     .bind (this) }
-  /** @type typeof _.post    */ get POST()    { return this.post    .bind (this) }
-  /** @type typeof _.patch   */ get PATCH()   { return this.patch   .bind (this) }
-  /** @type typeof _.delete  */ get DELETE()  { return this.delete  .bind (this) }
-  /** @type typeof _.delete  */ get DEL()     { return this.delete  .bind (this) } //> to avoid conflicts with cds.ql.DELETE
-  /** @type typeof _.options */ get OPTIONS() { return this.options .bind (this) }
-
-}
-
-const _args = (args) => {
-  const first = args[0], last = args[args.length-1]
-  if (first.raw) {
-    if (first[first.length-1] === '' && typeof last === 'object')
-      return [ String.raw(...args.slice(0,-1)), last ]
-    return [ String.raw(...args) ]
-  }
-  else if (typeof first !== 'string')
-    throw new Error (`Argument path is expected to be a string but got ${typeof first}`)
-  return args
-}
-
-const _error = (e) => {
-  if (e.errors) e = e.errors[0] // Node 20 sends AggregationErrors
-  if (e.code && e.port === 80 /* default port */) throw Object.assign (e, {
-    message:  e.message + '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.',
-    stack: null // stack is just clutter here
-  })
-  // Create new instance of Error to overcome AxiosError's inferior and cluttered output
-  const err = new Error (e.message); err.code = e.code
-  Object.defineProperty (err, 'response', { value: e.response, enumerable:false })
-  // Add original error thrown by the service, if exists
-  const o = err.response?.data?.error ; if (!o) throw err
-  err.message = !o.code || o.code == 'null' ? o.message : `${o.code} - ${o.message}`
-  err.cause = o instanceof Error ? o : Object.assign (new Error, o)
-  // Object.defineProperty (o, 'stack', { enumerable:false }) //> allow strict equal checks against {code,message}
-  throw err
-}
-
-const _ = Axios.prototype // eslint-disable-line no-unused-vars
-module.exports = Axios

package/lib/test/data.js

@@ -1,52 +0,0 @@
-const cds = require('../index')
-
-class DataUtil {
-
-  constructor() {
-    // This is to support simplified usage like that: beforeEach(test.data.reset)
-    const {reset} = this; this.reset = (x) => {
-      if (typeof x === 'function') reset.call(this).then(x) // x is the done callback of jest -> no return
-      else if (x?.assert) return reset.call(this) // x is a node --test TestContext object -> ignore
-      else return reset.call(this,x) // x is a db service instance
-    }
-  }
-
-  autoReset() {
-    global.beforeEach (() => this.reset())
-  }
-
-  async deploy(db) {
-    if (!db)  db = await cds.connect.to('db')
-    await cds.deploy.data(db)
-  }
-
-  async delete(db) {
-    if (!db)  db = await cds.connect.to('db')
-    if (!this._deletes) {
-      this._deletes = []
-      for (const entity of db.model.each('entity')) {
-        if (!entity.query && entity['@cds.persistence.skip'] !== true) {
-          this._deletes.push(DELETE.from(entity))
-        }
-        if (entity.drafts) {
-          this._deletes.push(DELETE.from(entity.drafts))
-        }
-      }
-    }
-    if (this._deletes.length > 0) {
-      await db.run(this._deletes)
-    }
-  }
-
-  /* delete + new deploy from csv */
-  async reset(db) {
-    if (!db) db = await cds.connect.to('db')
-    await this.delete(db)
-    await this.deploy(db)
-  }
-
-}
-
-module.exports = DataUtil
-
-/* eslint no-console: off */