@sap/cds 5.9.8 → 6.0.1

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

@@ -1,10 +1,9 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
-const { getHanaDbModuleDescriptor } = require('../../mtaUtil')
 const { OUTPUT_MODE_RESULT_ONLY, BUILD_OPTION_OUTPUT_MODE, SKIP_HDBTABLEDATA_GENERATION, SKIP_PACKAGE_JSON_GENERATION,
-    SKIP_MANIFEST_GENERATION, CONTENT_MANIFEST, CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA } = require('../../constants')
-const { BuildError, setProperty, relativePaths, getProperty } = require('../../util')
+    CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA, CSV_FILE_DETECTION, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, CONTENT_NODE_MODULES } = require('../../constants')
+const { BuildError, relativePaths } = require('../../util')
 const CSV = require('../../csv-reader')
 const to_hdbmigration = require('./2migration')
 const to_hdbtabledata = require('./2tabledata')
@@ -20,7 +19,6 @@ const FILE_EXT_HDBMIGRATIONTABLE = ".hdbmigrationtable"
 const FILE_NAME_HDICONFIG = ".hdiconfig"
 const FILE_NAME_HDINAMESPACE = ".hdinamespace"
 const FILE_NAME_PACKAGE_JSON = "package.json"
-const FILE_NAME_MANIFEST_YML = "manifest.yml"
 const PATH_LAST_DEV_CSN = "last-dev/csn.json"
 const FILE_NAME_UNDEPLOY_JSON = "undeploy.json"
 
@@ -32,10 +30,17 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             dest: this.task.dest,
             hana: []
         }
+
         // set unified option values in order to easy access later on
-        this.task.options[CONTENT_MANIFEST] = !this.hasBuildOption(CONTENT_MANIFEST, false) && !this.hasBuildOption(SKIP_MANIFEST_GENERATION, true) ? true : false
+        // default value: true
         this.task.options[CONTENT_PACKAGE_JSON] = !this.hasBuildOption(CONTENT_PACKAGE_JSON, false) && !this.hasBuildOption(SKIP_PACKAGE_JSON_GENERATION, true) ? true : false
         this.task.options[CONTENT_HDBTABLEDATA] = !this.hasBuildOption(CONTENT_HDBTABLEDATA, false) && !this.hasBuildOption(SKIP_HDBTABLEDATA_GENERATION, true) ? true : false
+        this.task.options[CSV_FILE_DETECTION] = !this.hasBuildOption(CSV_FILE_DETECTION, false) ? true : false
+
+        // default value: false
+        this.task.options[CONTENT_NODE_MODULES] = this.hasBuildOption(CONTENT_NODE_MODULES, true) ? true : false
+        this.task.options[CONTENT_ENV] = this.hasBuildOption(CONTENT_ENV, true) ? true : false
+        this.task.options[CONTENT_DEFAULT_ENV_JSON] = this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? true : false
 
         this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
     }
@@ -49,22 +54,15 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const plugins = await this._compileToHana(model)
 
         if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            // TODO: option 'mtxOriginalSrc' is only a workaround as native hana content part of reuse modules is still an open issue!
-            // The option is set by mtx build_helper - the path refers to the base model: 'node_modules/_base/<dbDir>'
-            // All files except *.cds files will be copied from base model folder to '#this.task.dest/src/**'.
-            // Note:
-            // Native hana artifacts are currently not supported by extensions - thus content copied from the base model cannot overwrite
-            // content defined by the extension.
-            if (getProperty(this.task, "options.build.mtxOriginalSrc")) {
-                const baseModelDbSrcPath = path.join(this.buildOptions.root, this.task.options.build.mtxOriginalSrc)
-                if (await fs.pathExists(baseModelDbSrcPath)) {
-                    await this._copyNativeContent(baseModelDbSrcPath, dest)
-                }
+            if (this.hasBuildOption(CSV_FILE_DETECTION, false)) {
+                await this._copyResources(src, dest)
+            } else {
+                await this._copyResourcesExt(src, dest, model)
             }
 
-            await this._copyNativeContent(src, dest)
             await this._writeHdiConfig(plugins)
             await this._writeHdiNamespace()
+
             // TODO disabled as this contradicts the MTX domain concept which allows partial app deployments
             //await this._writeUndeployJson()
 
@@ -74,10 +72,6 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             if (this.hasBuildOption(CONTENT_PACKAGE_JSON, true)) {
                 await this._writePackageJson()
             }
-            if (this.hasBuildOption(CONTENT_MANIFEST, true)) {
-                await this._writeManifestYml()
-                await this._writeCfIgnore()
-            }
         }
         return this._result
     }
