@sap/cds-dk 6.8.3 → 7.0.0

package/lib/util/cfUtil.js

@@ -0,0 +1,366 @@
+// eslint-disable-next-line no-console
+
+const cp = require('child_process');
+const fsp = require('fs').promises;
+const os = require('os');
+const path = require('path');
+const util = require('util');
+
+const IS_WIN = os.platform() === 'win32';
+const execAsync = util.promisify(cp.exec);
+
+const cds = require('../cds')
+
+const LOG = cds.log ? cds.log('deploy') : console;
+const DEBUG = cds.debug('deploy');
+
+const { bold, warn } = require('./term');
+const { CliError } = require('../client/helper/errors');
+
+const CF_COMMAND = 'cf';
+
+const POLL_COUNTER = 40;
+const POLL_DELAY = 2500; //ms
+
+const OPERATION_STATE_INITIAL = 'initial';
+const OPERATION_STATE_IN_PROGRESS = 'in progress';
+const OPERATION_STATE_FAILED = 'failed';
+const OPERATION_STATE_SUCCEEDED = 'succeeded';
+
+const CF_CLIENT_MINIMUM_VERSION = 8;
+
+
+class CfUtil {
+
+    _clear() {
+        this.spaceInfo = null;
+    }
+
+    async _sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+
+    async _cfRun(...args) {
+        args = args.map(arg => arg.replace(/"/g, '\\"'));
+        const cmdLine = `${CF_COMMAND} "${args.join('" "')}"`;
+        DEBUG && console.time(cmdLine);
+        LOG.debug('>>>', cmdLine);
+
+        try {
+            const result = await execAsync(cmdLine, {
+                shell: IS_WIN,
+                stdio: ['inherit', 'pipe', 'inherit']
+            });
+            result.stdout = result.stdout?.trim();
+            result.stderr = result.stderr?.trim();
+            return result;
+        } catch (err) {
+            err.stdout = err.stdout?.trim();
+            err.stderr = err.stderr?.trim();
+            throw err;
+        } finally {
+            // eslint-disable-next-line no-console
+            DEBUG && console.timeEnd(cmdLine);
+        }
+    }
+
+    async _cfRequest(urlPath, queryObj, bodyObj) {
+        if (queryObj) {
+            const entries = Object.entries(queryObj);
+            const queryStr = entries.map(([key, value]) => {
+                // commas cause problems in cf curl when not double encoded
+                value = value.replace(/,/g, encodeURIComponent(','));
+                return `${key}=${encodeURIComponent(value)}`;
+            }).join('&');
+
+            urlPath = urlPath + `?${queryStr}`;
+        }
+
+        // cf curl PATH [-iv] [-X METHOD] [-H HEADER]... [-d DATA] [--output FILE]
+        const args = ['curl', urlPath];
+        if (bodyObj) {
+            args.push('-d');
+            args.push(JSON.stringify(bodyObj)); // cfRun uses spawn so no special handling for quotes on cli required
+        }
+
+        const result = await this._cfRun(...args);
+        let response = {};
+        if (result.stdout) {
+            response = JSON.parse(result.stdout);
+        } else if (result.stderr) {
+            response = { errors: [{ title: result.stderr }] };
+        }
+
+        if (response.errors) {
+            const errorMessage = response.errors.map((entry) => `${entry.title || ''}: ${entry.detail || ''} (${entry.code || ''})`).join('\n');
+            throw new Error(errorMessage);
+        }
+
+        return response;
+    }
+
+    _extract(string, pattern, errorMsg) {
+        const match = string.match(pattern);
+        if (match?.[1]) {
+            return match[1];
+        }
+        throw new Error(errorMsg);
+    }
+
+    async getCfTargetFromConfigFile() {
+        const cfHome = process.env.CF_HOME || process.env.cf_home || path.join(os.homedir(), '.cf');
+        try {
+            const fileContent = await fsp.readFile(path.join(cfHome, 'config.json'));
+            const config = JSON.parse(fileContent);
+            if (config) {
+                return {
+                    apiEndpoint: this._extract(config.Target, /\s*(.+)\s*/, `CF API endpoint is missing. Use 'cf login' to login.`),
+                    org: this._extract(config.OrganizationFields.Name, /\s*(.+)\s*/, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
+                    space: this._extract(config.SpaceFields.Name, /\s*(.+)\s*/, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`)
+                }
+            }
+        } catch (err) {
+            LOG.debug(`getCfTargetFromConfigFile: ${err}`);
+        }
+    }
+
+    async getCfTargetFromCli() {
+        const result = await this._cfRun('target');
+        if (result?.stdout) {
+            return {
+                apiEndpoint: this._extract(result.stdout, /api endpoint\s*:\s*([^\s]+)/i, `CF API endpoint is missing. Use 'cf login' to login.`),
+                user: this._extract(result.stdout, /user\s*:\s*(.+)/i, `CF user is missing. Use 'cf login' to login.`),
+                org: this._extract(result.stdout, /org\s*:\s*(.+)/i, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
+                space: this._extract(result.stdout, /space\s*:\s*(.+)/i, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`),
+            };
+        }
+    }
+
+    async getCfAuthorization() {
+        DEBUG?.('getting authorization');
+        try {
+            return (await this._cfRun('oauth-token')).stdout;
+        } catch (err) {
+            throw new CliError(err.message);
+        }
+    }
+
+    async getCfTarget() {
+        await this.checkCliVersion();
+        await this.getCfAuthorization();
+        return await this.getCfTargetFromConfigFile() || await this.getCfTargetFromCli();
+    }
+
+    async checkCliVersion() {
+        const result = await this._cfRun('-v');
+        const version = result?.stdout?.match(/version.*(\d+\.\d+\.\d+)/i)
+        if (parseInt(version?.[1]) < CF_CLIENT_MINIMUM_VERSION) {
+            console.log(warn(`
+[Warning] You are using Cloud Foundry client version ${version[1]}. We recommend version ${CF_CLIENT_MINIMUM_VERSION} or higher.
+Deployment will stop in the near future for Cloud Foundry client versions < ${CF_CLIENT_MINIMUM_VERSION}.
+`));
+        }
+    }
+
+    async getCfSpaceInfo() {
+        if (!this.spaceInfo) {
+            LOG.debug('getting space info');
+
+            const target = await this.getCfTarget();
+
+            const { org, space } = target;
+            const orgs = await this._cfRequest(`/v3/organizations`, { names: org });
+            if (!orgs?.resources?.length) {
+                throw new Error(`CF org ${bold(org)} not found!`);
+            }
+
+            const orgGuid = orgs.resources[0].guid;
+            const spaces = await this._cfRequest(`/v3/spaces`, { names: space, organization_guids: orgGuid });
+            if (!spaces?.resources?.length) {
+                throw new Error(`CF space ${bold(space)} not found in org ${bold(org)}!`);
+            }
+
+            const spaceGuid = spaces.resources[0].guid;
+
+            this.spaceInfo = Object.assign({}, target, { orgGuid, spaceGuid });
+        }
+
+        return this.spaceInfo;
+    }
+
+    async getService(serviceName, showMessage = true) {
+        showMessage && console.log(`Getting service ${bold(serviceName)}`);
+        const spaceInfo = await this.getCfSpaceInfo();
+
+        let counter = POLL_COUNTER;
+        while (counter > 0) {
+            counter--;
+            const serviceInstances = await this._cfRequest('/v3/service_instances', {
+                names: serviceName,
+                space_guids: spaceInfo.spaceGuid,
+                organization_guids: spaceInfo.orgGuid
+            });
+            if (!serviceInstances?.resources?.length) {
+                return null;
+            }
+
+            const serviceInstance = serviceInstances.resources[0];
+            switch (serviceInstance?.last_operation?.state?.toLowerCase()) {
+                case OPERATION_STATE_INITIAL:
+                case OPERATION_STATE_IN_PROGRESS:
+                    await this._sleep(POLL_DELAY);
+                    break;
+
+                case OPERATION_STATE_SUCCEEDED:
+                    return serviceInstance;
+
+                case OPERATION_STATE_FAILED:
+                    throw new Error(`The returned service reported state '${OPERATION_STATE_FAILED}'.\n${JSON.stringify(serviceInstance, null, 4)}`);
+
+                default:
+                    console.error(`Unsupported server response state '${serviceInstance?.last_operation?.state}'. Waiting for next response.`);
+                    break;
+            }
+        }
+
+        throw new Error(`Timeout occurred while getting service ${bold(serviceName)}`);
+    }
+
+
+    async getOrCreateService(serviceOfferingName, planName, serviceName, options) {
+
+        const probeService = await this.getService(serviceName, false);
+        if (probeService) {
+            console.log(`Getting service ${bold(serviceName)}`);
+            return probeService;
+        }
+
+        console.log(`Creating service ${bold(serviceName)} - please be patient...`);
+
+        const spaceInfo = await this.getCfSpaceInfo();
+
+        const servicePlan = await this._cfRequest(`/v3/service_plans`, {
+            names: planName,
+            space_guids: spaceInfo.spaceGuid,
+            organization_guids: spaceInfo.orgGuid,
+            service_offering_names: serviceOfferingName
+        });
+
+        if (!servicePlan?.resources?.length) {
+            throw new Error(`No service plans found`);
+        }
+
+        const body = {
+            type: 'managed',
+            name: serviceName,
+            tags: [serviceOfferingName],
+            relationships: {
+                space: {
+                    data: {
+                        guid: spaceInfo.spaceGuid
+                    }
+                },
+                service_plan: {
+                    data: {
+                        guid: servicePlan.resources[0].guid
+                    }
+                }
+            }
+        }
+
+        if (options) {
+            body.parameters = { ...options };
+        }
+
+        const postResult = await this._cfRequest('/v3/service_instances', undefined, body);
+        if (postResult?.errors) {
+            throw new Error(postResult.errors[0].detail);
+        }
+
+        const newService = await this.getService(serviceName, false);
+        if (newService) {
+            return newService;
+        }
+
+        throw new Error(`Could not create service ${bold(serviceName)}`);
+    }
+
+
+    async getServiceKey(serviceInstance, serviceKeyName, showMessage = true) {
+        showMessage && console.log(`Getting service key ${bold(serviceKeyName)}`);
+
+        let counter = POLL_COUNTER;
+        while (counter > 0) {
+            counter--;
+            const bindings = await this._cfRequest(`/v3/service_credential_bindings`, { names: serviceKeyName, service_instance_guids: serviceInstance.guid });
+            if (!bindings?.resources?.length) {
+                return null;
+            }
+
+            const binding = bindings.resources[0];
+            switch (binding?.last_operation?.state?.toLowerCase()) {
+                case OPERATION_STATE_INITIAL:
+                case OPERATION_STATE_IN_PROGRESS:
+                    await this._sleep(POLL_DELAY);
+                    break;
+
+                case OPERATION_STATE_SUCCEEDED: {
+                    const keyDetails = await this._cfRequest(`/v3/service_credential_bindings/${encodeURIComponent(binding.guid)}/details`);
+                    return keyDetails.credentials;
+                }
+
+                case OPERATION_STATE_FAILED:
+                    throw new Error(`The returned binding reported state '${OPERATION_STATE_FAILED}'.\n${JSON.stringify(binding, null, 4)}`);
+
+                default:
+                    console.error(`Unsupported server response state '${binding?.last_operation?.state}'. Waiting for next response.`);
+                    break;
+            }
+        }
+
+        throw new Error(`Timeout occurred while getting service key ${bold(serviceKeyName)}`);
+    }
+
+
+    async getOrCreateServiceKey(serviceInstance, serviceKeyName) {
+
+        const serviceKey = await this.getServiceKey(serviceInstance, serviceKeyName, false);
+        if (serviceKey) {
+            console.log(`Getting service key ${bold(serviceKeyName)}`);
+            return serviceKey;
+        }
+
+        console.log(`Creating service key ${bold(serviceKeyName)} - please be patient...`);
+
+        const body = {
+            type: 'key',
+            name: serviceKeyName,
+            relationships: {
+                service_instance: {
+                    data: {
+                        guid: serviceInstance.guid
+                    }
+                }
+            },
+            parameters: {
+                permissions: 'development'
+            }
+        }
+
+        const postResult = await this._cfRequest('/v3/service_credential_bindings', undefined, body);
+        if (postResult?.errors) {
+            throw new Error(postResult.errors[0].detail);
+        }
+
+        const newServiceKey = await this.getServiceKey(serviceInstance, serviceKeyName, false);
+        if (newServiceKey) {
+            return newServiceKey;
+        }
+
+        throw new Error(`Could not create service key ${bold(serviceKeyName)}`);
+    }
+}
+
+module.exports = new CfUtil();

package/lib/util/command.js

@@ -21,7 +21,7 @@ class CommandUtil {
      *
      * @returns Promise
      */
-    async spawnCommand(cmd, args, options = {}, collectResult = false) {
+    async spawnCommand(cmd, args, options = {}, collectResult = false, showOutput = true) {
         args = this._sanitizeArgs(args);
         return new Promise((resolve, reject) => {
             DEBUG?.(`[spawn] ${cmd} ${args.join(' ')}`);
@@ -31,14 +31,14 @@ class CommandUtil {
             const child = this._getChildProcess(cmd, args, options);
 
             // use inplace methods to ensure logger is called in context
-            const stdLogBuffer = new LogBuffer((chunk) => console.log(chunk), collectResult);
+            const stdLogBuffer = new LogBuffer(showOutput || DEBUG ? (chunk) => console.log(chunk) : undefined, 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) => console.error(chunk), (IS_WIN || collectResult));
+            const errLogBuffer = new LogBuffer(showOutput || DEBUG ? (chunk) => console.error(chunk) : undefined, (IS_WIN || collectResult));
             child.stderr.on('data', (chunk) => {
                 errLogBuffer.handleChunk(chunk);
             });

package/lib/util/gitUtil.js

@@ -0,0 +1,55 @@
+const cp = require('child_process');
+const path = require('path');
+const fs = require('fs').promises;
+const util = require('util');
+const os = require('os');
+
+const cds = require('../cds');
+const DEBUG = cds.debug('cli');
+
+const GIT_IGNORE_FILE = '.gitignore';
+
+class GitUtil {
+
+    constructor() {
+        this.execAsync = util.promisify(cp.exec);
+    }
+
+    async ensureFileIsGitignored(file, currentFolder = cds.root) {
+        const gitIgnorePath = path.join(currentFolder, GIT_IGNORE_FILE);
+
+        try {
+            await this.execAsync(`git check-ignore -n -v ${file}`, {
+                cwd: currentFolder
+            });
+            return; // file is git ignored, nothing to do
+        } catch (err) {
+            if (err.code === 'ENOENT') {   // git command not found
+                DEBUG?.('git command not found');
+                return;
+            }
+
+            if (!err.stdout.match(/::/)) {   // included or not a git repo
+                DEBUG?.(err.message);
+                return;
+            }
+        }
+
+        console.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
+        let gitignore = await this.readFileSafely(gitIgnorePath);
+        gitignore = gitignore + `${os.EOL}# added by cds${os.EOL}${file}${os.EOL}`;
+
+        await fs.mkdir(path.dirname(gitIgnorePath), { recursive: true });
+        await fs.writeFile(gitIgnorePath, gitignore, 'utf8');
+    }
+
+    async readFileSafely(file) {
+        try {
+            return await fs.readFile(file, 'utf8');
+        } catch (err) {
+            return '';
+        }
+    }
+}
+
+module.exports = new GitUtil();

package/lib/util/version.js

@@ -0,0 +1,27 @@
+const { join } = require('path')
+
+function _oldMtx(cds = require('../cds')) {
+    function _hasMtxDependency() {
+        try {
+            return require(join(cds.root, 'package.json'))?.dependencies?.['@sap/cds-mtx']
+        } catch(e) {
+            return false
+        }
+    }
+    return (_hasMtxDependency() || process.env.OLD_MTX?.toLowerCase() === 'true') ?? false
+}
+
+function checkMtx(cds) {
+    if (_oldMtx(cds)) {
+        const { CliError } = require('../client/helper/errors')
+        throw new CliError(`Package @sap/cds-mtx is deprecated and incompatible with @sap/cds-dk >= 7.
+To continue using it, install version 6 of @sap/cds-dk in your project with:
+  npm i @sap/cds-dk@6
+However, it is RECOMMENDED to migrate to @sap/cds-mtxs instead.
+See https://cap.cloud.sap/docs/guides/multitenancy/old-mtx-migration for more.`)
+    }
+}
+
+module.exports = {
+    checkMtx
+}