@sap/cds-dk 6.8.2 → 7.0.0

package/lib/build/provider/nodejs/index.js

@@ -0,0 +1,178 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../../cds')
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const { BuildError } = require('../../util')
+const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX,
+    CONTENT_PACKAGELOCK_JSON, CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON } = require('../../constants')
+const { WARNING } = BuildTaskHandlerEdmx
+
+class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
+    init() {
+        super.init()
+        if (this.task.options.compileDest) {
+            throw new BuildError("Option not supported - compileDest")
+        }
+        // fallback if src has been defined as '.'
+        this.destSrv = this.isStagingBuild() ? path.resolve(this.task.dest, cds.env.folders.srv) : path.join(this.task.dest, FOLDER_GEN)
+    }
+
+    options() {
+        const options = super.options()
+        if (cds.env.requires.extensibility || cds.env.requires.toggles) {
+            options.flavor = 'xtended'
+        }
+        return options
+    }
+
+    async build() {
+        const destSrv = this.isStagingBuild() ? this.destSrv : path.resolve(this.destSrv, cds.env.folders.srv)
+        const destRoot = this.isStagingBuild() ? this.task.dest : this.destSrv
+
+        if (cds.env.odata?.version === ODATA_VERSION_V2) {
+            // log warning as nodejs is only supporting odata version V4
+            this.pushMessage("OData v2 is not supported by node runtime. Make sure to define OData v2 in cds configuration.", WARNING)
+        }
+        // by default model contains all features
+        const model = await this.model()
+        if (!model) {
+            return
+        }
+
+        const { dictionary, sources } = await this.compileAll(model, destSrv, destRoot)
+
+        // collect and write language bundles into single i18n.json file
+        await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
+
+        if (this.hasBuildOption(CONTENT_EDMX, true)) {
+            const m = await cds.load(sources.base, super.options()) // REVISIT: Quick hack to get inferred model as expected by cds.compile.to.edmx()
+            await this.compileToEdmx(m, this.destSrv)
+        }
+
+        if (this.isStagingBuild() && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
+            const srcSrv = this.task.src === cds.root ? path.resolve(this.task.src, cds.env.folders.srv) : this.task.src
+            await this._copyNativeContent(cds.root, srcSrv, destRoot)
+            await this._fixCapireSamplesDeps(destRoot)
+        }
+        return this._result
+    }
+
+    // REVISIT: fix for capire samples - needs to be reworked
+    // Instead of adding relative paths we may better delete the entire entry as relative paths
+    // cannot be resolved in cloud deployments anyway.
+    // Support for HANA native artifacts defined in sub-modules required
+    async _fixCapireSamplesDeps(dest) {
+        const packageJson = path.join(dest, 'package.json')
+        try {
+            const content = require(packageJson)
+            const { dependencies } = content
+            let changed
+            for (let dependency in dependencies) {
+                if (dependency.startsWith('@capire/')) {
+                    dependencies[dependency] = path.relative(dest, path.dirname(require.resolve(dependency + '/package.json')))
+                    changed = true
+                }
+            }
+            if (changed) {
+                return this.write(JSON.stringify(content, null, '  ')).to(packageJson)
+            }
+        } catch (e) {/*ignore*/ }
+    }
+
+    async clean() {
+        // staging build content is deleted by BuildTaskEngine
+        if (cds.env.build.target === '.') {
+            // delete the entire 'task.dest' folder otherwise, for details see #constructor
+            // - the value of the folder 'src' has been appended to the origin 'task.dest' dir
+            this.logger._debug && this.logger.debug(`Deleting build target folder ${this.destSrv}`)
+            await fs.promises.rm(this.isStagingBuild() ? this.task.dest : this.destSrv, { force: true, recursive: true })
+        }
+    }
+
+    async _copyNativeContent(srcRoot, srcSrv, destRoot) {
+        // project/srv/** -> 'gen/srv/srv/**'
+        const filesFilter = await this._copySrvContent(srcSrv, destRoot)
+
+        // project/* -> 'gen/srv/*'
+        await this.copyProjectRootContent(srcRoot, destRoot, (entry) => !filesFilter.includes(path.basename(entry)))
+    }
+
+    /**
+     * Copy files for nodejs staging builds from the given <em>src</em>' folder (e.g. 'project/srv') to either <em>destRoot</em> (e.g. 'project/gen/srv')
+     * or <em>destSrv</em> (e.g. 'project/gen/srv/srv') folders according to the file semantics.
+     * Files with project semantics like 'package.json' or '.npmrc' file are copied to <em>destRoot</em> while others like '.js' service handlers
+     * are copied to <em>destSrv</em>.
+     * @param {*} src
+     * @param {*} destRoot - folder name representing the app root folder (e.g. gen/srv)
+     * @returns the list of files that have been copied
+     */
+    async _copySrvContent(src, destRoot) {
+        const srvRootBlockList = RegExp('package\\.json$|package-lock\\.json$|\\.npmrc$|\\.cdsrc\\.json$')
+        const srvBlockList = RegExp('\\.cds$|csn\\.json$|\\.csn$|manifest\\.y.?ml$|\\.env($|\\..*$)|default-env\\.json$')
+        const srvRootFileNames = []
+
+        // 1. copy all files to 'destSrv' except those contained in the blocklist (including node_modules)
+        // project/srv -> 'gen/srv/srv'
+        await super.copyNativeContent(src, destRoot, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                // TODO shall not copy language bundles - return !/(\/|\\)(node_modules|_i18n)(\/|\\)?$/.test(entry)
+                return !/(\/|\\)node_modules(\/|\\)?$/.test(entry)
+            }
+            // make sure the file exists on srv root level - see https://github.tools.sap/cap/issues/issues/12077
+            if (srvRootBlockList.test(entry) && path.dirname(entry) === src) {
+                srvRootFileNames.push(path.basename(entry))
+                return false
+            }
+            return !srvBlockList.test(entry)
+        })
+
+        // 2. copy dedicated files like package.json, .npmrc to 'destRoot'
+        // project/srv -> 'gen/srv'
+        let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
+        srvAllowList += !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? "|package-lock\\.json$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_NPMRC, false) ? "|\\.npmrc$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC_JSON, false) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
+        srvAllowList = new RegExp(srvAllowList)
+        await Promise.all(srvRootFileNames.map(fileName => {
+            if (srvAllowList.test(fileName)) {
+                return this.copy(path.join(src, fileName)).to(path.join(destRoot, fileName))
+            }
+        }))
+
+        return srvRootFileNames
+    }
+
+    /**
+     * Copy dedicated files (files with project semantics like package.json, .npmrc, .cdsrc, etc.)
+     * from the given <em>src</em> folder (e.g. 'project') into the given <em>dest</em> folder (e.g. 'project/gen/srv')
+     * @param {*} src
+     * @param {*} dest
+     * @param {*} filter - copy file if filter function returns true
+     */
+    async copyProjectRootContent(src, dest, filter) {
+        let { folders = ['i18n'] } = cds.env.i18n
+        folders.push('handlers')
+        folders = folders.map(folder => path.join(src, folder))
+        let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
+        srvAllowList += !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? "|package-lock\\.json$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_NPMRC, false) ? "|\\.npmrc$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC_JSON, false) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
+        srvAllowList = new RegExp(srvAllowList)
+
+        await super.copyNativeContent(src, dest, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                return folders.some(folder => entry.startsWith(folder))
+            }
+            if (/\.js$|\.properties$/.test(entry)) {
+                return true
+            }
+            return srvAllowList.test(entry) && (!filter || filter.call(this, entry))
+        })
+    }
+}
+
+module.exports = NodejsModuleBuilder