@@ -91,7 +85,50 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         if (this.isStagingBuild()) {
             return super.clean()
         }
-        return fs.remove(this.task.options.compileDest)
+        return fs.promises.rm(this.task.options.compileDest, { force: true, recursive: true })
+    }
+
+    /**
+     * Copies all files located at <src> (except HANA artefacts not contained in <db>/src/**) to the folder <dest>.
+     * '*.csv' files are read based on the corresponding CDS model file location and copied as flat list into folder '<dest>/src/gen>'.
+     * 
+     * @param {string} src 
+     * @param {string} dest 
+     * @param {Object} model 
+     */
+    async _copyResourcesExt(src, dest, model) {
+        const deploy = require('../../../../lib/deploy')
+        const resources = Object.keys(await deploy.resources(model))
+        const csvPath = path.join(src, "data")
+        // determine subfolder name used by the application for backward compatibility
+        const csvFolder = resources.some(res => res && res.startsWith(csvPath)) ? "data" : "csv"
+
+        // 1. copy csv files into 'src/gen/data' or 'src/gen/csv' subfolder
+        const promises = []
+        resources.forEach(res => {
+            if (res && /\.csv$/.test(res)) {
+                promises.push(this.copy(res).to(path.join(this.task.options.compileDest, csvFolder, path.basename(res))))
+            }
+        })
+        await Promise.all(promises)
+
+        // 2. copy files except *.cds, *.csv, .env, default-env.json, ./node_modules/**
+        let blockList = "\\.cds$|\\.csv$|\\.hdbtabledata$"
+        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)) {
+                // entire native content
+                return true
+            }
+            if (fs.statSync(entry).isDirectory()) {
+                return !/(\/|\\)node_modules(\/|\\)?$/.test(entry) || this.hasBuildOption(CONTENT_NODE_MODULES, true)
+            }
+            return !blockList.test(entry)
+        })
     }
 
     /**
@@ -101,21 +138,19 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
      * @param {string} src
      * @param {string} dest
      */
