@sap/cds 6.1.0 → 6.1.3

package/CHANGELOG.md

@@ -4,6 +4,73 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 6.1.3 - 2022-09-13
+
+### Added
+
+- Configuration to change maximum body size in bytes for remote requests: `cds.env.remote.max_body_length: 1000` sets it to 1 MB
+
+### Changed
+
+- For structured input, foreign keys are generated as non-enumerable properties on application-service layer
+
+### Fixed
+
+- Deep insert/update/upsert requests where the key of an association is provided in a structured format will not be rejected anymore if the target has default or mandatory fields
+- For some configurations, mtxs services were bootstrapped twice
+
+## Version 6.1.2 - 2022-09-05
+
+### Fixed
+
+- Missing key insertion from where clauses in references for deep update statements
+- Prevent duplicate entries for some `INSERT` statements
+- Log details were not properly displayed in Kibana
+- getCsn in model-provider if `cds.requires.toggles` is false
+- HTTP calls in messaging have the correct content length
+- Performance issue for OData <entity>/$count requests
+- Typescript definition for SQL-native variant of `srv.run`, like `srv.run('SELECT * from Authors where name like ?',['%Poe%'])`
+- Typescript definitions for `srv.run( [query] )` and `srv.send( {query, headers} )`
+- Typescript definitions for `cds.log` are improved, level indicators like `cds.log()._debug` added
+- Typescript definitions for `tx` now carry additional service methods
+- `cds login` now returns errors with a better root cause messages
+- `$expand` requests for to-one associations that do not select the foreign key
+- `UPDATE` statement accepts empty objects: `UPDATE('Foo').with({ bar: {} })`
+- URI encoding of parameters in remote service calls
+
+### Removed
+
+## Version 6.1.1 - 2022-08-24
+
+### Added
+
+- The configuration schema now includes `cds.extends` and `new-fields` (in `cds.xt.ExtensibilityService`)
+- `srv.run(fn)` now accepts a function as first argument, which will be run in an active outer transaction, if any, or in a newly created one. This is in contrast to `srv.tx(fn)` which always creates a new tx.
+  ```js
+  cds.run (tx => { // nested operations are guaranteed to run in a tx
+    await INSERT.into (Foo, ...)
+    await INSERT.into (Bar, ...)
+  })
+  ```
+
+### Fixed
+
+- Erroneous checks for `join` in `SELECT.from(SELECT.from('xxx'))`
+- Virtual fields with default values in draft context
+- View resolving without model information doesn't crash
+- Unable to upload large attachments. Uploading a large attachment (base64 encoded) caused a runtime exception.
+- `cds.Query.then()` is using `AsyncResource.runInAsyncScope` from now on. &rarr; this avoids callstacks being cut off, e.g. in debuggers.
+- `cds.tx()` and `cds.context` have been fixed to avoid accidential fallbacks to auto-commit mode.
+- HDI configuration data (e.g. `./cfg`, `.hdiignore`) is now included in the `resources.tgz` file which is required for Streamlined MTX.
+- `cds deploy` accepts in addition to `VCAP_SERVICES` also `TARGET_CONTAINER` and `SERVICE_REPLACEMENTS` from vcap file when using `--vcap-file` parameter.
+- `cds build` doesn't duplicate CSV files that are contained in `db/src/**`.
+- Typescript issues in `apis/log.d.ts`
+- `cds build` adds OS agnostic base model path to generated feature CSN.
+- Unhandled promise rejection in `expand` handling
+- `cds.context.model` middleware is not mounted for not extensible services
+- `cds.context` continuation was sometimes not reset in REST adapter
+- Requests don't fail with `RangeError: Unable to get service from service map due to error: Invalid time value` anymore
+
 ## Version 6.1.0 - 2022-08-10
 
 ### Added

package/apis/log.d.ts