package/lib/build/util.js

@@ -0,0 +1,263 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../cds')
+const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants')
+
+function getProperty(src, segments) {
+    segments = Array.isArray(segments) ? segments : segments.split('.')
+    return segments.reduce((p, n) => p && p[n], src)
+}
+
+function setProperty(src, segments, value) {
+    segments = Array.isArray(segments) ? segments : segments.split('.')
+    segments.reduce((p, n, idx) => {
+        if (segments.length === idx + 1) {
+            p[n] = value
+        } else {
+            if (p[n] === undefined) {
+                p[n] = {}
+            }
+        }
+        return p[n]
+    }, src)
+}
+
+/**
+ * Returns whether this project is a java project or not.
+ * @param {Array} dirs - the absolute path names to check.
+*/
+function hasJavaNature(dirs) {
+    return dirs.flat().reduce((acc, dir) => {
+        if (dir) {
+            const file = path.join(dir, 'pom.xml')
+            if (fs.existsSync(file)) {
+                acc.push(file)
+            }
+        }
+        return acc
+    }, []).length > 0
+}
+
+/**
+ * Determines whether the both values are identical.
+ * @param {*} actual
+ * @param {*} expected
+ */
+function hasOptionValue(actual, expected) {
+    if (typeof expected === 'undefined') {
+        return actual !== undefined
+    }
+    if (typeof actual === 'undefined') {
+        return false
+    }
+    if (typeof expected === 'boolean') {
+        if (typeof actual === 'string') {
+            return String(expected) === actual
+        }
+    }
+    if (typeof expected === 'number') {
+        return (actual & expected) !== 0
+    }
+    return actual === expected
+}
+
+// Returning the project relative path representation of the given path(s),
+function relativePaths(root, qualifiedPaths) {
+    qualifiedPaths = typeof qualifiedPaths === "string" ? [qualifiedPaths] : qualifiedPaths
+    if (Array.isArray(qualifiedPaths)) {
+        return qualifiedPaths.map(qualifiedPath => {
+            const relPath = path.relative(root, qualifiedPath)
+            return relPath || "."
+        })
+    }
+    return qualifiedPaths
+}
+
+function redactCredentials(config, o) {
+    return JSON.stringify(config, (k, v) => {
+        if (!v) {
+            return v
+        }
+        if (k === 'credentials') {
+            try {
+                return _redacted(v)
+            } catch (e) {/* ignored */ }
+        }
+        return v
+    }, o && o.indents || 2)
+}
+
+/** redacts password-like strings, also reducing clutter in output */
+function _redacted(cred) {
+    const secrets = /(password)|(certificate)|(ca)/i // 'certificate' and 'ca' on HANA
+    const newCred = Object.assign({}, cred)
+    Object.keys(newCred)
+        .filter(k => typeof newCred[k] === 'string' && secrets.test(k))
+        .forEach(k => newCred[k] = '...')
+    return newCred
+}
+
+
+/**
+ * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved.
+ * E.g. the module might NOT have been installed.
+ * @param {Array} modelPaths
+ * @returns {Array}
+ */
+function resolveRequiredSapModels(modelPaths) {
+    return Array.isArray(modelPaths) && modelPaths.filter(p => {
+        if (p.startsWith('@sap/')) {
+            const files = cds.resolve(p)
+            return !files || files.length === 0
+        }
+    })
+}
+
+function getDefaultModelOptions() {
+    const fts = cds.env.features.folders
+    const modelPaths = cds.resolve(!fts ? '*' : ['*', fts], false)
+    return _pushModelPaths(modelPaths)
+}
+
+function _pushModelPaths(...modelPaths) {
+    const model = new Set()
+    // may contain nested arrays
+    modelPaths = flatten(modelPaths)
+    const { roots } = cds.env
+    modelPaths.forEach(m => {
+        if (m && !model.has(m) && !model.has(m + "/")) {
+            // filter root model paths that do not exist
+            // other entries are added as is, e.g. reuse model entries
+            if (roots.includes(m)) {
+                const dir = path.resolve(cds.root, m)
+                if (fs.existsSync(dir)) {
+                    model.add(m.replace(/\/$/, ''))
+                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compatibility to old build configs
+                    model.add(m)
+                }
+            } else {
+                model.add(m)
+            }
+        }
+    })
+    return [...model]
+}
+
+function flatten(modelPaths) {
+    return modelPaths.reduce((acc, m) => {
+        if (Array.isArray(m)) {
+            acc = acc.concat(flatten(m))
+        } else if (m) {
+            acc.push(m)
+        }
+        return acc
+    }, [])
+}
+
+/**
+ * Copy a file or directory. The directory can have contents.
+ * REVISIT: 'fs.promises.cp' replacement for nodejs 14
+ * @param src <String> Note that if src is a directory it will copy everything inside of this directory, not the entire directory itself.
+ * @param dest <String> Note that if src is a file, dest cannot be a directory.
+ */
+async function copy(src, dest) {
+    if ((await fs.promises.stat(src)).isDirectory()) {
+        const entries = await fs.promises.readdir(src)
+        return Promise.all(entries.map(async each => copy(path.join(src, each), path.join(dest, each))))
+    } else {
+        await fs.promises.mkdir(path.dirname(dest), { recursive: true })
+        return fs.promises.copyFile(src, dest)
+    }
+}
+
+/**
+ * Return gnu-style error string for location `loc`:
+ *  - 'File:Line:Col' without `loc.end`
+ *  - 'File:Line:StartCol-EndCol' if Line = start.line = end.line
+ *  - 'File:StartLine.StartCol-EndLine.EndCol' otherwise
+ *
+ * @param {CSN.Location|CSN.Location} location
+ */
+function _locationString(loc) {
+    if (!loc)
+        return '<???>';
+    if (!(loc instanceof Object))
+        return loc;
+    if (!loc.line) {
+        return loc.file;
+    }
+    else if (!loc.endLine) {
+        return (loc.col)
+            ? `${loc.file}:${loc.line}:${loc.col}`
+            : `${loc.file}:${loc.line}`;
+    }
+
+    return (loc.line === loc.endLine)
+        ? `${loc.file}:${loc.line}:${loc.col}-${loc.endCol}`
+        : `${loc.file}:${loc.line}.${loc.col}-${loc.endLine}.${loc.endCol}`;
+}
+
+/**
+ * Class for individual build message.
+ *
+ * @class BuildMessage
+ */
+class BuildMessage {
+    /**
+     * Creates an instance of BuildMessage.
+     * @param {string} message The message text
+     * @param {string} [severity='Error'] Severity: Debug, Info, Warning, Error
+     * @param {any} location Location of the message
+     * 
+     * @memberOf BuildMessage
+     */
+    constructor(message, severity = SEVERITY_ERROR, location) {
+        this.message = message
+        this.name = "BuildMessage"
+        this.severity = severity
+        this.$location = location
+    }
+    toString() {
+        return `${this.$location?.file ? _locationString(this.$location) + ':' : ''} ${this.severity}: ${this.message}`
+    }
+}
+
+/**
+ * Class for combined build and compiler errors. 
+ * Additional members:
+ *   messages: vector of detailed build messages
+ * @class BuildError
+ * @extends {Error}
+ */
+class BuildError extends Error {
+    constructor(message, messages = []) {
+        super(message)
+        this.name = "BuildError"
+        this.messages = Array.isArray(messages) ? messages : [messages]
+        this.stack = ""
+    }
+
+    // for compatibility reasons
+    get errors() {
+        return this.messages
+    }
+
+    toString() {
+        return this.message + (this.messages.length > 0 ? '\n' + this.messages.map(m => m.toString()).join('\n') : '')
+    }
+}
+
+module.exports = {
+    getProperty,
+    setProperty,
+    hasJavaNature,
+    redactCredentials,
+    hasOptionValue,
+    relativePaths,
+    resolveRequiredSapModels,
+    getDefaultModelOptions,
+    flatten,
+    copy,
+    BuildMessage,
+    BuildError
+}

