@sap/cds-dk 4.3.3 → 4.5.0

package/lib/init/template/data/index.js

@@ -25,14 +25,20 @@ module.exports = class DataTemplate extends TemplateBase {
     const logger = this.logger;
 
     cds.root = this.projectPath;
-    let csn = await cds.compile.to.csn(['*']); // normal CSN
-    csn = cds.compile.for.sql(csn, { names:env.sql.names }); // CSN w/ persistence information
+    let csn = await cds.compile.to.csn(cds.env.roots); // normal CSN
+
+    // Also include 'external' entities w/ cds.persistence.skip (similar to 'mocked' option of serve).
+    // Could be too much sometimes, but don't want to bother users w/ a separate option for this.
+    cds.deploy.include_external_entities_in(csn)
+
+    csn = cds.compile.for.sql(csn, { names:env.sql.names, messages:[] })  // CSN w/ persistence information
     csn = cds.reflect(csn); // reflected model (adds additional helper functions)
 
     csn.all('entity')
       .filter(prefixedWith)
-      .filter (entity => !entity.query) // exclude entities with queries (projection on, select from ...)
-      .forEach(entity => processEntity(entity, dest, this.projectPath, csn, force, logger));
+      .filter (e => !e.query) // exclude entities with queries (projection on, select from ...)
+      .filter (e => e.name !== 'DRAFT.DraftAdministrativeData' && !e.name.endsWith('.drafts')) // exclude draft stuff
+      .forEach(e => processEntity(e, dest, this.projectPath, csn, force, logger));
   }
 
 }
@@ -44,15 +50,15 @@ function processEntity (entity, dest, projectPath, csn, force, logger) {
     dataFileName = `${entity.name}.csv`;
   }
   else {
-    const entityName = entity.name.replace(namespace + ".", "");
+    const entityName = entity.name.replace(namespace + '.', '');
     dataFileName = `${namespace}-${entityName}.csv`;
   }
 
