@sap/cds 8.9.4 → 9.0.2

package/lib/req/request.js

@@ -1,4 +1,4 @@
-const cds = require('../index'), {production} = cds.env
+const cds = require('../index')
 const { Responses, Errors } = require('./response')
 
 /**
@@ -8,6 +8,11 @@ const { Responses, Errors } = require('./response')
  */
 class Request extends require('./event') {
 
+  constructor(_) { super(_)
+    /** For IntelliSense only: @type import('../ql/cds.ql-Query') */
+    this.query
+  }
+
   toString() { return `${this.event} ${this.path}` }
 
   get assert(){ return super.assert = require('./assert')(this) }
@@ -26,7 +31,7 @@ class Request extends require('./event') {
 
   set entity(e) { if (e) super.entity = e.name ? (this.target = e).name : e }
   get entity() {
-    return this._set ('entity', this.target && this.target.name)
+    return this._set ('entity', this.target?.name)
   }
 
   set params(p) { if (p) super.params = p }
@@ -52,44 +57,41 @@ class Request extends require('./event') {
   set data(d) { if (d) super.data = d }
   get data() {
     const q = this.query; if (!q) return this._set ('data', undefined)
-    const I = q.INSERT || q.UPSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
-    const U = q.UPDATE; if (U) return this._set ('data', U.data ||{})
+    const I = q.INSERT || q.UPSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) || {})
+    const U = q.UPDATE; if (U) return this._set ('data', U.data ??= {})
     return this._set ('data', {})
   }
 
   set subject(d) { if (d) super.subject = d }
   get subject() {
     const q = this.query
-    let subject = (
-      q?.SELECT?.from ||
-      q?.INSERT?.into ||
-      q?.UPSERT?.into ||
-      q?.UPDATE?.entity ||
-      q?.DELETE?.from
-    )
-
-    const {target} = this; if (!target) return undefined
-
-    // programmatic action calls as of now only in format /Books(201)/action
-    if (!subject) {
-      let where = []
-      for (const param of this.params) {
-        if (typeof param === 'object') {
-          for (const key in param) {
-            if (key in target.keys) {
-              if (where.length > 1) where.push('and')
-              where.push({ ref: [key] }, '=', { val: param[key] })
-            }
+    if (q) {
+      let subject = q._subject
+        || q.SELECT?.from
+        || q.INSERT?.into
+        || q.UPSERT?.into
+        || q.UPDATE?.entity
+        || q.DELETE?.from
+      if (!subject) return super.subject = undefined
+      while ('SELECT' in subject) subject = subject.SELECT.from
+      return super.subject = { ref: subject.ref } // REVISIT: copy is neccessary for now, as there's code modifying req.subject
+    }
+
+    const {target} = this; if (!target) return super.subject = undefined
+    const where = []
+    for (const param of this.params) {
+      if (typeof param === 'object') {
+        for (const key in param) {
+          if (key in target.keys) {
+            if (where.length > 1) where.push('and')
+            where.push({ ref: [key] }, '=', { val: param[key] })
           }
-        } else {
-          where.push({ ref: [Object.keys(target.keys)[0]] }, '=', { val: param })
         }
+      } else {
+        where.push({ ref: [Object.keys(target.keys)[0]] }, '=', { val: param })
       }
-      subject = { id: target.name, where }
     }
-
-    const ref = subject.ref || [ subject ]
-
+    const ref = [{ id: target.name, where }]
     return super.subject = { ref }
   }
 
@@ -100,20 +102,17 @@ class Request extends require('./event') {
   notify (...args) { return this._messages.add (1, ...args) }
   info   (...args) { return this._messages.add (2, ...args) }
   warn   (...args) { return this._messages.add (3, ...args) }
-  error  (...args) { return this._errors.add (4, ...args) }
+  error  (...args) { return this._errors.add (null, ...args) }
   reject (...args) {
     if (args.length === 0 && this.errors) {
-      let errs = this.errors
-      if (errs.length === 1) throw errs[0]
-      let me = new cds.error ('MULTIPLE_ERRORS', { details: errs }, this.reject)
-      if (!production) me.stack += errs.map (e => '\n---------------------------------\n'+ e.stack
-        .replace('\n',': '+ (e.element||e.target||'')+'\n---------------------------------\n')
-        .replace(/^Error: /,'')
-      ).join('')
-      throw me
+      if (this.errors.length === 1) throw this.errors[0]
+      const err = new cds.error ('MULTIPLE_ERRORS', { details: this.errors })
+      delete err.stack
+      throw err
     }
     let e = this.error(...args)
-    if (!e.stack) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
+    if (!('stack' in e)) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
+    if (!('message' in e)) e.message = String (e.code || e.status)
     throw e
   }
 
@@ -174,6 +173,11 @@ const _path4 = (x,p) => {
 //
 //  REVISIT: Legacy stuff...
 //
-Object.defineProperties (Request.prototype, {
-  diff: { get: ()=> require('../../libx/_runtime/common/utils/differ').reqDiff }
+Object.defineProperty (Request.prototype, 'diff', {
+  get() {
+    const { reqDiff: diff } = require ('../../libx/_runtime/common/utils/differ')
+    Object.defineProperty (Request.prototype, 'diff', { value: diff })
+    return diff
+  },
+  configurable: true
 })

package/lib/req/response.js

@@ -5,7 +5,7 @@ const placeholders = [...'x'.repeat(9)].map((x,i) => `{${i+1}}`)
  * Messages Collector, used for `req.errors` and `req.messages`
  */
 class Responses extends Array {
-  static get (severity, code, message, target, args) {
+  add (severity, code, message, target, args) {
     let e // be filled in below...
     if (code?.raw) {
       if (typeof message === 'object') {
@@ -30,20 +30,16 @@ class Responses extends Array {
         }
       }
     }
-    if (!e.numericSeverity) e.numericSeverity = severity
+    if (severity) e.numericSeverity ??= severity
+    this.push(e)
     return e
   }
-
-  add (...args) {
-    const response = Responses.get(...args)
-    this.push(response)
-    return response
-  }
 }
 
 class Errors extends Responses {
   push(e) {
-    'stack' in e || Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
+    if ('stack' in e) return super.push (...arguments)
+    else Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
     return super.push(e)
   }
 }

package/lib/req/spawn.js

@@ -0,0 +1,38 @@
+const { EventEmitter } = require('events')
+const EventContext = require('./context')
+
+module.exports = function spawn (o, fn, /** @type {import('../index')} */ 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._with (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
+  em.timer = (
+    o?.every ? setInterval(fx, o.every) :
+    o?.after ? setTimeout(fx, o.after) :
+    setImmediate(fx)
+  ).unref()
+  if (cds.env.server.shutdown_on_uncaught_errors) em.on ('failed', e => {
+    if (cds.error.isSystemError(e)) cds.shutdown(e)
+  })
+  return em
+}

package/lib/req/validate.js

@@ -5,7 +5,6 @@ const cds = require('..')
  * @returns {Error[]|undefined} an array of errors or undefined if no errors occurred
  */
 const conf = module.exports = exports = function validate (data, target, options={}) {
-  if (!target || target._unresolved) return
   const vc = new Validation (data, target, options)
   target.validate (data, null, vc)
   return vc.errors
@@ -18,6 +17,7 @@ class Validation {
   constructor (data, target, options={}) {
     this.data = data
     this.target = target
+    this.protocol = options.protocol
     this.options = options
     this.insert = options.insert ?? options.mandatories
     this.rejectIgnore = options.rejectIgnore
@@ -49,7 +49,7 @@ class Validation {
   }
 
   unknown(e,d,input) {
-    if (e.match(/@.*\./)) return delete input[e] //> skip all annotations, like @odata.Type (according to OData spec annotations contain an "@" and a ".")
+    if (this.protocol === 'odata' && e.match(/^\w*@\w+\.\w+$/)) return delete input[e] //> skip all annotations, like @odata.Type (according to OData spec annotations contain an "@" and a ".")
     d['@open'] || cds.error (`Property "${e}" does not exist in ${d.name}`, {status:400})
   }
 }
@@ -68,9 +68,7 @@ class ValidationErrors extends Array {
     stack: { configurable:true, get() { return this.message },
       set(v) { Object.defineProperty (this, 'stack', { value:v, writable:true, configurable:true }) },
     },
-    code: { value: '400', writable:true }, // REVISIT: should be 'ASSERT_'... (i.e. msg) but we need to adjust all tests, and have a code catalogue
-    statusCode: { value: 400 }, // REVISIT: should go into mappings in adapter's error handlers -> requires a code catalogue // REVISIT: .statusCode vs .status?
-    numericSeverity: { value: 4, enumerable: true }, // REVISIT: that is OData-specific
+    status: { value: 400 },
   })
 }
 exports.ValidationErrors = ValidationErrors
@@ -148,6 +146,7 @@ const $any = class any {
         else return false // joined field which can't be mandatory, e.g. SELECT from Books { author.name as author }
         function alias4 (x) { return x.as || x.ref?.at(-1) }
       }
+      if (d.notNull && !d.default && (d.parent?.kind === 'action' || d.parent?.kind === 'function')) return true // only for action/function params
       else return false
     })
   }
@@ -193,10 +192,9 @@ const $any = class any {
 /** Structs iterate over their elements to validate them. */
 class struct extends $any {
   validate (data, path, /** @type {Validation} */ ctx, elements = this.elements, skip={}) {
-    const path_ = !path ? [] : [...path, this.name]; if (path?.row) path_.push({...path})
     if (data == null) return
-    // REVISIT cds^9: rm typeof data !== 'function', misuse in cds-mtxs
-    if (typeof data !== 'object' && typeof data !== 'function') return ctx.error ('ASSERT_DATA_TYPE', path_, this.name, data, this.target)
+    const path_ = !path ? [] : [...path, this.name]; if (path?.row) path_.push({...path})
+    if (typeof data !== 'object') return ctx.error ('ASSERT_DATA_TYPE', path_, this.name, data, this.target)
     // check for required elements in case of inserts -- note: null values are handled in the payload loop below
     if (ctx.insert || data && path_.length && this._is_insert(data)) for (let each of this._required (elements)) {
       if (each.name in data) continue // got value for required element
@@ -243,6 +241,9 @@ class action extends struct {
   validate (data, path, ctx) {
     super.validate (data, path, ctx, this.params || {})
   }
+
+  // REVISIT: why is e['@mandatory'] not checked here?
+  _is_mandatory(e) { return e.notNull && !e.default } // params
 }
 
 /** Managed associations are struct-like, with foreign keys as elements to validate. */

package/lib/srv/bindings.js

@@ -1,7 +1,8 @@
 
-const cds = require ('..'), {fs} = cds.utils
+const cds = require ('..')
 const LOG = cds.log('serve|bindings',{label:'cds'})
 const registry = '~/.cds-services.json'
+const fs = require('fs')
 
 class Bindings {
 

package/lib/srv/cds-connect.js

@@ -19,7 +19,7 @@ const connect = module.exports = async function cds_connect (options) {
  * or with options configured in cds.env.requires.<datasource>.
  * @param { string|Function|object } [datasource]
  * @param {{ kind?:String, impl?:String }} [options]
- * @returns { Promise<import('./cds.ServiceClient')> }
+ * @returns { Promise<import('./cds.Service')> }
  */
 connect.to = (datasource, options) => {
   let Service = cds.service.factory
@@ -44,7 +44,7 @@ connect.to = (datasource, options) => {
     }
     // construct new service instance
     let srv = await new Service (datasource,m,o); await (Service._is_service_class ? srv.init?.() : Service.init?.(srv))
-    if (o.outbox) srv = cds.outboxed(srv)
+    if (!(srv instanceof cds.DatabaseService) && _is_queued(o)) srv = cds.queued(srv)
     if (datasource && !options) {
       if (datasource === 'db') cds.db = srv
       cds.services[datasource] = srv
@@ -77,3 +77,6 @@ function model4 (o) {
   if (cds.model) return cds.model         // use global model if available
   if (o.model) return cds.load (o.model) // load specified model from file
 }
+
+// at least one option is truthy and none is false
+const _is_queued = o => (o.queued || o.outboxed || o.outbox) && o.queued !== false && o.outboxed !== false && o.outbox !== false

package/lib/srv/cds-serve.js

@@ -3,7 +3,6 @@ const Service = cds.service.factory
 const _pending = cds.services._pending ??= {}
 const _ready = Symbol()
 const TRACE = cds.debug('trace')
-if (TRACE && !cds.env.features.odata_new_adapter) require('./../../libx/_runtime/cds-services/adapter/odata-v4/to')
 
 
 /** @param som - a service name or a model (name or csn) */
@@ -95,7 +94,6 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
     /** Fluent method to serve constructed providers to express app */
     in (app) {
       const { serve } = cds.service.protocols
-      if (!cds.env.features.odata_new_adapter && cds.edmxs) ready = ready.then (()=> cds.edmxs)
       ready = ready.then (()=> all.forEach (each => {
         const d = each.definition || {}
         if (d['@protocol'] === 'none' || d['@cds.api.ignore']) return each._is_dark = true

package/lib/srv/cds.Service.js

@@ -1,131 +1,191 @@
-//////////////////////////////////////////////////////////////
-//
-//  PLEASE DO NOT RUN prettier ON THIS FILE
-//
-//////////////////////////////////////////////////////////////
-
-const cds = require('../index')
 const EventHandlers = require('./srv-handlers')
+const Request = require('../req/request')
+const Event = require('../req/event')
+const cds = require('../index')
 
 
 /**
- * Private base class which contains all model & reflection-related APIs.
+ * This class constitutes the API used by service consumers to send requests, and emit events.
+ *
+ * - `dispatch()` - is the central method ultimately called by all the other methods below.
+ * - `emit()` - is the central method of the **Messaging API** to emit asynchronous event messages.
+ * - `send()` - is the central method of the **Request API** to send synchronous requests.
+ * - `run()` - is the central method of the **Querying API** to execute queries.
+ *
+ * The other methods, like `read`, `create`, `update`, `delete`, are **CRUD-style** syntactical
+ * sugar variants provided for convenience, or **REST-style** like `get`, `put`, `post`, `patch`.
  */
-class ModeledService {
+class ConsumptionAPI {
+
+  async dispatch() {}
+
+  emit (event, data, headers) {
+    if (is_object(event)) return this.dispatch (event instanceof Event ? event : new Event(event))
+    else return this.dispatch (new Event ({ event, data, headers }))
+  }
+
+  send (req, path, data, headers) {
+    if (is_object(req)) return this.dispatch (req instanceof Request ? req : new Request(req))
+    if (is_object(path)) return this.dispatch (new Request (path.is_linked //...
+      ? { method:req, entity:path, data, headers }
+      : { method:req, data:path, headers:data }))
+    else return this.dispatch (new Request({ method:req, path, data, headers }))
+  }
+  schedule (method, path, data, headers) {
+    // not great to normalize args... better way? need to 'merge' with after/every
+    const req = method instanceof cds.Request ? method : new cds.Request(_nrm4skd(method, path, data, headers))
+    return {
+      after (ms) {
+        req.queue ??= {}
+        req.queue.after = ms
+        return this
+      },
+      every (ms) {
+        req.queue ??= {}
+        req.queue.every = ms
+        return this
+      },
+      then: (r, e) => {
+        return cds.queued(this).send(req).then(r, e)
+      }
+    }
+  }
+  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) }
 
   /**
-   * Constructs a new instance. Argument name can be omitted if the model contains only one service.
-   * @param {string} [name] - the name of the service
-   * @param {object} [model] - the CSN model
-   * @param {object} [options] - additional options
-   * @param {string} [options.kind] - the kind of the service
-   * @param {function} [options.impl] - the implementation function
+   * Queries can be passed as one of the following:
+   * - a CQL tagged template string, which is converted into an instance of `cds.ql.Query`
+   * - a CQN object, or an array of such
+   * - a native SQL string, with binging parameters in the second argument `data`
    */
-  constructor (model, name, options={}) {
-    this.name = name || new.target.name
-    this.options = options
-    if (options.kind) this.kind = options.kind // shortcut
-    if (model) this.model = model
+  run (query, data) {
+    if (query.raw) [ query, data ] = [ cds.ql (...arguments) ]
+    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.
+   */
+  foreach (query, data, callback) {
+    if (!callback)  [ data, callback ] = [ undefined, data ]
+    return this.run (query, data) .then (rows => rows.forEach(callback) || rows)
+  }
+
+  // Internal-only API to free resources when tenants offboard
+  /** @protected */ disconnect(tenant) {} // eslint-disable-line no-unused-vars
+}
+
+
+/**
+ * This class provides API used by service providers to reflect
+ * their service definitions from a given model.
+ */
+class ReflectionAPI extends ConsumptionAPI {
 
   /** @param {import('../core/linked-csn').LinkedCSN} csn */
   set model (csn) {
     super.model = csn ? cds.compile.for.nodejs(csn) : undefined
   }
 
-  /**
-   * Lazy get the service definition from this.model
-   * @type import('../core/classes').service
-   */
+  /** @type import('../core/classes').service */
   get definition() {
     const defs = this.model?.definitions; if (!defs) return super.definition = undefined
     return super.definition = defs[this.options.service] || defs[this.name]
   }
-
-  /** The namespace always is the service definition name */
   get namespace()  {
     return super.namespace  = this.definition?.name
     || this.model?.namespace
     || !this.isDatabaseService && !/\W/.test(this.name) && this.name
     || undefined
   }
-
-  // Reflection methods
   get entities()   { return super.entities = this.reflect (d => d.kind === 'entity') }
   get events()     { return super.events   = this.reflect (d => d.kind === 'event') }
   get types()      { return super.types    = this.reflect (d => !d.kind || d.kind === 'type') }
   get actions()    { return super.actions  = this.reflect (d => d.kind === 'action' || d.kind === 'function') }
-  /** @deprecated */ get operations() { return this.actions } // compatibility
-  reflect(filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
+  reflect (filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
 }
 
 
-class Service extends ModeledService {
+/**
+ * This class provides the API used by service providers to add event handlers.
+ * It inherits the ConsumptionAPI and ReflectionAPI.
+ */
+class Service extends ReflectionAPI {
 
-  constructor (name, model, options) {
-    if (typeof name === 'object') {
-      [ model, options ] = [ name, model ]
-      let srv = cds.linked(model).services[0] || cds.error.expected `${{model}} passed as first argument to be a CSN with a single service definition`
-      name = srv.name
-    }
-    super (model, name, options)
+  constructor (name, model, options) { super()
+    if (typeof name === 'object') [ model, options, name = _service_in(model) ] = [ name, model ]
+    this.name = name || new.target.name // i.e. when called without any arguments
+    this.options = options ??= {}
+    if (options.kind) this.kind = options.kind // shortcut, e.g. for 'sqlite', ...
+    if (model) this.model = model
+    this.handlers = new EventHandlers(this)
+    this.decorate()
   }
-
-  /**
-   * Empty init() function to allow custom code to always call super.init()
-   * without having to care for if .init() exists.
-  */
- init(){ return this }
-
- // Event Handlers Registration API
-  handlers = new EventHandlers
-  prepend (fn)      { return this.handlers.prepend.call (this,fn) }
-  before  (...args) { return this.handlers.register (this, 'before', ...args) }
-  on      (...args) { return this.handlers.register (this, 'on',     ...args) }
-  after   (...args) { return this.handlers.register (this, 'after',  ...args) }
-  reject  (e, path) { return this.handlers.register (this, '_initial', e, path,
+  init(){ return this } //> essentially a constructor without arguments
+
+  // Handler registration API
+  prepend (fn) { return this.handlers.prepend.call (this,fn) }
+  /** @typedef {( entity?, path?, handler:(req:import('../req/request'))=>{})=> Service} boa */
+  /** @type boa */ before (...args) { return this.handlers.register (this, 'before', ...args) }
+  /** @type boa */ on     (...args) { return this.handlers.register (this, 'on',     ...args) }
+  /** @type boa */ after  (...args) { return this.handlers.register (this, 'after',  ...args) }
+  reject (e, path) { return this.handlers.register (this, '_initial', e, path,
     r => r.reject (405, `Event "${r.event}" not allowed for entity "${r.path}".`)
   )}
 
-  // Event Dispatching API
-  dispatch (req) {
-    const { dispatch } = require('./srv-dispatch')
-    return (Service.prototype.dispatch = dispatch) .call (this,req)
+   // Overrriding `srv.run()` to additionally allow running a function in a managed transaction.
+  run (fn) {
+    if (typeof fn !== 'function') return super.run (...arguments)
+    if (this.context) return fn(this)                       // if this is already 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
   }
 
-  handle (req) {
-    const { handle } = require('./srv-dispatch')
-    return (Service.prototype.handle = handle) .call (this,req)
-  }
-
-  tx (...args) {
-    return (Service.prototype.tx = require('./srv-tx')) .call (this,...args)
-  }
-
-  /**
-   * @deprecated Flag to control whether this service is extensible.
-   * Can be overridden by subclasses.
-   */
-  get isExtensible() { // REVISIT: can we eliminate this?
-    return this.model === cds.model && !this.name?.startsWith('cds.xt.')
-  }
+  // Inofficial APIs - for internal use only
+  /** @protected */ static _is_service_class = true //> for factory
+  /** @protected */ get endpoints() { return super.endpoints = cds.service.protocols.endpoints4(this) }
+  /** @protected */ set endpoints(p) { super.endpoints = p }
+  /** @protected */ get path() { return super.path = cds.service.protocols.path4(this) }
+  /** @protected */ set path(p) { super.path = p }
 
+  // Deprecated APIs - kept for backwards compatibility
   /** @deprecated */ get _handlers() { return this.handlers }
+  /** @deprecated */ get operations() { return this.actions }
+  /** @deprecated */ get transaction() { return this.tx }
+  /** @deprecated */ get isExtensible() { return this.model === cds.model && !this.name?.startsWith('cds.xt.') }
 }
 
-/** @deprecated */ Service.prototype.transaction = function(...args) { return this.tx(...args) }
-/** @deprecated */ Service.prototype._implicit_next = cds.env.features.implicit_next
-
-Service._is_service_class = true              //> for factory
-
-//--------------------------------------------------------------------------
-// EXPERIMENTAL: It is not decided yet, whether we should keep the stuff below
-// => Please do not use anywhere!
-Service.prototype.onSucceeded = function (...args) { return _req_on (this, 'succeeded', ...args) }
-Service.prototype.onFailed = function (...args) { return _req_on (this, 'failed', ...args) }
-const _req_on = (srv, succeeded_or_failed, event, path, handler) => {
-  if (!handler) [path,handler] = [undefined,path]
-  return srv.before (event,path, req => req.on(succeeded_or_failed,handler))
+const { dispatch, handle } = require('./srv-dispatch')
+Service.prototype.dispatch = dispatch
+Service.prototype.handle = handle
+Service.prototype.tx = require('./srv-tx')
+Service.prototype.decorate = require('./srv-methods')
+
+const is_object = x => typeof x === 'object'
+const is_query = x => x?.bind || Array.isArray(x) && !x.raw
+const is_rest = x => typeof x === 'string' && x[0] === '/'
+const _service_in = m => cds.linked(m).services?.[0]?.name
+|| cds.error.expected `${{model:m}} to be a CSN with a single service definition`
+const _nrm4skd = (method, path, data, headers) => {
+  if (typeof method === 'object') return method
+  if (typeof path !== 'object') return { method, path, data, headers }
+  if (path.is_linked) return { method, entity: path, data, headers }
+  return { method, data: path, headers: data }
 }
 
-module.exports = Service
+
+exports = module.exports = Service
+exports.Service = Service