@sap/cds-dk 7.9.4 → 8.0.2

package/lib/mtx/activate.js

@@ -1,238 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-const axios = require('axios');
-
-const cds = require('../cds');
-const AuthManager = require('./auth_manager');
-
-require('../util/axios').pruneErrors();
-const { collectFileContent, collectFiles, toUnixPath } = require('./util/fs');
-const { getMessage } = require('./util/logging');
-const { handleHttpError } = require('./util/errors');
-const { concatUrls } = require('./util/urls');
-const { checkProject, getMtxApiUrl } = require('./util/legacy_ext');
-
-const DEBUG = cds.debug('cli');
-
-const COMMAND_URL_SUFFIX = 'asyncActivate';
-const COMMAND_URL_SUFFIX_SYNC = 'activate';
-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 { status, error } = (await axios.get(statusUrl, params.get('reqAuth'))).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(getMessage(`Job ${jobId} failed`, { error }));
-        }
-        console.log('Extension active');
-        finisher.resolve();
-    }
-}
-
-module.exports = class Activate {
-
-    static get COMMAND_URL_SUFFIX() { return COMMAND_URL_SUFFIX; }
-    static get COMMAND_URL_SUFFIX_SYNC() { return COMMAND_URL_SUFFIX_SYNC; }
-    static get UPDATE_CUSTOM_FILE_URL_SUFFIX() { return UPDATE_CUSTOM_FILE_URL_SUFFIX; }
-
-    static async run(injection, paramValues) {
-        const params = await AuthManager.login(paramValues);
-
-        if (process.env.DEBUG) {
-            console.log('Activating extension with parameters', JSON.stringify({
-                appUrl: params.get('appUrl'),
-                projectFolder: params.get('projectFolder'),
-                undeploy: params.get('undeploy'),
-                sync: params.get('sync')
-            }));
-        } else {
-            console.log('Activating extension located at', params.get('projectFolder'), 'to URL', params.get('appUrl'));
-        }
-
-        if (!await checkProject(params.get('projectFolder'))) {
-            throw params.get('projectFolder') + ' is not a valid extension project';
-        }
-
-        try {
-            await this.runActivate(injection.cds, params);
-            if (params.get('wsdl')) {
-                await this.runCustomFileUpload(params);
-            }
-        } catch (error) {
-            handleHttpError(error, params, { command: 'activate' });
-        }
-    }
-
-    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) {
-            console.warn('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. */
-                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(folder => {
-            const i18nFiles = collectFiles(projectFolder, folder, entry => {
-                const ext = path.extname(entry);
-                return I18N_WHITELIST.includes(ext);
-            });
-            allFiles = new Map([...allFiles, ...i18nFiles]);
-        });
-
-        let pkgJson;
-        try {
-            pkgJson = await fs.readFile(path.join(absoluteFolder, 'package.json'), 'utf-8');
-        } catch (error) {
-            throw getMessage('No package.json file found', { error });
-        }
-        allFiles.set('package.json', pkgJson);
-
-        return allFiles;
-    }
-
-    static collectCustomFiles(projectFolder) {
-        const wsdlFolder = path.join(projectFolder, 'wsdl');
-
-        const wsdlFiles = collectFiles(projectFolder, wsdlFolder);
-        if (wsdlFiles.size === 0) {
-            console.log('No custom files found');
-        }
-        return wsdlFiles;
-    }
-
-    static async runActivate(cds, params) {
-        let activationUrl;
-        const isSync = params.get('sync');
-
-        return this.collectExtensionFiles(cds, params.get('projectFolder'))
-        .then(allFiles => {
-            if (allFiles.size === 0) {
-                return null;
-            }
-
-            console.log('Activating extension...');
-
-            const urlSuffix = isSync ? this.COMMAND_URL_SUFFIX_SYNC : this.COMMAND_URL_SUFFIX;
-            activationUrl = getMtxApiUrl(params.get('appUrl'), urlSuffix);
-            const requestOptions = Object.assign({
-                headers: {}
-            }, params.get('reqAuth'));
-            requestOptions.headers['Content-Type'] = 'application/json';
-
-            return axios.post(activationUrl, {
-                extension: [...allFiles],
-                undeployExtension: params.get('undeploy')
-            }, requestOptions);
-        })
-        .then(response => {
-            if (isSync || response === null) {
-                return;
-            }
-
-            const { jobID: jobId, statusPath } = response.data;
-
-            if (jobId === undefined) {
-                throw 'Activation failed: did not receive job ID';
-            }
-
-            if (!statusPath) {
-                throw `Job ${jobId} failed: did not receive job-status path`;
-            }
-
-            DEBUG?.(`Job ID: ${jobId}`);
-
-            return new Promise((resolve, reject) => {
-                const statusUrl = 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) {
-        console.log('Uploading custom files to', params.get('appUrl'), '...');
-
-        const customFiles = this.collectCustomFiles(params.get('projectFolder'));
-
-        const customFilesSerialized = [];
-        customFiles.forEach((value, key) => {
-            customFilesSerialized.push({
-                category: "wsdl",
-                name: key,
-                content: value
-            });
-        });
-
-        const customFileUrl = getMtxApiUrl(params.get('appUrl'), this.UPDATE_CUSTOM_FILE_URL_SUFFIX);
-        const requestOptions = Object.assign({
-            headers: {},
-        }, params.get('reqAuth'));
-        requestOptions.headers['Content-Type'] = 'application/json';
-
-        await axios.post(customFileUrl, {
-            content: customFilesSerialized
-        }, requestOptions);
-
-        console.log('Custom file upload finished');
-    }
-
-}

package/lib/mtx/extend.js

@@ -1,173 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const axios = require('axios');
-
-const AuthManager = require('./auth_manager');
-
-require('../util/axios').pruneErrors();
-const { normalizePath, isParent } = require('./util/fs');
-const Question = require('./util/question');
-const { getMessage } = require('./util/logging');
-const { handleHttpError } = require('./util/errors');
-const { checkProject, getMtxApiUrl } = require('./util/legacy_ext');
-
-const COMMAND_URL_SUFFIX = 'content';
-const CUSTOM_FILE_URL_SUFFIX = 'customTenantContent';
-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 {
-
-    static get COMMAND_URL_SUFFIX() { return COMMAND_URL_SUFFIX; }
-    static get CUSTOM_FILE_URL_SUFFIX() { return CUSTOM_FILE_URL_SUFFIX; }
-
-    static async storeFiles(content, targetDirectory, filter) {
-        fs.mkdirSync(targetDirectory, { recursive: true });
-        targetDirectory = fs.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);
-            fs.mkdirSync(path.dirname(normalizedFilepath), { recursive: true });
-            fs.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)) {
-                console.log('Ignoring template', normalizedPath, ': not in', DB_FOLDER, 'or', SRV_FOLDER);
-                return false;
-            }
-            return true;
-        });
-    }
-
-    static async run(paramValues) {
-        const params = await AuthManager.login(paramValues);
-
-        if (process.env.DEBUG) {
-            console.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 {
-            console.log('\n\nCreating extension project for', params.get('appUrl'), 'subdomain', params.get('subdomain'), 'in folder', params.get('projectFolder'));
-        }
-
-        const runOnExistingProject = await checkProject(params.get('projectFolder'));
-        if (runOnExistingProject && !(params.get('force') || params.get('templates'))) {
-            throw getMessage(folderExists(params.get('projectFolder')), { command: 'extend' });
-        }
-
-        try {
-            await Extend.runExtend(params);
-        } catch (error) {
-            await handleHttpError(error, params, { command: 'extend' });
-        }
-    }
-
-    static async runExtend(params) {
-        const contentUrl = getMtxApiUrl(params.get('appUrl'), COMMAND_URL_SUFFIX);
-        const requestOptions = Object.assign({ retry: 0 }, params.get('reqAuth'));
-
-        console.log('Retrieving files...');
-
-        const [ response ] = (await axios.get(contentUrl, requestOptions)).data;
-
-        console.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 fs.promises.mkdir(path.join(params.get('projectFolder'), DB_FOLDER), { recursive: true });
-        await fs.promises.mkdir(path.join(params.get('projectFolder'), SRV_FOLDER), { recursive: true });
-
-        console.log('\nPut database extension models into', DB_FOLDER, 'folder.');
-        console.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) {
-                console.log('Writing template files to', DB_FOLDER, 'and', SRV_FOLDER, 'folder');
-                await Extend.storeTemplateFiles(response.templates, params.get('projectFolder'));
-            } else {
-                console.log('Ignoring templates because extension is already active.');
-            }
-        }
-
-        if (params.get('wsdl')) {
-            console.log('Writing custom files');
-            const customFileUrl = getMtxApiUrl(params.get('appUrl'), CUSTOM_FILE_URL_SUFFIX);
-            const customFiles = (await axios.get(customFileUrl, requestOptions)).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 = fs.existsSync(targetDirectory);
-            if (!targetExists || await this.promptTemplateOverwrite()) {
-                if (targetExists) {
-                    await fs.promises.rm(targetDirectory, { force: true, recursive: true });
-                }
-                console.log('Writing template files to', TEMPLATE_FOLDER, 'folder');
-                await Extend.storeTemplateFiles(templates, targetDirectory);
-            }
-
-        } else {
-            console.log('No templates available');
-        }
-    }
-
-    static promptTemplateOverwrite() {
-        return Question.askBooleanQuestion(`This  will overwrite existing templates in folder ${TEMPLATE_FOLDER}. Continue (yN)? `);
-    }
-
-    static _logWrittenFile(file) {
-        console.log('CREATE:', file);
-    }
-
-}

