@sap/cds-dk 4.4.2 → 4.5.4

package/lib/client/activate.js

@@ -0,0 +1,243 @@
+const path = require('path');
+const axios = require('axios');
+const { fse } = require('@sap/cds-foss');
+
+const AuthManager = require('./auth_manager');
+const BaseCommand = require('./base_command');
+const { collectFileContent, collectFiles, toUnixPath } = require('./helper/fs_helper');
+const Logger = require('./helper/logging');
+
+const COMMAND_URL_SUFFIX = 'asyncActivate';
+const UPDATE_CUSTOM_FILE_URL_SUFFIX = 'updateCustomTenantContent';
+
+const I18N_WHITELIST = ['.properties', '.csv'];
+
+const JOB_STATUS = {
+    QUEUED: 'QUEUED',
+    RUNNING: 'RUNNING',
+    FINISHED: 'FINISHED',
+    FAILED: 'FAILED'
+};
+
+async function checkFinished(jobId, statusUrl, params, finisher) {
+    const requestOptions = Object.assign({
+        method: 'GET'
+    }, params.get('reqAuth'));
+
+    const { status, error } = (await axios(statusUrl, requestOptions)).data;
+
+    if ((status === JOB_STATUS.FINISHED || status === JOB_STATUS.FAILED) && !finisher.finished) {
+        finisher.finished = true;
+        clearInterval(finisher.timer);
+        if (status === JOB_STATUS.FAILED) {
+            return finisher.reject(new Error(`Job ${jobId} failed: ${error.message || JSON.stringify(error)}`));
+        }
+        Logger.log('Extension active');
+        finisher.resolve();
+    }
+}
+
+module.exports = class Activate extends BaseCommand {
+
+    static get COMMAND_URL_SUFFIX() { return COMMAND_URL_SUFFIX; }
+    static get UPDATE_CUSTOM_FILE_URL_SUFFIX() { return UPDATE_CUSTOM_FILE_URL_SUFFIX; }
+
+    static async run(injection, paramValues) {
+        try {
+            const params = await AuthManager.loginAndUpdateSettings(paramValues);
+
+            if (process.env.DEBUG) {
+                Logger.log('Activating extension with parameters ' + JSON.stringify({
+                    appUrl: params.get('appUrl'),
+                    projectFolder: params.get('projectFolder'),
+                    undeploy: params.get('undeploy')
+                }));
+            } else {
+                Logger.log(`Activating extension located at ${params.get('projectFolder')} to URL ${params.get('appUrl')}`);
+            }
+
+            if (!await Activate.checkProject(params.get('projectFolder'))) {
+                throw new Error(params.get('projectFolder') + ' is not a valid extension project');
+            }
+
+            try {
+                await Activate.runActivate(injection.cds, params);
+                if (params.get('wsdl')) {
+                    await Activate.runCustomFileUpload(params);
+                }
+            } catch (error) {
+                Activate.handleHttpError(error, params);
+            }
+        } catch (error) {
+            Logger.error(undefined, error);
+        }
+    }
+
+    static async collectExtensionFiles(cds, projectFolder) {
+
+        const absoluteFolder = projectFolder;
+        const dbFolder = path.join(absoluteFolder, 'db');
+        const srvFolder = path.join(absoluteFolder, 'srv');
+
+        const resolvedPathDb = cds.resolve(dbFolder, { root: dbFolder });
+        const resolvedPathSrv = cds.resolve(srvFolder, { root: srvFolder });
+
+        let resolvedPaths = [];
+        if (resolvedPathSrv) {
+            resolvedPaths = resolvedPaths.concat(resolvedPathSrv);
+        }
+
+        if (resolvedPathDb) {
+            resolvedPaths = resolvedPaths.concat(resolvedPathDb);
+        }
+
+        let allFiles = new Map();
+
+        if (resolvedPaths.length < 1) {
+            Logger.log('No extension files found');
+            return allFiles;
+        }
+
+        const csn = await cds.load(resolvedPaths);
+        const sources = csn.$sources || csn._sources;
+
+        const filteredSources = sources && sources.filter((entry) => {
+            if (! entry.startsWith(projectFolder)) {
+                /* Current file might be below the base model's node_modules, in which case compilation on server should succeed.
+                   Otherwise, compilation will probably fail, with this message giving a hint. */
+                Logger.debug(`Source file outside project folder will not be uploaded: ${entry}`);
+                return false;
+            }
+            const unixFilename = toUnixPath(entry);
+            return !/.*node_modules\/_base\/.*/.test(unixFilename);
+        }) || [];
+
+        const sourceFiles = await collectFileContent(filteredSources, projectFolder);
+        allFiles = new Map([...allFiles, ...sourceFiles]);
+
+        const modelFiles4I18n = { $sources: filteredSources };
+
+        let i18nFolders = cds.localize.folders4(modelFiles4I18n);
+        i18nFolders = i18nFolders.filter(i18nFolder => {
+            const unixFilename = toUnixPath(i18nFolder);
+            return !(/.*node_modules\/_base\/.*/.test(unixFilename));
+        });
+
+        i18nFolders.forEach(async(folder) => {
+            const i18nFiles = collectFiles(projectFolder, folder, entry => {
+                const ext = path.extname(entry);
+                return I18N_WHITELIST.includes(ext);
+            });
+            allFiles = new Map([...allFiles, ...i18nFiles]);
+        });
+
+        try {
+            const pkgJson = await fse.readFile(path.join(absoluteFolder, 'package.json'), 'utf-8');
+            allFiles.set('package.json', pkgJson);
+        } catch(e) {
+            Logger.log('No package.json file found');
+            Logger.error('No package.json file found', e);
+        }
+
+        return allFiles;
+    }
+
+    static collectCustomFiles(projectFolder) {
+        const wsdlFolder = path.join(projectFolder, 'wsdl');
+
+        try {
+            const wsdlFiles = collectFiles(projectFolder, wsdlFolder);
+            if (wsdlFiles.size === 0) {
+                Logger.log('No custom files found');
+            }
+            return wsdlFiles;
+        } catch (error) {
+            Logger.error(undefined, error);
+            throw new Error('No custom files found');
+        }
+    }
+
+    static async runActivate(cds, params) {
+        let activationUrl;
+
+        return Activate.collectExtensionFiles(cds, params.get('projectFolder'))
+        .then(allFiles => {
+            if (allFiles.size === 0) {
+                return null;
+            }
+
+            Logger.log('Activating extension...');
+
+            activationUrl = Activate.getMtxApiUrl(params.get('appUrl'), COMMAND_URL_SUFFIX);
+            const requestOptions = Object.assign({
+                method: 'POST',
+                headers: {},
+                data: {
+                    extension: [...allFiles],
+                    undeployExtension: params.get('undeploy')
+                }
+            }, params.get('reqAuth'));
+            requestOptions.headers['Content-Type'] = 'application/json';
+
+            return axios(activationUrl, requestOptions);
+        })
+        .then(response => {
+            if (response === null) {
+                return;
+            }
+
+            const { jobID: jobId, statusPath } = response.data;
+
+            if (jobId === undefined) {
+                throw new Error('Activation failed: did not receive job ID');
+            }
+
+            if (!statusPath) {
+                throw new Error(`Job ${jobId} failed: did not receive job-status path`);
+            }
+
+            Logger.debug(`Job ID: ${jobId}`);
+
+            return new Promise((resolve, reject) => {
+                const statusUrl = Activate.concatUrls(params.get('appUrl'), statusPath);
+                const finisher = {
+                    resolve,
+                    reject,
+                    finished: false,
+                    timer: null
+                };
+                finisher.timer = setInterval(checkFinished.bind(undefined, jobId, statusUrl, params, finisher), 250);
+            });
+        });
+    }
+
+    static async runCustomFileUpload(params) {
+        Logger.log(`Uploading custom files to ${params.get('appUrl')}...`);
+
+        const customFiles = Activate.collectCustomFiles(params.get('projectFolder'));
+
+        const customFilesSerialized = [];
+        customFiles.forEach((value, key) => {
+            customFilesSerialized.push({
+                category: "wsdl",
+                name: key,
+                content: value
+            });
+        });
+
+        const customFileUrl = Activate.getMtxApiUrl(params.get('appUrl'), Activate.UPDATE_CUSTOM_FILE_URL_SUFFIX);
+        const requestOptions = Object.assign({
+            method: 'POST',
+            headers: {},
+            data: {
+                content: customFilesSerialized
+            }
+        }, params.get('reqAuth'));
+        requestOptions.headers['Content-Type'] = 'application/json';
+
+        await axios(customFileUrl, requestOptions);
+
+        Logger.log('Custom file upload finished');
+    }
+
+}

