@sap/cds 6.3.2 → 6.4.1

package/bin/build/provider/buildTaskHandlerInternal.js

@@ -1,5 +1,6 @@
 const fs = require('fs')
 const path = require('path')
+const cds = require('../cds')
 const BuildTaskHandler = require('../buildTaskHandler')
 const { hasOptionValue } = require('../util')
 const { FOLDER_GEN, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
@@ -13,14 +14,6 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
         //injected by framework
         return this._logger;
     }
-    /**
-     * Returns the cds module providing access to the CDS compiler functionality and other framework functionality.
-     * @returns {object}
-     */
-    get cds() {
-        //injected by framework
-        return this._cds
-    }
     /**
      * Returns the build options used for this CDS build execution
      * @returns {object}
@@ -28,13 +21,6 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
     get buildOptions() {
         return this._buildOptions
     }
-    /**
-     * Returns the effective CDS environment used by this CDS build execution.
-     * @returns {object}
-     */
-    get env() {
-        return this.cds.env
-    }
     /**
      * Custom build handlers are executed before internal handlers in order
      * ensure and content cannot be overwritten by mistake.
@@ -58,13 +44,6 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
     set logger(logger) {
         super.logger = logger;
     }
-    /**
-     * Used by the framework to initialize the correct cds context.
-     * @param {object} cds
-     */
-    set cds(cds) {
-        super.cds = cds;
-    }
     /**
      * Sets the build options used for this CDS build execution
      * @param {object} options
@@ -106,7 +85,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
      * @param {any=} value
      */
     hasCdsEnvOption(qualifiedName, value) {
-        return hasOptionValue(this.env.get(qualifiedName), value)
+        return hasOptionValue(cds.env.get(qualifiedName), value)
     }
 
     /**
@@ -173,7 +152,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
             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 csnStr = cds.compile.to.json(model, jsonOptions)
         if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
             await this.write(csnStr).to(csnFile)
         }
@@ -188,7 +167,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
     async collectLanguageBundles(model, bundleDest) {
         // collect effective i18n properties...
         let bundles = {}
-        const bundleGenerator = this.cds.localize.bundles4(model)
+        const bundleGenerator = cds.localize.bundles4(model)
         if (bundleGenerator && bundleGenerator[Symbol.iterator]) {
             for (let [locale, bundle] of bundleGenerator) {
                 // fallback bundle has the name ""
@@ -204,7 +183,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
             bundles = {}
         }
         // copied from ../compile/i18n.js
-        const { file: base = 'i18n' } = this.env.i18n
+        const { file: base = 'i18n' } = cds.env.i18n
         const file = path.join(bundleDest, base + '.json')
 
         // bundleDest might be null
@@ -240,7 +219,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
 
     static _find(srcDir, filter) {
         const files = []
-        BuildTaskHandlerInternal._traverseFileSystem(srcDir, files, filter)
+        this._traverseFileSystem(srcDir, files, filter)
         return files;
     }
 
@@ -252,15 +231,15 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
             // ignore if not existing
         }
         entries.map(subDirEntry => path.join(srcDir, subDirEntry)).forEach((entry) => {
-            BuildTaskHandlerInternal._handleResource(entry, files, filter)
+            this._handleResource(entry, files, filter)
         })
     }
 
     static _handleResource(entry, files, filter) {
         if (!filter || filter.call(this, entry)) {
-            var stats = BuildTaskHandlerInternal._getResourceStatus(entry)
+            var stats = this._getResourceStatus(entry)
             if (stats.isDirectory()) {
-                BuildTaskHandlerInternal._traverseFileSystem(entry, files, filter)
+                this._traverseFileSystem(entry, files, filter)
             } else if (stats.isFile() || stats.isSymbolicLink()) {
                 files.push(entry)
             }

package/bin/build/provider/buildTaskProviderInternal.js

@@ -1,24 +1,17 @@
 const fs = require('fs')
 const path = require('path')
-const { hasJavaNature, getProperty, isStreamlinedMtx, BuildError } = require('../util')
+const cds = require('../cds')
+const { hasJavaNature, getProperty, isStreamlinedMtx, getDefaultModelOptions, BuildError } = require('../util')
 const BuildTaskProvider = require('../buildTaskProvider')
 
 const { FILE_EXT_CDS, BUILD_TASK_HANA, BUILD_TASK_FIORI, BUILD_TASK_JAVA, BUILD_TASK_JAVA_CF, BUILD_TASK_NODEJS, BUILD_TASK_NODE_CF, BUILD_TASK_MTX,
-    BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION } = require("../constants")
+    BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION, CDS_MODEL_EXCLUDE_LIST } = require("../constants")
 
 class BuildTaskProviderInternal extends BuildTaskProvider {
-    constructor(cds, logger) {
+    constructor(logger) {
         super()
-        this._cds = cds
         this._logger = logger
     }
-
-    get cds() {
-        return this._cds
-    }
-    get env() {
-        return this.cds.env
-    }
     get logger() {
         return this._logger
     }
@@ -38,42 +31,49 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         return this._createTasks(tasks, buildOptions, tasks.length > 0)
     }
 
-    async applyTaskDefaults(task) {
+    async applyTaskDefaults(task, buildOptions) {
         const taskFor = BuildTaskProviderInternal._getForValueFromTask(task)
+        const { root: projectPath } = buildOptions
         task.for = task.for || taskFor
         task.use = task.use || `${BUILD_TASK_PREFIX}/${taskFor}`
 
-        if (!task.src) {
-            switch (taskFor) {
-                case BUILD_TASK_HANA:
-                    task.src = BuildTaskProviderInternal._normalizePath(this.env.folders.db)
-                    break
-                case BUILD_TASK_JAVA:
-                case BUILD_TASK_JAVA_CF:
-                case BUILD_TASK_NODEJS:
-                case BUILD_TASK_NODE_CF:
-                    task.src = BuildTaskProviderInternal._normalizePath(this.env.folders.srv)
-                    break
-                case BUILD_TASK_FIORI:
-                    task.src = BuildTaskProviderInternal._normalizePath(this.env.folders.app)
-                    break
-                case BUILD_TASK_MTX_EXTENSION:
-                case BUILD_TASK_MTX:
-                    task.src = "."
-                    break
-                case BUILD_TASK_MTX_SIDECAR:
-                    task.src = MTX_SIDECAR_FOLDER
-                    break
-                default:
-                    throw new Error(`Unknown build task '${task.use || task.for}'`)
-            }
+        switch (taskFor) {
+            case BUILD_TASK_HANA:
+                task.src = task.src || BuildTaskProviderInternal._normalizePath(cds.env.folders.db)
+                break
+            case BUILD_TASK_JAVA:
+            case BUILD_TASK_JAVA_CF:
+                task.src = task.src || BuildTaskProviderInternal._normalizePath(cds.env.folders.srv)
+                if (!task.options?.model) {
+                    BuildTaskProviderInternal._setDefaultModelOptionsForJava(task, projectPath)
+                }
+                break
+            case BUILD_TASK_NODEJS:
+            case BUILD_TASK_NODE_CF:
+                task.src = task.src || BuildTaskProviderInternal._normalizePath(cds.env.folders.srv)
+                break
+            case BUILD_TASK_FIORI:
+                task.src = task.src || BuildTaskProviderInternal._normalizePath(cds.env.folders.app)
+                break
+            case BUILD_TASK_MTX_SIDECAR:
+                task.src = task.src || MTX_SIDECAR_FOLDER
+                if (!task.options?.model && BuildTaskProviderInternal._hasJavaNature(projectPath, cds.env.folders.srv)) {
+                    BuildTaskProviderInternal._setDefaultModelOptionsForJava(task, projectPath)
+                }
+                break
+            case BUILD_TASK_MTX_EXTENSION:
+            case BUILD_TASK_MTX:
+                task.src = task.src || "."
+                break
+            default:
+                throw new Error(`Unknown build task '${task.use || task.for}'`)
         }
     }
 
     async _createTasks(tasks, buildOptions, addRequiredTasks) {
         const { root: projectPath } = buildOptions
-        let db = typeof this.env.folders.db === "string" ? [BuildTaskProviderInternal._normalizePath(this.env.folders.db)] : this.env.folders.db
-        let srv = typeof this.env.folders.srv === "string" ? [BuildTaskProviderInternal._normalizePath(this.env.folders.srv)] : this.env.folders.srv
+        let db = typeof cds.env.folders.db === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.db)] : cds.env.folders.db
+        let srv = typeof cds.env.folders.srv === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.srv)] : cds.env.folders.srv
 
         const dbOptions = {
             model: []
@@ -119,8 +119,8 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 }
             }
         } else {
-            !db && this.logger._debug && this.logger.debug(`project doesn't have a database module '${this.env.folders.db}'`)
-            !srv && this.logger._debug && this.logger.debug(`project doesn't have a service module '${this.env.folders.srv}'`)
+            !db && this.logger._debug && this.logger.debug(`project doesn't have a database module '${cds.env.folders.db}'`)
+            !srv && this.logger._debug && this.logger.debug(`project doesn't have a service module '${cds.env.folders.srv}'`)
 
             // create hana build task
             const dbTask = this._createDbTask(projectPath, db, dbOptions, buildOptions)
@@ -142,14 +142,14 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
 
     _createDbTask(projectPath, src, taskOptions, buildOptions) {
         this.logger.debug("determining database kind.")
-        if (!src || BuildTaskProviderInternal._isExtension(this.env)) {
+        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
             return null
         }
         let task = null
         if (this._useHana(projectPath, buildOptions)) {
             this.logger.debug("found HANA database.")
             // legacy build supports dest property
-            const compileDest = this.env.data?.dest
+            const compileDest = cds.env.data?.dest
             if (compileDest) {
                 //../db/src/gen
                 // compileDest is relative to src folder in modular build - resolve correctly
@@ -169,37 +169,37 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
     _useHana(projectPath, buildOptions) {
         if (getProperty(buildOptions, "for.hana.skipManifestGeneration") // deprecated fallback for webide fullstack and mtx
             || getProperty(buildOptions, "for.hana.contentManifest") === false // fallback for webide fullstack and mtx
-            || this.env.requires.db?.kind === "hana"
-            || this.env.requires.db?.dialect === "hana") {
+            || cds.env.requires.db?.kind === "hana"
+            || cds.env.requires.db?.dialect === "hana") {
 
             return true
         }
         // false if other db has been defined
-        if (this.env.requires.db?.kind) {
+        if (cds.env.requires.db?.kind) {
             return false
         }
         // check whether cds config represents a legacy build system config for which requires.db was not configured
         // Note: compat layer sets requires.db: {}
-        const userEnv = this.cds.env.for("cds", projectPath, false)
+        const userEnv = cds.env.for("cds", projectPath, false)
         return userEnv && (userEnv.data?.model || userEnv.service?.model)
     }
 
     _createMtxTask(projectPath, src, dest, tasks) {
         // MTX build task creation is NOT supported for Java projects
-        if (tasks.find(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
+        if (tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
             return null
         }
-        this.logger.debug("determining mtx type for nodejs")
+        this.logger.debug("determining mtx version of nodejs project")
 
-        if (isStreamlinedMtx(this.cds)) {
-            if (this.env.requires["cds.xt.ModelProviderService"]?.kind === "rest") { // "cds.xt.ModelProviderService": "from-sidecar"
+        if (isStreamlinedMtx()) {
+            if (cds.env.requires["cds.xt.ModelProviderService"]?.kind === "rest") { // "cds.xt.ModelProviderService": "from-sidecar"
                 this.logger.debug("Nodejs Streamlined MTX app with sidecar")
 
                 const sidecarPath = path.join(projectPath, MTX_SIDECAR_FOLDER)
                 if (!fs.existsSync(sidecarPath)) {
                     throw new BuildError("CDS build failed", `MTX sidecar directory '${sidecarPath}' not existing. Custom build task configuration necessary if the folder is named differently.`)
                 }
-                const sidecarEnv = this.env.for("cds", sidecarPath)
+                const sidecarEnv = cds.env.for("cds", sidecarPath)
                 if (sidecarEnv.requires["cds.xt.ModelProviderService"]?.kind === "in-sidecar") {
                     return {
                         for: BUILD_TASK_MTX_SIDECAR
@@ -208,7 +208,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 throw new BuildError("CDS build failed", 'Invalid MTX sidecar configuration. Make sure to add required service "cds.xt.ModelProviderService": "in-sidecar".')
             }
 
-            if (this.env.requires["cds.xt.ModelProviderService"]?.kind === "in-sidecar") {
+            if (cds.env.requires["cds.xt.ModelProviderService"]?.kind === "in-sidecar") {
                 // cds build is executed in sidecar folder
                 throw new BuildError("CDS build failed", "Invalid working directory. Make sure to execute 'cds build' in CAP project root directory.")
             }
@@ -220,14 +220,14 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
             }
         }
 
-        if (BuildTaskProviderInternal._isExtension(this.env)) {
+        if (BuildTaskProviderInternal._isMtxExtension()) {
             this.logger.debug("Streamlined MTX extension app")
             return {
                 for: BUILD_TASK_MTX_EXTENSION
             }
         }
 
-        if (this.env.requires.multitenancy) {
+        if (cds.env.requires.multitenancy) {
             this.logger.debug("Nodejs Classic MTX app without sidecar")
             return {
                 src: ".",
@@ -239,7 +239,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
 
     _createSrvTask(projectPath, src, taskOptions) {
         this.logger.debug("determining implementation technology")
-        if (!src || BuildTaskProviderInternal._isExtension(this.env)) {
+        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
             return null
         }
         let task = null
@@ -254,7 +254,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
     _createJavaTask(projectPath, src, taskOptions) {
         this.logger.debug("found implementation technology java")
         // legacy build supports dest property
-        const compileDest = this.env.service?.dest
+        const compileDest = cds.env.service?.dest
         if (compileDest) {
             // compileDest is relative to src folder in modular build - resolve correctly
             taskOptions.compileDest = path.relative(path.resolve(projectPath, src), path.resolve(projectPath, compileDest))
@@ -275,8 +275,20 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         }
     }
 
-    static _isExtension(env) {
-        return !!env.extends
+    static _isMtxExtension() {
+        return !!cds.env.extends
+    }
+
+    /**
+     * REVISIT: filter model options in order to avoid that the bootstrap service gets added to the application model
+     * https://github.tools.sap/cap/issues/issues/12770#issuecomment-1805719
+     */
+    static _setDefaultModelOptionsForJava(task, projectPath) {
+        const defaultModelPaths = new Set(getDefaultModelOptions(projectPath))
+        defaultModelPaths.add(task.src)
+        CDS_MODEL_EXCLUDE_LIST.forEach(m => defaultModelPaths.delete(m))
+        task.options = task.options || {}
+        task.options.model = [...defaultModelPaths]
     }
 
     /**

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

@@ -1,4 +1,5 @@
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const URL = require('url')
 const { getProperty, isOldJavaStack, relativePaths } = require('../../util')
@@ -44,14 +45,14 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
         fioriBuildOptions[BUILD_OPTION_OUTPUT_MODE] = OUTPUT_MODE_RESULT_ONLY
 
         try {
-            const edmxOptions = { version: this.env.odata?.version }
+            const edmxOptions = { version: cds.env.odata?.version }
 
             if (edmxOptions.version !== ODATA_VERSION_V2) {
                 const javaTask = this.buildOptions.tasks.find(task => task.for === BUILD_TASK_JAVA_CF || task.for === BUILD_TASK_JAVA)
 
                 if (javaTask
                     && await isOldJavaStack([javaTask.src, this.buildOptions.root])
-                    && !this.env.for("cds", this.buildOptions.root, false).odata?.version) {
+                    && !cds.env.for("cds", this.buildOptions.root, false).odata?.version) {
 
                     // old java stack
                     // default is now v4 and not v2 anymore, so overwrite with v2 if using default
@@ -62,7 +63,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
 
             for (let [appFolder, appModelGroup] of appModelGroups.entries()) {
                 this.logger.log(`building module [${appFolder}] using [${this.constructor.name}]`)
-                const modelPaths = this.cds.resolve(Array.from(appModelGroup.values()), this.buildOptions)
+                const modelPaths = cds.resolve(Array.from(appModelGroup.values()), this.buildOptions)
                 if (!modelPaths || modelPaths.length === 0) {
                     this.logger.log(`no model found`)
                     continue
@@ -71,7 +72,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
 
                 //cache model per fiori app root folder
                 const options = this.options()
-                const model = await this.cds.load(modelPaths, options)
+                const model = await cds.load(modelPaths, options)
                 fioriBuildOptions.appModel.set(appFolder, model)
 
                 await this.compileToEdmx(model, null, edmxOptions)
@@ -155,7 +156,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
         // NOTE: assumption is that the service definition can be resolved - either by
         // - defining corresponding using statement in annotations model or
         // - adding the service module folder to the model option
-        let service = this.cds.reflect(model).find(service => uriSegments.find(segment => service.name === segment))
+        let service = cds.reflect(model).find(service => uriSegments.find(segment => service.name === segment))
 
         if (service) {
             const allServices = this.getBuildOption("appEdmx").get(appFolder)

package/bin/build/provider/hana/2migration.js

@@ -6,6 +6,7 @@ const cds = require('../../cds'), { compiler: cdsc } = cds
 const cdscVersion = `-- generated by cds-compiler version ${cdsc.version()}`
 const { getArtifactCdsPersistenceName } = cdsc
 let logger = cds.log(LOG_MODULE_NAMES)
+const ANNO_PERSISTENCE_JOURNAL = '@cds.persistence.journal'
 
 module.exports = async (model, lastDevVersion, srcPath, options = {}) => {
   if (options.logger) {
@@ -29,7 +30,7 @@ module.exports = async (model, lastDevVersion, srcPath, options = {}) => {
       definitionResult.push(definitionEntry)
     }
   }
-  return { definitions: definitionResult, deletions, afterImage }
+  return { definitions: definitionResult, deletions, afterImage: _filterJournalArtifacts(afterImage) }
 }
 
 function _toHdiMigration(model, lastDevVersion, journalFileNames, options) {
@@ -55,7 +56,7 @@ ${migration ? migration.changeset.map(change => change.sql).join('\n') : 'Empty
 /**
  * Returns an object providing access to the .hdbmigrationtable file content and its corresponding filename.
  *
- * @param {String} srcPath Fully quailified path of the directory containing .hdbmigrationtable files
+ * @param {String} srcPath Fully qualified path of the directory containing .hdbmigrationtable files
  * @param {String} migration the migration descriptor
  * @param {String} tableSql SQL TABLE definition
  * @returns {Object} Providing access to 'content' and 'fileName'.
@@ -137,7 +138,7 @@ function _emptyMigration(name) {
 
 function _getJournalFileNames(model) {
   const journalNames = new Set(cds.reflect(model).all(item => {
-    if (item.kind === 'entity' && item['@cds.persistence.journal'] === true) {
+    if (item.kind === 'entity' && item[ANNO_PERSISTENCE_JOURNAL] === true) {
       if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
         logger.warn(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`)
       }
@@ -151,3 +152,19 @@ function _getJournalFileNames(model) {
 
   return journalNames
 }
+
+// delete all entities that are not relevant
+function _filterJournalArtifacts(csn) {
+  if (!csn) {
+    return
+  }
+  const dict = csn.definitions
+  for (const name in dict) {
+    if (dict[name][ANNO_PERSISTENCE_JOURNAL] !== true) {
+      delete dict[name]
+    }
+  }
+  // mark CSN as modified by cds build
+  csn.meta.build = `CDS Build v${cds.version}`
+  return csn;
+}

package/bin/build/provider/hana/2tabledata.js

@@ -11,6 +11,7 @@ module.exports = async (model, options = {}) => {
     logger = options.logger
   }
 
+  model = cds.minify(model)
   const baseDir = options.baseDir  // where the hdbtabledata will be located, for usage in the file_name path
   const dirs = Array.isArray(options.dirs) ? options.dirs : _csvDirs(model.$sources.map(path.dirname))
   if (dirs.length === 0) return []  // nothing to do

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

@@ -1,5 +1,6 @@
 const fs = require('fs')
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
 const { OUTPUT_MODE_RESULT_ONLY, BUILD_OPTION_OUTPUT_MODE, SKIP_HDBTABLEDATA_GENERATION, SKIP_PACKAGE_JSON_GENERATION,
     CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA, CSV_FILE_DETECTION, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, CONTENT_NODE_MODULES } = require('../../constants')
@@ -99,22 +100,21 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
      * @param {Object} model
      */
     async _copyResourcesExt(src, dest, model) {
-        const resources = Object.keys(await this.cds.deploy.resources(model))
+        const resources = Object.keys(await cds.deploy.resources(model)).reverse() // reverse to get reuse resources first and app resources last
         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 = []
         const dbSrc = path.join(src, 'src')
 
-        resources.forEach(res => {
+        // await each copy as order is important - reuse resources first and app resources last
+        for (const res of resources) {
             // 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))))
+                await this.copy(res).to(path.join(this.task.options.compileDest, csvFolder, path.basename(res)))
             }
-        })
-        await Promise.all(promises)
+        }
 
         // 2. staging build: copy files except *.cds, .env, default-env.json, ./node_modules/**
         if (this.isStagingBuild()) {
@@ -156,7 +156,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
                 if (fs.statSync(entry).isDirectory()) {
                     return !/(\/|\\)node_modules(\/|\\)?$/.test(entry)
                 }
-                return (!regex.test(entry) && entry !== this.env.build.outputfile) ||
+                return (!regex.test(entry) && entry !== cds.env.build.outputfile) ||
                     (regexData.test(entry) && !entry.startsWith(dbCsvDir) && !entry.startsWith(dbDataDir))
             })
         }
