@sap/cds-dk 4.8.0 → 4.9.0

package/lib/init/util/fsUtil.js

@@ -1,3 +1,4 @@
+const fs = require('fs').promises;
 const path = require('path');
 
 const {fse, yaml} = require('@sap/cds-foss')
@@ -5,6 +6,10 @@ const JSONC = require('../../util/jsonc');
 
 const UTF_8 = 'utf-8';
 
+/**
+ * this util implements FsUtil declared in ../types.d.ts
+ * the interface FsUtil is also used by @sap/generator-cap-project
+ */
 module.exports = class FsUtil {
 
     constructor() {
@@ -30,10 +35,16 @@ module.exports = class FsUtil {
     }
 
     async readFile(src) {
-        return await fse.readFile(src, UTF_8);
+        return await fs.readFile(src, UTF_8);
     }
 
-    async readJSON(src) {
+    async readJSON(src, projectDescriptor) {
+        const file = await this.readFile(src);
+        if (projectDescriptor) {
+            const Mustache = require('mustache');
+            const renderedFile = Mustache.render(file, projectDescriptor);
+            return JSON.parse(renderedFile);
+        }
         return await fse.readJSON(src);
     }
 
@@ -64,7 +75,7 @@ module.exports = class FsUtil {
     }
 
     async readdir(filePath) {
-        return await fse.readdir(filePath);
+        return await fs.readdir(filePath);
     }
 
     getTouchedFiles() {
@@ -76,7 +87,7 @@ module.exports = class FsUtil {
     }
 
     async stat(filePath) {
-        return await fse.stat(filePath);
+        return await fs.stat(filePath);
     }
 
     async hasContent(folderPath) {

package/lib/init/util/projectReader.js

@@ -1,6 +1,7 @@
 const path = require('path')
 const { nullLogger } = require('../util/logger')
 const { BuildTaskFactory } = require('@sap/cds/bin/build')
+const { fs } = require('@sap/cds/lib/utils')
 const P_LANGUAGE_JAVA = 'java'
 const P_LANGUAGE_NODEJS = 'nodejs'
 const DEFAULT_P_LANGUAGE = P_LANGUAGE_NODEJS
@@ -60,12 +61,17 @@ module.exports = class ProjectReader {
 
     async _getCapDescriptor(env, options) {
         let capDescriptor = {
+            for: options && options.for,
             pLanguage: DEFAULT_P_LANGUAGE,
             srv: {},
             db: [],
             requires: [],
             get isMultitenant() {
-                return options && options.add.has('mtx') || env.requires.multitenancy || env.requires.db && env.requires.db.multiTenant || false
+                return options && options.add && options.add.has('mtx') ||
+                    env.requires.multitenancy ||
+                    env.requires.db && env.requires.db.multiTenant ||
+                    this.isJava && fs.existsSync('mtx-sidecar') ||
+                    false
             },
             get isNodejs() {
                 return this.pLanguage === P_LANGUAGE_NODEJS
@@ -87,6 +93,9 @@ module.exports = class ProjectReader {
             },
             get needsSidecar() {
                 return (options && options.add.has('hana') || this.db.length > 0) && (this.isJava || !this.isMultitenant)
+            },
+            get hasApprouter() {
+                return !!env.requires.approuter
             }
         }
 
@@ -179,14 +188,6 @@ module.exports = class ProjectReader {
             uiDescriptor.appPath = env.folders.app
         }
 
-        const packageJson = await (async () => { try {
-            return await this.fsUtil.readFile(absoluteAppPath+'package.json')
-        } catch(error) { /* ignore */ }
-        })()
-
-        if (packageJson && packageJson.dependencies) {
-            uiDescriptor.appRouterEnabled = packageJson.dependencies['@sap/approuter'] !== undefined
-        }
         return uiDescriptor
     }
 
@@ -316,25 +317,27 @@ module.exports = class ProjectReader {
         const hanaResources = new Map()
         const otherResources = new Map()
 
-        for (let key of Object.keys(env.requires)) {
+        for (const key of Object.keys(env.requires)) {
             // ignore abstract helper definitions like sql
             if (key === 'sql' || key === 'sqlite' || key === 'hana') continue
-            if (env.requires[key].kind === 'hana') {
+            const { kind } = env.requires[key]
+            if (kind === 'hana' || kind === 'hana-mt' || kind === 'hana-cloud') {
                 hanaResources.set(key, env.requires[key])
             } else {
                 otherResources.set(key, env.requires[key])
             }
         }
-        for (let [key, value] of hanaResources) {
-            let resource = this._getReqResource(key, value, capDescriptor)
+
+        for (const [key, value] of hanaResources) {
+            const resource = this._getReqResource(key, value, capDescriptor)
             if (resource) {
                 // using production profile
                 capDescriptor.requires.push({ resource })
             }
         }
         // add after hana resource dependencies have been handled as multitenant information is required
-        for (let [key, value] of otherResources) {
-            let resource = this._getReqResource(key, value, capDescriptor)
+        for (const [key, value] of otherResources) {
+            const resource = this._getReqResource(key, value, capDescriptor)
             if (resource) {
                 // using production profile
                 capDescriptor.requires.push({ resource })
@@ -391,9 +394,9 @@ module.exports = class ProjectReader {
                 break
 
             case 'xsuaa':
-                if (capDescriptor.isMultitenant) {
-                    resource.name += '-mt'
-                }
+                // if (capDescriptor.isMultitenant) {
+                //     resource.name += '-mt'
+                // }
                 resource.service = reqEntry.kind
                 resource.vcap.plan = 'application'
                 break

package/lib/init/util/templateUtil.js

@@ -32,6 +32,14 @@ module.exports = class TemplateUtil {
         }
     }
 
+    async sortDependencies(packageJSONPath) {
+        const json = await this.fsUtil.readJSON(packageJSONPath);
+        json.dependencies = Object.fromEntries(
+            Object.entries(json.dependencies).sort(([a],[b]) => a>b ? 1 : -1)
+        )
+        await this.fsUtil.writeJSON(packageJSONPath, json);
+    }
+
     async _writeTemplateFile(src, destination, templateValues, overwrite = false) {
         const destinationPath = destination.replace(TEMPLATE_EXTENSION_REGEX, '');
         if (overwrite || !(await this.fsUtil.pathExists(destinationPath))) {
@@ -80,8 +88,8 @@ module.exports = class TemplateUtil {
         return target || source;
     }
 
-    async mergeJSON(targetPath, sourcePath, projectDescriptor, semantics) {
-        const source = await this.fsUtil.readJSON(sourcePath, projectDescriptor)
+    async mergeJSON(targetPath, from, projectDescriptor, semantics) {
+        const source = typeof from === 'string' ? await this.fsUtil.readJSON(from, projectDescriptor) : from
 
         if (! await this.fsUtil.pathExists(targetPath)) {
             await this.fsUtil.writeJSON(targetPath, source);
@@ -97,7 +105,7 @@ module.exports = class TemplateUtil {
             await this.fsUtil.writeJSON(targetPath, result)
         } else {
             const target = await this.fsUtil.readJSON(targetPath);
-            const sourceFile = await this._processTemplateFile(sourcePath, projectDescriptor);
+            const sourceFile = await this._processTemplateFile(from, projectDescriptor);
             const source = JSON.parse(sourceFile);
             const result = target && source ? this._deepMerge(target, source) : target || source;
             await this.fsUtil.writeJSON(targetPath, result);
@@ -120,11 +128,16 @@ module.exports = class TemplateUtil {
             templateExistenceMap.set(existence.ref, undefined)
         });
 
+        const { deletions } = semantics
+        deletions && deletions.forEach(deletion => {
+            existenceMap.set(deletion.existence.ref, undefined)
+        })
+
         const missingRelationshipsMap = new Map()
 
         const relationships = semantics.relationships && semantics.relationships.filter(r => r)
         relationships && relationships.forEach(relationship =>
-            missingRelationshipsMap.set(relationship.in, undefined)
+            missingRelationshipsMap.set(relationship.in.ref, undefined)
         )
 
         let collectionStack = [target.contents]
@@ -133,22 +146,35 @@ module.exports = class TemplateUtil {
         const _getYAMLProperty = (object, keyPath) => keyPath.reduce((p, n) => p && p.get(n), object)
 
         const _validateConstraints = (node, dict, index) => {
-            existences.forEach(existence => {
-                const json = JSON.parse(String(node))
-                const constraintsFulfilled = existence.constraints.every(constraint =>
-                    constraint.value === _getProperty(json, constraint.comparisonKeyPath)
-                )
-                if (constraintsFulfilled) dict.set(existence.ref, { json, node, index })
+            const _addToMap = existences => existences
+                .filter(existence => {
+                    if (!existence.in) return true
+                    const neededParent = existence.in && dict.get(existence.in.ref) && dict.get(existence.in.ref).node
+                    return collectionStack.includes(neededParent)
+                })
+                .forEach(existence => {
+                    const json = JSON.parse(String(node));
+                    const constraintsFulfilled = existence.constraints.every(constraint =>
+                        constraint.value === _getProperty(json, constraint.comparisonKeyPath)
+                    )
+                    if (constraintsFulfilled) {
+                        const [collection] = collectionStack
+                        dict.set(existence.ref, { json, node, index, collection })
+                    }
             })
+            _addToMap(existences)
+            deletions && _addToMap(deletions.map(deletion => deletion.existence))
         }
 
         function _traverseYAMLNode(node, index, actions, templateNode) {
             let shifted = false
             switch (node.type) {
-                case 'MAP':
+                case 'MAP': {
                     actions && actions.visitMap && actions.visitMap(node, index)
-                    if (collectionStack[0] && collectionStack[0].type === 'SEQ') { collectionStack.unshift(node); shifted = true}
+                    const [collection] = collectionStack
+                    if (collection && collection.type === 'SEQ') { collectionStack.unshift(node); shifted = true}
                     break;
+                }
                 case 'SEQ':
                     break;
                 case 'PAIR':
@@ -235,15 +261,35 @@ module.exports = class TemplateUtil {
         })
 
         // 3. Apply overwrites to already found existences
-        semantics.overwrites && semantics.overwrites.forEach(({ in: ref, keyPath, replacement }) => {
-            const existence = existenceMap.get(ref)
+        semantics.overwrites && semantics.overwrites.forEach(({ in: inExistence, keyPath, replacement }) => {
+            const existence = existenceMap.get(inExistence.ref)
             if (existence) {
                 _getYAMLProperty(existence.node, keyPath.slice(0, keyPath.length - 1))
                     .set(keyPath[keyPath.length - 1], replacement)
             }
         })
 
-        // 4. Create missing existences and pairs
+        // 4. Delete existences from the project (e.g. separate deployer module when adding mtx)
+        semantics.deletions && semantics.deletions.forEach(({ existence: { ref }, relationships }) => {
+            const existence = existenceMap.get(ref)
+            if (!existence) return
+            existence.collection.delete(existence.index)
+
+            relationships && relationships.forEach(relationship => {
+                const parent = target.get(relationship.allWithinKeyPath[0])
+                for (const child of parent.items) {
+                    const c = child.get(relationship.inKeyPath[0])
+                    const i = c.items.findIndex(node =>
+                        node.get(relationship.into) === _getProperty(existence.json, relationship.existenceKeyPath)
+                    )
+                    if (i > -1) {
+                        c.delete(i)
+                    }
+                }
+            })
+        })
+
+        // 5. Create missing existences and pairs
         _traverseYAMLNode(target.contents, null, {
             mergePair: (collection, templateNode) => {
                 const childIsArray = false//templateNode.value.type !== 'MAP' && !!templateNode.value.items
@@ -257,30 +303,34 @@ module.exports = class TemplateUtil {
                     const [,parent] = collectionStack
                     const missingExistences = semantics.existences
                         .filter(e => e)
-                        .filter(existence =>
-                            parent.get(existence.keyPath[0]) === targetNode
-                        ).filter(existence =>
-                            !existenceMap.get(existence.ref)
-                        )
+                        .filter(existence => {
+                            const requiredParent = existence.in &&
+                                                   existenceMap.get(existence.in.ref) &&
+                                                   existenceMap.get(existence.in.ref).node
+                            return !existence.in || requiredParent === parent
+
+                        })
+                        .filter(({keyPath}) => parent.get(keyPath[0]) === targetNode)
+                        .filter(({ref}) => !existenceMap.get(ref))
                     missingExistences.forEach(existence => {
-                        const templateExistence = YAML.createNode(templateExistenceMap.get(existence.ref).node)
+                        const templateNode = templateExistenceMap.get(existence.ref).node
+                        const templateExistence = YAML.createNode(templateNode)
                         templateExistence.spaceBefore = existence.spaceBefore
                         targetNode.add(templateExistence)
-                        existenceMap.set(existence.ref, templateExistence)
                         //this.fsUtil.writeYAML(targetPath, target)
                     })
                 }
             },
         }, source.contents)
 
-        // 5. Re-validate the existences in the project
+        // 6. Re-validate the existences in the project
         _traverseYAMLNode(target.contents, null, {
             visitMap: (node, index) => {
                 _validateConstraints(node, existenceMap, index)
             }
         })
 
-        // 6. Create missing relationships
+        // 7. Create missing relationships
         _traverseYAMLNode(target.contents, null, {
             mergeCollection: (targetNode, templateNode) => {
                 if (templateNode.type === 'SEQ') {
@@ -288,18 +338,18 @@ module.exports = class TemplateUtil {
                     const relationship = semantics.relationships && semantics.relationships
                         .filter(r => r)
                         .find(relationship => {
-                            const existingNode = _getYAMLProperty(existenceMap.get(relationship.in).node, relationship.inKeyPath)
+                            const existingNode = _getYAMLProperty(existenceMap.get(relationship.in.ref).node, relationship.inKeyPath)
                             return targetNode === existingNode
                     })
                     if (!relationship) return
 
                     const missingPairs = relationship.existences
-                        .filter(existenceKey =>
+                        .filter(({ref}) =>
                             !targetJSON.some(item =>
-                                _getProperty(existenceMap.get(existenceKey).json, relationship.existenceKeyPath) === item[relationship.into]
+                                _getProperty(existenceMap.get(ref).json, relationship.existenceKeyPath) === item[relationship.into]
                             )
                         )
-                        .map(existenceKey => existenceMap.get(existenceKey).node.get(relationship.into))
+                        .map(({ref}) => existenceMap.get(ref).node.get(relationship.into))
                     missingPairs.forEach(pair => {
                         targetNode.add(YAML.createNode({ [relationship.into]: pair }))
                         //await this.fsUtil.writeYAML(targetPath, target)

package/lib/util/exec.js

@@ -3,7 +3,7 @@ const { spawn, spawnSync } = require('child_process');
 const cds = require('@sap/cds/lib');
 const log = cds.log('exec');
 
-function* commandIterator(strs, ...args) {
+function* commandIterator(strs, args) {
     for (let i=0; i<strs.length; i++) {
         const str = strs[i];
         const regex = /((\s+)|(["'])|$)/g;
@@ -38,7 +38,7 @@ function* commandIterator(strs, ...args) {
     }
 }
 
-function processTemplate(strs, args) {
+function processTemplate(strs, ...args) {
     let quote;
     const result = [];
     let index = 0;

package/lib/watch/livereload-server.js

@@ -66,6 +66,9 @@ module.exports = class LiveReload {
         this.wsServer.on('close', () => { debug && debug('Socket closed') })
         this.wsServer.on('error', (e) => debug && debug(e))
       }
+      const close = () => { this.wsServer.close(); server.close(); debug && debug('Reload server closed') }
+      process.once('SIGTERM', close)
+      process.once('SIGINT', close)
     })
   }
 

package/lib/watch/node-watch.js

@@ -7,7 +7,14 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   // Phoning home...
   const EventEmitter = require('events')
   const emitter = new EventEmitter
-  process.on('exit', () => { _kill (child);  emitter.emit('quit') })
+
+  const killAndExit = (sig) => {
+    DEBUG && DEBUG('Signal:', sig)
+    emitter.emit('quit')
+    _kill (child, () => process.exit())
+  }
+  process.on('SIGTERM', killAndExit)
+  process.on('SIGINT', killAndExit)
 
   // Re-starting child process...
   const { fork } = require('child_process')