@sap/cds-dk 4.4.2 → 4.5.0

package/lib/client/extend.js

@@ -0,0 +1,179 @@
+const axios = require('axios');
+const path = require('path');
+const { fse } = require('@sap/cds-foss');
+
+const AuthManager = require('./auth_manager');
+const BaseCommand = require('./base_command');
+const { normalizePath, isParent } = require('./helper/fs_helper');
+const Logger = require('./helper/logging');
+const Question = require('./helper/question');
+
+const COMMAND_URL_SUFFIX = 'content';
+const CUSTOM_FILE_FOLDERS = ['wsdl'];
+const DB_FOLDER = 'db';
+const SRV_FOLDER = 'srv';
+const TEMPLATE_FOLDER = 'tpl';
+
+function folderExists(folder) {
+    return `${folder} already contains an extension project, use another directory or use --force.` +
+        '\nWhen using --force, make sure you are using a version control system (like git) to avoid data loss';
+}
+
+module.exports = class Extend extends BaseCommand {
+
+    static get COMMAND_URL_SUFFIX() { return COMMAND_URL_SUFFIX; }
+
+    static async storeFiles(content, targetDirectory, filter) {
+        if (!fse.existsSync(targetDirectory)) {
+            fse.mkdirpSync(targetDirectory);
+        }
+        targetDirectory = fse.realpathSync(targetDirectory)
+        const writtenFiles = new Set();
+        const filesToWrite = new Map();
+        for (const [filename, filecontent] of content) {
+            const filepath = path.join(targetDirectory, filename);
+            if (filepath.startsWith(targetDirectory) && (!filter || await filter(filepath))) {
+                filesToWrite.set(filepath, filecontent);
+            }
+        }
+        for (const [filepath, content] of [...filesToWrite.entries()]) {
+            const normalizedFilepath = normalizePath(filepath);
+            fse.mkdirpSync(path.dirname(normalizedFilepath));
+            fse.writeFileSync(normalizedFilepath, content);
+            writtenFiles.add(path.relative(process.cwd(), normalizedFilepath));
+            Extend._logWrittenFile(normalizedFilepath);
+        }
+        return writtenFiles;
+    }
+
+    static async storeCustomFiles(directory, customFiles) {
+        const customFileMap = new Map();
+        customFiles.forEach(entry => {
+            if (entry.category === 'wsdl') {
+                const normalizedFilename = normalizePath(entry.name);
+                const folder = normalizedFilename.split(path.sep)[0];
+                if (CUSTOM_FILE_FOLDERS.includes(folder)) {
+                    customFileMap.set(entry.name, entry.content);
+                }
+            }
+        });
+        await Extend.storeFiles([...customFileMap], directory);
+    }
+
+    static async storeTemplateFiles(templates, directory) {
+        await Extend.storeFiles(templates, directory, async filepath => {
+            const normalizedPath = normalizePath(filepath);
+            if (!isParent(path.join(directory, DB_FOLDER), normalizedPath) && !isParent(path.join(directory, SRV_FOLDER), normalizedPath)) {
+                Logger.log(`Ignoring template ${normalizedPath}: not in ${DB_FOLDER} or ${SRV_FOLDER}`);
+                return false;
+            }
+            return true;
+        });
+    }
+
+    static async run(paramValues) {
+        try {
+            const params = await AuthManager.loginAndUpdateSettings(paramValues);
+
+            if (process.env.DEBUG) {
+                Logger.log(`\n\nCreating extension project with parameters ${JSON.stringify({
+                    appUrl: params.get('appUrl'),
+                    projectFolder: params.get('projectFolder'),
+                    subdomain: params.get('subdomain'),
+                    passcode: params.get('passcode'),
+                    username: params.get('username'),
+                    password: params.get('password') ? '***' : 'undefined'
+                })}`);
+            } else {
+                Logger.log(`\n\nCreating extension project for ${params.get('appUrl')}, subdomain '${params.get('subdomain')}', in folder '${params.get('projectFolder')}'`);
+            }
+
+            const runOnExistingProject = await Extend.checkProject(params.get('projectFolder'));
+            if (runOnExistingProject && !(params.get('force') || params.get('templates'))) {
+                throw new Error(folderExists(params.get('projectFolder')));
+            }
+
+            try {
+                await Extend.runExtend(params);
+            } catch (error) {
+                await Extend.handleHttpError(error, params);
+            }
+        } catch (mainError) {
+            Logger.error(undefined, mainError);
+        }
+    }
+
+    static async runExtend(params) {
+        const extendUrl = Extend.getMtxApiUrl(params.get('appUrl'), COMMAND_URL_SUFFIX);
+        const requestOptions = Object.assign({
+            method: 'GET',
+            retry: 0
+        }, params.get('reqAuth'));
+
+        Logger.log('Retrieving files...');
+
+        const [ response ] = (await axios(extendUrl, requestOptions)).data;
+
+        Logger.log('\nWriting files to: ' + params.get('projectFolder'));
+
+        if (params.get('templates')) {
+            await Extend.storeTemplateFilesToTpl(response.templates, params.get('projectFolder'));
+            return; // only write templates
+        }
+
+        const content = response.base.concat(response.extension);
+
+        await Extend.storeFiles(content, params.get('projectFolder'));
+
+        await fse.mkdirp(path.join(params.get('projectFolder'), DB_FOLDER));
+        await fse.mkdirp(path.join(params.get('projectFolder'), SRV_FOLDER));
+
+        Logger.log(`\nPut database extension models into ${DB_FOLDER} folder.`);
+        Logger.log(`Put service extension models into ${SRV_FOLDER} folder.`);
+
+        if (response.templates && response.templates.length > 0) {
+            // only write templates if there are no extensions so far
+            if (response.extension && response.extension.length === 0) {
+                Logger.log(`Writing template files to ${DB_FOLDER} and ${SRV_FOLDER} folder`);
+                await Extend.storeTemplateFiles(response.templates, params.get('projectFolder'));
+            } else {
+                Logger.log('Ignoring templates because extension is already active.');
+            }
+        }
+
+        if (params.get('wsdl')) {
+
+            Logger.log('Writing custom files');
+
+            const customFileUrl = Extend.getMtxApiUrl(params.get('appUrl'), Extend.CUSTOM_FILE_URL_SUFFIX);
+            const customFiles = (await axios(customFileUrl, params)).data;
+            await Extend.storeCustomFiles(params.get('projectFolder'), customFiles);
+        }
+    }
+
+    static async storeTemplateFilesToTpl(templates, projectFolder) {
+        if (templates && templates.length > 0) {
+            const targetDirectory = path.join(projectFolder, TEMPLATE_FOLDER);
+            const targetExists = await fse.pathExists(targetDirectory);
+            if (!targetExists || await this.promptTemplateOverwrite()) {
+                if (targetExists) {
+                    await fse.remove(targetDirectory);
+                }
+                Logger.log(`Writing template files to ${TEMPLATE_FOLDER} folder`);
+                await Extend.storeTemplateFiles(templates, targetDirectory);
+            }
+
+        } else {
+            Logger.log('No templates available');
+        }
+    }
+
+    static promptTemplateOverwrite() {
+        return Question.askBooleanQuestion(`This  will overwrite extisting templates in folder ${TEMPLATE_FOLDER}. Continue (yN)? `);
+    }
+
+    static _logWrittenFile(file) {
+        Logger.log('CREATE: ' + file);
+    }
+
+}