package/lib/client/auth_manager.js

@@ -0,0 +1,115 @@
+const util = require('util');
+const axios = require('axios');
+
+const Logger = require('./helper/logging');
+const { SettingsManager } = require('./settings_manager');
+const { ParamCollection } = require('./params');
+
+function addTokenInfo(params, authData) {
+    params.set('token', authData.access_token);
+    if (authData.expires_in) {
+        params.set('tokenExpirationDate', Date.now() + authData.expires_in * 1000);
+    } else {
+        params.delete('tokenExpirationDate');
+    }
+    if (authData.refresh_token) {
+        params.set('refreshToken', authData.refresh_token);
+    } else {
+        params.delete('refreshToken');
+    }
+}
+function addUrlInfo(params, authData) {
+    params.set('passcodeUrl', authData.passcode_url);
+}
+function getTokenUrl(params) {
+    const tokenUrl = new URL(params.get('tokenUrl'));
+    tokenUrl.search = `subdomain=${params.get('subdomain')}`;
+
+    if (params.has('refreshToken')) {
+        tokenUrl.search += `&refresh_token=${params.get('refreshToken')}`;
+    } else if (params.has('passcode')) {
+        tokenUrl.search += `&passcode=${params.get('passcode')}`;
+    }
+    if (params.has('clientid')) {
+        tokenUrl.search += `&clientid=${params.get('clientid')}&clientsecret=${params.get('clientsecret')}`;
+    }
+    return tokenUrl.toString();
+}
+
+async function retrieveTokenOrPasscodeUrl(params) {
+    if (params.has('token')) {
+        if (params.get('renewLogin') || params.get('tokenExpirationDate') <= Date.now()) {
+            Logger.debug((params.get('renewLogin') ? 'Renewing' : 'Refreshing expired') + ' authentication token');
+            params.delete('token');
+            params.delete('tokenExpirationDate');
+        } else {
+            return;
+        }
+    }
+    if (!params.has('passcode') && !params.has('refreshToken') && params.has('passcodeUrl')) {
+        return;
+    }
+
+    let retry;
+    let authData;
+    do {
+        const tokenUrl = getTokenUrl(params);
+        Logger.debug(`Getting authentication token or passcode URL from ${(params.obfuscateQueryParams(tokenUrl))}`);
+
+        let response;
+        try {
+            response = await axios(tokenUrl.toString(), { method: 'GET' });
+        } catch (error) {
+            throw new Error(`Failed to get authentication token: ${error}.\nResponse body: ${util.inspect(response && response.data)}`);
+        }
+        authData = response.data;
+
+        retry = !authData.access_token && params.has('refreshToken') && (params.delete('refreshToken'), true);
+    } while (retry);
+
+    if (authData.access_token) {
+        addTokenInfo(params, authData);
+    } else {
+        addUrlInfo(params, authData);
+    }
+}
+
+
+module.exports = class AuthManager {
+
+    static async loginAndUpdateSettings(paramValues) {
+        SettingsManager.init();
+        const params = new ParamCollection(paramValues);
+        await SettingsManager.loadAndMergeSettings(params);
+        if (params.has('username')) {
+            params.set('reqAuth', { auth: { username: params.get('username'), password: params.get('password') } });
+        } else {
+            await retrieveTokenOrPasscodeUrl(params);
+            if (!params.has('token')) {
+                await SettingsManager.saveSettings(params);
+                throw new Error('Failed to login: no valid token or passcode provided. ' +
+                    'Get a passcode' + (params.get('passcodeUrl') ? ' from ' + params.get('passcodeUrl') : '') +
+                    ' and supply the code when re-running the command');
+            }
+            params.set('reqAuth', { headers: { Authorization: 'Bearer ' + params.get('token') } });
+        }
+
+        await SettingsManager.saveSettings(params); // saves token conditionally
+
+        return params;
+    }
+
+    static async logout(paramValues) {
+        SettingsManager.init();
+        const params = new ParamCollection(paramValues);
+        if (params.get('clearInvalid')) {
+            await SettingsManager.deleteInvalid();
+        } else {
+            await SettingsManager.deleteToken(params);
+            if (params.get('deleteSettings')) {
+                await SettingsManager.deleteSettingsWithoutToken(params);
+            }
+        }
+    }
+
+}

