@sap/cds 6.0.3 → 6.1.1

package/CHANGELOG.md

@@ -4,6 +4,152 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## 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. → 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
+
+- Detailed information about pool state: `borrowed`, `pending`, `size`, `available`, `max` to the timeout error
+- Odata v2 payloads for `cds.Time` are converted from hh:mm:ss to PThhHmmMssS e.g. 12:34:56 to PT12H34M56S if provided in hh:mm:ss format
+- Odata v2 payloads for `cds.Integer` are converted to String if not provided as String
+- New OData parser supports aliased parameters e.g. `...function(ID=@p)?@p=5`
+- Support for locale "en_US_x_saprigi"
+- Parameter `rows` in ql API function `limit` can be omitted for remote services, e.g. `SELECT.limit(undefined, 5)`
+- New OData parser supports $filter with "in" operator, e.g. `$filter=ID in (1,2,3)`
+- `cds build` copies `package.json` and `.cdsrc.json` into _main folder of MTX sidecar app.
+- New OData parser supports null parameter in function/action, e.g `/findBooks(author=1,title=null)`
+- New enviroment variable `schemas` contains locations for json schemas validating `package.json`, `.cdsrc.json` and `.cdsrc-private.json` in VS Code
+- `cds.test` can now listen on a fixed port by way of additional arguments '--port', '<PORT_NUMBER>
+- `cds.requires.db.kind = 'sql-mt'` is introduced as a shorthand for
+  ```js
+  "db": {
+    "kind": "sqlite",
+    "[production]": {
+      "kind": "hana-mt"
+    }
+  }
+  ```
+- `cds build` support for Streamlined MTX extension projects based on build task `mtx-extension`
+- TS definitions for `SELECT.forSharedLock` and `SELECT.forUpdate`
+- TS definitions for `log`
+- Support for new cds build task option `deploy-format`. Java apps may use this option instead of the corresponding global CDS config option.
+- The `ExtensibilityService` serves an endpoint to retrieve a subdomain-specific JWT, which is used by `cds login`
+- The endpoint `/-/cds/extensibility/push` now checks restrictions for new extensions. The configuration is added to the `cds.xt.ExtensibilityService`
+  ```js
+  "requires": {
+    "cds.xt.ExtensibilityService": {
+      "element-prefix": ["Z_", "ZZ_"],
+      "namespace-blocklist": ["com.sap.", "sap."],
+      "extension-allowlist": [
+        {
+          "for": ["my.bookshop"],
+          "kind": "entity",
+          "new-fields": 2
+        },
+        {
+          "for": ["CatalogService"],
+          "new-entities": 2
+        }
+      ]
+    }
+  }
+  ```
+- `cds build` validates required service models `@sap/**` for MTX sidecar app and logs an ERROR if some couldn't be resolved.
+- Configuration schema for many properties of the `cds` configuration block in `package.json` or `.cdsrc.json`, especially for `cds.requires...`
+
+### Changed
+
+- Streamlined calculation of the difference for `DELETE` queries using `req.diff()`
+- Improved error messages for rest / new odata parser
+- Adjust types for `SELECT.from` and `SELECT.one` to accept array classes as well
+- No `"` added around search values in OData v2 e.g. Foo?search=name is passed through as is
+- If an entity can not be read after write (e.g. insert only entity) no error is shown in the log
+- Throw not supported error for pagination in `$expand`
+
+### Fixed
+
+- Wrong context in `tx.run(query)` when `query` is an array
+- We now detect and ignore erroneous attempts to re-register framework-generated stubs as handlers for custom actions/functions.
+- Emits with `persistent-outbox` also work with manual transactions
+- You can now use `cds.ql` fluent API to query tables not in the model, but in database.
+  For example, within `cap/samples/bookshop` this works now:
+  ```sql
+  await SELECT.from('sqlite_master')
+  await cds.read('sqlite_master')
+  ```
+  Caveat: the following undocumented usage of unqualified names happened to work in the past.
+  But this was very fragile and caused lots of issues, and therefore was removed:
+  ```sql
+  await SELECT.from('Books')
+  await cds.read('Books')
+  ```
+  Always use qualified names, or reflected definitions instead:
+  ```sql
+  const Books = 'sap.capire.bookshop.Books'
+  await SELECT.from(Books)
+  await cds.read(Books)
+  ```
+  ```sql
+  const {Books} = cds.entities ('sap.capire.bookshop')
+  await SELECT.from(Books)
+  await cds.read(Books)
+  ```
+- Wrong results for expand to many without `orderBy`
+- `cds deploy` api endpoint regex for cli now ignores trailing version info in url
+- Default values no longer overwrite payload values on fields of new drafts
+- Unmanaged to-one navigation caused malformed SQL statement in draft
+- `cds.compile.to.serviceinfo` fix failure to detect Java services if `odataV4.endpoint.path` or `odataV2.endpoint.path` missing in `cds` configuration in `application.yaml`
+- Data type conversion did not work in some expand cases
+- Failed connection to SAP HANA with no or malformed credentials was leading to credentials being written to the log
+- `cds build` no longer fails with an error `no such file` if one of the following files has been defined in some `srv` subfolder - `package.json, package-lock.json, .cdsrc.json, .npmrc`
+- Tar issue on Windows: 'The command line is too long'.
+- `$search`: Lifecycle issue that causes an empty search result when the `$search` and `$expand` query options were combined
+- Operator `IN` with Tagged Template String Literals e.g.:
+  ```sql
+  SELECT.from(Object).where`userId IN ${aUserIDs}`
+  ```
+- `cds build` now uses a closed version range in the node engines version of the deployed application's `package.json`
+- `cds build` no longer generates EDMX files for services that aren't odata protocol enabled
+- `cds deploy` handles orgs and spaces containing commas correctly
+- Incorrect decoding of special characters when reading data of type `cds.LargeString` from SAP HANA using `hdb@^0.19.5` driver
+- The payload is added to the delete request in rest adapter as req.data
+
+## Version 6.0.4 - 2022-07-20
+
+### Fixed
+
+- Local mocking of external services using `cds watch`
+
 ## Version 6.0.3 - 2022-07-14
 
 ### Changed
