@sap/cds-dk 6.2.2 → 6.3.0

package/lib/init/util/templateUtil.js

@@ -1,375 +1,32 @@
-const path = require('path');
-const YAML = require('@sap/cds-foss').yaml;
-const Mustache = require('mustache');
-const { fs } = require('../../cds').utils;
-
-const TEMPLATE_EXTENSION = '.hbs';
-const TEMPLATE_EXTENSION_REGEX = new RegExp(`${TEMPLATE_EXTENSION}$`);
-
-module.exports = class TemplateUtil {
-
-    constructor(templateRoot, fsUtil) {
-        this.templateRoot = templateRoot;
-        this.fsUtil = fsUtil;
-    }
-
-    async copyFiles(template, destinationPath, templateValues, overwrite = false) {
-        const templatePath = this._getTemplatePath(template);
-
-        const files = await this.fsUtil.readdir(templatePath);
-        for (const file of files) {
-            const fileNew = Mustache.render(file, templateValues);
-            const src = path.join(templatePath, file);
-            const dest = path.join(destinationPath, fileNew);
-
-            const stat = await this.fsUtil.stat(src);
-            if (stat.isDirectory()) {
-                await this.copyFiles(path.join(template, file), dest, templateValues, overwrite);
-            } else if (this._isTemplateFile(file)) {
-                await this._writeTemplateFile(src, dest, templateValues, overwrite);
-            } else {
-                await this.fsUtil.copy(src, dest);
-            }
-        }
-    }
-
-    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))) {
-            const content = await this._processTemplateFile(src, templateValues);
-            await this.fsUtil.writeFile(destinationPath, content);
-        }
-    }
-
-    async _processTemplateFile(src, templateValues) {
-        const content = await this.fsUtil.readFile(src);
-        return Mustache.render(content, templateValues);
-    }
-
-    _getTemplatePath(templatePath) {
-        return path.join(this.templateRoot, templatePath);
-    }
-
-    _isTemplateFile(filename) {
-        return path.extname(filename) === TEMPLATE_EXTENSION;
-    }
-
-    /*
-    Will do a syntactic merge when `semantics` is undefined.
-    Syntactic merges are sufficient in some cases,
-    e.g merging dependencies in a package.json, as they are
-    just maps where you can do a key-value replacement.
-    */
-    _deepMerge(target, source) {
-        const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse)
-        if (this._isObject(target) && this._isObject(source)) {
-            for (const key in source) {
-                if (this._isObject(source[key])) {
-                    if (!target[key]) Object.assign(target, { [key]: source[key] })
-                    else this._deepMerge(target[key], source[key])
-                } else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
-                    target[key] = unique([...source[key], ...target[key]])
-                } else {
-                    Object.assign(target, { [key]: target[key] || source[key] })
-                }
+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);
+
+        if (isdir(src)) {
+            await copyFiles(path.join(templatePath, dirent), dest, templateValues, overwrite);
+        } else if (path.extname(dirent) === '.hbs') {
+            const destinationPath = dest.replace('.hbs', '');
+            if (overwrite || !exists(destinationPath)) {
+                const content = await render(src, templateValues);
+                await write(destinationPath, content, { spaces: 2 });
             }
-        } else if (Array.isArray(target) && Array.isArray(source)) {
-            target = unique([...source, ...target])
-        }
-        return target || source
-    }
-
-    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)
-        } else if (semantics) {
-            const target = await this.fsUtil.readJSON(targetPath)
-
-            if (!target) return // Has no JSON file
-
-            const targetYAML = await YAML.parseDocument(YAML.stringify(target))
-            const sourceYAML = await YAML.parseDocument(YAML.stringify(source))
-            const resultYAML = await this.mergeYAML(targetYAML, sourceYAML, projectDescriptor, semantics)
-            const result = YAML.parse(YAML.stringify(resultYAML))
-            await this.fsUtil.writeJSON(targetPath, result)
         } else {
-            const target = await this.fsUtil.readJSON(targetPath)
-            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)
+            await copy(src, dest);
         }
     }
+}
 
