@sap/cds 6.8.4 → 7.0.1

package/bin/build/provider/hana/template/.hdiconfig-hanacloud

@@ -1,137 +0,0 @@
-
-{
-    "file_suffixes": {
-        "csv": {
-            "plugin_name": "com.sap.hana.di.tabledata.source"
-        },
-        "hdbafllangprocedure": {
-            "plugin_name": "com.sap.hana.di.afllangprocedure"
-        },
-        "hdbanalyticprivilege": {
-            "plugin_name": "com.sap.hana.di.analyticprivilege"
-        },
-        "hdbcalculationview": {
-            "plugin_name": "com.sap.hana.di.calculationview"
-        },
-        "hdbcollection": {
-            "plugin_name": "com.sap.hana.di.collection"
-        },
-        "hdbconstraint": {
-            "plugin_name": "com.sap.hana.di.constraint"
-        },
-        "hdbdropcreatetable": {
-            "plugin_name": "com.sap.hana.di.dropcreatetable"
-        },
-        "hdbflowgraph": {
-            "plugin_name": "com.sap.hana.di.flowgraph"
-        },
-        "hdbfunction": {
-            "plugin_name": "com.sap.hana.di.function"
-        },
-        "hdbgraphworkspace": {
-            "plugin_name": "com.sap.hana.di.graphworkspace"
-        },
-        "hdbhadoopmrjob": {
-            "plugin_name": "com.sap.hana.di.virtualfunctionpackage.hadoop"
-        },
-        "hdbindex": {
-            "plugin_name": "com.sap.hana.di.index"
-        },
-        "hdblibrary": {
-            "plugin_name": "com.sap.hana.di.library"
-        },
-        "hdbmigrationtable": {
-            "plugin_name": "com.sap.hana.di.table.migration"
-        },
-        "hdbprocedure": {
-            "plugin_name": "com.sap.hana.di.procedure"
-        },
-        "hdbprojectionview": {
-            "plugin_name": "com.sap.hana.di.projectionview"
-        },
-        "hdbprojectionviewconfig": {
-            "plugin_name": "com.sap.hana.di.projectionview.config"
-        },
-        "hdbreptask": {
-            "plugin_name": "com.sap.hana.di.reptask"
-        },
-        "hdbresultcache": {
-            "plugin_name": "com.sap.hana.di.resultcache"
-        },
-        "hdbrole": {
-            "plugin_name": "com.sap.hana.di.role"
-        },
-        "hdbroleconfig": {
-            "plugin_name": "com.sap.hana.di.role.config"
-        },
-        "hdbsearchruleset": {
-            "plugin_name": "com.sap.hana.di.searchruleset"
-        },
-        "hdbsequence": {
-            "plugin_name": "com.sap.hana.di.sequence"
-        },
-        "hdbstatistics": {
-            "plugin_name": "com.sap.hana.di.statistics"
-        },
-        "hdbstructuredprivilege": {
-            "plugin_name": "com.sap.hana.di.structuredprivilege"
-        },
-        "hdbsynonym": {
-            "plugin_name": "com.sap.hana.di.synonym"
-        },
-        "hdbsynonymconfig": {
-            "plugin_name": "com.sap.hana.di.synonym.config"
-        },
-        "hdbsystemversioning": {
-            "plugin_name": "com.sap.hana.di.systemversioning"
-        },
-        "hdbtable": {
-            "plugin_name": "com.sap.hana.di.table"
-        },
-        "hdbtabledata": {
-            "plugin_name": "com.sap.hana.di.tabledata"
-        },
-        "hdbtabletype": {
-            "plugin_name": "com.sap.hana.di.tabletype"
-        },
-        "hdbtrigger": {
-            "plugin_name": "com.sap.hana.di.trigger"
-        },
-        "hdbview": {
-            "plugin_name": "com.sap.hana.di.view"
-        },
-        "hdbvirtualfunction": {
-            "plugin_name": "com.sap.hana.di.virtualfunction"
-        },
-        "hdbvirtualfunctionconfig": {
-            "plugin_name": "com.sap.hana.di.virtualfunction.config"
-        },
-        "hdbvirtualpackagehadoop": {
-            "plugin_name": "com.sap.hana.di.virtualpackage.hadoop"
-        },
-        "hdbvirtualpackagesparksql": {
-            "plugin_name": "com.sap.hana.di.virtualpackage.sparksql"
-        },
-        "hdbvirtualprocedure": {
-            "plugin_name": "com.sap.hana.di.virtualprocedure"
-        },
-        "hdbvirtualprocedureconfig": {
-            "plugin_name": "com.sap.hana.di.virtualprocedure.config"
-        },
-        "hdbvirtualtable": {
-            "plugin_name": "com.sap.hana.di.virtualtable"
-        },
-        "hdbvirtualtableconfig": {
-            "plugin_name": "com.sap.hana.di.virtualtable.config"
-        },
-        "properties": {
-            "plugin_name": "com.sap.hana.di.tabledata.properties"
-        },
-        "tags": {
-            "plugin_name": "com.sap.hana.di.tabledata.properties"
-        },
-        "txt": {
-            "plugin_name": "com.sap.hana.di.copyonly"
-        }
-    }
-}