@@ -251,8 +251,8 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const pluginTypes = new Set([...REQUIRED_PLUGIN_TYPES, ...undeployTypes])
 
         // compile to old format (.hdbcds) or new format (.hdbtable / .hdbview)
-        const format = this.getBuildOption(DEPLOY_FORMAT) || this.env.requires.db?.[DEPLOY_FORMAT] || this.env.hana?.[DEPLOY_FORMAT]
-        if (!this.cds.compile.to[format]) {
+        const format = this.getBuildOption(DEPLOY_FORMAT) || cds.env.requires.db?.[DEPLOY_FORMAT] || cds.env.hana?.[DEPLOY_FORMAT]
+        if (!cds.compile.to[format]) {
             return Promise.reject(new Error(`Invalid deploy-format defined: ${format}`))
         }
 
@@ -267,8 +267,8 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
     async _compileToHdb(model, pluginTypes, format) {
         const relDest = path.relative(this.task.dest, this.task.options.compileDest)
         // enforces sqlNames option for compiler in tests
-        const options = { ...this.options(), sql_mapping: this.env.sql.names }
-        const result = this.cds.compile.to[format](model, options)
+        const options = { ...this.options(), sql_mapping: cds.env.sql.names }
+        const result = cds.compile.to[format](model, options)
         const promises = []
 
         for (const [content, key] of result) {
@@ -297,7 +297,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             lastDev = JSON.parse((await fs.promises.readFile(lastDevCsnDir, 'utf-8')).toString())
         }
         // 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 options = { ...this.options(), logger: this.logger, sql_mapping: cds.env.sql.names, "deploy-format": format }
 
         const compilationResult = await to_hdbmigration(model, lastDev, dbSrcDir, options)
         const definitions = compilationResult.definitions
@@ -324,18 +324,20 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
                 if (suffix === FILE_EXT_HDBTABLE) {
                     // issue an error in case a .hdbmigrationtable file already exists
                     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)
+                        throw new BuildError(`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.`)
                     }
                 }
             }
         }
         await Promise.all(promises)