package/lib/client/base_command.js

@@ -0,0 +1,55 @@
+const path = require('path');
+const { fse } = require('@sap/cds-foss');
+
+const Logger = require('./helper/logging');
+
+const MTX_URL_PATH_PREFIX = 'mtx/v1/model/';
+const CUSTOM_FILE_URL_SUFFIX = 'customTenantContent';
+
+module.exports = class BaseCommand {
+
+    static get CUSTOM_FILE_URL_SUFFIX() { return CUSTOM_FILE_URL_SUFFIX; }
+
+    static async checkProject(folder) {
+        return fse.pathExists(path.join(folder, 'package.json'));
+    }
+
+    static async handleHttpError(error, params) {
+        if (!('isAxiosError' in error)) {
+            throw error;
+        }
+
+        switch (error.response.status) {
+            case 401:
+                Logger.error('Request failed: authorization might have expired. Please retry with valid passcode' +
+                    (params.has('passcodeUrl') ? ` from ${params.get('passcodeUrl')}` : ''), error);
+                break;
+            case 404:
+                Logger.error(`Request failed. Please check application URL ${params.get('appUrl')}`, error);
+                break;
+            default:
+                // Including 422 (compilation or native-extension error).
+                Logger.error(undefined, error);
+        }
+    }
+
+    static concatUrls(base, ...paths) {
+        function trimBeginSlash(str) {
+            return str.replace(/^\//, '');
+        }
+        function trimEndSlash(str) {
+            return str.replace(/\/$/, '');
+        }
+        function trimSlashes(str) {
+            return trimBeginSlash(trimEndSlash(str));
+        }
+        const concatenated = new URL(base);
+        concatenated.pathname = trimEndSlash(concatenated.pathname) + '/' +
+            paths.map((p, i) => i < paths.length - 1 ? trimSlashes(p) : trimBeginSlash(p)).join('/');
+        return concatenated.toString();
+    }
+
+    static getMtxApiUrl(url, action) {
+        return BaseCommand.concatUrls(url, MTX_URL_PATH_PREFIX, action);
+    }
+}

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);
+    }
+
+}