@sap/cds-dk 6.2.2 → 6.3.0

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

@@ -1,24 +1,15 @@
 const path = require('path');
-
-const TemplateBase = require('../templateBase');
-
+const { copyFiles } = require('../../util/templateUtil')
 const commandUtil = require('../../util/commandUtil');
 const mvnArchetypes = require('../../util/mvnArchetypeUtil');
 const term = require('../../../util/term');
-
 const { PROJECT_TYPE, OPTION_JAVA, URLS } = require('../../constants');
 
-
-
-module.exports = class SamplesTemplate extends TemplateBase {
+module.exports = class SamplesTemplate extends require('../templateBase') {
     constructor(projectPath, generator) {
         super(projectPath, generator, __dirname);
     }
 
-    async checkEnabled() {
-        return true;
-    }
-
     async run() {
         switch (await this.getProjectType()) {
             case PROJECT_TYPE.java:
@@ -35,19 +26,19 @@ module.exports = class SamplesTemplate extends TemplateBase {
 
     async _addJavaSamples() {
         // only execute if not add via cds init --add java, otherwise samples would be added twice
-        // do not check in checkEnabled since log output "> adding samples" wouldn't appear
+        // do not check in canRun since log output "> adding samples" wouldn't appear
         if (!this.options.add.has(OPTION_JAVA)) {
             // keep sequence since plugin needs samples to generate test classes
             const mvnAddSamplesArgs = mvnArchetypes.getAddSamplesCmdArgs(this.options);
             try {
                 await commandUtil.spawnCommand('mvn', mvnAddSamplesArgs, {
                     cwd: this.projectPath
-                }, this.logger);
+                });
 
                 const mvnAddTestsArgs = mvnArchetypes.getAddTestsCmdArgs(this.options);
                 await commandUtil.spawnCommand('mvn', mvnAddTestsArgs, {
                     cwd: this.projectPath
-                }, this.logger);
+                });
             } catch (err) {
                 if (err.code === 'ENOENT' && err.path === 'mvn') {
                     throw new Error(`Maven executable 'mvn' not found, follow ${term.info(URLS.MAVEN_INSTALL_HELP)} and install Maven on your machine.`);
@@ -60,10 +51,10 @@ module.exports = class SamplesTemplate extends TemplateBase {
     async _addNodejsSamples() {
         const folders = (await this.getEnv()).folders;
         const dbFolder = path.join(this.projectPath, folders.db);
-        await this.templateUtil.copyFiles('nodejs/db', dbFolder, {}, this.options.force);
+        await copyFiles(path.join(__dirname, 'files', 'nodejs', 'db'), dbFolder, {}, this.options.force);
 
         const srvFolder = path.join(this.projectPath, folders.srv);
-        await this.templateUtil.copyFiles('nodejs/srv', srvFolder, {
+        await copyFiles(path.join(__dirname, 'files', 'nodejs', 'srv'), srvFolder, {
             dbFolder: folders.db.replace(/[\\/]+$/, '')
         }, this.options.force);
     }

package/lib/init/template/templateBase.js

@@ -4,29 +4,25 @@ const path = require('path');
 const TemplateUtil = require('../util/templateUtil');
 
 const { PROJECT_TYPE } = require('../constants');
-
+const { exists } = require('../../cds').utils;
 
 module.exports = class TemplateBase {
     /**
      * @constructor
      */
-    constructor(projectPath, generator, dirName, dontAnnounce) {
+    constructor(projectPath, generator, dirName) {
         if (generator.options && generator.options.for && typeof generator.options.for !== 'string') {
             throw new Error('The --for argument must not be empty.')
         }
         this.projectPath = path.resolve(projectPath);
         this.options = generator.options || {};
         this.projectPath = path.resolve(projectPath);
-        this.fsUtil = generator.fsUtil;
-        this.logger = generator.logger;
         this.generator = generator;
 
         this.cwd = this.options.cwd || process.cwd();
         this.name = (dirName ? path.basename(dirName) : this.constructor.name.replace(/template/i, '').toLowerCase());
-        this.dontAnnounce = dontAnnounce;
 
         this.projectName = path.basename(this.projectPath);
-        this.templateUtil = new TemplateUtil(path.join(dirName, 'files'), this.fsUtil);
     }
 
     /**
@@ -42,24 +38,27 @@ module.exports = class TemplateBase {
      * @returns true, if template should handle this request, false otherwise
      * @throws Error, if request is invalid, e.g. a file exists already
      */
-    async checkEnabled() {
+    async canRun() {
+        return true;
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    static hasFacet(env, projectPath, options) {
         return true;
     }
 
     /**
      * calls cds env and caches result
-     * @param {boolean} force, ignore cached value
      * @returns {object} the current cds env
      */
-    async getEnv() {
-        let projectPath;
-        if (await this.fsUtil.pathExists(this.projectPath)) {
-            projectPath = this.projectPath;
-        } else {
-            projectPath = this.cwd;
+     async getEnv(profile = 'production') {
+        const cdsEnvVar = process.env.CDS_ENV
+        process.env.CDS_ENV = profile
+        try {
+            return cds.env.for('cds', exists(this.projectPath) ? this.projectPath : this.cwd);
+        } finally {
+            cdsEnvVar ? process.env.CDS_ENV = cdsEnvVar : delete process.env.CDS_ENV
         }
-
-        return cds.env.for('cds', projectPath);
     }
 
     /**
@@ -98,11 +97,11 @@ module.exports = class TemplateBase {
      * @returns PROJECT_TYPE for current project
      */
     async getProjectType() {
-        if (await this.fsUtil.pathExists(path.join(this.projectPath, 'pom.xml'))) {
+        if (exists(path.join(this.projectPath, 'pom.xml'))) {
             return PROJECT_TYPE.java;
         }
 
-        if (await this.fsUtil.pathExists(path.join(this.projectPath, 'package.json'))) {
+        if (exists(path.join(this.projectPath, 'package.json'))) {
             return PROJECT_TYPE.nodejs;
         }
 

package/lib/init/template/toggles/files/cdsrc.json

@@ -0,0 +1,5 @@
+{
+  "requires": {
+    "toggles": true
+  }
+}

package/lib/init/template/toggles/files/cdsrc.json.hbs

@@ -0,0 +1,7 @@
+{
+  "requires": {
+    "[{{cap.for}}]": {
+      "toggles": true
+    }
+  }
+}

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

@@ -1,11 +1,15 @@
 const cds = require('../../../cds'), { path } = cds.utils
-const TemplateBase = require('../templateBase')
 const ProjectReader = require('../../util/projectReader')
+const { mergeJSON, sortDependencies } = require('../../util/merge')
 
-module.exports = class TogglesTemplate extends TemplateBase {
+module.exports = class TogglesTemplate extends require('../templateBase') {
   constructor(projectPath, generator) {
     super(projectPath, generator, __dirname)
-    this.projectReader = new ProjectReader(this)
+    this.projectReader = new ProjectReader(projectPath)
+  }
+
+  static hasFacet(env) {
+    return !!env.requires?.toggles
   }
 
   async run() {
@@ -14,10 +18,12 @@ module.exports = class TogglesTemplate extends TemplateBase {
     if (isNodejs) {
       const packageJSONPath = path.join(this.projectPath, 'package.json')
       const cdsTemplateFile = forProfile ? 'cds.package.json.hbs' : 'cds.package.json'
-      await this.templateUtil.mergeJSON(packageJSONPath, path.join(__dirname, 'files', cdsTemplateFile), projectDescriptor)
-      await this.templateUtil.sortDependencies(packageJSONPath)
+      await mergeJSON(packageJSONPath, path.join(__dirname, 'files', cdsTemplateFile), projectDescriptor)
+      await sortDependencies(packageJSONPath)
     } else if (isJava) {
-      // TODO: implement
+      const cdsrcPath = path.join(this.projectPath, '.cdsrc.json')
+      const cdsTemplateFile = path.join(__dirname, 'files', forProfile ? 'cdsrc.json.hbs' : 'cdsrc.json')
+      await mergeJSON(cdsrcPath, cdsTemplateFile, projectDescriptor)
     }
     await this.runDependentMerging()
   }

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

@@ -1,19 +1,48 @@
 const path = require('path')
-const cds = require('../../../cds'), { fs } = cds.utils
-const TemplateBase = require('../templateBase')
+const cds = require('../../../cds')
+const { copy } = cds.utils
 const ProjectReader = require('../../util/projectReader')
+const { mergeJSON, mergeYAML } = require('../../util/merge')
 const { srvNode, srvJava, xsuaa, mtxSidecar } = require('../_merging/registry-mta')
 const { PROJECT_TYPE } = require('../../constants')
 
-module.exports = class XsuaaTemplate extends TemplateBase {
+module.exports = class XsuaaTemplate extends require('../templateBase') {
     constructor(projectPath, generator) {
         super(projectPath, generator, __dirname)
-        this.projectReader = new ProjectReader(this)
+        this.projectReader = new ProjectReader(projectPath)
+    }
+
+    static hasFacet(env) {
+        return env.requires?.auth?.kind === 'xsuaa'
+    }
+
+    async run() {
+        const { projectPath } = this
+        const templatePath = path.join(__dirname, 'files')
+        const projectDescriptor = await this.projectReader.read(this.options)
+        const projectType = await this.getProjectType();
+        const { for: forProfile } = projectDescriptor.cap
+
+        if (projectType === PROJECT_TYPE.java) {
+            const cdsrcJSONPath = path.join(projectPath, '.cdsrc.json')
+            const cdsTemplateFile = forProfile ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
+            const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
+            await mergeJSON(cdsrcJSONPath, cdsTemplatePath, projectDescriptor)
+        } else if (projectType === PROJECT_TYPE.nodejs) {
+            const packageJSONPath = path.join(projectPath, 'package.json')
+            const cdsTemplateFile = forProfile ? 'cds.package.json.hbs' : 'cds.package.json'
+            const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
+            await mergeJSON(packageJSONPath, cdsTemplatePath, projectDescriptor)
+            const dependenciesTemplatePath = path.join(templatePath, 'dependencies.package.json')
+            await mergeJSON(packageJSONPath, dependenciesTemplatePath)
+        }
+
+        await this.runDependentMerging()
     }
 
     async runDependentMerging() {
         const projectDescriptor = await this.projectReader.read(this.options)
-        const { isMultitenant, isExtensible, hasMtaDeployment, hasHelmDeployment, isNodejs, isJava } = projectDescriptor.cap
+        const { isMultitenant, isExtensible, hasMta, hasHelm, isNodejs, isJava } = projectDescriptor.cap
 
         const cds = require('../../../../lib/compile')
         const xsSecurity = await (async () => { try {
@@ -30,9 +59,9 @@ module.exports = class XsuaaTemplate extends TemplateBase {
             }],
         }))}
         const xsSecurityPath = path.join(this.projectPath, 'xs-security.json')
-        await this.templateUtil.mergeJSON(xsSecurityPath, xsSecurity, projectDescriptor, mergingSemantics)
+        await mergeJSON(xsSecurityPath, xsSecurity, projectDescriptor, mergingSemantics)
 
-        if (hasMtaDeployment) {
+        if (hasMta) {
             const srv = isNodejs ? srvNode : srvJava
             const additions = [srv, xsuaa]
             if (isMultitenant && isJava) additions.push(mtxSidecar)
@@ -47,7 +76,7 @@ module.exports = class XsuaaTemplate extends TemplateBase {
                 into: [mtxSidecar, 'requires', 'name']
             })
 
-            await this.templateUtil.mergeYAML(
+            await mergeYAML(
                 mtaYAMLPath,
                 `${__dirname}/files/mta.yaml.hbs`,
                 projectDescriptor,
@@ -58,15 +87,18 @@ module.exports = class XsuaaTemplate extends TemplateBase {
             )
         }
 
-        if (hasHelmDeployment) {
-            await fs.copy(path.join(__dirname, 'files', 'xsuaa.yaml'), path.join(this.projectPath, 'chart', 'templates', 'xsuaa.yaml'))
-            await this.templateUtil.mergeYAML(
+        if (hasHelm) {
+            await copy(
+                path.join(__dirname, 'files', 'xsuaa.yaml'),
+                path.join(this.projectPath, 'chart', 'templates', 'xsuaa.yaml')
+            )
+            await mergeYAML(
                 path.join(this.projectPath, 'chart', 'values.yaml'),
                 path.join(__dirname, 'files', 'values.yaml.hbs'),
                 projectDescriptor, { forceOverwrite: true }
             )
             // REVISIT: Shared xs-security.json location for Helm and MTA?
-            await fs.copy(
+            await copy(
                 path.join(this.projectPath, 'xs-security.json'),
                 path.join(this.projectPath, 'chart', 'xs-security.json')
             )
@@ -86,33 +118,4 @@ module.exports = class XsuaaTemplate extends TemplateBase {
             await extensibilityTemplate.runDependentMerging()
         }
     }
-
-    async run() {
-        const { projectPath } = this
-        const templatePath = path.join(__dirname, 'files')
-        const projectDescriptor = await this.projectReader.read(this.options)
-        const { for: forProfile } = projectDescriptor.cap
-
-        const projectType = await this.getProjectType();
-        switch (projectType) {
-            case PROJECT_TYPE.java: {
-                const cdsrcJSONPath = path.join(projectPath, '.cdsrc.json')
-                const cdsTemplateFile = forProfile ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
-                const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
-                await this.templateUtil.mergeJSON(cdsrcJSONPath, cdsTemplatePath, projectDescriptor)
-                break
-            }
-            case PROJECT_TYPE.nodejs: {
-                const packageJSONPath = path.join(projectPath, 'package.json')
-                const cdsTemplateFile = forProfile ? 'cds.package.json.hbs' : 'cds.package.json'
-                const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
-                await this.templateUtil.mergeJSON(packageJSONPath, cdsTemplatePath, projectDescriptor)
-                const dependenciesTemplatePath = path.join(templatePath, 'dependencies.package.json')
-                await this.templateUtil.mergeJSON(packageJSONPath, dependenciesTemplatePath)
-                break
-            }
-        }
-
-        await this.runDependentMerging()
-    }
 }

package/lib/init/types.d.ts

@@ -28,41 +28,6 @@ export interface CDSGenerator {
   uiConfig?: any;
 }
 
-
-/**
- * An interface providing logging functionality.
- */
-export interface Logger {
-  /**
-   * True if logger is in debug mode
-   */
-  isDebug: boolean;
-  /**
-   * Writes a debug message to log.
-   * @param message the message to write to log
-   */
-  debug(message: string): void;
-
-  /**
-   * Writes a message to log.
-   * @param message the message to write to log
-   */
-  log(message: string): void;
-
-  /**
-   * Writes a warning message to log.
-   * @param message the message to write to log
-   */
-  warn(message: string): void;
-
-  /**
-   * Writes an error to log.
-   * @param Error the error to write to log
-   */
-  error(error: Error): void;
-}
-
-
 /**
  * This is a helper interface to provide support for different file system implementations.
  * Depending on the scenario different file systems will be used, e.g. Yeoman vs. native FS.
@@ -129,30 +94,6 @@ export interface FsUtil {
   * @param skipFileLog do not log files if true
   */
   copy(source: string, destination: string, options?: any, skipFileLog?: boolean): Promise<void>;
-
-  /**
-   * Checks if given path exists.
-   * @param filePath the absolute path
-   * @returns true if given path exists, otherwise false
-   */
-  pathExists(filePath: string): Promise<boolean>;
-
-  /*
-  * Methods mapping to fs-extra
-  */
-  readdir(filePath: string): Promise<string[]>;
-
-  mkdirp(folderPath: string): Promise<void>;
-
-  stat(filePath: string): Promise<any>;
-
-  /*
-  * Helper methods
-  */
-  hasContent(folderPath: string): Promise<boolean>;
-
-  getTouchedFiles(): string[];
-
 }
 
 /**

package/lib/init/util/commandUtil.js

@@ -1,10 +1,10 @@
 const cp = require('child_process');
 const os = require('os');
+const cds = require('../../cds')
+const LOG = cds.log('cds')
 
 const { IS_WIN } = require('../constants');
 
-const { nullLogger } = require('./logger');
-
 class CommandUtil {
 
     /**
@@ -13,30 +13,29 @@ class CommandUtil {
      * @param cmd command
      * @param args command args
      * @param options spawn options
-     * @param logger logger to use
      * @param collectResult if true, return complete console output as promise resolve value
      *                      this might result in a huge string!
      *
      * @returns Promise
      */
-    async spawnCommand(cmd, args, options = {}, logger = nullLogger, collectResult = false) {
+    async spawnCommand(cmd, args, options = {}, collectResult = false) {
         args = this._sanitizeArgs(args);
         return new Promise((resolve, reject) => {
-            logger.debug(`[spawn] ${cmd} ${args.join(' ')}`);
+            LOG.debug(`[spawn] ${cmd} ${args.join(' ')}`);
 
             options.env = options.env || process.env;
 
             const child = this._getChildProcess(cmd, args, options);
 
             // use inplace methods to ensure logger is called in context
-            const stdLogBuffer = new LogBuffer((chunk) => logger.log(chunk), collectResult);
+            const stdLogBuffer = new LogBuffer((chunk) => LOG.info(chunk), collectResult);
             child.stdout.on('data', (chunk) => {
                 stdLogBuffer.handleChunk(chunk);
             });
 
             // use inplace methods to ensure logger is called in context
             // collect error log in case of Win to handle command not found (ENOENT),
-            const errLogBuffer = new LogBuffer((chunk) => logger.error(chunk), (IS_WIN || collectResult));
+            const errLogBuffer = new LogBuffer((chunk) => LOG.error(chunk), (IS_WIN || collectResult));
             child.stderr.on('data', (chunk) => {
                 errLogBuffer.handleChunk(chunk);
             });

package/lib/init/util/fsUtil.js

@@ -1,127 +1,41 @@
-const fs = require('fs').promises;
-const path = require('path');
-
-const {yaml:YAML} = require('@sap/cds-foss')
+const { yaml: YAML } = require('@sap/cds-foss')
 const JSONC = require('../../util/jsonc');
+const { read, write } = require('../../cds').utils;
 
-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() {
-        this.touchedFiles = new Set();
-    }
-
-    async writeFile(filepath, content, skipFileLog = false) {
-        if (!skipFileLog) {
-            this._addTouchedFile(filepath);
-        }
-        await fs.mkdir(path.dirname(filepath), { recursive: true })
-        await fs.writeFile(filepath, content, UTF_8);
-    }
-
-    async writeJSON(filepath, object, options = { spaces: 2 }, skipFileLog = false) {
-        const content = JSON.stringify(object, null, options.spaces)
-        await this.writeFile(filepath, content, skipFileLog)
-    }
-
-    async writeYAML(filepath, yaml, skipFileLog = false) {
-        await this.writeFile(filepath, YAML.stringify(yaml, { collectionStyle: 'block' }), skipFileLog);
-    }
-
-    async readFile(src) {
-        return await fs.readFile(src, UTF_8);
-    }
-
-    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 JSON.parse(file)
-    }
-
-    async readJSONC(src) {
-        const fileContents = await this.readFile(src);
-        return JSONC.parse(fileContents);
-    }
+module.exports = new class FsUtil {
 
     async readYAML(src, projectDescriptor) {
-        let file;
+        let file
         try {
-            file = await this.readFile(src);
+            file = await read(src, 'utf8')
         } catch (e) {
-            if (e.code === 'ENOENT') return undefined;
-            throw e;
+            if (e.code === 'ENOENT') return undefined
+            throw e
         }
         if (projectDescriptor) {
-            const Mustache = require('mustache');
-            const renderedFile = Mustache.render(file, projectDescriptor);
-            return YAML.parseDocument(renderedFile);
-        }
-        return YAML.parseDocument(file);
-    }
-
-    // eslint-disable-next-line no-unused-vars
-    async copy(source, destination, options = {}, skipFileLog = false) {
-        if (!skipFileLog) {
-            this._addTouchedFile(destination);
-        }
-        if (fs.cp) { // Node.js >= 16.7
-            await fs.cp(source, destination, { recursive: true })
-        } else {
-            await _copy(source, destination);
+            const Mustache = require('mustache')
+            const renderedFile = Mustache.render(file, projectDescriptor)
+            return YAML.parseDocument(renderedFile)
         }
+        return YAML.parseDocument(file)
     }
 
-    async pathExists(filePath) {
-        return fs.access(filePath).then(() => true).catch(() => false)
-    }
-
-    async readdir(filePath) {
-        return await fs.readdir(filePath);
-    }
-
-    getTouchedFiles() {
-        return Array.from(this.touchedFiles.keys());
-    }
-
-    async mkdirp(folderPath) {
-        await fs.mkdir(folderPath, { recursive: true });
+    async writeYAML(filepath, yaml) {
+        const content = YAML.stringify(yaml, { collectionStyle: 'block' })
+        await write(filepath, content)
     }
 
-    async stat(filePath) {
-        return await fs.stat(filePath);
-    }
-
-    async hasContent(folderPath) {
-        if (await this.pathExists(folderPath)) {
-            const projectContent = await this.readdir(folderPath);
-            return projectContent.length > 0;
+    async readJSON(src, projectDescriptor) {
+        const file = await read(src, 'utf8')
+        if (projectDescriptor) {
+            const Mustache = require('mustache')
+            const renderedFile = Mustache.render(file, projectDescriptor)
+            return JSON.parse(renderedFile)
         }
-
-        return false;
+        return JSON.parse(file)
     }
 
-    _addTouchedFile(filepath) {
-        const relativeFilepath = path.relative('', filepath);
-        this.touchedFiles.add(relativeFilepath);
-    }
-}
-
-// Polyfill for Node.14: asynchronously copies the entire content from src to dest.
-async function _copy(src, dest) {
-    if ((await fs.stat(src)).isDirectory()) {
-        const entries = await fs.readdir(src)
-        return Promise.all(entries.map(async each => _copy(path.join(src, each), path.join(dest, each))))
-    } else {
-        await fs.mkdir(path.dirname(dest), { recursive: true })
-        return fs.copyFile(src, dest)
+    async readJSONC(src) {
+        return JSONC.parse(await read(src, 'utf8'))
     }
 }