package/lib/util/exec.d.ts

@@ -1,54 +0,0 @@
-/*
- * Typings only for common use cases
- */
-
-interface AdditionalExecOptions {
-    acceptStatuses? : Array<Number> | '*',
-    appendEnv?: {[key: string]: string},
-    log?: object
-}
-
-interface SpawnReturns {
-    status : number,
-    stdout? : string,
-    stderr? : string
-}
-
-import { SpawnOptions, SpawnSyncOptions, SpawnSyncReturns } from "child_process";
-
-type execTemplate<T> = (template: TemplateStringsArray, ...args : any[]) => T;
-
-/**
- * Execute commands with template strings asynchronously.
- *
- * @example
- *
- * await exec `ls -l .`
- * await exec `ls -l ${'spaces are safe in expressions'}` => spawn('ls', [ '-l', 'spaces are safe in expressions' ])
- * await exec `ls -l "dir ${'with spaces'}"
- * await exec `ls -l ${['db', 'srv']}`
- * const out = (await exec({stdio: ['inherit', 'pipe', 'inherit']}) `ls -l`).stdout
- * const out = await exec({result: 'stdout}) `ls -l`
- */
-export function exec( template : TemplateStringsArray, ...args : any[] ) : Promise<SpawnReturns>
-export function exec( options : { result: 'stdout' | 'stderr' } & SpawnOptions & AdditionalExecOptions) : execTemplate<Promise<string>>;
-export function exec( options : SpawnOptions & AdditionalExecOptions) : execTemplate<Promise<SpawnReturns>>;
-
-/**
- * Execute commands with template strings synchronously.
- *
- * @example
- *
- * execSync `ls -l .`
- * execSync `ls -l ${'spaces are safe in expressions'}` => spawn('ls', [ '-l', 'spaces are safe in expressions' ])
- * execSync `ls -l "dir ${'with spaces'}"
- * execSync `ls -l ${['db', 'srv']}`
- * const out = (execSync({stdio: ['inherit', 'pipe', 'inherit']}) `ls -l`).stdout
- * const out = execSync({result: 'stdout}) `ls -l`
- */
-export function execSync( template : TemplateStringsArray, ...args : any[] ) : SpawnSyncReturns<string>;
-export function execSync( options : { result: 'stdout' | 'stderr' } & SpawnSyncOptions & AdditionalExecOptions) : execTemplate<string>;
-export function execSync( options : { encoding : 'buffer' | null } & SpawnOptions & AdditionalExecOptions) : execTemplate<SpawnSyncReturns<Buffer>>;
-export function execSync( options : SpawnOptions & AdditionalExecOptions) : execTemplate<SpawnSyncReturns<string>>;
-
-export { execSync as $ };