-  if (entity.name.endsWith(".texts")) {
+  if (entity.name.endsWith('.texts')) {
     // handle '.texts' entities (for localized elements) differently:
     // if there is already file exist with '_texts' (old cds versions) - overwrite this one (when --force is used)
     // otherwise use the new '.texts' format
-    const dataFileNameOldFormat = dataFileName.replace(".texts.csv","_texts.csv");
+    const dataFileNameOldFormat = dataFileName.replace('.texts.csv','_texts.csv');
     const dataFilePathOldFormat = join(dest, dataFileNameOldFormat);
     if (fs.existsSync(dataFilePathOldFormat)) {
       createDataFile(true, dataFilePathOldFormat, dest, projectPath, force, entity, logger);
@@ -68,62 +74,48 @@ function getDefaultTargetFolder (env, projectPath) {
   const dbFolder = env.folders.db;
   // csv files should be located in the 'db/data' folder unless a 'db/csv' folder already exists
   let mockDataFolder;
-  if (fs.existsSync(join(projectPath, dbFolder, "csv"))) {
-    mockDataFolder = "csv";
+  if (fs.existsSync(join(projectPath, dbFolder, 'csv'))) {
+    mockDataFolder = 'csv';
   } else {
-    mockDataFolder = "data";
+    mockDataFolder = 'data';
   }
   return join(dbFolder, mockDataFolder);
 }
 
 
 function createDataFile (isFileExists, dataFilePath, dest, projectPath, force, entity, logger) {
+  let relFilePath = dataFilePath;
+  if (dataFilePath.indexOf(projectPath) == 0) {
+    // use relative path in log (for readability), only when data files are added within the project
+    // (potentially can be located anywhere using the --out parameter)
+    relFilePath = relative(projectPath, dataFilePath);
+  }
   if (isFileExists && !force) {
-    let loggedDataFilePath = dataFilePath;
-    if (dataFilePath.indexOf(projectPath) == 0) {
-      // use relative path in log (for readability), only when data files are added within the project
-      // (potentially can be located anywhere using the --out parameter)
-      loggedDataFilePath = relative(projectPath, dataFilePath);
-    }
-    logger.log(`file ${loggedDataFilePath} already exists with no '--force' option - skip add data for entity ${entity.name}`);
+    logger.log(`Skipping ${relFilePath}`);
   }
   else {
-    // continue only if file not already exists, or "--force" option provided
+    // continue only if file not already exists, or '--force' option provided
     const dataFileContent = prepareDataFileContent(entity);
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, {recursive: true});
+    if (dataFileContent && dataFileContent.length) {
+      if (!fs.existsSync(dest))  fs.mkdirSync(dest, {recursive: true})
+      fs.writeFileSync(dataFilePath, dataFileContent);
+      isFileExists ? logger.log(`Overwriting `+relFilePath) : logger.log(`Creating `+relFilePath)
     }
-    fs.writeFileSync(dataFilePath, dataFileContent);
   }
 }
 
 function prepareDataFileContent (entity) {
-  const persistenceKeyNames = Object.values(entity.keys)
-    .map(element => element['@cds.persistence.name']);
-
-  const persistenceNames = Object.values(entity.elements)
+  const persistenceKeyNames = Object.values(entity.keys||[]).map(element => element['@cds.persistence.name']);
+  return Object.values(entity.elements)
     .filter(element => !(element instanceof cds.Association)) // exclude associations+compositions
-    .map(element => element['@cds.persistence.name'])
-    .filter(elementName => persistenceKeyNames.indexOf(elementName) === -1); // filter out key elements
-
-  let content = "";
-  let isFirst = true;
-  // create keys first (assuming keys cannot be empty)
-  persistenceKeyNames.forEach(name => {
-    if (isFirst) {
-      content += `${name}`;
-      isFirst = false;
-    }
-    else {
-      content += `;${name}`;
-    }
-  });
-
-  persistenceNames.forEach(name => {
-    content += `;${name}`;
-  });
-
-  return content;
+    .filter(element => !!element['@cds.persistence.name']) // exclude no-persistence elements, e.g. virtual ones
+    .map (element => element['@cds.persistence.name'])
+    .sort((e1, e2) => { // sort with keys first
+      if (persistenceKeyNames.includes(e1)  && !persistenceKeyNames.includes(e2)) return -1
+      if (!persistenceKeyNames.includes(e1) && persistenceKeyNames.includes(e2))  return 1
+      return 0 // preserve original order otherwise
+    })
+    .join(';')
 }
 
 // Logic is taken from cds-compile

package/lib/init/template/hana/index.js

@@ -161,7 +161,7 @@ module.exports = class HanaTemplate extends TemplateBase {
         }
     }
 
-    _isUsingHana(modelName) {
-        return this.env.get(`requires.${modelName}.kind`) === KIND_HANA || this.env.get(`requires.${modelName}.use`) === KIND_HANA;
+    _isUsingHana(db) {
+        return this.env.get(`requires.${db}.kind`) === KIND_HANA || this.env.get(`requires.${db}.dialect`) === KIND_HANA || this.env.get(`requires.${db}.use`) === KIND_HANA;
     }
 }

package/lib/init/template/lint/files/.eslint/tests/no-entity-moo/fixed/schema.cds

@@ -0,0 +1,4 @@
+namespace my.bookshop;
+entity Moon {
+  key ID : Integer;
+}

package/lib/init/template/lint/files/.eslint/tests/no-entity-moo/invalid/schema.cds

@@ -0,0 +1,4 @@
+namespace my.bookshop;
+entity Moo {
+  key ID : Integer;
+}

package/lib/init/template/lint/files/.eslint/tests/no-entity-moo/test.js

@@ -0,0 +1,10 @@
+const path = require("path");
+const rule = require("../../rules/no-entity-moo");
+const { runRuleTester } = require("@sap/eslint-plugin-cds/lib/api");
+
+runRuleTester({
+  root: path.resolve(__dirname),
+  rule,
+  filename: 'schema.cds',
+  errors: [{ message: "Entity 'Moo' not allowed!" }],
+});

package/lib/init/template/lint/files/.eslint/tests/no-entity-moo/valid/schema.cds

@@ -0,0 +1,6 @@
+namespace my.bookshop;
+entity Books {
+  key ID : Integer;
+  title  : String;
+  stock  : Integer;
+}

package/lib/init/template/lint/index.js

@@ -52,26 +52,28 @@ module.exports = class LintTemplate extends TemplateBase {
       // Require local ESLint plugin installation and corresponding config
       this._checkEslintPlugin();
       this._addEslintPluginConfig();
-      // Generate custom lint rules dirs
-      await this._generateEslintDirs();
       // Include custom lint sample rule and test ('lint:dev')
       if (this.customRuleExample) {
+        // Generate custom lint rules dirs
+        await this._generateEslintDirs();
+
         if (!fs.existsSync(".eslint/rules/no-entity-moo.js")) {
           await this._copyFromTemplate(".eslint/rules", this.rulesPath);
         }
         if (!fs.existsSync(".eslint/tests/no-entity-moo.test.js")) {
           await this._copyFromTemplate(".eslint/tests", this.testsPath);
         }
+        // Generate custom lint rules docs
+        await generators.genDocs(this.projectPath);
       }
-      // Generate custom lint rules docs
-      await generators.genDocs(this.projectPath);
     }
 
     // Generate VS Code extension settings
     await io.sanitizeVscodeSettings(
       this.projectPath,
       path.join(this.projectPath, ".vscode/settings.json"),
-      this.lintType
+      this.lintType,
+      this.customRuleExample
     );
   }
 
@@ -96,7 +98,7 @@ module.exports = class LintTemplate extends TemplateBase {
           this.missingNpmDependencies["msgs"].forEach((msg, i) => {
             this.logger.log(`(${i + 1}) ${msg}`);
             if (i === this.missingNpmDependencies["msgs"].length - 1) {
-              this.logger.log('\n');
+              this.logger.log("\n");
             }
           });
 

package/lib/init/template/mta/projectReader.js

@@ -331,7 +331,10 @@ module.exports = class ProjectReader {
 
     _hasHanaServiceBinding(env) {
         const kind = ProjectReader._getProperty(env, 'requires.db.kind')
-        return kind === 'hana' || (kind === 'sql' && ProjectReader._getProperty(env, 'requires.db.use') === 'hana')
+        return kind === 'hana' || kind === 'sql' && (
+            ProjectReader._getProperty(env, 'requires.db.dialect') === 'hana' ||
+            ProjectReader._getProperty(env, 'requires.db.use') === 'hana'
+        )
     }
 
     _getReqResource(key, reqEntry, capDescriptor) {
@@ -359,7 +362,7 @@ module.exports = class ProjectReader {
         switch (reqEntry.kind) {
             case 'sql':
             case 'hana':
-                if (reqEntry.kind === 'sql' && reqEntry.use !== 'hana') {
+                if (reqEntry.kind === 'sql' && reqEntry.dialect !== 'hana' && reqEntry.use !== 'hana') {
                     break
                 }
                 // use different service name to avoid conflicts when switching from single tenant to multitenant
@@ -394,12 +397,12 @@ module.exports = class ProjectReader {
     }
 
     /**
-     * Parse a given string containing xml 
+     * Parse a given string containing xml
      * used to remove the _text object from converted json i.e. from xml-js.
      * example : converted json has "groupId":[{"_text":["customer"]}]
      * and after removing textAttributes (using this function): "groupId":["customer"]
      * @param xml string to parse
-     * @returns parsed json object 
+     * @returns parsed json object
      */
     async _parseXml(pomXmlPath) {
         const xmljs = require('xml-js');
@@ -426,7 +429,7 @@ module.exports = class ProjectReader {
         }
     }
 
-    /* 
+    /*
         Remove the _text attributes and convert value it into array
         input : "groupId":[{"_text":["customer"]}]
         output: "groupId":["customer"]

package/lib/init/template/nodejs/files/.vscode/extensions.json

@@ -4,7 +4,7 @@
 
 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
-		// >>>>>>>> Add CDS Editor here as soon it is available of vscode marketplace!,
+		"SAPSE.vscode-cds",
 		"dbaeumer.vscode-eslint",
 		"esbenp.prettier-vscode",
 		"mechatroner.rainbow-csv",

package/lib/init/template/nodejs/index.js

@@ -1,7 +1,7 @@
 const path = require('path');
 
 const TemplateBase = require('../templateBase');
-const { COMMAND_ADD, OPTION_JAVA, OPTION_JAVA_MVN, OPTION_JAVA_PACKAGE, OPTION_NODEJS, URLS } = require('../../constants');
+const { COMMAND_ADD, OPTION_JAVA, OPTION_NODEJS, URLS } = require('../../constants');
 
 
 module.exports = class NodeJSTemplate extends TemplateBase {
@@ -18,13 +18,6 @@ module.exports = class NodeJSTemplate extends TemplateBase {
             throw new Error(`Only one runtime per project is supported. Specify either ${OPTION_JAVA} or ${OPTION_NODEJS}.`);
         }
 
-        if (this.options[OPTION_JAVA_PACKAGE]) {
-            this.logger.warn(`Specified Java package will be ignored since project type is not Java. Use --add java to create project type Java.`);
-        }
-        if (this.options[OPTION_JAVA_MVN]) {
-            this.logger.warn(`Specified Maven parameters will be ignored since project type is not Java. Use --add java to create project type Java.`);
-        }
-
         return true;
     }
 

package/lib/init/util/logger.js

@@ -2,7 +2,7 @@
 
 const term = require('../../util/term');
 const cds = require('@sap/cds/lib');
-const LOG = cds.log('init');
+const LOG = cds.log ? cds.log('init') : console;
 
 const defaultLogger = {
     isDebug: LOG._debug,

package/lib/lint/Linter.js

@@ -1,8 +1,6 @@
 const os = require("os");
 const fs = require("fs");
-const cp = require("child_process");
-const util = require("util");
-const execAsync = util.promisify(cp.exec);
+const commandUtil = require("../init/util/commandUtil");
 const path = require("path");
 const glob = require("glob");
 const term = require("../util/term");
@@ -23,6 +21,7 @@ class Linter {
     this.eslintCmdOpts = {};
     this.eslintCmdOptsIndex = 0;
     this.eslintCmdFileExpr = "";
+    this.isFile = false;
     this.help = "";
     this.debug = "";
     this.flags = [];
@@ -71,7 +70,7 @@ class Linter {
    */
   async lint(args, options) {
     this.eslintCmdOpts = this._sanitizeUserOpts(options);
-    this.eslintCmdFileExpr = args;
+    this.eslintCmdFileExpr = args.length ? args : ['.']
     if (this.eslintCmdOpts.help) {
       this._printHelp();
     } else {
@@ -96,16 +95,10 @@ class Linter {
       // Limit to CDS file extensions
       this._addExtensions();
       // Run ESLint with collected options
-      let result = "";
       try {
-        result = await this._runEslint();
+        await this._runEslint();
       } catch (err) {
-        if (err.stdout) {
-          console.log(err.stdout);
-        }
-      }
-      if (result.stdout) {
-        console.log(result.stdout);
+        term.error(err);
       }
     }
   }
@@ -150,10 +143,6 @@ class Linter {
       "ext",
       ".cds,.csn"
     );
-    // Enable colored output
-    if (process.stdout.isTTY) {
-      this.eslintCmdOpts = io.mergeWithUserOpts(this.eslintCmdOpts, "color");
-    }
     // Add custom CDS formatter
     const formatterPath = this.pluginPath.replace(
       "index.js",
@@ -164,72 +153,86 @@ class Linter {
       "format",
       path.relative(".", formatterPath)
     );
+    // Enable colored output
+    if (process.stdout.isTTY) {
+      this.eslintCmdOpts = io.mergeWithUserOpts(this.eslintCmdOpts, "color");
+    }
     return;
   }
 
   async _runEslint(dryRun = false) {
     const eslintCmdOpts = [];
     // Collect cmd line options
-    for (let key in this.eslintCmdOpts) {
-      let value = this.eslintCmdOpts[key];
-      if (this.flags.includes(`--${key}`)) {
-        eslintCmdOpts.push(`--${key}`);
-      } else {
-        if (value) {
+    try {
+      for (let key in this.eslintCmdOpts) {
+        let value = this.eslintCmdOpts[key];
+        if (this.flags.includes(`--${key}`)) {
           eslintCmdOpts.push(`--${key}`);
-          // Always quote args which are not paths
-          if (!fs.existsSync(value)) {
-            eslintCmdOpts.push(`"${value}"`);
-            // Paths are quoted according on os
-          } else {
-            if (IS_WIN) {
+        } else {
+          if (value) {
+            eslintCmdOpts.push(`--${key}`);
+            // Always quote args which are not paths
+            if (!fs.existsSync(value)) {
               eslintCmdOpts.push(`"${value}"`);
+              // Paths are quoted according on os
             } else {
-              eslintCmdOpts.push(value);
+              if (IS_WIN) {
+                eslintCmdOpts.push(`"${value}"`);
+              } else {
+                eslintCmdOpts.push(value);
+              }
             }
           }
         }
       }
-    }
-    // Only lint file extensions prescribed by plugin
-    const fileExtensions = getFileExtensions();
-    eslintCmdOpts.push("--ignore-pattern");
-    let ignorePattern = "*.*";
-    if (IS_WIN) {
-      ignorePattern = `"${ignorePattern}"`;
-    }
-    eslintCmdOpts.push(ignorePattern);
-    fileExtensions.forEach((ext) => {
+      // Only lint file extensions prescribed by plugin
+      const fileExtensions = getFileExtensions();
       eslintCmdOpts.push("--ignore-pattern");
-      ignorePattern = `!${ext}`;
+      let ignorePattern = "*.*";
       if (IS_WIN) {
         ignorePattern = `"${ignorePattern}"`;
+      } else {
+        ignorePattern = `'${ignorePattern}'`;
       }
       eslintCmdOpts.push(ignorePattern);
-    });
-    let input = '';
-    if (IS_WIN) {
-      input = `"${this.eslintCmdFileExpr.join('" "')}"`;
-    }
-    // Run ESLint with given cmd line options
-    if (this.eslintCmdOpts.debug) {
-      console.log(
-        `Linting:\n ${term.info(
-          `${this.eslintCmdShort} ${eslintCmdOpts.join(" ")} ${input}`
-        )}`
-      );
-    }
-    if (!dryRun) {
-      return execAsync(
-        `${this.eslintCmd} ${eslintCmdOpts.join(" ")} ${input}`,
-        {
-          cwd: process.cwd(),
-          shell: IS_WIN,
-          stdio: "inherit",
+      fileExtensions.forEach((ext) => {
+        eslintCmdOpts.push("--ignore-pattern");
+        ignorePattern = `!${ext}`;
+        if (IS_WIN) {
+          ignorePattern = `"${ignorePattern}"`;
+        } else {
+          ignorePattern = `'${ignorePattern}'`;
         }
-      );
-    } else {
-      return Promise.resolve("");
+        eslintCmdOpts.push(ignorePattern);
+      });
+      let input = "";
+      if (IS_WIN) {
+        // Braucht es diese unterscheidung wirklich? Unterstützt Windows nicht auch single quotes?
+        input = `"${this.eslintCmdFileExpr.join('" "')}"`;
+      } else {
+        input = `'${this.eslintCmdFileExpr.join("' '")}'`;
+      }
+      const eslintCmdSplit = this.eslintCmd.split(" ");
+      this.eslintCmd = eslintCmdSplit[0];
+      eslintCmdOpts.unshift(eslintCmdSplit[1]);
+      eslintCmdOpts.push(input);
+      // Run ESLint with given cmd line options
+      if (this.eslintCmdOpts.debug) {
+        console.log(
+          `Linting:\n ${term.info(`${this.eslintCmd} ${eslintCmdOpts.join(' ')}`)}`
+        );
+      }
+      if (!dryRun) {
+        return commandUtil.spawnCommand(this.eslintCmd, eslintCmdOpts, {
+          cwd: process.cwd(),
+          shell: true,
+          stdio: process.env.NODE_ENV === 'test' ? 'pipe' : 'inherit',
+        });
+      } else {
+        return Promise.resolve("");
+      }
+    } catch (err) {
+      return Promise.resolve(err);
     }
   }
 
@@ -244,8 +247,22 @@ class Linter {
 
   _getConfigFileAndSetProjectPath(args) {
     let input;
+    // Only resolve the first input argument
+    //
     if (args.length > 0) {
-      input = glob.sync(args[0])[0]
+      let stats;
+      try {
+        stats = fs.statSync(args[0]);
+      } catch (err) {
+        // Do nothing
+      }
+      if (
+        args[0] === "." ||
+        (stats && (stats.isFile() || stats.isDirectory()))
+      ) {
+        this.isFile = true;
+      }
+      input = glob.sync(args[0])[0];
     }
     this.configPath = getConfigPath(input);
     if (!this.configPath) {
@@ -290,7 +307,7 @@ class Linter {
           this.esllintCmdOpts = io.mergeWithUserOpts(
             this.eslintCmdOpts,
             "rule",
-            `${rule}: ${rules[rule]}`
+            `${rule}:${rules[rule]}`
           );
         }
       });

package/lib/lint/io.js

@@ -172,10 +172,10 @@ module.exports = {
    * (3) "Global" case adds configFile and removes rulePaths
    * @param {*} settingsPath VS Code settings file
    */
-  async sanitizeVscodeSettings(projectPath, settingsPath, lintType) {
+  async sanitizeVscodeSettings(projectPath, settingsPath, lintType, customRuleExample = false) {
     let settings = (await this.readVscodeSettings(settingsPath)) || {};
     const lintFileTypes = ["cds", "csn"];
-    const rulePaths = [path.join(projectPath, ".eslint", "rules")];
+    const rulePaths = [path.join(".eslint/rules")];
     const configFile = path.join(__dirname, ".eslintrc.js");
 
     function _addArrayOrString(array) {
@@ -194,42 +194,18 @@ module.exports = {
       settings["eslint.validate"] = lintFileTypes;
     }
 
-    switch (lintType) {
-      case "local":
-        if (settings["eslint.runtime"]) {
-          delete settings["eslint.runtime"];
-        }
-        if (settings["eslint.nodePath"]) {
-          delete settings["eslint.nodePath"];
-        }
-        if (settings["eslint.options"]) {
-          if (settings["eslint.options"]["configFile"]) {
-            delete settings["eslint.options"]["configFile"];
-          }
+    if (lintType === "local") {
+      if (settings["eslint.options"]) {
+        if (customRuleExample) {
           settings["eslint.options"]["rulePaths"] = rulePaths;
-        } else {
-          settings["eslint.options"] = {
-            rulePaths: rulePaths,
-          };
         }
-        break;
-      case "global":
-        settings["eslint.runtime"] = "node";
-        settings["eslint.nodePath"] = path.join(__dirname, "../../node_modules");
-        if (settings["eslint.options"]) {
-          if (settings["eslint.options"]["rulePaths"]) {
-            delete settings["eslint.options"]["rulePaths"];
-          }
-          settings["eslint.options"]["configFile"] =
-            _addArrayOrString(configFile);
-        } else {
+      } else {
+        if (customRuleExample) {
           settings["eslint.options"] = {
-            configFile: _addArrayOrString(configFile),
+            rulePaths: rulePaths,
           };
         }
-        break;
-      default:
-        break;
+      }
     }
 
     await this.writeVscodeSettings(settings, settingsPath);