@@ -1,48 +1,124 @@
-/**
- * Returns a trace logger for the given module if trace is switched on for it,
- * otherwise returns null. All cds runtime packages use this method for their
- * trace and debug output.
- * 
- * @see [capire](https://cap.cloud.sap/docs/node.js/cds-log)
- *
- * By default this logger would prefix all output with '[sql] - '.
- * You can change this by specifying another prefix in the options:
- *
- *    const LOG = cds.log('sql|db',{ prefix:'cds.ql' })
- *
- * Call cds.log() for a given module again to dynamically change the log level
- * of all formerly created loggers, for example:
- *
- *    const LOG = cds.log('sql')
- *    LOG.info ('this will show, as default level is info')
- *    cds.log('sql','warn')
- *    LOG.info ('this will be suppressed now')
- * 
- */
 export = cds
 declare class cds {
-    log(name: string, options?: string | number | { level: number, prefix: string }): Logger
+    /**
+     * Create a new logger, or install a custom log formatter
+     */
+    log: LogFactory
+
+    /**
+     * Shortcut to `cds.log(...).debug`, returning `undefined` if `cds.log(...)._debug` is `false`.
+     * Use like this:
+     * ```
+     *   const dbg = cds.debug('foo')
+     *   ...
+     *   dbg && dbg('message')
+     * ```
+     *
+     * @param name logger name
+     */
+    debug(name: string): undefined | Log
 }
 