package/lib/util/exec.js

@@ -1,211 +0,0 @@
-const { spawn, spawnSync } = require('child_process');
-
-const cds = require('../cds');
-const log = cds.log('exec');
-const DEBUG = cds.debug('exec');
-
-function* commandIterator(strs, args) {
-    for (let i=0; i<strs.length; i++) {
-        const str = strs[i];
-        const regex = /((\s+)|(["'])|$)/g;
-        let match;
-        let lastIndex = 0;
-        do {
-            match = regex.exec(str);
-            if (match.index > lastIndex) {
-                yield { type: 'WORD', value: str.substr(lastIndex, match.index - lastIndex) };
-            }
-            if (match[2]) {
-                yield { type: 'SPACE', value: match[2] };
-            }
-            if (match[3]) {
-                yield { type: 'QUOTE', value: match[3] }
-            }
-            lastIndex = match.index + match[0].length;
-        } while (lastIndex < str.length);
-
-        if (args[i]) {
-            if (Array.isArray(args[i])) {
-                let sep = false;
-                for (const value of args[i]) {
-                    if (sep) yield { type: 'SPACE', value: ' '};
-                    yield { type: 'WORD', value };
-                    sep = true;
-                }
-            } else {
-                yield { type: 'WORD', value: args[i] };
-            }
-        }
-    }
-}
-
-function processTemplate(strs, ...args) {
-    let quote;
-    const result = [];
-    let index = 0;
-
-    const append = str => result[index] = (result[index] || '') + str;
-    const push = () => { if (index < result.length) index++; };
-
-    for (const token of commandIterator(strs, args)) {
-        switch (token.type) {
-            case 'WORD':
-                append(token.value);
-                break;
-            case 'SPACE':
-                if (quote) {
-                    append(token.value);
-                } else {
-                    push();
-                }
-                break;
-            case 'QUOTE':
-                if (quote === token.value) {
-                    quote = undefined;
-                } else if (quote) {
-                    append(token.value);
-                } else {
-                    quote = token.value;
-                }
-                break;
-        }
-    }
-
-    return result;
-}
-
-function fetchOptions(cmd) {
-    const { options, args } = cmd;
-    if (typeof args[0] === 'object' && !Array.isArray(args[0])) {
-        const newOptions = args[0];
-        cmd.options      = {...options, ...newOptions};
-        cmd.args         = args.slice(1);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-function exec_func(...args) {
-    const cmd = { options: {
-            log,
-            acceptStatuses: [ 0 ],
-            stdio: 'inherit',
-            shell: false,
-            encoding: 'utf-8'
-        }, args };
-
-    let hasOptions = false;
-    while (fetchOptions(cmd)) hasOptions = true;
-    if (hasOptions && cmd.args.length === 0) {
-        return (...args) => exec_func(cmd.options, ...args);
-    }
-
-    if (Array.isArray(cmd.args[0])) cmd.args = processTemplate(...cmd.args);
-    return cmd.options.executer(cmd.options, ...cmd.args);
-}
-
-function getExecOptions(options) {
-    const execOptions = {...options};
-    [ 'acceptStatuses', 'appendEnv', 'exec', 'log', 'result' ].forEach( name => delete execOptions[name] );
-
-    const { appendEnv, result } = options;
-    if (appendEnv) {
-        execOptions.env = {...(options.env || process.env),...appendEnv};
-    }
-
-    switch (result) {
-        case 'stdout':
-            execOptions.stdio = [ 'inherit', 'pipe', 'inherit' ];
-            break;
-        case 'stderr':
-            execOptions.stdio = [ 'inherit', 'inherit', 'pipe' ];
-            break;
-        case undefined:
-            break;
-
-        default:
-            throw new Error `Unexpected "result" option: "${result}"`;
-    }
-
-    return execOptions;
-}
-
-function toString(a) {
-    return typeof a === 'string' ? a : Buffer.from(a).toString('utf-8');
-}
-
-function processResult(result, options) {
-    switch (options.result) {
-        case 'stdout':
-            return toString(result.stdout);
-        case 'stderr':
-            return toString(result.stderr);
-        case undefined:
-            return result;
-
-        default:
-            throw new Error(`Unexpected "result" option: "${result}"`);
-    }
-}
-
-
-function executeSync(options = {}, command, ...args) {
-    const { acceptStatuses } = options;
-    const execOptions = getExecOptions(options);
-
-    DEBUG?.(`exec: ${command} ${args.map( v => v.match(/\s/) ? `"${v}"` : v ).join(' ')}`);
-    const result = spawnSync(command, args, execOptions);
-
-    if (acceptStatuses !== '*' && acceptStatuses.indexOf(result.status) === -1) throw new Error(`Command '${command} ${args.join(' ')}' returned with status code ${result.status}`);
-    return processResult(result, options);
-}
-
-async function executeAsync(options = {}, command, ...args) {
-    const { acceptStatuses } = options;
-    const execOptions = getExecOptions(options);
-
-//    ctx.log(`exec: ${command} ${args.map( v => v.match(/\s/) ? `"${v}"` : v ).join(' ')}`);
-
-
-    const result = await new Promise( (resolve, reject) => {
-        const child = spawn(command, args, execOptions);
-        const stdoutChunks = [];
-        const stderrChunks = [];
-
-        if (child.stdout) {
-            child.stdout.on('data', data => {
-                stdoutChunks.push(Buffer.from(data));
-            });
-        }
-
-        if (child.stderr) {
-            child.stderr.on('data', data => {
-                stderrChunks.push(Buffer.from(data));
-            });
-        }
-
-        const exit = status => {
-            if (acceptStatuses !== '*' && acceptStatuses.indexOf(status) === -1) reject(new Error(`Command '${command} ${args.join(' ')}' returned with status code ${status}`))
-            else resolve({
-                status,
-                stdout: child.stdout ? Buffer.concat(stdoutChunks).toString("utf-8") : undefined,
-                stderr: child.stderr ? Buffer.concat(stderrChunks).toString("utf-8") : undefined
-            })
-        };
-
-        child.on('close', exit);
-        child.on('exit', exit);
-    });
-
-    return processResult(result, options);
-}
-
-const exec = exec_func({ executer: executeAsync });
-const execSync = exec_func({ executer: executeSync });
-
-module.exports = {
-    exec,
-    execSync,
-    $ : execSync
-}