-    async mergeYAML(into, from, projectDescriptor, semantics) {
-        const target =
-            typeof into === 'string' ? await this.fsUtil.readYAML(into) :
-            into instanceof YAML.Document ? into :
-            new YAML.Document(into)
-        const source =
-            typeof from === 'string' ? await this.fsUtil.readYAML(from, projectDescriptor)
-            : from instanceof YAML.Document ? from :
-            new YAML.Document(from)
-
-        if (!target || !target.contents) {
-            if (typeof into === 'string' && typeof from === 'string') {
-                return projectDescriptor ? this.fsUtil.writeYAML(into, source) : fs.copy(from, into)
-            }
-            return /* has no YAML */
-        }
-
-        const existenceMap = new Map()
-        const templateExistenceMap = new Map()
-
-        const { additions, overwrites, deletions, relationships } = semantics
-        additions?.forEach(existence => {
-            existenceMap.set(existence.ref, undefined)
-            templateExistenceMap.set(existence.ref, undefined)
-        })
-        deletions?.forEach(deletion => {
-            existenceMap.set(deletion.item.ref, undefined)
-        })
-        relationships?.forEach(relationship => {
-            const [existence] = relationship.into
-            const [insertExistence] = relationship.insert
-            const ref = insertExistence.ref + ' -> ' + existence.ref
-            existenceMap.set(ref, undefined)
-        })
-
-        let collectionStack = [target.contents]
-
-        const _getProperty = (object, keyPath) => keyPath.split('.').reduce((p, k) => p && p[k], object)
-        const _getYAMLProperty = (object, keyPath) => keyPath.split('.').reduce((p, k) => p && p.get(k), object)
-
-        const _validateWhere = (node, dict, index) => {
-            const _addToMap = existences => existences?.filter(existence => {
-                    let where = existence.in
-                    if (typeof where === 'string') return true // just a key path on the document root
-                    else where = where[0] // a more complex list of constraints, a sequence/array is involved
-                    const neededParent = dict.get(where.ref)?.node
-                    return collectionStack.includes(neededParent) // lookbehind in parent collection stack
-                    // REVISIT: Only look behind until sequence is reached?
-            }).forEach(({ where, ref }) => {
-                const json = JSON.parse(String(node))
-                const whereFulfilled = where.every(constraint =>
-                    constraint.isEqualTo === _getProperty(json, constraint.property)
-                )
-                if (whereFulfilled) {
-                    const [collection] = collectionStack
-                    dict.set(ref, { json, node, index, collection })
-                }
-            })
-            if (additions) _addToMap(additions)
-            if (deletions) _addToMap(deletions.map(deletion => deletion.item))
-            if (relationships) _addToMap(relationships?.map(({into: [existence]}) => existence).filter(e => e))
-        }
-
-        function _traverseYAMLNode(node, index, actions, templateNode) {
-            let shifted = false
-            if (YAML.isMap(node)) {
-                actions?.visitMap && actions.visitMap(node, index)
-                const [collection] = collectionStack
-                if (YAML.isSeq(collection)) {
-                    collectionStack.unshift(node)
-                    shifted = true
-                }
-            } else if (YAML.isPair(node) && node.value?.items) {
-                collectionStack.unshift(node.value)
-            } else if (YAML.isScalar(node) && semantics.forceOverwrite && templateNode) {
-                node.value = templateNode.value ?? templateNode.items?.[0]?.value?.value
-            }
-
-            if (node.items) {
-                if (YAML.isSeq(node) && templateNode?.items) {
-                    actions?.mergeCollection && actions.mergeCollection(node, templateNode)
-                    _traverseYAMLCollection(node, actions, templateNode)
-                } else {
-                    _traverseYAMLCollection(node, actions, templateNode)
-                }
-            } else if (node.value?.items || node.value && semantics.forceOverwrite) {
-                _traverseYAMLNode(node.value, index, actions, templateNode && templateNode.value)
-            }
-
-            if (node.value?.items || shifted) {
-                collectionStack.shift()
-            }
-        }
-        _traverseYAMLNode.bind(this)
-
-        function _traverseYAMLCollection (collection, actions, templateCollection) {
-            if (!collection) return
-
-            const keyToIndex = new Map, templateIndexToIndex = new Map
-
-            // Map collection items to their semantic counterpart(s)
-            collection.items.forEach((node, i) => {
-                if (node.key) keyToIndex.set(node.key.value, i)
-                const existence = [...existenceMap.entries()].find(([,value]) => value?.node === node)
-                if (existence) {
-                    const [existenceKey] = existence
-                    const templateExistence = existenceKey && templateExistenceMap.get(existenceKey)
-                    const templateIndex = templateExistence?.index
-                    if (templateIndex !== undefined) templateIndexToIndex.set(templateIndex, i)
-                }
-                if (!templateCollection) _traverseYAMLNode(node, i, actions)
-            })
-
-            if (!templateCollection) return
-
-            templateCollection.items.forEach((templateNode, templateIndex) => {
-                if (YAML.isScalar(templateNode)) {
-                    if (!collection.items.map(item => item.value).includes(templateNode.value)) {
-                        collection.add(templateNode)
-                    }
-                } else if (YAML.isPair(templateNode)) {
-                    const i = keyToIndex.get(templateNode.key.value)
-                    const [collection] = collectionStack
-                    const targetNode = collection.items && collection.items[i]
-                    if (targetNode) {
-                        _traverseYAMLNode(targetNode, templateIndex, actions, templateNode)
-                    } else if (actions.mergePair) {
-                        actions.mergePair(collection, templateNode)
-                    }
-                } else if (YAML.isMap(templateNode)) {
-                    const targetNode = collection.items[templateIndexToIndex.get(templateIndex)]
-                    if (actions.mergeCollection) actions.mergeCollection(targetNode, templateNode)
-                    if (targetNode) {
-                        _traverseYAMLNode(targetNode, templateIndex, actions, templateNode)
-                    }
-                }
-            })
-        }
-        _traverseYAMLCollection.bind(this)
-
-        // 1. Validate the existences in the template
-        _traverseYAMLNode(source.contents, null, {
-            visitMap: (node, index) => {
-                _validateWhere(node, templateExistenceMap, index)
-            }
-        })
-
-        // 2. Validate the existences in the project
-        _traverseYAMLNode(target.contents, null, {
-            visitMap: (node, index) => {
-                _validateWhere(node, existenceMap, index)
-            }
-        })
-
-        // 3. Apply overwrites to already found existences
-        overwrites?.forEach(({ item, withValue }) => {
-            const keyPath = Array.isArray(item) && typeof item[0] === 'string' ? item[0] : typeof item === 'string' ? item : item[1]
-            const inExistence = Array.isArray(item) && typeof item[0] === 'object' ? item[0] : typeof item === 'object' ? item : item[1]
-            const node = inExistence && existenceMap.get(inExistence.ref) ? existenceMap.get(inExistence.ref).node : collectionStack[collectionStack.length - 1]
-            const keys = keyPath.split('.')
-            if (!node.getIn(keys)) return
-            _getYAMLProperty(node, keys.slice(0, keys.length - 1).join('.'))
-                .set(keys[keys.length - 1], withValue)
-        })
-
-        // 4. Delete existences from the project (e.g. separate deployer module when adding mtx)
-        deletions?.forEach(({ item: { ref }, relationships }) => {
-            const existence = existenceMap.get(ref)
-            if (!existence) return
-            existence.collection.delete(existence.index)
-
-            relationships?.forEach(relationship => {
-                const [allWithinKeyPath, inKeyPath, into] = relationship.allWithin
-                const parent = _getYAMLProperty(target, allWithinKeyPath)
-                for (const child of parent.items) {
-                    const grandchild = _getYAMLProperty(child, inKeyPath)
-                    const i = grandchild?.items?.findIndex(node =>
-                        node.get(into) === _getProperty(existence.json, relationship.removeProperty)
-                    ) ?? - 1
-                    if (i > -1) grandchild.delete(i)
-                }
-            })
-        })
-
-        // 5. Create missing existences and pairs
-        _traverseYAMLNode(target.contents, null, {
-            mergePair: (collection, templateNode) => {
-                if (YAML.isMap(collection)) {
-                    collection.add(templateNode)
-                }
-            },
-            mergeCollection: (targetNode, templateNode) => {
-                if (YAML.isSeq(templateNode)) {
-                    let [,parent] = collectionStack
-                    additions?.filter(addition => {
-                            if (typeof addition.in === 'string' || Array.isArray(addition.in) && typeof addition.in[0] === 'string') return true
-                            const inExistence = Array.isArray(addition.in) ? existenceMap.get(addition.in[0].ref) : existenceMap.get(addition.in.ref)
-                            return inExistence?.node === parent
-                        })
-                        .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 > 1) parent = collectionStack[keys.length]
-                            return _getYAMLProperty(parent, keyPath) === targetNode
-                        })
-                        .filter(({ ref }) => {
-                            return !existenceMap.get(ref)
-                        })
-                        .forEach(({ ref, at }) => {
-                            const templateNode = templateExistenceMap.get(ref).node
-                            at !== undefined ? targetNode.items.splice(at, 0, templateNode) : targetNode.add(templateNode)
-                        })
-                }
-            },
-        }, source.contents)
-
-        // 6. Re-validate the existences in the project
-        _traverseYAMLNode(target.contents, null, {
-            visitMap: (node, index) => {
-                _validateWhere(node, existenceMap, index)
-            }
-        })
-
-        // 7. Create missing relationships
-        _traverseYAMLNode(target.contents, null, {
-            mergeCollection: (targetNode, templateNode) => {
-                if (YAML.isSeq(templateNode)) {
-                    const targetJSON = YAML.parse(String(targetNode))
-                    const relationship = semantics.relationships?.filter(r => r)
-                        .find(relationship => {
-                            const [existence, keyPath] = relationship.into
-                            if (!existenceMap.get(existence.ref)) return false
-                            const existingNode = _getYAMLProperty(existenceMap.get(existence.ref).node, keyPath)
-                            return targetNode === existingNode
-                    })
-                    if (!relationship) return
-
-                    const intoKey = relationship.into[relationship.into.length - 1]
-                    const [existence, existenceKeyPath] = relationship.insert
-                    const missingPairs = [existence]
-                        .filter(({ref}) =>
-                            !targetJSON.some(item =>
-                                _getProperty(existenceMap.get(ref).json, existenceKeyPath) === item[intoKey]
-                            )
-                        )
-                        .map(({ref}) => existenceMap.get(ref).node.get(intoKey))
-                    missingPairs.forEach(pair => {
-                        targetNode.add({ [intoKey]: pair })
-                    })
-                }
-            }
-        }, source.contents)
-
-        typeof into === 'string' && await this.fsUtil.writeYAML(into, target)
-        return target
-    }
+async function render(src, templateValues) {
+    const content = await read(src, 'utf-8');
+    return Mustache.render(content, templateValues);
+}
 