package/bin/build/provider/hana/template/.hdinamespace

@@ -1,4 +0,0 @@
-{
-    "name": "",
-    "subfolder": "ignore"
-}

package/bin/build/provider/hana/template/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "deploy",
-  "dependencies": {
-    "@sap/hdi-deploy": "^4"
-  },
-  "engines": {
-    "node": "^14 || ^16 || ^18"
-  },
-  "scripts": {
-    "start": "node node_modules/@sap/hdi-deploy/deploy.js"
-  }
-}

package/bin/build/provider/hana/template/undeploy.json

@@ -1,5 +0,0 @@
-[
-    "src/gen/**/*.hdbview",
-    "src/gen/**/*.hdbindex",
-    "src/gen/**/*.hdbconstraint"
-]

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

@@ -1,111 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const cds = require('../../cds')
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const { isOldJavaStack, BuildError } = require('../../util')
-
-const { BUILD_OPTION_OUTPUT_MODE, ODATA_VERSION_V2, OUTPUT_MODE_RESULT_ONLY, FILE_EXT_CDS, SKIP_ASSERT_COMPILER_V2, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
-const { INFO } = require('../../buildTaskHandler')
-
-const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
-
-class JavaModuleBuilder 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: cds.env.odata?.version
-        }
-
-        if (await isOldJavaStack([src, this.buildOptions.root])) {
-            if (!this._isCompilerV1() && !cds.env.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 (!cds.env.for('cds', this.buildOptions.root, false).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.persistence.name' annotations are required by old java stack
-            if (cds.env.sql.names !== 'plain') {
-                odataOptions.sql_mapping = cds.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
-            const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
-            const i18n = await this.collectLanguageBundles(model, path.join(this.task.dest, i18nFolder))
-            if (i18n) {
-                this._result.languageBundles = i18n.bundles
-            }
-        }
-        if (this.isStagingBuild() && !this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            await this._copyNativeContent(src, dest)
-        }
-        return this._result
-    }
-
-    async clean() {
-        if (this.isStagingBuild()) {
-            return super.clean()
-        }
-        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 = cds.compile.for.java(model, {
-            ...this._options4odata(),
-            ...compileOptions
-        })
-        const csnFile = path.join(csnDest, DEFAULT_CSN_FILE_NAME)
-        let csnModel
-        // adding csn to build result containing @source and _where persisted properties
-        if (this.hasBuildOption(CONTENT_DEFAULT_CSN, true)) { //default true or undefined
-            const csnStr = await this.compileToJson(model, csnFile)
-            csnModel = JSON.parse(csnStr)
-            csnModel.meta = model.meta
-        } else {
-            const csnStr = await this.compileToJson(m, csnFile)
-            csnModel = JSON.parse(csnStr)
-            csnModel.meta = m.meta
-        }
-        this._result.csn = csnModel
-
-        return m
-    }
-
-    _isCompilerV1() {
-        const version = cds.compiler.version()
-        const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
-        return match && match[1] === 1
-    }
-}
-module.exports = JavaModuleBuilder

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

@@ -1 +0,0 @@
-module.exports = require('../java')

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

@@ -1,268 +0,0 @@
-/* eslint-disable no-empty */
-const fs = require('fs')
-const path = require('path')
-const cds = require('../../cds')
-const BuildTaskProviderInternal = require("../buildTaskProviderInternal")
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const { isStreamlinedMtx, hasJavaNature } = require('../../util')
-const ResourcesTarProvider = require('./resourcesTarBuilder')
-
-const { BUILD_TASK_HANA, FOLDER_GEN } = require('../../constants')
-const { WARNING, ERROR } = BuildTaskHandlerEdmx
-const FOLDER_SDC = "sdc"
-const FOLDER_NODE_MODULES = "node_modules"
-const FOLDER_TEMPLATES = "tpl"
-
-class MtxModuleBuilder extends BuildTaskHandlerEdmx {
-    get priority() {
-        // should be scheduled after 'hana' build tasks are finished
-        return BuildTaskHandlerEdmx.PRIORITY_MIN_VALUE
-    }
-    init() {
-        super.init()
-
-        if (hasJavaNature([this.buildOptions.root, this.task.src, cds.env.folders.srv])) {
-            // Java projects having this build task configured are using Classic MTX
-            // Streamlined MTX based Java projects have to configure the 'mtx-sidecar' build task instead.
-            this._delegate = new ClassicMtxBuilder(this)
-        } else {
-            // Nodejs projects
-            if (isStreamlinedMtx()) {
-                this._delegate = new StreamlinedMtxBuilder(this)
-            } else {
-                this._delegate = new ClassicMtxBuilder(this)
-            }
-        }
-    }
-
-    async build() {
-        return this._delegate.build()
-    }
-
-    async clean() {
-        return this._delegate.clean()
-    }
-}
-
-class StreamlinedMtxBuilder {
-    constructor(handler) {
-        this._handler = handler
-    }
-    async build() {
-        // Non-sidecar scenario: model-provider is implemented by the Nodejs app itself (default for Nodejs).
-        // Only create resources TAR, compiled CSN(s) are created by the Nodejs app build task.
-        const dest = cds.env.build?.target !== "." ? this._handler.task.dest : path.join(this._handler.task.dest, FOLDER_GEN)
-        const model = await this._handler.model()
-        if (!model) {
-            return
-        }
-        return new ResourcesTarProvider(this._handler).createTar(dest, model)
-    }
-    async clean() {
-        // staging build content is deleted by BuildTaskEngine
-        if (this._handler.buildOptions.root === this._handler.buildOptions.target) {
-            // remove 'gen' folder
-            return fs.promises.rm(path.join(this._handler.task.dest, FOLDER_GEN), { force: true, recursive: true })
-        }
-    }
-}
-
-class ClassicMtxBuilder {
-    constructor(handler) {
-        this._handler = handler
-    }
-
-    async build() {
-        if (cds.env.requires.toggles === true) {
-            throw new Error("Feature toggles are only supported by Streamlined MTX")
-        }
-
-        const buildOptions = this._handler.buildOptions
-        const destSdc = buildOptions.root === buildOptions.target ? path.join(this._handler.task.dest, FOLDER_GEN, FOLDER_SDC) : path.join(this._handler.task.dest, FOLDER_SDC)
-        const model = await this._handler.model()
-        if (!model) {
-            return
-        }
-
-        // custom build tasks for srv and db modules might be defined
-        const tenantDbPath = await this._getHanaTenantDbPath()
-
-        // validate extension whitelists defined for this SaaS application
-        this._validateExtensionAllowLists(model, tenantDbPath)
-
-        // copy base model sources
-        await Promise.all(model.$sources.map(src => {
-            if (src.includes(FOLDER_NODE_MODULES)) {
-                return this._handler.copy(src).to(path.join(destSdc, src.substr(src.indexOf(FOLDER_NODE_MODULES))))
-            } else {
-                const relSrc = path.relative(buildOptions.root, src)
-                if (relSrc.startsWith("..")) {
-                    this._handler.logger.warn(`model file is out of project scope, skipping file ${src}`)
-                    return Promise.resolve()
-                }
-                return this._handler.copy(src).to(path.join(destSdc, relSrc))
-            }
-        }))
-
-        // collect and write language bundles into single i18n.json file
-        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
-        const i18n = await this._handler.collectLanguageBundles(model, path.join(destSdc, i18nFolder))
-        if (i18n) {
-            this._handler._result.languageBundles = i18n.bundles
-        }
-
-        // copy native hana content and templates
-        await this._copyNativeContent(this._handler.task.src, destSdc, tenantDbPath)
-    }
-
-    async clean() {
-        // staging build content is deleted by BuildTaskEngine
-        if (this._handler.buildOptions.root === this._handler.buildOptions.target) {
-            // remove 'gen' folder
-            return fs.promises.rm(path.join(this._handler.task.dest, FOLDER_GEN), { force: true, recursive: true })
-        }
-    }
-
-    async _copyNativeContent(src, dest, tenantDbPath) {
-        // copying templates
-        const tplSrc = path.join(src, FOLDER_TEMPLATES)
-        if (fs.existsSync(tplSrc)) {
-            const tplDest = path.join(path.dirname(dest), FOLDER_TEMPLATES)
-            await this._copyTemplates(tplSrc, tplDest)
-        }
-
-        if (tenantDbPath) {
-            // copy native HANA artifacts, e.g. .csv files
-            const dbDest = path.resolve(dest, path.relative(this._handler.buildOptions.root, tenantDbPath))
-            if (!src.startsWith(dbDest)) { // ensure valid paths
-                await this._copyNativeHanaContent(tenantDbPath, dbDest)
-            } else {
-                this.pushMessage(`Invalid mtx build task configuration detected, destination folder ${dbDest} must not be nested within 'src' folder`, ERROR)
-            }
-        }
-    }
-
-    async _copyNativeHanaContent(src, dest) {
-        return this._handler.copyNativeContent(src, dest, (entry) => {
-            if (fs.statSync(entry).isDirectory()) {
-                const folderName = path.basename(entry)
-                return folderName !== FOLDER_NODE_MODULES
-            }
-            // also add table data properties files containing translated texts
-            return /\.csv$|\.hdb.*$|^\.hdi.*|\.properties$|^undeploy\.json/.test(path.basename(entry))
-        })
-    }
-
-    async _copyTemplates(src, dest) {
-        return this._handler.copyNativeContent(src, dest, (entry) => {
-            if (fs.statSync(entry).isFile()) {
-                return /\.cds$/.test(path.basename(entry))
-            }
-            return true
-        })
-    }
-
-    /**
-     * Extensions shall be restricted to relevant entities, by default all entities and services can be extended.
-     * Empty whitelists indicate that all services or entities can be extended.
-     * <br>
-     * A warning is logged in case neither a 'entity-whitelist' nor a o service-whitelist has been defined.
-     * An error is thrown in case a invalid entry is found.
-     *
-     * @param {Object} model - the reflected csn for this SaaS application
-     */
-    _validateExtensionAllowLists(model, tenantDbPath) {
-        let entityWhitelist = cds.env.mtx?.["entity-whitelist"]
-        let serviceWhitelist = cds.env.mtx?.["service-whitelist"]
-        let extensionAllowlist = cds.env.mtx?.["extension-allowlist"]
-
-        // for java projects mtx configuration is part of sidecar config
-        if (!entityWhitelist && !serviceWhitelist && !extensionAllowlist && tenantDbPath) {
-            const dbEnv = cds.env.for("cds", tenantDbPath)
-            entityWhitelist = dbEnv.mtx?.["entity-whitelist"]
-            serviceWhitelist = dbEnv.mtx?.["service-whitelist"]
-            extensionAllowlist = dbEnv.mtx?.["extension-allowlist"]
-        }
-
-        function isValid(e, pattern, nsPattern, kind) {
-            return e && e.name && (e.name === pattern || (nsPattern && e.name.startsWith(nsPattern))) && (!kind || e.kind === kind)
-        }
-
-        if (extensionAllowlist || entityWhitelist || serviceWhitelist) {
-            const invalidEntries = new Set()
-            const reflected = cds.reflect(model)
-
-            if (Array.isArray(extensionAllowlist)) {
-                extensionAllowlist.forEach(allowListEntry => {
-                    if (Array.isArray(allowListEntry.for)) {
-                        allowListEntry.for.forEach(pattern => {
-                            if (pattern !== '*') {
-                                if (!reflected.find(e => isValid(e, pattern, pattern + '.', allowListEntry.kind))) {
-                                    invalidEntries.add(pattern)
-                                }
-                            }
-                        })
-                    }
-                })
-                if (invalidEntries.size > 0) {
-                    this._handler.pushMessage(`Invalid entries found in 'extension-allowlist' - [${[...invalidEntries].join(', ')}]`, WARNING)
-                }
-            } else if (Array.isArray(entityWhitelist) || Array.isArray(serviceWhitelist)) {
-                // validate whitelist entries
-                if (Array.isArray(entityWhitelist)) {
-                    entityWhitelist.forEach(name => {
-                        if (!reflected.find(e => isValid(e, name, null, "entity"))) {
-                            invalidEntries.add(name)
-                        }
-                    })
-                }
-                if (Array.isArray(serviceWhitelist)) {
-                    serviceWhitelist.forEach(name => {
-                        if (!reflected.find(e => isValid(e, name, null, "service"))) {
-                            invalidEntries.add(name)
-                        }
-                    })
-                }
-                if (invalidEntries.size > 0) {
-                    this._handler.pushMessage(`Invalid entries found in 'entity-whitelist' or 'service-whitelist' - [${[...invalidEntries].join(', ')}]`, WARNING) //NOSONAR
-                }
-            }
-        }
-    }
-
-    /**
-     * Returns the build tasks of this project - either user defined or calculated by BuildTaskFactory.
-     * A build task of type 'hana' is enforced in order to copy existing native hana artifacts later on.
-     *
-     * @returns {string} the src folder of the tenant db module
-     */
-    async _getHanaTenantDbPath() {
-        let tasks = this._handler.buildOptions.tasks || []
-        const modelPaths = this._handler.resolveModel()
-
-        // ensure that the hana task is contained even if this mtx task has been executed solely using "cds build --for mtx"
-        if (!tasks.find(task => task.for === BUILD_TASK_HANA)) {
-            //mtx task might have been executed as separate task
-            tasks = cds.env.build?.tasks || []
-            if (tasks.length === 0) {
-                const provider = new BuildTaskProviderInternal(this._handler.logger)
-                await provider.lookupTasks(tasks, this._handler.buildOptions)
-            }
-        }
-        // the SaaS app might use a tenant aware db as well as a shared db deployed using static hdi-deployer
-        // pick the hana build task referring to the tenant aware db - the src path has to be contained in this build task's model options
-        const hanaDbPaths = tasks.filter(task => task.for === BUILD_TASK_HANA).map(hanaTask => path.resolve(this._handler.buildOptions.root, hanaTask.src || cds.env.folders.db))
-        let tenantDbPath = hanaDbPaths.find(hanaDbPath => hanaDbPaths.length === 1 || modelPaths.some(modelPath => path.dirname(modelPath) === hanaDbPath))
-
-        if (!tenantDbPath) {
-            tenantDbPath = path.join(this._handler.buildOptions.root, cds.env.folders.db)
-            if (hanaDbPaths.length === 0) {
-                this._handler.pushMessage(`no 'hana' build task found, use default location '${tenantDbPath}'`, WARNING)
-            } else {
-                this._handler.pushMessage(`no 'hana' build task found matching model scope '${this._handler.task.options.model}', use default location '${tenantDbPath}'`, WARNING)
-            }
-        }
-        return tenantDbPath
-    }
-}
-module.exports = MtxModuleBuilder

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

@@ -1,95 +0,0 @@
-const path = require('path')
-const cds = require('../../cds')
-const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
-
-const { BUILD_TASK_HANA } = require('../../constants')
-const { fs } = require('../../../../lib/utils/cds-utils')
-const { WARNING } = BuildTaskHandlerInternal
-const DEFAULT_TAR_NAME = "resources.tgz"
-
-class ResourcesTarBuilder {
-    constructor(handler) {
-        this._handler = handler
-    }
-
-    get handler() { return this._handler }
-
-    async createTar(dest, model) {
-        const { root, resources } = await this._getResources(model)
-        if (resources.length === 0) {
-            // packTarArchive fails otherwise
-            this.handler.pushMessage("No deployment resources found - skip resources.tgz", WARNING)
-            return
-        }
-        await this.writeTarFile(path.join(dest, DEFAULT_TAR_NAME), root, resources)
-    }
-
-    /**
-     * Creates a TAR file at the given absolute tarPath. An optional resources list holds the files and folders 
-     * that will be added to the TAR. Paths are relative to the passed root directory. If omitted, the entire 
-     * root directory contents will be added. 
-     * @param {*} tarFile Absolute TAR file name.
-     * @param {*} root The root directory the passed resources are relative to.
-     * @param {*} resources Optional list of absolute or relative resource paths - relative to the given root directory. 
-     * If omitted all resources contained in the root directory are added to the TAR file.
-     */
-    async writeTarFile(tarFile, root, resources) {
-        const { tar } = require('../../../../lib').utils
-        await tar.czfd(tarFile, root, resources)
-        this.handler.pushFile(tarFile)
-    }
-
-    async _getResources(model) {
-        // distinguish HANA and SQLITE deployment
-        let root = await this._getHanaTenantDbDest()
-        let resources
-        if (root) {
-            resources = this._getHanaResources(root)
-        } else {
-            root = this.handler.buildOptions.root
-            resources = await this._getSqliteResources(model)
-        }
-        return { root, resources }
-    }
-
-    /**
-     * Reads a list of files and folders required for HANA deployment.
-     * This is a subset of all files contained in the directory.
-     * - 'db/src', 'db/cfg', 'db/undeploy.json'...
-     * See '../../../../lib.deploy'
-     * Note: the hana build task has already been executed
-     * @param {string} root
-     * @returns an array containing all resources
-     */
-    _getHanaResources(root) {
-        return ['src', 'cfg', 'undeploy.json', '.hdiignore'].reduce((acc, res) => {
-            const resPath = path.join(root, res)
-            if (fs.existsSync(resPath)) {
-                acc.push(resPath)
-            }
-            return acc
-        }, [])
-    }
-
-    /**
-     * Reads all resources for Sqlite deployment - see '../../../../lib.deploy'
-     *
-     * @param {object} model
-     * @returns
-     */
-    async _getSqliteResources(model) {
-        const { resources } = cds.deploy
-        return Object.keys(await resources(model))
-    }
-
-    async _getHanaTenantDbDest() {
-        const buildOptions = this.handler.buildOptions
-        let hanaTask = buildOptions.tasks ? buildOptions.tasks.find(task => task.for === BUILD_TASK_HANA) : undefined
-        if (!hanaTask) {
-            this.handler.pushMessage(`Found SQLite database configuration. Ensure that productive cloud deployments requiring SAP HANA database are built with 'production' profile.`, WARNING)
-            return null
-        }
-        return hanaTask.dest
-    }
-}
-module.exports = ResourcesTarBuilder