package/lib/client/helper/cf_helper.js

@@ -0,0 +1,186 @@
+const os = require('os');
+const { execFile } = require('child_process');
+
+const Logger = require('./logging');
+const Question = require('./question');
+const { formatObjectsFixedWidth } = require('./string_helper');
+const { schemaRegex } = require('./url_helper');
+
+function runCf(args, callback) {
+    const env = Object.assign({}, process.env, { LC_ALL: 'en_US.UTF-8' }); // enforce English headings
+    return execFile('cf', args, { env }, callback);
+}
+
+function getErrorMessage(error, stdout) {
+    return stdout.includes('Not logged in')
+        ? 'not logged in'
+        : error && error.message || stdout.replace('\n', ' ');
+}
+
+async function getAppFromSuggestions() {
+    const apps = await getApps();
+    if (apps.length === 0) {
+        Logger.debug('Failed to obtain list of apps from CF');
+        return undefined;
+    }
+
+    let choice;
+    let choiceNr;
+    do {
+        choice = await Question.askQuestion(`App URL not given.  From the following apps running in the CF org and space you are logged into,
+select one by entering a number or leave empty to quit:
+
+${formatObjectsFixedWidth(apps, ['name', 'url'], 3, { numbering: true })}
+
+Your choice: `);
+
+        if (!choice) {
+            Logger.debug('No app URL selected');
+            return undefined;
+        }
+        choiceNr = Number(choice);
+    } while (choiceNr > apps.length + 1);
+
+    return apps[choiceNr - 1];
+}
+
+async function getApps(nameRegex = /(?<!-db)$/) {
+    Logger.debug('Getting running apps from CF');
+
+    return new Promise(resolve => {
+        runCf(['apps'], function(error, stdout) {
+            if (! /^name\b/m.test(stdout)) {
+                return resolve(errorResult(getErrorMessage(error, stdout)));
+            }
+
+            const appLines = getAppLines(stdout);
+
+            const heading = appLines.shift();
+            if (!heading || appLines.length === 0) {
+                return resolve(errorResult('CF reports no running apps'));
+            }
+
+            const titles = heading.includes('processes') ? ['processes', 'routes'] : ['instances', 'urls'];
+            const offsets = {
+                name: 0,
+                instances: heading.indexOf(titles[0]),
+                urls: heading.indexOf(titles[1])
+            };
+
+            const result = [];
+
+            appLines.forEach((line) => {
+                if (Number(getSubstring(line, offsets.instances).replace(/(^.+:|\/.*)/g, '')) === 0) {
+                    return;
+                }
+                const name = getSubstring(line, offsets.name);
+                if (!nameRegex.test(name)) {
+                    return;
+                }
+                const urls = getSubstring(line, offsets.urls, true);
+                if (!urls) {
+                    return;
+                }
+                urls.split(/,\s*/).forEach((url) => {
+                    if (!url.includes('://')) {
+                        url = 'https://' + url;
+                    }
+                    result.push({
+                        name,
+                        url
+                    });
+                });
+            });
+
+            return resolve(result);
+        });
+    });
+
+    function getSubstring(line, offset, allowSpace = false) {
+        if (allowSpace) {
+            return line.substr(offset).trimRight();
+        }
+        const match = /^\S+/.exec(line.substr(offset));
+        if (!match) {
+            return undefined;
+        }
+        return match[0];
+    }
+
+    function getAppLines(stdout) {
+        let relevant = false;
+        return stdout.split('\n').filter((line) => {
+            if (/^name\b/.test(line)) {
+                relevant = true;
+                return true;
+            }
+            return line.length && relevant;
+        });
+    }
+
+    function errorResult(message) {
+        Logger.debug(`Failed to get apps: ${message}`);
+        return [];
+    }
+}
+
+async function getSubdomain(appName) {
+    Logger.debug('Getting subdomain from CF env');
+
+    return new Promise(resolve => {
+        runCf(['env', appName], function(error, stdout) {
+            if (! /Provided:$/m.test(stdout)) {
+                if (stdout.includes('not found')) {
+                    return resolve(errorResult(`CF reports that app '${appName}' is not found`));
+                }
+                return resolve(errorResult(getErrorMessage(error, stdout)));
+            }
+
+            const nl = os.EOL;
+            const match = new RegExp(`^System-Provided:${nl}(?:\\{${nl}((.|${nl})*?)^}|((.|${nl})*?^}))`, 'm').exec(stdout);
+            if (!match) {
+                return resolve(errorResult(`CF reports no system-provided environment for app '${appName}'`));
+            }
+
+            let content = (match[1] || match[3]).replace(/^(\s*)(?!")(\w+)/m, '"$2"');
+            if (! /^\s*{/.test(content)) {
+                content = '{' + content + '}';
+            }
+            let value = JSON.parse(content);
+            for (const segment of ['VCAP_SERVICES', 'xsuaa', 0, 'credentials', 'identityzone']) {
+                value = value[segment];
+                if (!value) {
+                    return resolve(errorResult(`CF reports insufficient information for app '${appName}' at segment '${segment}'`));
+                }
+            }
+
+            return resolve(value);
+        });
+    });
+
+    function errorResult(message) {
+        Logger.debug(message);
+        return undefined;
+    }
+}
+
+async function getAppName(appUrl) {
+    function equalIgnoringTls(url1, url2) {
+        return url1.replace(schemaRegex, '') === url2.replace(schemaRegex, '');
+    }
+
+    Logger.debug('Getting app name from CF apps');
+    const apps = await getApps();
+    const app = apps.find(app => equalIgnoringTls(app.url, appUrl));
+    if (!app) {
+        Logger.debug(`Failed to find app with URL ${appUrl}.  Running apps: ${apps.map(app => app.name)}`);
+    }
+    return app && app.name;
+}
+
+module.exports = {
+    getAppFromSuggestions,
+    getAppName,
+    getSubdomain,
+    getApps
+};

package/lib/client/helper/dependency_helper.js

@@ -0,0 +1,26 @@
+const os = require('os');
+const { execFileSync } = require('child_process');
+
+const Logger = require('./logging');
+
+let cachedDir;
+
+function globalModulesDir() {
+    if (!cachedDir) {
+        cachedDir = execFileSync('npm', ['root', '-g'], {
+            encoding: 'utf8',
+            shell: os.platform() === 'win32'
+        }).trim();
+    }
+    return cachedDir;
+}
+
+module.exports = function requireGlobal(packageId) {
+    try {
+        const packagePath = require.resolve(packageId, { paths: [globalModulesDir()] });
+        return require(packagePath);
+    } catch (error) {
+        // Ignore error.
+        Logger.debug(`Failed to find module '${packageId}' in ${globalModulesDir()}: ${error}`);
+    }
+}

package/lib/client/helper/env_helper.js

@@ -0,0 +1,4 @@
+module.exports = function isBas() {
+    const env = Object.entries(process.env);
+    return env.some(([key, value]) => key === 'WS_BASE_URL' && value.includes('applicationstudio') || /THEIA_(DEFAULT_)?PLUGINS/.test(key));
+}

package/lib/client/helper/fs_helper.js

@@ -0,0 +1,83 @@
+const path = require('path');
+const { fse } = require('@sap/cds-foss');
+
+async function collectFileContent(filePaths, root) {
+    const resultMap = new Map();
+    filePaths.forEach((filePath) => {
+        const fileContent = fse.readFileSync(filePath);
+        resultMap.set(toUnixPath(path.relative(root, filePath)), fileContent.toString('utf-8'));
+    });
+    return resultMap;
+}
+
+/**
+ * Returns map of files with content for a given directory
+ * @param root  Root directory
+ * @param sourceDir Directory to start the traversal
+ * @param filter Filter function
+ * @returns {Promise.<Map>}
+ */
+function collectFiles(root, sourceDir, filter) {
+    const files = new Map();
+    _traverseFileSystem(root, sourceDir, files, filter);
+
+    return files;
+}
+
+function _traverseFileSystem(root, sourceDir, files, filter) {
+    let absoluteDir = path.resolve(root, sourceDir);
+    if (!fse.existsSync(absoluteDir)) {
+        return;
+    }
+    absoluteDir = fse.realpathSync(absoluteDir);
+    if (fse.statSync(absoluteDir)) {
+        fse.readdirSync(absoluteDir)
+            .map(subDirEntry => path.join(absoluteDir, subDirEntry))
+            .forEach(entry => {
+                const stats = fse.statSync(entry)
+                if (stats.isDirectory()) {
+                    _traverseFileSystem(root, entry, files, filter);
+                }
+                if (stats.isFile() && (!filter || filter.call(this, entry))) {
+                    const fileContent = fse.readFileSync(entry);
+                    files.set(toUnixPath(path.relative(root, entry)), fileContent.toString('utf-8'));
+                }
+            });
+    }
+}
+
+/**
+ * Converts Windows paths by using unix separators
+ * @param aPath a path
+ * @returns {string}
+ */
+function toUnixPath(aPath) {
+    return aPath.replace(/\\/g, '/');
+}
+
+/**
+ * Normalizes filename to os specific format (but does not check for existence)
+ * @param {string} filename
+ */
+function normalizePath(filename) {
+    return path.normalize(filename);
+}
+
+/**
+ * Returns whether a given path is a parent of another path.
+ * @param maybeParent a potential parent path
+ * @param maybeChild a potential child path
+ * @returns {boolean} whether `maybeParent` is a parent path of `maybeChild`
+ */
+function isParent(maybeParent, maybeChild) {
+    return ! path.relative(maybeParent, maybeChild).startsWith('..');
+}
+
+
+module.exports = {
+    collectFileContent,
+    collectFiles,
+    toUnixPath,
+    normalizePath,
+    isParent
+};

package/lib/client/helper/logging.js

@@ -0,0 +1,37 @@
+/* eslint-disable no-console */
+
+module.exports = class Logger {
+
+    static log(logText) {
+        console.log(logText);
+    }
+
+    static error(errorText, error) {
+        console.error(this.getMessage(errorText, error));
+    }
+
+    static debug(debugText, error) {
+        if (process.env.DEBUG) {
+            console.error(this.getMessage(debugText, error));
+        }
+    }
+
+    static getMessage(errorText, error) {
+        let message = errorText && errorText + '\n' || '';
+        if (!error) {
+            return message;
+        }
+        if (process.env.DEBUG) {
+            if ('response' in error && error.response.data) {
+                const body = error.response.data;
+                if (body.error && body.error.message) {
+                    message += body.error.message + '\n';
+                }
+            }
+            message += '\n' + error.stack;
+        } else {
+            message += error.message;
+        }
+        return message;
+    }
+}

package/lib/client/helper/question.js

@@ -0,0 +1,50 @@
+const readline = require('readline');
+
+module.exports = class Question {
+
+    static askQuestion(question, defaultValue, hidden = false) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        if (defaultValue) {
+            question += '(' + defaultValue + ') ';
+        }
+        return new Promise(resolve => {
+            rl.question(question, answer => {
+                answer = answer.replace(/\r?\n|\r/g, '');
+                if (answer.length === 0 && defaultValue) {
+                    answer = defaultValue;
+                }
+                resolve(answer);
+                rl.close();
+            });
+
+            if (hidden) {
+                const rla = rl;
+                rla._writeToOutput = function _writeToOutput() {
+                    rla.output.write('*');
+                };
+            }
+        });
+    }
+
+    static askBooleanQuestion(question) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        return new Promise(resolve => {
+            rl.question(question, answer => {
+                if (answer === 'y' || answer === 'Y') {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+                rl.close();
+            });
+        });
+    }
+}

package/lib/client/helper/string_helper.js

@@ -0,0 +1,53 @@
+const os = require('os');
+
+function intWidth(number) {
+    return Math.floor(Math.log10(number)) + 1;
+}
+
+function formatObjectsFixedWidth(objects, columns, distance, options = {}) {
+    const { numbering = false } = options;
+
+    const maxWidths = columns.reduce((result, column) => Object.assign(result, {
+        [column]: Math.max(...objects.map((object) => ('' + object[column]).length))
+    }), {});
+    const numberingWidth = intWidth(objects.length);
+    const separator = ' '.repeat(distance);
+    let result = '';
+
+    for (let o = 0; o < objects.length; o++) {
+        const object = objects[o];
+        if (numbering) {
+            result += ' '.repeat(numberingWidth - intWidth(o + 1));
+            result += o + 1;
+            result += '.';
+            result += separator;
+        }
+        for (let c = 0; c < columns.length; c++) {
+            const column = columns[c];
+            const value = '' + object[column];
+            result += value;
+            result += ' '.repeat(maxWidths[column] - value.length);
+            if (c < columns.length - 1) {
+                result += separator;
+            } else {
+                result += o < objects.length - 1
+                    ? os.EOL
+                    : '';
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * from https://developer.mozilla.org/de/docs/Web/JavaScript/Guide/Regular_Expressions
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+    formatObjectsFixedWidth,
+    escapeRegex
+};

package/lib/client/helper/url_helper.js

@@ -0,0 +1,17 @@
+const IP_ADDR = /^[1-9][0-9]{0,2}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/;
+const schemaRegex = /^https?:\/\//;
+const defaultSchema = 'https://';
+
+function extractSubdomain(url) {
+    const hostname = new URL(url).hostname;
+    if (hostname === 'localhost' || IP_ADDR.test(hostname)) {
+        return undefined;
+    }
+    return hostname.split('.')[0];
+}
+
+module.exports = {
+    schemaRegex,
+    defaultSchema,
+    extractSubdomain
+};

package/lib/client/index.js

@@ -0,0 +1,14 @@
+const Activate = require('./activate');
+const AuthManager = require('./auth_manager');
+const Extend = require('./extend');
+const Question = require('./helper/question');
+const { SettingsManager } = require('./settings_manager');
+
+module.exports = {
+    extend: Extend.run,
+    activate: Activate.run,
+    login: AuthManager.loginAndUpdateSettings,
+    logout: AuthManager.logout,
+    question: Question,
+    config: SettingsManager.config
+};