-    _isObject(item) {
-        return item && typeof item === 'object' && !Array.isArray(item)
-    }
+module.exports = {
+    render,
+    copyFiles
 }

package/lib/lint/Linter.js

@@ -124,10 +124,9 @@ class Linter {
       for (let i = 0; i < configFiles.length; i++) {
         const configPath = path.join(configDir, configFiles[i]);
         if (configFiles[i] !== "package.json" || (
-          configFiles[i] !== "package.json" && require(configPath).eslintConfig
+          configFiles[i] === "package.json" && require(configPath).eslintConfig
         )) {
-          if (await exists(configPath) && await isfile(configPath)) {
-
+          if (exists(configPath) && await isfile(configPath)) {
             return configPath;
           }
         }

package/lib/lint/checks.js

@@ -106,7 +106,6 @@ module.exports = {
           cwd: inputPath,
           shell: IS_WIN,
         },
-        undefined,
         true
       );
     } catch (err) {

package/lib/lint/io.js

@@ -1,10 +1,9 @@
-const fsp = require("fs").promises;
 const path = require("path");
 const yaml = require("@sap/cds-foss")("yaml");
 const term = require("../util/term");
-const FsUtil = require("../init/util/fsUtil");
-const fsUtil = new FsUtil();
-const JSONC = require("../util/jsonc")
+const { read, write, exists } = require('../cds').utils;
+const { readJSONC } = require("../init/util/fsUtil");
+const JSONC = require('../util/jsonc');
 
 module.exports = {
   /**
@@ -14,8 +13,8 @@ module.exports = {
    */
   async readEslintConfig(configPath) {
     let config;
-    let configFile = path.basename(configPath);
-    let configString = await fsp.readFile(configPath, "utf8");
+    const configFile = path.basename(configPath);
+    const configString = await read(configPath, "utf8");
     switch (configFile) {
       case ".eslintrc.js":
       case ".eslintrc.cjs":
@@ -27,14 +26,14 @@ module.exports = {
         break;
       case ".eslintrc.yaml":
       case ".eslintrc.yml":
-        config = yaml.parse(await fsp.readFile(configPath, "utf8"));
+        config = yaml.parse(await read(configPath, "utf8"));
         break;
       case ".eslintrc.json":
       case ".eslintrc":
-        config = await fsUtil.readJSONC(configPath);
+        config = await readJSONC(configPath);
         break;
       case "package.json":
-        config = JSON.parse(await fsp.readFile(configPath, "utf8"));
+        config = JSON.parse(await read(configPath, "utf8"));
         if ("eslintConfig" in config) {
           config = config["eslintConfig"];
         } else {
@@ -60,7 +59,7 @@ module.exports = {
     let configContents = {};
     const isFilePath = typeof configIn === "string";
     if (isFilePath) {
-      if (await fsUtil.pathExists(configIn)) {
+      if (exists(configIn)) {
         configContents = (await this.readEslintConfig(configIn)) || {};
       }
     } else {
@@ -103,7 +102,7 @@ module.exports = {
    * Writes ESLint config contents to file
    * @param {*} configContents config file contents
    * @param {*} configPath config file path to write to
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async writeEslintConfig(configPath, configContents, logger=console) {
     const configType = "recommended";
@@ -139,15 +138,15 @@ module.exports = {
         break;
       case ".eslintrc.yaml":
       case ".eslintrc.yml":
-        await fsUtil.writeFile(configPath, yaml.stringify(configContents));
+        await write(configPath, yaml.stringify(configContents));
         break;
       case ".eslintrc.json":
       case ".eslintrc":
-        await fsUtil.writeFile(configPath, `${JSON.stringify(configContents, null, 2)}`);
+        await write(configPath, configContents, { spaces: 2 });
         break;
       case "package.json":
-        if (await fsUtil.pathExists(configPath)) {
-          contents = JSON.parse(await fsp.readFile(configPath, "utf8"));
+        if (exists(configPath)) {
+          contents = JSON.parse(await read(configPath, "utf8"));
         } else {
           contents = {};
         }
@@ -156,12 +155,11 @@ module.exports = {
         } else {
           contents["eslintConfig"] = [...configContents, ...contents["eslintConfig"]];
         }
-        await fsUtil.writeFile(configPath, `${JSON.stringify(contents, null, 2)}`);
+        await write(configPath, contents, { spaces: 2 });
         break;
       default:
         break;
     }
-    return;
   },
 
   /**
@@ -171,9 +169,9 @@ module.exports = {
    */
   async readVscodeSettings(settingsPath) {
     let settings;
-    if (fsUtil.pathExists(settingsPath)) {
+    if (exists(settingsPath)) {
       try {
-        settings = await fsUtil.readJSONC(settingsPath);
+        settings = await readJSONC(settingsPath);
       } catch (err) {
         settings = {};
       }
@@ -230,21 +228,7 @@ module.exports = {
       }
     }
 
-    await this.writeVscodeSettings(settingsPath, settings);
-  },
-
-  /**
-   * Writes VS Code settings from file
-   * @param {*} settings settings file contents
-   * @param {*} settingsPath settings file path to write to
-   * @returns {void}
-   */
-  async writeVscodeSettings(settingsPath, settings) {
-    if (!settings) {
-      await fsUtil.mkdirp(path.dirname(settingsPath));
-    }
-    await fsUtil.writeJSON(settingsPath, settings);
-    return;
+    await write(settingsPath, settings, { spaces: 2 });
   },
 
   /**