@sap/cds-dk 7.0.2 → 7.0.3

package/lib/init/util/merge.js

@@ -2,7 +2,7 @@ const YAML = require('@sap/cds-foss').yaml
 const { copy, read, write, exists } = require('../../cds').utils
 const { readYAML, writeYAML, readJSON } = require('../../util/fs')
 const { EOL } = require('node:os')
-
+const { detectIndent } = require('../util/indent')
 
 function _isObject(item) {
   return item && typeof item === 'object' && !Array.isArray(item)
@@ -53,15 +53,57 @@ async function mergeGitignore (into, from) {
     return enhanced
   }
 
+/**
+ * @typedef {Object} MatchedNode
+ * @property {string | MatchedNode} in - key path or matched node to start search from
+ * @property {Object[]} where - list of constraints
+ * @property {string} where[].property - property key path
+ * @property {string} where[].isEqualTo - comparison string
+ */
+
+/**
+ * @typedef {Object} Overwrites
+ * @property {(string | MatchedNode)[]} item - path to item to be overwritten
+ * @property {string} withValue - replacement string
+ */
+
+/**
+ * @typedef {Object} Deletion
+ * @property {MatchedNode} item - matched node to delete
+ * @property {Object[]} relationships - list of relationships to delete
+ * @property {string} relationships[].removeProperty - key path to to-be-removed property
+ * @property {string[]} relationships[].allWithin - key path to relationship
+ */
+
+/**
+ * @typedef {Object} Relationship
+ * @property {(string | MatchedNode)[]} insert - source path to matched node
+ * @property {(string | MatchedNode)[]} into - target path for inserted relationship
+ */
+
+/**
+ * @typedef {Object} MergingSemantics
+ * @property {boolean} [forceOverwrite] - overwrite values for existing keys
+ * @property {MatchedNode[]} [additions] - matched nodes to be added from source template
+ * @property {Overwrites[]} [overwrites] - matched keys to be overwritten with given string
+ * @property {Deletion[]} [deletions] - matched nodes to be deleted
+ * @property {Relationship[]} [relationships] - relationships to be inserted
+ */
+
+/**
+ * @param {string | JSON} into - file path or JSON to merge into
+ * @param {string | JSON} from - file path or JSON to merge from
+ * @param {import('./projectReader').readProject} [project] - project descriptor used for Mustache replacements
+ * @param {MergingSemantics} [semantics] - merging algorithm semantics
+ * @returns {Promise<JSON>} - merged JSON
+ */
 async function mergeJSON(into, from, project, semantics) {
     const source = typeof from === 'string' ? await readJSON(from, project) : from
 
-    if (typeof into === 'string' && !exists(into)) {
-        return write(into, source, { spaces: 2 })
-    }
-
     let result
-    if (semantics) {
+    if (typeof into === 'string' && !exists(into)) {
+        result = source
+    } else if (semantics) {
         const target = await read(into)
         const targetYAML = YAML.parseDocument(YAML.stringify(target))
         const sourceYAML = YAML.parseDocument(YAML.stringify(source))
@@ -71,19 +113,33 @@ async function mergeJSON(into, from, project, semantics) {
         const target = typeof into === 'string' ? await read(into) : into
         result = _deepMerge(target, source)
     }
-    if (typeof into === 'string') await write(into, result, { spaces: 2 })
+    // we need to stringify result on site to be able to apply the appropriate indentation.
+    // cds-utils.write is currently hardcoded to use spaces for indentation.
+    if (typeof into === 'string') {
+        const indent = exists(into) && detectIndent((await read(into, 'utf-8')).split(EOL))
+        await write(into, JSON.stringify(result, null, indent ?? 2))
+    }
     return result
 }
 
+/**
+ * @param {string | YAML.Document} into - file path or YAML to merge into
+ * @param {string | YAML.Document} from - file path or YAML to merge from
+ * @param {Object} [project] - project descriptor used for Mustache replacements
+ * @param {MergingSemantics} [semantics] - merging algorithm semantics
+ * @returns {Promise<YAML.Document>} - merged YAML
+ * @throws {Error} Throws an error if empty target YAML is passed in
+ */
 async function mergeYAML(into, from, project, semantics = {}) {
     const target = typeof into === 'string' ? await readYAML(into) : into instanceof YAML.Document ? into : new YAML.Document(into)
     const source = typeof from === 'string' ? await readYAML(from, project) : from instanceof YAML.Document ? from : new YAML.Document(from)
 
-    if (!target || !target.contents) {
+    if (!target?.contents) {
         if (typeof into === 'string' && typeof from === 'string') {
-            return project ? writeYAML(into, source) : copy(from, into)
+            project ? await writeYAML(into, source) : await copy(from, into)
+            return source
         }
-        return /* has no YAML */
+        throw new Error(`Target YAML doesn't exist`)
     }
 
     const entryMap = new Map, templateEntryMap = new Map()
@@ -148,7 +204,7 @@ async function mergeYAML(into, from, project, semantics = {}) {
 
         if (node.items) {
             if (YAML.isSeq(node) && templateNode?.items) {
-                actions?.mergeCollection && actions.mergeCollection(node, templateNode)
+                actions.mergeCollection?.(node, templateNode)
                 _traverseYAMLCollection(node, actions, templateNode)
             } else {
                 _traverseYAMLCollection(node, actions, templateNode)
@@ -194,12 +250,12 @@ async function mergeYAML(into, from, project, semantics = {}) {
                 const targetNode = collection.items?.[i]
                 if (targetNode) {
                     _traverseYAMLNode(targetNode, templateIndex, actions, templateNode)
-                } else if (actions.mergePair) {
-                    actions.mergePair(collection, templateNode)
+                } else {
+                    actions.mergePair?.(collection, templateNode)
                 }
             } else if (YAML.isMap(templateNode)) {
                 const targetNode = collection.items[templateIndexToIndex.get(templateIndex)]
-                if (actions.mergeCollection) actions.mergeCollection(targetNode, templateNode)
+                actions.mergeCollection?.(targetNode, templateNode)
                 if (targetNode) {
                     _traverseYAMLNode(targetNode, templateIndex, actions, templateNode)
                 }
@@ -266,7 +322,7 @@ async function mergeYAML(into, from, project, semantics = {}) {
                     .filter(addition => {
                         const keyPath = typeof addition.in === 'string' ? addition.in : Array.isArray(addition.in) && typeof addition.in[0] === 'string' ? addition.in[0] : addition.in[1]
                         const keys = keyPath.split('.')
-                        if (keys.length > collectionStack.length + 1) return
+                        if (keys.length > collectionStack.length + 1) return false
                         if (keys.length > 1) parent = collectionStack[keys.length]
                         return _getYAMLProperty(parent, keyPath) === targetNode
                     })

package/lib/init/util/mvn.js

@@ -1,5 +1,5 @@
 
-const { MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, SAMPLES, HANA }, REGEX_JAVA_PACKAGE } = require('../constants');
+const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, SAMPLES, HANA }, REGEX_JAVA_PACKAGE } = require('../constants');
 
 const { CliError } = require('../../client/helper/errors');
 
@@ -7,7 +7,8 @@ const { CliError } = require('../../client/helper/errors');
 const cp = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(cp.exec);
-
+const term = require('../../util/term');
+const cmd = require('../../util/command');
 
 const DEFAULT_GROUP_ID = 'customer';
 
@@ -15,7 +16,6 @@ const LOG = console
 const cds = require('../../cds')
 const DEBUG = cds.debug('cli')
 
-
 class MvnArchetypeUtil {
 
     _scanMvnParams(mvnParams, params) {
@@ -51,11 +51,12 @@ class MvnArchetypeUtil {
         return Array.from(params, ([arg, val]) => val !== null && val !== undefined ? `${arg}=${val}` : arg)
     }
 
-    getAddSamplesCmdArgs(options) {
+    getAddSamplesCmdArgs() {
         const params = new Map();
 
         params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:addSample`);
 
+        const { options } = cds.cli
         if (options[JAVA_MVN]) {
             this._scanMvnParams(options[JAVA_MVN], params);
         }
@@ -67,11 +68,12 @@ class MvnArchetypeUtil {
         return this._finalize(params);
     }
 
-    getAddTestsCmdArgs(options) {
+    getAddTestsCmdArgs() {
         const params = new Map();
 
         params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:addIntegrationTest`);
 
+        const { options } = cds.cli
         if (options[JAVA_MVN]) {
             this._scanMvnParams(options[JAVA_MVN], params);
         }
@@ -83,14 +85,15 @@ class MvnArchetypeUtil {
         return this._finalize(params);
     }
 
-    getAddHanaCmdArgs(options) {
+    getAddHanaCmdArgs() {
         const params = new Map();
 
         params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:addTargetPlatform`);
         params.set(`-DtargetPlatform`, `cloudfoundry`);
 
-        if (options[JAVA_MVN]) {
-            this._scanMvnParams(options[JAVA_MVN], params);
+        const javaMvn = cds.cli.options[JAVA_MVN]
+        if (javaMvn) {
+            this._scanMvnParams(javaMvn, params);
         }
 
         return this._finalize(params);
@@ -100,7 +103,7 @@ class MvnArchetypeUtil {
         return packageName.toLowerCase().replace(/-/g, '_').replace(/\.([0-9])/g, '._$1').replace(/^([0-9])/, '_$1').replace(/\.+/g, '.');
     }
 
-    async getGenerateCmdArgs(projectName, options) {
+    async getGenerateCmdArgs(projectName, options = cds.cli.options) {
         const params = new Map();
 
         // set header
@@ -184,6 +187,17 @@ class MvnArchetypeUtil {
             artifactId
         };
     }
+
+    async execMvn(args) {
+        try {
+            await cmd.spawnCommand('mvn', args, { cwd: cds.root });
+        } catch (err) {
+            if (err.code === 'ENOENT' && err.path === 'mvn') {
+                throw `Maven executable 'mvn' not found, follow ${term.info(URLS.MAVEN_INSTALL_HELP)} and install Maven on your machine.`;
+            }
+            throw err;
+        }
+    }
 }
 
 module.exports = new MvnArchetypeUtil();

package/lib/init/util/projectReader.js

@@ -1,15 +1,40 @@
 const cds = require('../../cds')
-const { path, read, exists } = cds.utils
+const { join, resolve, basename } = require('path')
+const { fs, exists } = cds.utils
 const { parseXml } = require('./xml')
-const P_LANGUAGE_JAVA = 'java'
-const P_LANGUAGE_NODEJS = 'nodejs'
-const DEFAULT_P_LANGUAGE = P_LANGUAGE_NODEJS
-const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
+const DEBUG = cds.debug('cli')
 
 module.exports = new class ProjectReader {
 
     constructor() {
         this.readProject = this.readProject.bind(this)
+
+        // 1. Use project name and static default values
+        this.appVersion = cds.cli.options.add?.has('java') ? '1.0.0-SNAPSHOT' : '1.0.0'
+        this.appName = this.appId = basename(cds.root)
+        this.appDescription = 'A simple CAP project.'
+
+        // 2. Use either pom.xml or package.json
+        if (exists('pom.xml')) {
+            const { artifactId = [], description = [], version = [], properties = [] } = parseXml(resolve(cds.root, 'pom.xml')) ?? {}
+            const v = version[0] === '${revision}' ? properties[0]?.revision[0] : version[0]
+            if (v) {
+                // check compliance with mta version format - copied from mbt error message
+                if (/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/.test(v)) {
+                    this.appVersion = v
+                }
+            }
+            if (artifactId[0])  this.appName = this.appId = artifactId[0].split(/-parent/)[0]
+            if (description[0]) this.appDescription = description[0]
+        }
+        else if (exists('package.json')) {
+            const { name, version, description } = JSON.parse(fs.readFileSync(join(cds.root, 'package.json')))
+            this.appVersion = version
+            const segments = name.trim().replace(/@/g, '').split('/').map(encodeURIComponent)
+            this.appName = segments[segments.length - 1]
+            this.appId = segments.join('.')
+            this.appDescription = description ?? this.appDescription
+        }
     }
 
     // REVISIT: There should be a better (and parallelizable) API provided by cds.env
@@ -27,25 +52,29 @@ module.exports = new class ProjectReader {
         }
     }
 
-    async readProject(options) {
-        // if (options?.cwd) cds.root = options.cwd
-
+    async readProject() {
         const env = this.getEnv()
-        DEBUG && DEBUG({ env })
+        const { appVersion, appName, appId, appDescription } = this
+        DEBUG?.({ env })
 
-        const _hasFacet = template => require(`../template/${template}`).hasFacet(env, options)
+        const _hasFacet = template => require(`../template/${template}`).hasFacet(env)
         const project = {
-            profile: options?.for,
-            language: DEFAULT_P_LANGUAGE,
-            srv: {},
-            db: [],
-            requires: [],
-            get hasRequires()    { return this.requires.length > 0 },
-            get needsSidecar()   { return (options?.add.has('hana') || this.db.length > 0) && (this.isJava || !this.isMultitenant) },
+            get profile()  { return cds.cli.options?.for },
+            get language() { return exists('pom.xml') ? 'java' : 'nodejs' },
+            get srvPath()  { return join(env.build.target, env.folders.srv.replace(/\/$/, '')).replace(/\\/g, '/') },
+            get archiveName() {
+                const pom = parseXml(resolve(cds.root, env.folders.srv, 'pom.xml'))
+                return (pom?.artifactId?.[0] ?? basename(cds.root)) + '-exec.' + pom?.packaging?.[0]
+            },
+            get db() {
+                const folder = env.folders.db
+                const name = folder.replace(/\/$/, '')
+                const path = join(env.build.target, name).replace(/\\/g, '/')
+                return { folder, name, path }
+            },
             get configFile()     { return exists('pom.xml') ? '.cdsrc.json' : 'package.json' },
             get isNodejs()       { return _hasFacet('nodejs') },
             get isJava()         { return _hasFacet('java') },
-            get hasSidecar()     { return exists('mtx', 'sidecar') },
             get isMultitenant()  { return _hasFacet('multitenancy') },
             get isExtensible()   { return _hasFacet('extensibility') },
             get hasHana()        { return _hasFacet('hana') },
@@ -57,158 +86,13 @@ module.exports = new class ProjectReader {
             get hasMta()         { return _hasFacet('mta') },
             get hasHelm()        { return _hasFacet('helm') },
             get appPath()        { return env.folders.app ?? 'app' },
+            get appVersion()     { return appVersion },
+            get appName()        { return appName },
+            get appId()          { return appId },
+            get appDescription() { return appDescription },
         }
 
-        // setting the effective env as it might have changed by already executed 'add' commands, e.g. cds init foo --add hana,mta
-        const cds = require('../../cds')
-        cds.env // make sure env is initialized, otherwise we cannot set it (exotic case)
-        cds.env = env
-
-        // check whether we have a hana service binding defined as a hana build task is returned by default for compatibility reasons if neither hana, nor sqlite has been defined
-        if (env?.requires?.db?.kind === 'hana') {
-            const dbFolder = env.folders.db.replace(/\/$/, '')
-            const relDbDestPath = path.join(env.build.target, dbFolder).replace(/\\/g, '/')
-            project.db.push({ path: relDbDestPath, name: dbFolder })
-        }
-
-        const srvFolder = env.folders.srv.replace(/\/$/, '')
-        const relSrvDestPath = path.join(env.build.target, srvFolder).replace(/\\/g, '/')
-        project.srvPath = relSrvDestPath
-        project.srvName = srvFolder
-
-        if (env['project-nature'] === 'java') {
-            project.language = P_LANGUAGE_JAVA
-            project.srvExt = await this._getJavaExtDescriptor(path.resolve(cds.root, srvFolder))
-        }
-
-        // setting app name, app description...
-        await this._setAppDetails(project)
-
-        // setting required resource information
-        this._setResourceDependencies(env, project)
-
-        DEBUG && DEBUG({ project })
+        DEBUG?.({ project })
         return project
     }
-
-    /**
-     * Determines java specific properties for the given module source path.
-     * @param {object} srcPath
-     */
-    async _getJavaExtDescriptor(srcPath) {
-        // by default spring-boot:repackage is used creating an executable jar archive
-        const pom = await parseXml(path.join(srcPath, 'pom.xml'))
-        if (pom) {
-            const dependencies = pom?.dependencies?.[0]?.dependency
-            const isOldJavaRuntime = [...dependencies].some(d => /com\.sap\.cloud\.servicesdk/.test(d?.groupId?.[0]))
-            if (isOldJavaRuntime) {
-                throw "Projects using the classic CAP Java SDK are not supported"
-            }
-
-            const descriptor = { archiveName: path.basename(cds.root) + "-exec.jar" }
-            const archiveName = pom?.artifactId?.[0]
-            const suffix = pom?.packaging?.[0]
-            if (archiveName) descriptor.archiveName = archiveName + '-exec.' + suffix
-            return descriptor
-        }
-    }
-
-    async _setAppDetails(cap) {
-        if (cap.language !== P_LANGUAGE_JAVA && cap.language !== P_LANGUAGE_NODEJS) {
-            throw Error(`${cap.language} not supported`)
-        }
-
-        // Use either pom.xml or package.json
-        if (exists('pom.xml')) {
-            const pom = await parseXml('pom.xml')
-            const [artifactId] = pom?.artifactId ?? []
-            const [description] = pom?.description ?? []
-            let [version] = pom?.version ?? []
-            // might need to resolve <version>${revision}</version> property
-            if (version === '${revision}') {
-                version = pom?.properties?.[0].revision[0]
-            }
-            if (version) {
-                // check compliance with mta version format - copied from mbt build error message
-                // if not compliant we use a static default value, see below...
-                if (/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/.test(version)) {
-                    cap.appVersion = version
-                }
-            }
-            if (artifactId) {
-                cap.appName = artifactId.split(/-parent/)[0]
-            }
-            if (description) {
-                cap.appDescription = description
-            }
-        }
-        else if (exists('package.json')) {
-            const { name, version, description } = await read('package.json')
-            cap.appDescription = cap.appDescription ?? description
-            cap.appVersion = cap.appVersion ?? version
-            if (name) {
-                const segments = name.trim().replace(/@/g, '').split('/').map(encodeURIComponent)
-                cap.appName = cap.appName ?? segments[segments.length - 1]
-                cap.appId = cap.appId ?? segments.join('.')
-                cap.appDescription = cap.appDescription ?? cap.appName
-            }
-        }
-
-        // 2. use project name and static default values
-        cap.appName = cap.appName ?? path.basename(cds.root)
-        cap.appDescription = cap.appDescription ?? cap.appName + " application"
-        cap.appId = cap.appId ?? cap.appName
-        cap.appVersion = cap.appVersion ?? '1.0.0'
-    }
-
-    // REVISIT: Only used for orphaned cds add cf-manifest. Still needed?
-    _setResourceDependencies(env, cap) {
-        for (const [key, require] of Object.entries(env.requires)) {
-            if (key === 'sql' || key === 'sqlite' || key === 'hana') continue // ignore abstract helper definitions like sql
-            const resource = this._getReqResource(key, require, cap)
-            if (resource) cap.requires.push({ resource }) // using production profile
-        }
-    }
-
-    _getReqResource(key, reqEntry, cap) {
-        const { kind, dialect, use, vcap = {}, multiTenant } = reqEntry
-        const { appName, isMultitenant } = cap
-        const resource = {
-            name: !key.includes(appName) ? `${appName}-${key}` : key,
-            service: '',
-            vcap,
-            get isMultitenant() { return isMultitenant || multiTenant || false },
-            get isManagedHana() { return this.vcap.label === 'service-manager' || this.service === 'service-manager' },
-            get isPlainHana()   { return this.service === 'hana' && !this.isManagedHana },
-            get isHana()        { return this.isPlainHana || this.isManagedHana },
-            get isXsuaa()       { return this.service === 'xsuaa' },
-        }
-
-        switch (kind) {
-            case 'sql':
-            case 'hana':
-                if (kind === 'sql' && dialect !== 'hana' && use !== 'hana') {
-                    break
-                }
-                // use different service name to avoid conflicts when switching from single tenant to multitenant
-                // otherwise we would enforce that users have to delete the db container first
-                if (resource.isMultitenant) {
-                    resource.service = 'service-manager'
-                    resource.vcap.plan = 'container'
-                } else {
-                    resource.service = 'hana'
-                    resource.vcap.plan = 'hdi-shared'
-                }
-                break
-
-            case 'xsuaa':
-                resource.service = kind
-                resource.vcap.plan = 'application'
-                break
-            default: {
-                vcap.plan ? resource.service = kind : DEBUG && DEBUG(`Skip resource ${key}`)
-            }
-        }
-        return resource.service ? resource : null
-    }
 }

package/lib/init/util/template.js

@@ -1,24 +1,25 @@
 const Mustache = require('mustache')
 const { copy, read, write, exists, readdir, path, isdir } = require('../../cds').utils
 
-async function copyFiles(templatePath, destinationPath, templateValues, overwrite = false) {
-    for (const dirent of await readdir(templatePath)) {
-        const fileNew = Mustache.render(dirent, templateValues)
-        const src = path.join(templatePath, dirent);
-        const dest = path.join(destinationPath, fileNew);
+async function copyFiles(from, into, replacements, overwrite = false) {
+    const dirents = await readdir(from)
+    await Promise.all(dirents.map(async dirent => {
+        const fileNew = Mustache.render(dirent, replacements)
+        const src = path.join(from, dirent)
+        const dest = path.join(into, fileNew)
 
         if (isdir(src)) {
-            await copyFiles(path.join(templatePath, dirent), dest, templateValues, overwrite);
+            return copyFiles(path.join(from, dirent), dest, replacements, overwrite)
         } else if (path.extname(dirent) === '.hbs') {
-            const destinationPath = dest.replace('.hbs', '');
+            const destinationPath = dest.replace('.hbs', '')
             if (overwrite || !exists(destinationPath)) {
-                const content = await render(src, templateValues);
-                await write(destinationPath, content, { spaces: 2 });
+                const content = await render(src, replacements)
+                await write(destinationPath, content, { spaces: 2 })
             }
         } else {
-            await copy(src, dest);
+            return copy(src, dest)
         }
-    }
+    }))
 }
 
 async function render(src, templateValues) {

package/lib/init/util/xml.js

@@ -1,5 +1,4 @@
-const cds = require('../../cds')
-const { read } = cds.utils
+const { readFileSync } = require('fs')
 
 /*
   Remove the _text attributes and convert value it into array
@@ -17,6 +16,8 @@ function _removeTextAttributes(value, parentElement) {
   }
 }
 
+// REVISIT: Simplify config
+// REVISIT: fast-xml-parser
 /**
  * Parse a given string containing xml
  * used to remove the _text object from converted json i.e. from xml-js.
@@ -24,11 +25,10 @@ function _removeTextAttributes(value, parentElement) {
  * and after removing textAttributes (using this function): "groupId":["customer"]
  * @param xml string to parse
  * @returns parsed json object
-*/
-
-async function parseXml(pomXmlPath) {
+ */
+function parseXml(path) {
   const xmljs = require('xml-js')
-  const xml = await read(pomXmlPath, 'utf-8')
+  const xml = readFileSync(path, { encoding: 'utf-8' })
   return JSON.parse(xmljs.xml2json(xml, {
       ignoreComment: true,
       compact: true,

package/lib/util/pruneAxiosErrors.js

@@ -0,0 +1,22 @@
+require('axios').interceptors.response.use(
+    response => response,
+    axError => {
+        const { url, method } = axError.config ?? {};
+        const { code, response } = axError;
+        const { status, data } = response ?? {};
+        const reason = data?.error /* RFC 6749 */ ?? axError.message;
+        const message = (url && method ? `${method.toUpperCase()} ${url} ` : '') +
+            'failed' +
+            (status || code ? ':' : '') +
+            (status ? ` ${status}` : '') +
+            (code ? ` ${code}` : '') +
+            `. ${reason}.` +
+            (data ? ` Details: '${data.error_description /* RFC 6749 */ || require('util').inspect(data)}'.` : '');
+
+        const error = new Error(message);
+        if (require('../').debug('req')) {
+            error.cause = axError;
+        }
+        return Promise.reject(error);
+    }
+);

package/lib/watch/open.js

@@ -50,7 +50,10 @@ function _open(args) {
     args = ['/c', 'start'].concat(args)
   }
 
-  return childProcess.execFile(command, args, null, err => {
-    err && console.error(`Error opening '${command} ${args}' : ${err.message}`)
-  })
+  const delay = parseInt(process.env.CDS_WATCH_OPEN_DELAY) || 1000
+  setTimeout(() => {
+    childProcess.execFile(command, args, null, err => {
+      err && console.error(`Error opening '${command} ${args}' : ${err.message}`)
+    })
+  }, delay);
 }