@@ -32,17 +178,18 @@
 ## Version 6.0.1 - 2022-07-05
 
 ### Added
+
 - Config option `cds.env.server.port` allows to configure the port to use (in addition to `process.env.PORT` and CLI option `--port`)
 
+### Changed
+
+- Plugins cannot be loaded as ES modules, but need to remain CommonJS modules
+
 ### Fixed
 
 - Removed debug log about shutdown from `cds serve`
 - Hiding timeout error in production mode
 
-### Changed
-
-- Plugins cannot be loaded as ES modules, but need to remain CommonJS modules
-
 ## Version 6.0.0 - 2022-06-30
 
 ### Added
@@ -89,7 +236,7 @@
 - Support for `FOR SHARE LOCK` on SAP HANA to acquire shared locks on the queried records so that the locked records
 stay intact until the transaction is committed or rolled back.
 - Consistent error information for remote batch requests
-- `cds.env` now supports expanding scalar `cds.requires` entries from `cds.requires.kinds`as follows:
+- `cds.env` now supports expanding scalar `cds.requires` entries from `cds.requires.kinds` as follows:
   ```jsonc
   { "cds": {
     "requires": {
@@ -108,23 +255,23 @@ stay intact until the transaction is committed or rolled back.
 - Ordering by aggregated value for draft-enabled active entity
 - `cds build` support for model provider service-based resource deployment.
 - Remote service:
-  - Conversion of OData V2 (`"kind": "odata-v2"`) function and action results to OData V4 format
-  - Conversion of binary data in CQN queries to `base64url` in URL and payload
-  - Key predicate is omitted for single-key entities in resulting URL (e.g. `GET /Foo(1)` instead of `GET /Foo(ID=1)`)
-  - Support of views with parameters
+  + Conversion of OData V2 (`"kind": "odata-v2"`) function and action results to OData V4 format
+  + Conversion of binary data in CQN queries to `base64url` in URL and payload
+  + Key predicate is omitted for single-key entities in resulting URL (e.g. `GET /Foo(1)` instead of `GET /Foo(ID=1)`)
+  + Support of views with parameters
 - Add `@odata.mediaContentType` if selecting stream property
 - Kubernetes service bindings: Support for servicebinding.io and SAP BTP Service Operator based bindings
 - `cds build` copies an existing `.npmrc` file located in the root or srv folder of your project into the deployment folder (usually `gen/srv`). This allows for dedicated npm configuration in cloud environments.  Can be switched off by cds build option `contentNpmrc`.
 - `cds build` copies an existing `.cdsrc.json` file located in the root or srv folder of your project into the deployment folder (usually `gen/srv`). The effective CDS configuration is created from the `.cdsrc.json` and CDS configuration defined in the `package.json` file. Can be switched off by cds build option `contentCdsrcJson`.
 - Beta OData URL to CQN parser (`cds.env.features.odata_new_parser = true`):
-  - `@odata.context` is derived without using okra, not yet supported:
-    - `$expand=*` query option
-  - Support for actions and functions
-  - Further `$apply` transformations supported
-    - (nested) `concat` transformations
-    - `orderBy` transformation
-    - `top` & `skip` transformation
-    - `identity` transformation
+  + `@odata.context` is derived without using okra, not yet supported:
+    + `$expand=*` query option
+  + Support for actions and functions
+  + Further `$apply` transformations supported
+    + (nested) `concat` transformations
+    + `orderBy` transformation
+    + `top` & `skip` transformation
+    + `identity` transformation
 - Log `BEGIN`/`COMMIT`/`ROLLBACK` commands when using SAP HANA as the underlying database
 - Binary data in payload is validated to be RFC-4648 and OData ABNF conformed
 - Support multiple media (streaming) properties in one entity
@@ -134,7 +281,6 @@ stay intact until the transaction is committed or rolled back.
 - $filter in $expand for remote services
 - Mapping of aliases in $expand for remote services
 
-
 ### Changed
 
 - `@sap/cds` can now be loaded from different install locations like any other module, i.e. `@require('@sap/cds')` will no longer return the same singleton instance.
@@ -188,6 +334,7 @@ Note that this is a breaking change for appliations that rely on error sanitizat
 
 ### Fixed
 
+- We don't rely on `global.cds` anymore -> allows to load and correctly work with multiple versions of `cds`
 - Improved shutdown for AMQP connections and file listeners
 - Using `CQL` with a tagged template string `SELECT from Foo { null as boo }` throwed an exception.
 - In case of `MULTIPLE_ERRORS` throw an `Error` instead of an object

package/apis/cds.d.ts

@@ -1,11 +1,15 @@
+
+type cds_facade = import('./core')
+& import('./models')
+& import('./connect')
+& import('./serve')
+& import('./ql').cds_ql
+& import('./services').cds
+& import('./services').QueryAPI
+& import('./log')
+
 declare global {
-	const cds : import ('./core')
-		& import ('./models')
-		& import ('./connect')
-		& import ('./serve')
-		& import ('./ql').cds_ql
-		& import ('./services').cds
-		& import ('./services').QueryAPI
+	const cds : cds_facade
 	class SELECT<T> extends cds.ql.SELECT<T>{}
 	class INSERT<T> extends cds.ql.INSERT<T>{}
 	class UPDATE<T> extends cds.ql.UPDATE<T>{}

package/apis/log.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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
+}
+
+declare class Logger {
+    /**
+     * 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:
+     *
+     *    cds.log.format = (module, level, ...args) => [ '[', module, ']', ...args ]
+     */
+    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 enum levels {
+    SILENT = 0, ERROR = 1, WARN = 2, INFO = 3, DEBUG = 4, TRACE = 5, SILLY = 5, VERBOSE = 5
+}

package/apis/ql.d.ts

@@ -15,6 +15,31 @@ export class cds_ql {
 	ql:QL & ((context:object) => QL)
 }
 
+export type PK = number | string | object
+
+// to support path expressions: https://pages.github.tools.sap/cap/docs/java/query-api#path-expressions
+// `Book.title` == `Proxy<Book>.title()`
+type Proxy<T> = {
+	[Key in keyof T]: () => Proxy<T[Key]>
+} & {
+	/**
+	 * Accesses any nested attribute based on a path:
+	 * `X.get('a.b.c.d')`. Note that you will not receive
+	 * proper typing after this call.
+	 * To still have access to typed results, use
+	 * `X.a().b().c().d()` instead.
+	 */
+	get: (path: string) => Proxy<unknown>
+}
+
+// any class (not value) of array to represent plural types used in cds-typer.
+// Mainly used as pattern match for SingularType
+type ArrayClass = {new():Array<unknown>}
+
+// concrete singular type.
+// `SingularType<typeof Books>` == `Book`.
+type SingularType<T extends ArrayClass> = InstanceType<T>[number]
+
 declare class QL {
 	SELECT : typeof SELECT & ((...columns:string[]) => SELECT<any>) & ((columns:string[]) => SELECT<any>)
 	INSERT : typeof INSERT & ((...entries:object[]) => INSERT<any>) & ((entries:object[]) => INSERT<any>)
@@ -26,12 +51,14 @@ declare class QL {
 
 // (new QL).SELECT.from('Foo').byKey(11).a
 
+
+
 export class SELECT<T> extends ConstructedQuery {
 	static one : SELECT_one & { from: SELECT_one }
 	static distinct : typeof SELECT
   static from : SELECT_from
-	from (entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) : this
-	byKey (primaryKey? : number | string | object) : this
+	from (entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) : this
+	byKey (primaryKey? : PK) : this
 	columns (projection:(e:T)=>void) : this
 	columns (...col:string[]) : this
 	where (predicate:object) : this
@@ -43,23 +70,53 @@ export class SELECT<T> extends ConstructedQuery {
 	groupBy (...expr : string[]) : this
 	orderBy (...expr : string[]) : this
 	limit (rows : number, offset? : number) : this
+	forSharedLock () : this
+	forUpdate () : this
 	SELECT : CQN.SELECT
 }
 
 type SELECT_one =
-((entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) => SELECT<any>)
+((entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) => SELECT<any>)
+
+// calling with class
+&   (<T extends ArrayClass>
+	(entityType: T)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+&
+	(<T extends ArrayClass>
+	(entityType: T, projection: (e: Proxy<SingularType<T>>) => void)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+&
+	(<T extends ArrayClass>
+	(entityType: T, primaryKey : PK, projection: (e: Proxy<SingularType<T>>) => void)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+
+
 & (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
-& (<T> (entity: T[], primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: T[], primaryKey : PK, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
 & (<T> (entity: {new():T}, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
-& (<T> (entity: {new():T}, primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: {new():T}, primaryKey : PK, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+
 
 
 type SELECT_from =
-((entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) => SELECT<any>)
+// calling with class
+	(<T extends ArrayClass>
+	(entityType: T)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+&
+	(<T extends ArrayClass>
+	(entityType: T, projection: (e: Proxy<SingularType<T>>) => void)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+&
+	(<T extends ArrayClass>
+	(entityType: T, primaryKey : PK, projection: (e: Proxy<SingularType<T>>) => void)
+	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+// calling with definition
+& ((entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) => SELECT<any>)
+// calling with concrete list
 & (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T[]>)
-& (<T> (entity: T[], primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
-& (<T> (entity: {new():T}, projection? : (e:T)=>void) => SELECT<T> & Promise<T[]>)
-& (<T> (entity: {new():T}, primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: T[], primaryKey : PK, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
 
 
 export class INSERT<T> extends ConstructedQuery {
@@ -76,8 +133,8 @@ export class INSERT<T> extends ConstructedQuery {
 }
 
 export class DELETE<T> extends ConstructedQuery {
-	static from (entity : Definition | string, primaryKey? : number | string | object) : DELETE<any>
-	byKey (primaryKey? : number | string | object) : this
+	static from (entity : Definition | string, primaryKey? : PK) : DELETE<any>
+	byKey (primaryKey? : PK) : this
 	where (predicate:object) : this
 	where (...expr : any[]) : this
 	and (predicate:object) : this
@@ -86,10 +143,10 @@ export class DELETE<T> extends ConstructedQuery {
 }
 
 export class UPDATE<T> extends ConstructedQuery {
-	static entity (entity : Definition | string, primaryKey? : number | string | object) : UPDATE<any>
-	static entity <T> (entity:Constructable<T>, primaryKey? : number | string | object) : UPDATE<T>
-	static entity <T> (entity:T, primaryKey? : number | string | object) : UPDATE<T>
-	byKey (primaryKey? : number | string | object) : this
+	static entity (entity : Definition | string, primaryKey? : PK) : UPDATE<any>
+	static entity <T> (entity:Constructable<T>, primaryKey? : PK) : UPDATE<T>
+	static entity <T> (entity:T, primaryKey? : PK) : UPDATE<T>
+	byKey (primaryKey? : PK) : this
 	// with (block: (e:T)=>void) : this
 	// set (block: (e:T)=>void) : this
 	set (data:object) : this

package/bin/build/buildTaskHandler.js

@@ -187,9 +187,8 @@ class BuildTaskHandler {
             return null
         }
         this._logger._debug && this._logger.debug(`model: ${relativePaths(this._buildOptions.root, files).join(", ")}`)
-        const options = { messages: this._messages }
         // $location paths are relative to current working dir by default - make sure a given project root folder is taken
-        options.cwd = this._buildOptions.root
+        const options = { ...this.options(), cwd: this._buildOptions.root }
 
         const model = await this._cds.load(files, options)
         if (!model) {
@@ -198,6 +197,10 @@ class BuildTaskHandler {
         return model
     }
 
+    options() {
+        return { messages: this._messages }
+    }
+
     /**
      * Adds the given fully qualified file path to the list of files that are written by this build task.
      * @param {string} filePath

package/bin/build/constants.js

@@ -14,7 +14,8 @@ exports.BUILD_TASK_HANA = "hana"
 exports.BUILD_TASK_FIORI = "fiori"
 exports.BUILD_TASK_MTX = "mtx"
 exports.BUILD_TASK_MTX_SIDECAR = "mtx-sidecar"
-exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD_TASK_NODEJS, this.BUILD_TASK_NODE_CF, this.BUILD_TASK_HANA, this.BUILD_TASK_FIORI, this.BUILD_TASK_MTX, this.BUILD_TASK_MTX_SIDECAR]
+exports.BUILD_TASK_MTX_EXTENSION = "mtx-extension"
+exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD_TASK_NODEJS, this.BUILD_TASK_NODE_CF, this.BUILD_TASK_HANA, this.BUILD_TASK_FIORI, this.BUILD_TASK_MTX, this.BUILD_TASK_MTX_SIDECAR, this.BUILD_TASK_MTX_EXTENSION]
 
 exports.ODATA_VERSION = "odata.version"
 exports.ODATA_VERSION_V2 = "v2"
@@ -44,6 +45,7 @@ exports.CSV_FILE_DETECTION = "csvFileDetection"             // detect CSV files
 exports.FOLDER_GEN = "gen"
 exports.FILE_EXT_CDS = ".cds"
 exports.MTX_SIDECAR_FOLDER = "mtx/sidecar"                  // default name of the mtx sidecar folder
+exports.DEFAULT_CSN_FILE_NAME = "csn.json"
 
 exports.CDS_CONFIG_PATH_SEP = "/"
 exports.SKIP_ASSERT_COMPILER_V2 = "skip-assert-compiler-v2"
@@ -59,3 +61,4 @@ exports.LOG_LEVEL_DEBUG = "debug"
 exports.LOG_LEVELS = [exports.LOG_LEVEL_ERROR, exports.LOG_LEVEL_WARN, exports.LOG_LEVEL_INFO, exports.LOG_LEVEL_DEBUG]
 exports.LOG_MODULE_NAMES = "cds|build"
 exports.OVERRIDE_METHOD_MSG = "Must override method"
+exports.SEMVER_REGEX = /^(\D*)(\d+\.)?(\d+\.)?(\*|\d+)/

package/bin/build/provider/buildTaskHandlerEdmx.js

@@ -5,16 +5,21 @@ const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../consta
 class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
     async compileToEdmx(model, edmxDest, compileOptions = {}) { // NOSONAR
         const promises = []
-        const services = this.cds.reflect(model).services
+
+        // generate edmx for services only that have the odata protocol
+        const serviceNames = this.cds.reflect(model).services
+            .filter(service => this._isOdataProtocol(service))
+            .map(service => service.name)
 
         // TODO mtx build_helper tests currently expects this, strange...
         this._result.languages.add('')
 
         // new compile impl is throwing error in case no services exist!
-        if (services.length > 0) {
+        if (serviceNames.length > 0) {
             const options = {
                 ...this._options4edmx(),
-                ...compileOptions
+                ...compileOptions,
+                serviceNames
             }
             this.logger._debug && this.logger.debug(`compiling edmx files using OData version ${options.version}`)
 
@@ -45,42 +50,9 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
         return Promise.all(promises)
     }
 
-    /**
-     * Collect and write language bundles into a single i18n.json file.
-     * @param {Object} model
-     * @param {string} bundleDest
-     */
-     async collectLanguageBundles(model, bundleDest, saveResult = true) {
-        // collect effective i18n properties...
-        let bundles = {}
-        const bundleGenerator = this.cds.localize.bundles4(model)
-        if (bundleGenerator && bundleGenerator[Symbol.iterator]) {
-            for (let [locale, bundle] of bundleGenerator) {
-                // fallback bundle has the name ""
-                if (typeof locale === 'string') {
-                    bundles[locale] = bundle
-                }
-            }
-        }
-
-        // omit bundles in case the fallback bundle is the only existing entry
-        const keys = Object.keys(bundles)
-        if (keys.length === 1 && keys[0] === "" && Object.keys(bundles[keys[0]]).length === 0) {
-            bundles = {}
-        }
-        // copied from ../compile/i18n.js
-        const { folders = ['i18n'], file = 'i18n' } = this.env.i18n
-
-        // bundleDest might be null
-        if (bundleDest && Object.keys(bundles).length > 0) {
-            if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                await this.write(bundles).to(path.join(bundleDest, folders[0], file + '.json'))
-            }
-        }
-        if (saveResult) {
-            this._result.languageBundles = bundles
-        }
-        return bundles
+    _isOdataProtocol(service) {
+        const { _protocol4Service } = this.cds.service.adapters
+        return /^odata/.test(_protocol4Service(service))
     }
 
     _options4odata() {

package/bin/build/provider/buildTaskHandlerFeatureToggles.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
+const { DEFAULT_CSN_FILE_NAME } = require('../constants')
 const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
 
 class FeatureToggleBuilder extends BuildTaskHandlerInternal {
@@ -31,7 +31,10 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
             dictionary.base = csn
         }
         // preserve @location as @source properties
-        await this.compileToJson(dictionary.base, destBase)
+        const csnStr = await this.compileToJson(dictionary.base, path.join(destBase, DEFAULT_CSN_FILE_NAME))
+        const csnModel = JSON.parse(csnStr)
+        csnModel.meta = csn.meta
+        this._result.csn = csnModel
 
         if (sources.features) {
             dictionary.features = await this._compileFeatures(sources.features, destBase, destFts)
@@ -41,13 +44,17 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
 
     async collectAllLanguageBundles(dictionary, paths, destBase, destFts) {
         // create language bundle for base model
-        await this.collectLanguageBundles(dictionary.base, destBase)
+        const i18n = await this.collectLanguageBundles(dictionary.base, destBase)
+        if (i18n) {
+            this._result.languageBundles = i18n.bundles
+        }
+
         if (dictionary.features) {
             // create language bundles for all features
             for (const ftName in dictionary.features) {
                 // attach the sources information for i18n location reference
                 dictionary.features[ftName]['$sources'] = paths.features[ftName]
-                await this.collectLanguageBundles(dictionary.features[ftName], path.join(destFts, this.ftsName, ftName), false)
+                await this.collectLanguageBundles(dictionary.features[ftName], path.join(destFts, this.ftsName, ftName))
             }
         }
     }
@@ -87,50 +94,23 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
         return paths
     }
 
-    async compileToJson(model, csnDest, saveResult = true) {
-        // This will als add a @source prop containing the relative path to the origin .cds source file
-        // and a parsed _where clause for @restrict.{grant,where} annotations.
-        // The @source annotation is required for correct custom handler resolution if no @impl annotation has been defined as
-        // custom service handler implementations are relative to the origin .cds source files.
-        // For staging builds (task.src !== task.dest) the csn.json file that is served at runtime is copied into a corresponding srv subfolder.
-        // As a consequence the src folder name has to be included in the @source file name while for inplace builds (task.src === task.dest) this is not the case.
-        // This ensures that the paths are relative to the cwd when executing cds run.
-        const jsonOptions = {
-            cwd: this.buildOptions.root,
-            src: this.task.src === this.task.dest ? this.task.src : this.buildOptions.root
-        }
-        const csnStr = this.cds.compile.to.json(model, jsonOptions)
-        const csn = JSON.parse(csnStr)
-        if (saveResult) {
-            this._result.csn = csn
-            this._result.csn.meta = model.meta
-        }
-
-        // csnDest might be null
-        if (csnDest && !this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            await this.write(csnStr).to(path.join(csnDest, 'csn.json'))
-        }
-        return csn
-    }
-
     async _compileFeatures(ftsPaths, destBase, destFts) {
         if (!ftsPaths) {
             return
         }
         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, 'csn.json')]
+            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, ftPath, false)
+            await this.compileToJson(ftCsn, path.join(ftPath, DEFAULT_CSN_FILE_NAME))
             await this._validateFeature(ftPath)
             features[ftName] = ftCsn
         }