package/lib/cds.js

@@ -1,27 +1,15 @@
-const _local = id => require(_resolve(id))
-
 /** @type { import('@sap/cds/lib') } */
-const cds = module.exports = _local ('@sap/cds')
-
-// for internal use in cds-dk only
-cds._log = _local ('@sap/cds/bin/utils/log')
-cds._local = _local
+const cds = _local ('@sap/cds')
 
-if (/^(4\.[56]|5|6\.[01])\b/.test(cds.version)) {
-  // cds.debug may return false as of @sap/cds@(>=4.5 && < 6.2).
-  // Patch this to be able to call `cds.debug(label)?.(message)`.
-  // REVISIT remove once we no longer support these versions
-  Object.defineProperty(cds, 'debug', {
-    value: function cds_debug_patched (module, options) {
-      const L = cds.log (module, options)
-      if (L._debug) return L.debug
-    }
-  })
-}
+module.exports = Object.defineProperties (cds, {
+  // for internal use in cds-dk only
+  _log: { value: _local ('../bin/util/log') },
+  _local: { value: _local },
+})
 
-function _resolve (id) {
-  return require.resolve (id, {paths:[
+function _local (id) {
+  return require(require.resolve (id, {paths:[
     process.cwd(), // project-local module is preferred
     __dirname      // otherwise from our own dependencies
-  ]})
+  ]}))
 }

package/lib/client/auth_manager.js

@@ -22,21 +22,35 @@ function addTokenInfo(params, authData) {
 function addUrlInfo(params, authData) {
     params.set('passcodeUrl', authData.passcode_url);
 }
-function getTokenUrl(params) {
-    const tokenUrl = new URL(params.get('tokenUrl'));
-    tokenUrl.search = `subdomain=${params.get('subdomain')}`;
-
+function* reqParams(params) {
+    const url = params.get('tokenUrl');
+    const d = {};
+    if (params.has('subdomain')) {
+        d.subdomain = params.get('subdomain');
+    }
     if (params.has('refreshToken')) {
-        tokenUrl.search += `&refresh_token=${encodeURIComponent(params.get('refreshToken'))}`;
+        d.refresh_token = params.get('refreshToken');
     } else if (params.has('passcode')) {
-        tokenUrl.search += `&passcode=${encodeURIComponent(params.get('passcode'))}`;
+        d.passcode = params.get('passcode');
     }
     if (params.has('clientsecret')) {
-        tokenUrl.search += `&clientid=${encodeURIComponent(params.get('clientid'))}&clientsecret=${encodeURIComponent(params.get('clientsecret'))}`;
+        d.clientid = params.get('clientid');
+        d.clientsecret = params.get('clientsecret');
     } else if (params.has('key')) {
-        tokenUrl.search += `&clientid=${encodeURIComponent(params.get('clientid'))}&key=${encodeURIComponent(params.get('key'))}`;
+        d.clientid = params.get('clientid');
+        d.key = params.get('key');
     }
-    return tokenUrl.toString();
+    const data = new URLSearchParams(d).toString();
+    yield {
+        method: 'post',
+        url,
+        data
+    };
+    yield {
+        method: 'get',
+        url: `${url}?${data}`,
+        data: undefined
+    };
 }
 
 async function retrieveTokenOrPasscodeUrl(params) {
@@ -56,14 +70,23 @@ async function retrieveTokenOrPasscodeUrl(params) {
     let retry;
     let authData;
     do {
-        const tokenUrl = getTokenUrl(params);
-        DEBUG?.(`Getting authentication token or passcode URL from ${(params.obfuscateQueryParams(tokenUrl))}`);
-
         let response;
-        try {
-            response = await axios.get(tokenUrl);
-        } catch (error) {
-            throw new CliError('Failed to get authentication token', { error });
+        for (const { method, url, data } of reqParams(params)) {
+            try {
+                DEBUG?.(`Getting authentication token or passcode URL from ${method.toUpperCase()} ${(params.obfuscateQueryParams(url))}`);
+                response = await axios[method](url, data);
+            } catch (error) {
+                if (error.response?.status === 404) { // may represent 405 in case of wrong method
+                    continue;
+                }
+                throw new CliError('Failed to get authentication token', { error });
+            }
+            if (response) {
+                break;
+            }
+        }
+        if (!response) {
+            throw new CliError('Failed to get authentication token');
         }
         authData = response.data;
 

package/lib/client/helper/dependency_helper.js

@@ -4,16 +4,17 @@ const { execFileSync } = require('child_process');
 const cds = require('../../cds');
 const DEBUG = cds.debug('cli');
 
-let cachedDir;
+let modulesDir;
 
 function globalModulesDir() {
-    if (!cachedDir) {
-        cachedDir = execFileSync('npm', ['root', '-g'], {
+    if (!modulesDir) {
+        modulesDir = execFileSync('npm', ['root', '-g'], {
             encoding: 'utf8',
-            shell: os.platform() === 'win32'
+            shell: os.platform() === 'win32',
+            stdio: ['ignore', 'pipe', 'ignore']
         }).trim();
     }
-    return cachedDir;
+    return modulesDir;
 }
 
 function requireGlobal(packageId) {
@@ -27,7 +28,7 @@ function requireGlobal(packageId) {
 }
 
 function resetCache() {
-    cachedDir = undefined;
+    modulesDir = undefined;
 }
 
 module.exports = {

package/lib/client/push.js

@@ -7,6 +7,7 @@ const { login } = require('./auth_manager');
 const BaseCommand = require('./base_command');
 const { CliError } = require('./helper/errors');
 const { schemaRegex } = require('./helper/url_helper');
+const buildSystem = require('../build')
 
 module.exports = class Push extends BaseCommand {
 
@@ -17,7 +18,7 @@ module.exports = class Push extends BaseCommand {
 
         if (!('extArchive' in pushOptions)) {
             console.log(`Building project`);
-            await cds.build({ project: projectFolder });
+            await buildSystem.build();
         }
 
         const { src, content } = await this.readSource(params, pushOptions);