@sap/cds 5.9.8 → 6.0.1

package/bin/build/provider/buildTaskProviderInternal.js

@@ -1,10 +1,11 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
-const { hasJavaNature, getProperty } = require('../util')
-const { FILE_EXT_CDS, BUILD_TASK_HANA, BUILD_TASK_FIORI, BUILD_TASK_JAVA, BUILD_TASK_NODE, BUILD_TASK_MTX,
-    CDS_CONFIG_PATH_SEP, BUILD_MODE_INPLACE, BUILD_TASK_PREFIX, BUILD_TASKS } = require("../constants")
+const { hasJavaNature, getProperty, isStreamlinedMtx } = 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 } = require("../constants")
+
 class BuildTaskProviderInternal extends BuildTaskProvider {
     constructor(cds, logger) {
         super()
@@ -33,8 +34,8 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         return require(`./${BuildTaskProviderInternal._getForValueFromTask(task)}`)
     }
 
-    async lookupTasks(buildOptions) {
-        return await this._createTasks(buildOptions)
+    async lookupTasks(tasks, buildOptions) {
+        return this._createTasks(tasks, buildOptions, tasks.length > 0)
     }
 
     async applyTaskDefaults(task) {
@@ -48,7 +49,9 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                     task.src = BuildTaskProviderInternal._normalizePath(this.env.folders.db)
                     break
                 case BUILD_TASK_JAVA:
-                case BUILD_TASK_NODE:
+                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:
@@ -57,16 +60,17 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 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}'`)
             }
         }
     }
 