-    async _copyNativeContent(src, dest) {
+    async _copyResources(src, dest) {
         const dbCsvDir = path.join(src, "csv")
         const dbDataDir = path.join(src, "data")
         const csvDirs = [dbCsvDir, dbDataDir]
         const regex = RegExp('\\.cds$|\\.csv$|\\.hdbtabledata$')
         const regexData = RegExp('\\.csv$|\\.hdbtabledata$')
-
-        await super.copyNativeContent(src, dest, (entry) => {
+        await this.copyNativeContent(src, dest, (entry) => {
             if (fs.statSync(entry).isDirectory()) {
-                return true // using common filter for folders
+                return !/(\/|\\)node_modules(\/|\\)?$/.test(entry)
             }
             return (!regex.test(entry) && entry !== this.env.build.outputfile) ||
-                (regexData.test(entry) && !entry.startsWith(dbCsvDir) && !entry.startsWith(dbCsvDir))
-        }) || []
-
+                (regexData.test(entry) && !entry.startsWith(dbCsvDir) && !entry.startsWith(dbDataDir))
+        })
         // handle *.csv and *.hdbtabledata located in '<dbSrc>/data' and '<dbSrc>/csv' folder
         const allFiles = csvDirs.reduce((acc, csvDir) => {
             return acc.concat(BuildTaskHandlerInternal._find(csvDir, (entry) => {
@@ -145,18 +180,18 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
     async _compileToHdbtabledata(model, dest) { //NOSONAR
         const tabledataDirs = new Set()
         const destSrcDir = path.join(dest, "src")
-        const csvFiles = BuildTaskHandlerInternal._find(destSrcDir, (entry) => {
+
+        const allCsvFiles = BuildTaskHandlerInternal._find(destSrcDir, (entry) => {
             if (fs.statSync(entry).isDirectory()) {
                 return true
             }
-            const extName = path.extname(entry)
-            if (extName === FILE_EXT_HDBTABLEDATA) {
+            if (/\.hdbtabledata$/.test(entry)) {
                 tabledataDirs.add(path.dirname(entry))
             }
-            return extName === FILE_EXT_CSV
+            return /\.csv$/.test(entry)
         })
-        if (csvFiles.length > 0) {
-            const csvDirs = csvFiles.map(path.dirname).reduce((dirs, dir) => {
+        if (allCsvFiles.length > 0) {
+            const csvDirs = allCsvFiles.map(path.dirname).reduce((dirs, dir) => {
                 if (!tabledataDirs.has(dir) && !dirs.includes(dir)) { // exclude any dir where a tabledata is present
                     dirs.push(dir)
                 }
@@ -165,7 +200,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
 
             // ODM csv data comes with license comments, so strip these
             if (!this.hasBuildOption("stripCsvComments", false)) {
-                await this._stripCsvComments(csvFiles)
+                await this._stripCsvComments(allCsvFiles)
             }
 
             const promises = []
@@ -214,7 +249,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         if (this.hasCdsEnvOption('features.journal', false) || format === 'hdbcds') {
             await this._compileToHdb(model, pluginTypes, format)
         } else {
-            await this._compileToHdbmigration(model, pluginTypes)
+            await this._compileToHdbmigration(model, pluginTypes, format)
         }
         return pluginTypes
     }
@@ -237,7 +272,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         await Promise.all(promises)
     }
 
-    async _compileToHdbmigration(model, pluginTypes) {
+    async _compileToHdbmigration(model, pluginTypes, format) {
         const relDestDir = path.relative(this.task.dest, this.task.options.compileDest)
         const relDbDestDir = path.relative(this.buildOptions.root, this.task.options.compileDest)
         const dbSrcDir = path.join(this.task.src, "src")
@@ -248,12 +283,11 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const promises = []
         const migrationTableFiles = []
 
-        if (await fs.pathExists(lastDevCsnDir)) {
-            lastDev = await fs.readJSON(lastDevCsnDir, 'utf-8')
+        if (fs.existsSync(lastDevCsnDir)) {
+            lastDev = JSON.parse((await fs.promises.readFile(lastDevCsnDir, 'utf-8')).toString())
         }
-        // enforces sqlNames option for compiler in tests
-        // pass options from cds env
-        const options = { ...this.options(), logger: this.logger, sql_mapping: this.env.sql.names }
+        // enforces sqlNames option for compiler in tests, pass options from cds env, ensures that the correct format is taken
+        const options = { ...this.options(), logger: this.logger, sql_mapping: this.env.sql.names, "deploy-format": format }
 
         const compilationResult = await to_hdbmigration(model, lastDev, dbSrcDir, options)
         const definitions = compilationResult.definitions
@@ -279,7 +313,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
                 }
                 if (suffix === FILE_EXT_HDBTABLE) {
                     // issue an error in case a .hdbmigrationtable file already exists
-                    if (await fs.pathExists(path.join(dbSrcDir, name + FILE_EXT_HDBMIGRATIONTABLE))) {
+                    if (fs.existsSync(path.join(dbSrcDir, name + FILE_EXT_HDBMIGRATIONTABLE))) {
                         this.pushMessage(`Multiple files exist defining the same HANA artifact - [${path.join(relDbSrcDir, name + FILE_EXT_HDBMIGRATIONTABLE)}, ${path.join(relDbDestDir, file)}].\nEither annotate the model entity using @cds.persistence.journal or undeploy the file [${path.join('src', name + FILE_EXT_HDBMIGRATIONTABLE)}] using an undeploy.json file.`, ERROR)
                     }
                 }
@@ -300,7 +334,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
 
     async _writePackageJson() {
         const packageJson = path.join(this.task.src, "package.json")
-        const exists = await fs.pathExists(packageJson)
+        const exists = fs.existsSync(packageJson)
 
         if (exists) {
             this.logger._debug && this.logger.debug(`skip create [${relativePaths(this.buildOptions.root, packageJson)}], already existing`)
@@ -356,8 +390,8 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             const undeployJsonSrc = path.join(this.task.src, FILE_NAME_UNDEPLOY_JSON)
             const templateEntries = await this._readTemplateAsJson(FILE_NAME_UNDEPLOY_JSON)
             let newEntries = []
-            if (await fs.pathExists(undeployJsonSrc)) {
-                newEntries = await fs.readJSON(undeployJsonSrc, 'utf-8')
+            if (fs.existsSync(undeployJsonSrc)) {
+                newEntries = await JSON.parse((await fs.promises.readFile(undeployJsonSrc, 'utf-8')).toString())
                 newEntries = Array.isArray(newEntries) ? newEntries : []
                 templateEntries.forEach(entry => {
                     if (!newEntries.includes(entry)) {
@@ -377,64 +411,20 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         }
     }
 
-    /**
-     * Create .cfignore file only for staging build.
-     * This is to have a fast-turnaround at development
-     */
-    async _writeCfIgnore() {
-        if (this.isStagingBuild()) {
-            const content = `node_modules/\n`
-            await this.write(content).to(path.join(this.task.dest, '.cfignore'))
-        }
-    }
-
-    async _writeManifestYml() {
-        if (!this.isStagingBuild()) {
-            return
-        }
-        if (await fs.pathExists(path.join(this.task.src, FILE_NAME_MANIFEST_YML)) || await fs.pathExists(path.join(this.task.src, 'manifest.yml'))) {
-            this.logger.debug('skip cf manifest generation, already existing')
-            return
-        }
-        try {
-            const descriptor = await getHanaDbModuleDescriptor(this.buildOptions.root, path.basename(this.task.src), this.logger)
-            const MANIFEST_YML_CONTENT = `---
-applications:
-  - name: ${descriptor.appName}
-    path: .
-    no-route: true
-    health-check-type: process
-    memory: 256M
-    buildpacks:
-      - nodejs_buildpack
-    services:
-      - ${descriptor.hdiServiceName}`
-
-            this.logger.debug("Cloud Foundry service binding required for HDI container. To create a service use CF command")
-            this.logger._debug && this.logger.debug(`  cf cs hana hdi-shared ${descriptor.hdiServiceName}`)
-
-            await this.write(MANIFEST_YML_CONTENT).to(path.join(this.task.dest, FILE_NAME_MANIFEST_YML))
-        } catch (e) {
-            if (e.name === 'YAMLSyntaxError') {
-                this.logger.error("Failed to parse [mta.yaml] - skip manifest.yml generation")
-            }
-            this.logger.error(e)
-        }
-    }
-
     async _readTemplateAsJson(template) {
         const templatePath = path.join(__dirname, 'template', template)
-        return fs.readJSON(templatePath, 'utf-8').catch((error) => {
-            this.logger.error(`Failed to read template [${templatePath}]`)
-            return Promise.reject(error)
-        })
+        return fs.promises.readFile(templatePath, 'utf-8').then(f => JSON.parse(f.toString()))
+            .catch((error) => {
+                this.logger.error(`Failed to read template [${templatePath}]`)
+                return Promise.reject(error)
+            })
     }
 
     async _readTypesFromUndeployJson() {
         const result = new Set()
         const file = path.join(this.task.src, "undeploy.json")
-        if (await fs.pathExists(file)) {
-            const undeployList = await fs.readJSON(file)
+        if (fs.existsSync(file)) {
+            const undeployList = JSON.parse((await fs.promises.readFile(file)).toString())
             if (Array.isArray(undeployList)) {
                 undeployList.forEach(entry => result.add(path.extname(entry)))
             }

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

@@ -1,10 +1,11 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs').promises
+const {existsSync} = require('fs')
 class MigrationTableParser {
   constructor() {
   }
 
   async read(filePath, options = { encoding: 'utf8' }) {
-    if (await fs.pathExists(filePath)) {
+    if (existsSync(filePath)) {
       return this.parse((await fs.readFile(filePath, options)).replace(/\r\n/g, '\n'))
     }
     return null
@@ -289,7 +290,7 @@ class MigrationTableModel {
     return idxBase
   }
 
-  /** 
+  /**
    * Migrations are identical if the corresponding DDL statements are identical,
    * ignoring order and ignoring comments.
    */

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

@@ -0,0 +1,101 @@
+const fs = require('fs')
+const path = require('path')
+
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const { isOldJavaStack, BuildError } = require('../../util')
+
+const { BUILD_OPTION_OUTPUT_MODE, ODATA_VERSION, ODATA_VERSION_V2, OUTPUT_MODE_RESULT_ONLY, FILE_EXT_CDS, SKIP_ASSERT_COMPILER_V2, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN } = require('../../constants')
+const { INFO } = require('../../buildTaskHandler')
+
+const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
+
+class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
+    init() {
+        super.init()
+        this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
+    }
+
+    async build() {
+        const { src, dest } = this.task
+
+        const odataOptions = {
+            version: this.env.get(ODATA_VERSION)
+        }
+
+        if (await isOldJavaStack([src, this.buildOptions.root])) {
+            if (!this._isCompilerV1() && !this.env.get(`build.${SKIP_ASSERT_COMPILER_V2}`)) {
+                throw new BuildError('CDS compiler version 2 does no longer support the classic CAP Java runtime. It is recommended to migrate to the current CAP Java runtime SDK. See https://cap.cloud.sap/docs/java/migration for more.')
+            }
+            // default is now v4 and not v2 anymore, so warn and overwrite with v2 if using default
+            if (!this.env.for('cds', this.buildOptions.root, false).get(ODATA_VERSION)) {
+                odataOptions.version = ODATA_VERSION_V2
+                this.pushMessage('Forcing OData v2 for building though the default is v4. Make sure to define OData v2 in cds configuration.', INFO)
+            }
+
+            // 'sql_mapping' and 'cds.persinstence.name' annotations are required by old java stack
+            if (this.env.sql.names !== 'plain') {
+                odataOptions.sql_mapping = this.env.sql.names
+            }
+        }
+
+        const model = await this.model()
+        if (!model) {
+            return this._result
+        }
+
+        const odata = await this._compileForOdata(model, this.task.options.compileDest, odataOptions)
+        await this.compileToEdmx(odata, this.task.options.compileDest, odataOptions)
+
+        if (this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, true)) {
+            // collect and write language bundles into single i18n.json file
+            await this.collectLanguageBundles(model, this.task.dest)
+        }
+        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
+            await this._copyNativeContent(src, dest)
+        }
+        return this._result
+    }
+
+    async clean() {
+        if (this.isStagingBuild()) {
+            await super.clean()
+            return
+        }
+        this.logger._debug && this.logger.debug(`Deleting build target folder ${this.task.options.compileDest}`)
+        await fs.promises.rm(this.task.options.compileDest, {force: true, recursive: true})
+    }
+
+    async _copyNativeContent(src, dest) {
+        return super.copyNativeContent(src, dest, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                return true // using common filter for folders
+            } else {
+                const extname = path.extname(entry)
+                return extname !== FILE_EXT_CDS
+            }
+        })
+    }
+
+    async _compileForOdata(model, csnDest, compileOptions) {
+        // csn for service providers
+        const m = this.cds.compile.for.java(model, {
+            ...this._options4odata(),
+            ...compileOptions
+        })
+
+        // adding csn to build result containing @source and _where persisted properties
+        if (this.hasBuildOption(CONTENT_DEFAULT_CSN, true)) { //default true or undefined
+            await this.compileToJson(model, csnDest)
+        } else {
+            await this.compileToJson(m, csnDest)
+        }
+        return m
+    }
+
+    _isCompilerV1() {
+        const version = this.cds.compiler.version()
+        const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
+        return match && match[1] === 1
+    }
+}
+module.exports = JavaCfModuleBuilder

package/bin/build/provider/java-cf/index.js

@@ -1,101 +1 @@
-const { fs } = require('@sap/cds-foss')
-const path = require('path')
-
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const { isOldJavaStack, BuildError } = require('../../util')
-
-const { BUILD_OPTION_OUTPUT_MODE, ODATA_VERSION, ODATA_VERSION_V2, OUTPUT_MODE_RESULT_ONLY, FILE_EXT_CDS, SKIP_ASSERT_COMPILER_V2, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN } = require('../../constants')
-const { INFO } = require('../../buildTaskHandler')
-
-const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
-
-class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
-    init() {
-        super.init()
-        this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
-    }
-
-    async build() {
-        const { src, dest } = this.task
-
-        const odataOptions = {
-            version: this.env.get(ODATA_VERSION)
-        }
-
-        if (await isOldJavaStack([src, this.buildOptions.root])) {
-            if (!this._isCompilerV1() && !this.env.get(`build.${SKIP_ASSERT_COMPILER_V2}`)) {
-                throw new BuildError('CDS compiler version 2 does no longer support the classic CAP Java runtime. It is recommended to migrate to the current CAP Java runtime SDK. See https://cap.cloud.sap/docs/java/migration for more.')
-            }
-            // default is now v4 and not v2 anymore, so warn and overwrite with v2 if using default
-            if (!this.env.for('cds', this.buildOptions.root, false).get(ODATA_VERSION)) {
-                odataOptions.version = ODATA_VERSION_V2
-                this.pushMessage('Forcing OData v2 for building though the default is v4. Make sure to define OData v2 in cds configuration.', INFO)
-            }
-
-            // 'sql_mapping' and 'cds.persinstence.name' annotations are required by old java stack
-            if (this.env.sql.names !== 'plain') {
-                odataOptions.sql_mapping = this.env.sql.names
-            }
-        }
-
-        const model = await this.model()
-        if (!model) {
-            return this._result
-        }
-
-        const odata = await this._compileForOdata(model, this.task.options.compileDest, odataOptions)
-        await this.compileToEdmx(odata, this.task.options.compileDest, odataOptions)
-
-        if (this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, true)) {
-            // collect and write language bundles into single i18n.json file
-            await this.collectLanguageBundles(model, this.task.dest)
-        }
-        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            await this._copyNativeContent(src, dest)
-        }
-        return this._result
-    }
-
-    async clean() {
-        if (this.isStagingBuild()) {
-            await super.clean()
-            return
-        }
-        this.logger._debug && this.logger.debug(`Deleting build target folder ${this.task.options.compileDest}`)
-        await fs.remove(this.task.options.compileDest)
-    }
-
-    async _copyNativeContent(src, dest) {
-        return super.copyNativeContent(src, dest, (entry) => {
-            if (fs.statSync(entry).isDirectory()) {
-                return true // using common filter for folders
-            } else {
-                const extname = path.extname(entry)
-                return extname !== FILE_EXT_CDS
-            }
-        })
-    }
-
-    async _compileForOdata(model, csnDest, compileOptions) {
-        // csn for service providers
-        const m = this.cds.compile.for.java(model, {
-            ...this._options4odata(),
-            ...compileOptions
-        })
-
-        // adding csn to build result containing @source and _where persisted properties
-        if (this.hasBuildOption(CONTENT_DEFAULT_CSN, true)) { //default true or undefined
-            await this.compileToJson(model, csnDest)
-        } else {
-            await this.compileToJson(m, csnDest)
-        }
-        return m
-    }
-
-    _isCompilerV1() {
-        const { version } = require('@sap/cds-compiler/package.json')
-        const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
-        return match && match[1] === 1
-    }
-}
-module.exports = JavaCfModuleBuilder
+module.exports = require('../java')