-class Logger {
+declare type LogFactory = {
     /**
-     * Formats a log outputs by returning an array of arguments which are passed to
-     * console.log() et al.
-     * You can assign custom formatters like that:
+     * Returns a trace logger for the given module if trace is switched on for it,
+     * otherwise returns null. All cds runtime packages use this method for their
+     * trace and debug output.
      *
-     *    cds.log.format = (module, level, ...args) => [ '[', module, ']', ...args ]
+     * By default this logger would prefix all output with `[sql] - `
+     * You can change this by specifying another prefix in the options:
+     * ```
+     *   const LOG = cds.log('sql|db',{ prefix:'cds.ql' })
+     * ```
+     * Call `cds.log()` for a given module again to dynamically change the log level
+     * of all formerly created loggers, for example:
+     * ```
+     *   const LOG = cds.log('sql')
+     *   LOG.info ('this will show, as default level is info')
+     *   cds.log('sql','warn')
+     *   LOG.info ('this will be suppressed now')
+     * ```
+     * @param name logger name
+     * @param options level and prefix
+     * @returns the logger
+     *
+     * @see [capire](https://cap.cloud.sap/docs/node.js/cds-log)
+     */
+    (name: string, options?: string | number | { level?: number, prefix?: string }): Logger
+
+    /**
+     * Set a custom formatter function like that:
+     * ```
+     *   cds.log.format = (module, level, ...args) => [ '[', module, ']', ...args ]
+     * ```
+     *
+     * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
+     *
+     * @param module logger name
+     * @param level log level
+     * @param args additional arguments
      */
     format(module: string, level: number, args: any[]): any[]
-    trace(message?: any, ...optionalParams: any[]): void
-    debug(message?: any, ...optionalParams: any[]): void
-    log(message?: any, ...optionalParams: any[]): void
-    info(message?: any, ...optionalParams: any[]): void
-    warn(message?: any, ...optionalParams: any[]): void
-    error(message?: any, ...optionalParams: any[]): void
 }
 
-declare const levels = {
-    SILENT: 0, ERROR: 1, WARN: 2, INFO: 3, DEBUG: 4, TRACE: 5, SILLY: 5, VERBOSE: 5
+declare class Logger {
+    /**
+     * Logs with 'trace' level
+     */
+    trace: Log
+    /**
+     * Logs with 'debug' level
+     */
+    debug: Log
+    /**
+     * Logs with 'info' level
+     */
+    info: Log
+    /**
+     * Logs with 'warn' level
+     */
+    warn: Log
+    /**
+     * Logs with 'error' level
+     */
+    error: Log
+    /**
+     * Logs with default level
+     */
+    log: Log
+
+    /**
+     * @returns whether 'trace' level is active
+     */
+    _trace: boolean
+    /**
+     * @returns whether 'debug' level is active
+     */
+     _debug: boolean
+    /**
+     * @returns whether 'info' level is active
+     */
+     _info: boolean
+    /**
+     * @returns whether 'warn' level is active
+     */
+     _warn: boolean
+    /**
+     * @returns whether 'error' level is active
+     */
+     _error: boolean
+}
+
+declare type Log = {
+    /**
+     * Logs a message
+     *
+     * @param message text to log
+     * @param optionalParams additional parameters, same as in `console.log(text, param1, ...)`
+     */
+     (message?: any, ...optionalParams: any[]): void
 }
 
-declare const { ERROR, WARN, INFO, DEBUG, TRACE } = levels
+declare enum levels {
+    SILENT = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4, TRACE = 5, SILLY = 5, VERBOSE = 5
+}

package/apis/services.d.ts

@@ -34,7 +34,7 @@ export class QueryAPI {
 	/**
 	 * @see [docs](https://cap.cloud.sap/docs/node.js/services#srv-run)
 	 */
-	run (query : ConstructedQuery) : Promise<ResultSet | any>
+	run (query : ConstructedQuery|ConstructedQuery[]) : Promise<ResultSet | any>
 
 	/**
 	 * @see [docs](https://cap.cloud.sap/docs/node.js/services#srv-run)
@@ -42,6 +42,11 @@ export class QueryAPI {
 	run (query : Query) : Promise<ResultSet | any>
 
 	/**
+	 * @see [docs](https://cap.cloud.sap/docs/node.js/services#srv-run-sql)
+	 */
+	 run (query : string, args? : any[]|object) : Promise<ResultSet | any>
+
+	 /**
 	 * @see [docs](https://cap.cloud.sap/docs/node.js/services#srv-run)
 	 */
 	foreach (query : Query, callback: (row:object) => void) : this
@@ -141,6 +146,12 @@ export class Service extends QueryAPI {
 	send (details: { event: Events, data?: object, headers?: object }) : Promise<this>
 
 	/**
+	 * Constructs and sends a synchronous request.
+	 * @see [capire docs](https://cap.cloud.sap/docs/node.js/services#srv-send)
+	 */
+	send (details: { query: ConstructedQuery, headers?: object }) : Promise<this>
+
+	 /**
 	 * Constructs and sends a GET request.
 	 * @see [capire docs](https://cap.cloud.sap/docs/node.js/services#srv-send)
 	 */
@@ -190,7 +201,7 @@ export class Service extends QueryAPI {
 
 }
 
-export interface Transaction extends QueryAPI {
+export interface Transaction extends Service {
 	commit() : Promise<void>
 	rollback() : Promise<void>
 }

package/bin/build/provider/buildTaskHandlerFeatureToggles.js

@@ -100,17 +100,16 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
         }
         const features = {}
         const options = { ...this.options(), flavor: 'parsed' }
-        const srvFolder = path.relative(destFts, destBase)
 
         // create feature models
         for (const ftName in ftsPaths) {
             const ftCsn = await this.cds.load(ftsPaths[ftName], options)
+            const ftPath = path.join(destFts, this.ftsName, ftName)
 
             // replace require paths by base model path to ensure precedence of feature annos
             // see https://pages.github.tools.sap/cap/docs/cds/compiler-messages#anno-duplicate-unrelated-layer
-            ftCsn.requires = [path.join('../..', srvFolder, DEFAULT_CSN_FILE_NAME)]
+            ftCsn.requires = [path.join(path.relative(ftPath, destBase), DEFAULT_CSN_FILE_NAME).replace(/\\/g,'/')]
 
-            const ftPath = path.join(destFts, this.ftsName, ftName)
             await this.compileToJson(ftCsn, path.join(ftPath, DEFAULT_CSN_FILE_NAME))
             await this._validateFeature(ftPath)
             features[ftName] = ftCsn

package/bin/build/provider/hana/index.js

@@ -106,8 +106,11 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
 
         // 1. copy csv files into 'src/gen/data' or 'src/gen/csv' subfolder
         const promises = []
+        const dbSrc = path.join(src, 'src')
+
         resources.forEach(res => {
-            if (res && /\.csv$/.test(res)) {
+            // do not duplicate resources that are already contained in db/src/**
+            if (res && /\.csv$/.test(res) && !res.startsWith(dbSrc)) {
                 promises.push(this.copy(res).to(path.join(this.task.options.compileDest, csvFolder, path.basename(res))))
             }
         })
@@ -118,7 +121,6 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         blockList += this.hasBuildOption(CONTENT_ENV, false) ? "|\\.env($|\\..*$)" : ""
         blockList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, false) ? "|default-env\\.json$" : ""
         blockList = new RegExp(blockList)
-        const dbSrc = path.join(src, 'src')
 
         await this.copyNativeContent(src, dest, (entry) => {
             if (entry.startsWith(dbSrc)) {

package/bin/build/provider/mtx/resourcesTarBuilder.js

@@ -47,20 +47,16 @@ class ResourcesTarBuilder {
      * Reads all resources for HANA deployment - 'db/src/**' and 'db/undeploy.json'.
      * - CSV files, native HANA artefacts, generated HANA artefacts, undeploy.json
      * See '../../../../lib.deploy'
-     * 
+     * Note: the hana build task has already been executed
      * @param {string} root 
      * @returns an array containing all resources
      */
     _getHanaResources(root) {
-        const hanaSrcFolder = path.join(root, 'src')
-        const undeployJson = path.join(root, 'undeploy.json')
+        const hanaNativeFolders = [path.join(root, 'src'), path.join(root, 'cfg')]
+        const hanaNativeFiles = [path.join(root, 'undeploy.json'), path.join(root, '.hdiignore')]
 
-        // hana build task has already been executed
         return BuildTaskHandlerInternal._find(root, (res) => {
-            if (res === undeployJson) {
-                return true
-            }
-            if (res.startsWith(hanaSrcFolder)) {
+            if (hanaNativeFolders.some(folder => res.startsWith(folder)) || hanaNativeFiles.some(file => res === file)) {
                 return true
             }
             return false

package/bin/deploy/to-hana/hana.js

@@ -35,7 +35,7 @@ class HanaDeployer {
     this.logger = logger;
 
     this.logger.log(`${bold('Starting deploy to SAP HANA ...')}`);
-    if (vcapFile)  {
+    if (vcapFile) {
       this.logger.log();
       this.logger.log(`Using VCAP_SERVICES from file ${vcapFile} (beta feature).`);
       bindCallback = null // credentials are given - no cds bind then
@@ -49,9 +49,9 @@ class HanaDeployer {
 
     const { buildResults } = await this._build(buildTaskOptions, model);
 
-    let vcapServices;
+    let vcapFileEnv;
     if (vcapFile) {
-      vcapServices = await this._loadVCAPServices(vcapFile);
+      vcapFileEnv = await this._loadDefaultEnv(vcapFile);
     }
 
     for (const buildResult of buildResults) {
@@ -71,7 +71,7 @@ class HanaDeployer {
         serviceKeyName = cfServiceInstanceKeyName;
         serviceName = serviceName || cfServiceInstanceName;
 
-        vcapServices = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        vcapFileEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
 
         if (!noSave && !bindCallback) {
           await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
@@ -95,7 +95,7 @@ class HanaDeployer {
         });
       }
 
-      await hdiDeployUtil.deploy(currentModelFolder, vcapServices, hdiOptions);
+      await hdiDeployUtil.deploy(currentModelFolder, vcapFileEnv, hdiOptions);
 
       if (bindCallback) {
         const args = [path.relative(projectPath, buildResult.task.src)];
@@ -204,16 +204,12 @@ class HanaDeployer {
   }
 
 
-  async _loadVCAPServices(vcapFile) {
+  async _loadDefaultEnv(defaultEnvFile) {
     try {
-      const content = JSON.parse(await fs.readFile(vcapFile));
-      if (!content.VCAP_SERVICES) {
-        throw new Error(`The vcap file ${vcapFile} does not contain a VCAP_SERVICES entry.`);
-      }
-
-      return content.VCAP_SERVICES;
+      const content = await fs.readFile(defaultEnvFile);
+      return JSON.parse(content);
     } catch (err) {
-      throw new Error(`Error reading vcap file: ${err.message}`);
+      throw new Error(`Error reading default env file: ${err.message}`);
     }
   }
 
@@ -237,13 +233,10 @@ class HanaDeployer {
       }
 
       const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
-      defaultEnvJson.VCAP_SERVICES = {
-        ...defaultEnvJson.VCAP_SERVICES,
-        ...hanaEntry
-      }
+      Object.assign(defaultEnvJson, hanaEntry);
 
       this.logger.log(`Writing ${defaultEnvJsonPath}`);
-      await fs.mkdir(path.dirname(defaultEnvJsonPath), {recursive: true})
+      await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
       await fs.writeFile(defaultEnvJsonPath, JSON.stringify(defaultEnvJson, null, 2));
     }
   }
@@ -251,13 +244,15 @@ class HanaDeployer {
 
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
-      hana: [
-        {
-          name: serviceInstanceName,
-          tags: ['hana'],
-          credentials: serviceKey
-        }
-      ]
+      VCAP_SERVICES: {
+        hana: [
+          {
+            name: serviceInstanceName,
+            tags: ['hana'],
+            credentials: serviceKey
+          }
+        ]
+      }
     };
   }
 

package/bin/deploy/to-hana/hdiDeployUtil.js

@@ -20,7 +20,10 @@ class HdiDeployUtil {
         await this._executeDeploy(dbDir, env, logger);
     }
 
-    async deploy(dbDir, vcapServices, options = {}) {
+    async deploy(dbDir, vcapEnv, options) {
+        vcapEnv = vcapEnv || {}; // handles null and undefined
+        options = options || {};
+
         LOG.log();
         LOG.log(`Deploying to HANA from ${dbDir}`);
 
@@ -34,7 +37,15 @@ class HdiDeployUtil {
             deployerEnv = hdiDeployLib.clean_env(deployerEnv);
         }
 
-        deployerEnv.VCAP_SERVICES = JSON.stringify(vcapServices);
+        if (vcapEnv.VCAP_SERVICES) {
+            deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
+        }
+        if (vcapEnv.SERVICE_REPLACEMENTS) {
+            deployerEnv.SERVICE_REPLACEMENTS = JSON.stringify(vcapEnv.SERVICE_REPLACEMENTS);
+        }
+        if (vcapEnv.TARGET_CONTAINER) {
+            deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
+        }
 
         if (options.autoUndeploy) {
             LOG.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);

package/lib/dbs/cds-deploy.js

@@ -111,7 +111,7 @@ exports.create = async function (db, csn=db.model, o) {
       console.log(); for (let each of drops) console.log(each)
       console.log(); for (let each of creates) console.log(each,'\n')
       return
-    } else return db.tx (async tx => {
+    } else return db.run (async tx => {
       await tx.run(drops)
       await tx.run(creates)
       return true
@@ -120,7 +120,7 @@ exports.create = async function (db, csn=db.model, o) {
 }
 
 
-exports.init = (db, csn=db.model, log=()=>{}) => db.tx (async tx => {
+exports.init = (db, csn=db.model, log=()=>{}) => db.run (async tx => {
   const resources = await exports.resources(csn, {testdata: cds.env.features.test_data})
   const inits=[]
   for (let [file,e] of Object.entries(resources)) {

package/lib/env/schemas/cds-rc.json

@@ -126,6 +126,10 @@
         }
       }
     },
+    "extends": {
+      "description": "Name of the application that shall be extended",
+      "type": "string"
+    },
     "requires": {
       "type": "object",
       "description": "CDS Dependencies to databases and services can be configured by listing them within a requires section.",
@@ -567,7 +571,7 @@
           "uniqueItems": true,
           "items": {
             "type": "object",
-            "additionalProperties": true,
+            "additionalProperties": false,
             "properties": {
               "for": {
                 "type": "array",
@@ -595,6 +599,11 @@
                 "type": "integer",
                 "description": "Number of fields to be added at most",
                 "minimum": 1
+              },
+              "new-entities": {
+                "type": "integer",
+                "description": "Number of entities to be added at most",
+                "minimum": 1
               }
             }
           }

package/lib/index.js

@@ -73,7 +73,7 @@ const cds = module.exports = extend (new facade) .with ({
   Request: require ('./req/request'),
   Event: require ('./req/event'),
   User: require ('./req/user'),
-  ql: lazy => require ('./ql/cds-ql'),
+  ql: require ('./ql/cds-ql'),
   tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
   /** @type Service */ db: undefined,
 

package/lib/log/format/kibana.js

@@ -56,6 +56,24 @@ module.exports = (module, level, ...args) => {
     if (cf.length) toLog['#cf'] = { string: cf }
   }
 
+  const getCircularReplacer = () => {
+    const seen = new WeakSet()
+    return (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return 'cyclic'
+        }
+        seen.add(value)
+      }
+      return value
+    }
+  }
+  
   // return array with the stringified toLog (to avoid multiple log lines) as the sole element
-  return [util.inspect(toLog, { compact: true, breakLength: Infinity, depth: null })]
+  try {
+    return [JSON.stringify(toLog)]
+  } catch (e) {
+    // try again with removed circular references
+    return [JSON.stringify(toLog, getCircularReplacer())]
+  }
 }

package/lib/ql/Query.js

@@ -1,7 +1,8 @@
+const { AsyncResource } = require('async_hooks')
 const { inspect } = require('util')
 const cds = require('../index')
 
-module.exports = class Query {
+class Query {
 
   constructor(_={}) { this[this.cmd] = _ }
 
@@ -16,8 +17,10 @@ module.exports = class Query {
   }
 
   /** Turns all queries into Thenables which execute with primary db by default */
-  then (r,e) {
-    return (this._srv || cds.db) .run (this) .then (r,e)
+  get then() {
+    const srv = this._srv || cds.db || cds.error `Can't execute query as no primary database is connected.`
+    const q = new AsyncResource('await cds.query')
+    return (r,e) => q.runInAsyncScope (srv.run, srv, this) .then (r,e)
   }
 
   /** Beautifies output in REPL */
@@ -87,3 +90,6 @@ const _target4 = (target, arg2) =>  target && (
 )
 
 const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
+
+
+module.exports = Query

package/lib/ql/SELECT.js

@@ -94,7 +94,7 @@ module.exports = class SELECT extends Whereable {
     return Object.defineProperty(this, '_where_or_having', { value: 'on', configurable: true })
   }
   on (...args) {
-    if (!this.SELECT.from || !this.SELECT.from.join)
+    if (!this.SELECT.from || !this.SELECT.from.join || !this.SELECT.from.args) // `join` can also be a function, e.g. in SELECT.from(SELECT.from('foo'))
       throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
     return this._where (args,'and','on')
   }

package/lib/ql/UPDATE.js

@@ -54,8 +54,8 @@ module.exports = class UPDATE extends Whereable {
       const o = args[0]
       for (let col in o) {
         let op = '=', v = o[col]
-        if (typeof v === 'object' && !(v === null || v.map || v.pipe || v instanceof Buffer || v instanceof Date)) {
-          let o = Object.keys(v)[0] || this._expected `${{v}} to be an object with an operator as single key`
+        if (typeof v === 'object' && !(v === null || v.map || v.pipe || v instanceof Buffer || v instanceof Date || v instanceof RegExp)) {
+          let o = Object.keys(v)[0] //|| this._expected `${{v}} to be an object with an operator as single key`
           if (o in operators) v = v[op=o]
         }
         _add (this, col, op, v && (v.val !== undefined || v.ref || v.xpr || v.func || v.SELECT) ? v : {val:v})

package/lib/ql/cds-ql.js

@@ -1,4 +1,5 @@
 const cds = require('../index')
+const Query = require('./Query')
 require = path => { // eslint-disable-line no-global-assign
   const clazz = module.require (path); if (!clazz._api) return clazz
   Object.defineProperty (clazz.prototype, 'cmd', { value: path.match(/\w+$/)[0] })
@@ -6,12 +7,14 @@ require = path => { // eslint-disable-line no-global-assign
 }
 
 module.exports = Object.assign (_deprecated_srv_ql, { cdr: true,
+  Query,
   SELECT: require('./SELECT'),
   INSERT: require('./INSERT'),
   UPDATE: require('./UPDATE'),
   DELETE: require('./DELETE'),
   CREATE: require('./CREATE'),
   DROP: require('./DROP'),
+  clone(q) { return Query.prototype.clone.call(q) }
 })
 
 function _deprecated_srv_ql() { // eslint-disable-next-line no-console
@@ -22,18 +25,9 @@ function _deprecated_srv_ql() { // eslint-disable-next-line no-console
   return module.exports
 }
 
-if (cds.env.features.cls && cds.env.features.debug_queries) {
-  const Query = require('./Query'), { then } = Query.prototype
-  const { AsyncResource } = require('async_hooks')
-  Object.defineProperty (Query.prototype,'then',{ get(){
-    const q = new AsyncResource('cds.Query')
-    return (r,e) => q.runInAsyncScope (then,this,r,e)
-  }})
-}
-
 module.exports._reset = ()=>{ // for strange tests only
   const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
-  Object.defineProperty (require('./Query').prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {
+  Object.defineProperty (Query.prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {
     return `${cmd} ${_name(this._target.name)} `
   }})
   return this