-    async _createTasks(buildOptions) { // NOSONAR
-        this.logger.debug("determining CDS build tasks from CDS configuration - applying defaults")
+    async _createTasks(tasks, buildOptions, addRequiredTasks) {
         const { root: projectPath } = buildOptions
-        let tasks = []
         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
 
@@ -82,64 +86,62 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         if (Array.isArray(srv) && srv.length > 0) {
             srv = BuildTaskProviderInternal._getModuleFolder(projectPath, srv) || null
         }
-        if (db) {
+        // create required build tasks
+        if (addRequiredTasks) {
+            const mtxTask = tasks.find(task => task.for === BUILD_TASK_MTX || task.for === BUILD_TASK_MTX_SIDECAR)
+            if (mtxTask) {
+                //restore used tasks as they might have been filtered by 'cds build --for mtx'
+                if (mtxTask._uses) {
+                    mtxTask._uses.map(use => use.task).forEach(task => {
+                        if (!tasks.includes(task)) {
+                            tasks.push(task)
+                        }
+                    })
+                }
+                let dbTask = tasks.find(task => task.for === BUILD_TASK_HANA)
+                if (!dbTask) {
+                    //  db task might be missing if mtx task is enforced by 'cds build --for mtx'
+                    dbTask = this._createDbTask(projectPath, db, dbOptions)
+                    if (dbTask) {
+                        tasks.push(dbTask)
+                    }
+                }
+                if (dbTask && (!mtxTask._uses || !mtxTask._uses.map(use => use.task).includes(dbTask))) {
+                    const use = { task: dbTask }
+                    mtxTask._uses ? mtxTask._uses.push(use) : mtxTask._uses = [use]
+                }
+            }
+        } else {
+            if (!db) {
+                this.logger.log(`project doesn't have a database module [${this.env.folders.db}]`)
+            }
+            if (!srv) {
+                this.logger.log(`project doesn't have a service module '${this.env.folders.srv}'`)
+            }
             // create hana build task
             const dbTask = this._createDbTask(projectPath, db, dbOptions, buildOptions)
             if (dbTask) {
                 tasks.push(dbTask)
             }
-        } else {
-            this.logger.log(`project doesn't have a database module [${this.env.folders.db}]`)
-        }
-
-        if (srv) {
             // create java or node build task
             const srvTask = this._createSrvTask(projectPath, srv, srvOptions)
             if (srvTask) {
                 tasks.push(srvTask)
             }
-
-            // auto-create fiori build tasks only in Webide Fullstack compatibility mode
-            if (this.env.build.mode === BUILD_MODE_INPLACE) {
-                // create fiori build tasks
-                const defaultModels = this._getDefaultModelOptions(projectPath)
-                const fioriSrvOptions = {
-                    model: [...defaultModels]
-                }
-                const fioriTasks = this._createFioriTasks(projectPath, fioriSrvOptions)
-                if (fioriTasks.length > 0) {
-                    tasks = tasks.concat(fioriTasks)
-                    const appDirs = this._getFioriAppModelPaths(fioriTasks, projectPath)
-                    if (!BuildTaskProviderInternal._appDirsIncluded(defaultModels, appDirs)) {
-                        // adding additional appDirs, otherwise use default
-                        // tasks.forEach(task => task.options.model = BuildTaskProviderInternal._pushModelPaths(projectPath, defaultModels, appDirs))
-                        srvOptions.model = BuildTaskProviderInternal._pushModelPaths(projectPath, defaultModels, appDirs)
-                        dbOptions.model = BuildTaskProviderInternal._pushModelPaths(projectPath, defaultModels, appDirs)
-                    }
-                }
-            }
-        } else {
-            this.logger.log(`project doesn't have a service module '${this.env.folders.srv}'`)
-        }
-
-        // create mtx build task for node applications
-        if (db && tasks.find(task => task.for === BUILD_TASK_NODE)) {
-            const mtxTask = this._createMtxTask(srv)
+            // create mtx build task
+            const mtxTask = this._createMtxTask(projectPath, srv, srv, tasks)
             if (mtxTask) {
                 tasks.push(mtxTask)
             }
         }
-        return tasks
-    }
-
-    static _appDirsIncluded(defaultDirs, appDirs) {
-        return !appDirs.some(appDir => !defaultDirs.includes(appDir))
     }
 
     _createDbTask(projectPath, src, taskOptions, buildOptions) {
         this.logger.debug("determining database kind.")
+        if (!src) {
+            return null
+        }
         let task = null
-
         if (this._useHana(projectPath, buildOptions)) {
             this.logger.debug("found HANA database.")
             // legacy build supports dest property
@@ -149,7 +151,6 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 // compileDest is relative to src folder in modular build - resolve correctly
                 taskOptions.compileDest = path.relative(path.resolve(projectPath, src), path.resolve(projectPath, compileDest))
             }
-
             task = {
                 src: src,
                 for: BUILD_TASK_HANA,
@@ -162,8 +163,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
     }
 
     _useHana(projectPath, buildOptions) {
-        if (this.env.get("build.mode") === BUILD_MODE_INPLACE
-            || getProperty(buildOptions, "for.hana.skipManifestGeneration") // deprecated fallback for webide fullstack and mtx
+        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.get("requires.db.kind") === "hana"
             || this.env.get("requires.db.dialect") === "hana") {
@@ -180,151 +180,83 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         return userEnv && (userEnv.get("data.model") || userEnv.get("service.model"))
     }
 
-    _createMtxTask(srv) {
-        this.logger.debug("determining single or multi-tenant strategy.")
+    _createMtxTask(projectPath, src, dest, tasks) {
         let task = null
-
-        if (this.env.get("requires.multitenancy") && (this.env.get("requires.db.kind") === "hana" || this.env.get("requires.db.dialect") === "hana")) {
-            this.logger.debug("found multi-tenant app.")
+        const isJava = tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)
+        const isNode = tasks.some(task => task.for === BUILD_TASK_NODEJS || task.for === BUILD_TASK_NODE_CF)
+
+        this.logger.debug("determining mtx type for nodejs")
+        if (isStreamlinedMtx(this.cds) && !isJava) {
+            if (this.env.requires["cds.xt.ModelProviderService"]) {
+                // sidecar scenario for Nodejs or Java
+                const sidecarEnv = this.env.for("cds", path.join(projectPath, MTX_SIDECAR_FOLDER))
+                if (this._isSidecar(sidecarEnv)) {
+                    task = {
+                        for: BUILD_TASK_MTX_SIDECAR
+                    }
+                    this.logger.debug(`${isJava ? "Java" : "Nodejs"} MTX sidecar scenario`)
+                } else {
+                    throw Error(`MTX sidecar module '${MTX_SIDECAR_FOLDER}' not found`)
+                }
+            } else if (isNode) {
+                task = {
+                    for: BUILD_TASK_MTX,
+                    src
+                }
+                this.logger.debug("Nodejs MTX scenario without sidecar")
+            }
+        } else if (this.env.get("requires.multitenancy") && isNode) {
+            // classic mtx
             task = {
                 src: ".",
                 for: BUILD_TASK_MTX,
-                dest: srv
+                dest
             }
-        } else {
-            this.logger.debug("found single-tenant app - skipping mtx build task")
+            this.logger.debug("classic Nodejs MTX scenario")
         }
         return task
     }
 
     _createSrvTask(projectPath, src, taskOptions) {
-        this.logger.debug("fetermining implementation technology")
-        let task = this._createJavaTask(projectPath, src, taskOptions)
-
-        if (!task) {
-            this.logger.debug("found implementation technology node")
-            task = {
-                src: src,
-                for: BUILD_TASK_NODE,
-                options: taskOptions
-            }
+        this.logger.debug("determining implementation technology")
+        if (!src) {
+            return null
+        }
+        let task = null
+        if (this._hasJavaNature(projectPath, src)) {
+            task = this._createJavaTask(projectPath, src, taskOptions)
+        } else {
+            task = this._createNodeTask(src, taskOptions)
         }
         return task
     }
 
     _createJavaTask(projectPath, src, taskOptions) {
-        if (this._hasJavaNature(projectPath, src)) {
-            this.logger.debug("found implementation technology java")
-            // legacy build supports dest property
-            const compileDest = this.env.get("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))
-            }
-            return {
-                src: src,
-                for: BUILD_TASK_JAVA,
-                options: taskOptions
-            }
+        this.logger.debug("found implementation technology java")
+        // legacy build supports dest property
+        const compileDest = this.env.get("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))
         }
-        return null
-    }
-
-    /**
-     * Only used in WebIDE Fullstack szenario
-     * @deprecated
-     * @param {*} projectPath
-     * @param {*} fioriSrvOptions
-     * @returns
-     */
-    _createFioriTasks(projectPath, fioriSrvOptions) {
-        let tasks = []
-        this.logger.debug("determining fiori modules - matching modules */webapp/manifest.json")
-        // fiori-app build-tasks
-        let appDirs = this.env.ui && this.env.ui.apps ? this.env.ui.apps : undefined
-        if (!appDirs) {
-            const DEFAULT_UI_MANIFEST_PATTERNS = [
-                "*/webapp/manifest.json" // top-level UI apps  (typical Web IDE layout)
-            ]
-            let app = BuildTaskProviderInternal._normalizePath(this.env.folders.app)
-            if (typeof app === "string") {
-                DEFAULT_UI_MANIFEST_PATTERNS.push(path.join(app, "*/webapp/manifest.json"))
-            } else if (Array.isArray(app)) {
-                app.forEach(entry => DEFAULT_UI_MANIFEST_PATTERNS.push(path.join(entry, "*/webapp/manifest.json")))
-            }
-
-            const manifestPaths = BuildTaskProviderInternal._findFiles(projectPath, DEFAULT_UI_MANIFEST_PATTERNS)
-
-            // use '/' for any cds-config path entries
-            appDirs = manifestPaths.map(manifestPath => path.relative(projectPath, manifestPath.split("webapp")[0]).replace(/\\/g, CDS_CONFIG_PATH_SEP))
-        } else {
-            appDirs = appDirs.map(appDir => {
-                if (path.basename(appDir) === "webapp") {
-                    return path.dirname(appDir)
-                }
-                return appDir
-            })
+        return {
+            src: src,
+            for: BUILD_TASK_JAVA,
+            options: taskOptions
         }
-        this.logger._debug && this.logger.debug(`found fiori app paths [${appDirs}]`)
-        appDirs.forEach(appDir => {
-            appDir = BuildTaskProviderInternal._normalizePath(appDir)
-            let modelPaths = this._resolveModel(path.resolve(projectPath, appDir))
-            const newTask = {
-                src: appDir,
-                for: "fiori",
-                options: {
-                    model: BuildTaskProviderInternal._pushModelPaths(projectPath, fioriSrvOptions.model, modelPaths.length > 0 ? [appDir] : [])
-                }
-            }
-            if (!tasks.find((task) => {
-                return task.src === newTask.src && task.for === newTask.for
-            })) {
-                tasks.push(newTask)
-            }
-        })
-        return tasks
-    }
-
-    _getDefaultModelOptions(projectPath) {
-        // clear model cache - see https://github.tools.sap/cap/cds/pull/181
-        // Required as cds.serve is invoking cds.resolve('*') which caused cds to cache the current model state
-        // which in turn screwed-up all subsequent tests - see ./lib/compile/resolve.js#L67 and ./lib/compile/resolve.js#L58
-        const fts = this.env.features.folders
-        const modelPaths = this.cds.resolve(!fts ? '*' : ['*', fts], false)
-        return BuildTaskProviderInternal._pushModelPaths(projectPath, [], modelPaths)
     }
 
-    _getFioriAppModelPaths(tasks, projectPath) {
-        const appDirs = []
-
-        tasks.forEach((task) => {
-            // the build task is only relevant if it contains an annotations model
-            // only in that case options.model is containing an entry <task.src>
-            if (task.for === BUILD_TASK_FIORI && task.options.model.find(cur => cur === task.src)) {
-                const appRoot = task.src.split(CDS_CONFIG_PATH_SEP)[0]
-                let appDir = task.src
-                let model = this._resolveModel(path.resolve(projectPath, appRoot))
-                if (model.length > 0) {
-                    // appRoot may contain index.cds file
-                    appDir = appRoot
-                }
-
-                if (appDir && !appDirs.find(cur => cur === appDir)) {
-                    appDirs.push(appDir)
-                }
-            }
-        })
-        return appDirs
+    _createNodeTask(src, taskOptions) {
+        this.logger.debug("found implementation technology node")
+        return {
+            src: src,
+            for: BUILD_TASK_NODEJS,
+            options: taskOptions
+        }
     }
 
-    _resolveModel(modelPath) {
-        let model
-        try {
-            model = this.cds.resolve(modelPath)
-        } catch (e) {
-            // silently ignore -> assume no model exists
-        }
-        return model ? model : []
+    _isSidecar(env) {
+        return env.requires['cds.xt.ModelProviderService']?.root
     }
 
     /**
@@ -340,69 +272,6 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         return task.for ? task.for : task.use && task.use.substring(BUILD_TASK_PREFIX.length + 1)
     }
 
-    static _pushModelPaths(projectPath, model, ...modelPaths) {
-        model = new Set(model)
-        // may contain nested arrays
-        modelPaths = BuildTaskProviderInternal._flatten(modelPaths)
-
-        modelPaths.forEach(m => {
-            if (m && !model.has(m) && !model.has(m + "/")) {
-                const dir = path.resolve(projectPath, m)
-                if (fs.existsSync(dir)) {
-                    model.add(BuildTaskProviderInternal._normalizePath(m))
-                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compability to old build configs
-                    model.add(m)
-                }
-            }
-        })
-        return [...model]
-    }
-
-    static _flatten(modelPaths) {
-        return modelPaths.reduce((acc, m) => {
-            if (Array.isArray(m)) {
-                acc = acc.concat(BuildTaskProviderInternal._flatten(m))
-            } else if (m) {
-                acc.push(m)
-            }
-            return acc
-        }, [])
-    }
-
-    static _strippedPath(p) {
-        return p.replace(/^(\/|\\)/, '').replace(/(\/|\\)$/, '') // strip leading and trailing slash or backslash
-    }
-
-    static _readDirs(dir) {
-        if (!fs.existsSync(dir) || !fs.lstatSync(dir).isDirectory()) return []
-        return fs.readdirSync(dir)
-            .map(f => path.resolve(dir, f))
-            .filter(f => fs.lstatSync(f).isDirectory())
-    }
-
-    static _findFiles(projectPath, patterns) {
-        const files = []
-        patterns.forEach(pattern => {
-            const starIndex = pattern.indexOf('*')
-            if (starIndex >= 0) {
-                const dir = path.resolve(projectPath, pattern.substring(0, starIndex))
-                const subPattern = BuildTaskProviderInternal._strippedPath(pattern.substring(starIndex + 1, pattern.length)) // '*/foo/bar/' -> 'foo/bar'
-                files.push(...BuildTaskProviderInternal._readDirs(dir).map(subDir => BuildTaskProviderInternal._findFiles(subDir, [subPattern])))
-            } else {
-                const file = path.resolve(projectPath, pattern)
-                if (fs.existsSync(file)) files.push(file)
-            }
-        })
-
-        function _flatten(o, arr = []) {
-            if (o) {
-                Array.isArray(o) ? o.forEach(e => _flatten(e, arr)) : arr.push(o)
-            }
-            return arr
-        }
-        return _flatten(files)
-    }
-
     /**
      * For valid paths remove trailing '/'. Otherwise return as is - important!!
      * @param {*} dir

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

@@ -3,7 +3,7 @@ const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const URL = require('url')
 const { getProperty, isOldJavaStack, relativePaths } = require('../../util')
 
-const { ODATA_VERSION, ODATA_VERSION_V2, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, BUILD_TASK_FIORI, BUILD_TASK_JAVA, CDS_CONFIG_PATH_SEP } = require('../../constants')
+const { ODATA_VERSION, ODATA_VERSION_V2, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, BUILD_TASK_FIORI, BUILD_TASK_JAVA_CF, CDS_CONFIG_PATH_SEP, BUILD_TASK_JAVA } = require('../../constants')
 
 /**
  * With cds 4 service metadata for the UI service binding is no longer created by default.
@@ -47,7 +47,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
             const edmxOptions = { version: this.env.get(ODATA_VERSION) }
 
             if (edmxOptions.version !== ODATA_VERSION_V2) {
-                const javaTask = this.buildOptions.tasks.find(task => task.for === BUILD_TASK_JAVA)
+                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])

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

@@ -1,10 +1,10 @@
 const path = require('path')
 const parser = require('./migrationtable')
-const { getProperty, BuildError } = require('../../util')
-const { getArtifactCdsPersistenceName } = require('@sap/cds-compiler')
+const { BuildError } = require('../../util')
 const { LOG_MODULE_NAMES } = require('../../constants')
-const cdscVersion = `-- generated by cds-compiler version ${require('@sap/cds-compiler/package.json').version}`
 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)
 
 module.exports = async (model, lastDevVersion, srcPath, options = {}) => {
@@ -22,7 +22,7 @@ module.exports = async (model, lastDevVersion, srcPath, options = {}) => {
     if (suffix === '.hdbtable') {
       if (journalFileNames.has(name)) {
         const migration = migrations.find(migration => migration.name === name)
-        definitionEntry = await _2migrationtable(srcPath, migration || _emptyMigration(name), sql, options)
+        definitionEntry = await _2migrationtable(srcPath, migration || _emptyMigration(name), sql)
       }
     }
     if (definitionEntry) {
@@ -58,10 +58,9 @@ ${migration ? migration.changeset.map(change => change.sql).join('\n') : 'Empty
  * @param {String} srcPath Fully quailified path of the directory containing .hdbmigrationtable files
  * @param {String} migration the migration descriptor
  * @param {String} tableSql SQL TABLE definition
- * @param {Object} options compile options
  * @returns {Object} Providing access to 'content' and 'fileName'.
  */
-async function _2migrationtable(srcPath, migration, tableSql, options) {
+async function _2migrationtable(srcPath, migration, tableSql) {
   let migrationTableModel = null
   const file = path.join(srcPath, migration.name + migration.suffix)
   try {
@@ -73,10 +72,11 @@ async function _2migrationtable(srcPath, migration, tableSql, options) {
 
   if (migrationTableModel) {
     // adding new changeset if change exist, ignore otherwise
-    const migrationEntry = _getNewMigrationEntry(migration.changeset, migrationTableModel.versionNumber, options)
+    const migrationEntry = _getNewMigrationEntry(migration.changeset, migrationTableModel.versionNumber)
     if (migrationEntry) {
       const versionNumber = migrationTableModel.versionNumber + 1
-      const migrations = `${migrationEntry.content}${migrationTableModel.migrations.entries.length > 0 ? '\n\n' : ''}${migrationTableModel.migrations.toString()}`
+      const migrationCount = migrationTableModel.migrations.entries.length
+      const migrations = `${migrationEntry.content}${migrationCount > 0 ? '\n' : ''}${migrationTableModel.migrations.toString()}${migrationCount > 0 ? '\n' : ''}`
       return {
         name: migration.name,
         suffix: migration.suffix,
@@ -90,10 +90,10 @@ async function _2migrationtable(srcPath, migration, tableSql, options) {
     }
   }
   // initial migration file version
-  return { name: migration.name, suffix: migration.suffix, content: `== version=1\n${tableSql}`, changed: true }
+  return { name: migration.name, suffix: migration.suffix, content: `== version=1\n${tableSql}\n`, changed: true }
 }
 
-function _getNewMigrationEntry(changeset, currentVersion, options) {
+function _getNewMigrationEntry(changeset, currentVersion) {
   if (changeset && changeset.length > 0) {
     const dropColumns = changeset.some(e => e.drop)
     const manualChange = changeset.some(e => !e.sql)
@@ -144,7 +144,7 @@ function _getJournalFileNames(model) {
       return true
     }
     return false
-  }).map(entity => getArtifactCdsPersistenceName(entity.name, 'quoted', model)))
+  }).map(entity => getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')))
 
   logger._debug && logger.debug(`\n[hdbmigrationtable] found ${journalNames.size} model entities annotated with '@cds.persistence.journal`)
   logger._debug && logger.debug(`[hdbmigrationtable] ${[...journalNames].join(', ')}\n`)

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

@@ -40,7 +40,7 @@ async function _tabledata4(dir, csvFile, model, baseDir, naming) {
     return logger.warn(`[hdbtabledata] ${message}`)
   }
 
-  const tableName = getArtifactCdsPersistenceName(entity.name, naming, model)
+  const tableName = getArtifactCdsPersistenceName(entity.name, naming, model, 'hana')
   const tabledata = { format_version: 1, imports: [] }
   const _import = {
     target_table: tableName,
@@ -57,7 +57,7 @@ async function _tabledata4(dir, csvFile, model, baseDir, naming) {
   cols.forEach(csvCol => {
     // Only translate the column name, but do not check for the existence of the element in the model.
     // This gets tricky for foreign key elements, and the DB deployment anyways checks the column.
-    const tableCol = getElementCdsPersistenceName(csvCol, naming)
+    const tableCol = getElementCdsPersistenceName(csvCol, naming, 'hana')
     _import.import_settings.import_columns.push(tableCol)
     _import.column_mappings[tableCol] = csvCol
   })
@@ -68,7 +68,7 @@ async function _tabledata4(dir, csvFile, model, baseDir, naming) {
   if (entity.elements.locale) {
     const locale = /_texts_(.+)\.csv$/.test(csvFile) ? RegExp.$1 : null
     if (locale) {
-      const localeKey = getElementCdsPersistenceName(entity.elements.locale.name/*usually 'LOCALE'*/, naming)
+      const localeKey = getElementCdsPersistenceName(entity.elements.locale.name/*usually 'LOCALE'*/, naming, 'hana');
       _import.import_settings.include_filter.push({ [localeKey]: locale })
     }
   }