-        await this._validateHdbmigrationtables()
+        await this._validateMigrationTableFiles()
 
         // update last development version
         if (afterImage) {
             if (migrationTableFiles.length > 0) {
-                await this.write(afterImage).to(lastDevCsnDir)
+                if (!HanaModuleBuilder._toEqualIgnoreMeta(lastDev, afterImage)) {
+                    await this.write(afterImage).to(lastDevCsnDir)
+                }
             }
         } else {
             throw new BuildError(`Inconsistent CDS compilation results - file ${lastDevCsnFolder} missing`)
@@ -373,7 +375,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             this.logger.error(`'HANA plugin not found for file suffix [${Array.from(plugins).join(',')}]`)
         }
         // TODO - Be on the save side for now - go for the content use case later on if this works as expected.
-        if (this.env.hana['deploy-format'] === 'hdbtable') {
+        if (cds.env.hana['deploy-format'] === 'hdbtable') {
             await this.write(content).to(hdiConfig)
         } else {
             await this.write(template).to(hdiConfig)
@@ -442,7 +444,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         return result
     }
 
-    async _validateHdbmigrationtables() {
+    async _validateMigrationTableFiles() {
         const dbSrcDir = path.join(this.task.src, "src")
         const migrationTableFiles = BuildTaskHandlerInternal._find(dbSrcDir, (res) => {
             return fs.statSync(res).isFile() && path.extname(res) === FILE_EXT_HDBMIGRATIONTABLE
@@ -463,5 +465,26 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
             }))
         }
     }
+
+    static _toEqualIgnoreMeta(csn1, csn2) {
+        function toString(csn) {
+            return JSON.stringify(csn, (k, v) => {
+                if (v?.creator) {
+                    // make sure it's the compiler meta tag
+                    if (k === 'meta' && v.creator?.startsWith('CDS Compiler'))
+                        return
+                }
+                return v
+            })
+        }
+
+        if (csn1 === csn2) {
+            return true
+        }
+        if (!csn1 || !csn2) {
+            return false
+        }
+        return toString(csn1) === toString(csn2)
+    }
 }
 module.exports = HanaModuleBuilder