@sap/cds-dk 4.5.4 → 4.6.4

package/lib/bind/bindingResolver.js

@@ -0,0 +1,138 @@
+const Config = require('@sap/cds/lib/env')
+const cds = require('@sap/cds/lib');
+const LOG = cds.log('bind');
+
+function getUnresolvedBindings({cwd = process.cwd(), env}) {
+    if (!env) env = Config.for('cds', cwd)
+    if (feature(env) === false || feature(env) === "false") return {}
+
+    const requires = env.requires || {}
+    let bindings = {}
+    for (const name in requires) {
+        const service = requires[name]
+        if (service && service.binding && !service.binding.resolved) {
+            bindings[name] = {...service.binding, kind: service.kind }
+        }
+    }
+
+    return bindings
+}
+
+async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'info', cache = {} }) {
+    const config = { requires: { } }
+    bindings = bindings || getUnresolvedBindings({cwd, env})
+    if (Object.keys(bindings).length===0) return config;
+    LOG[output](`resolving cloud service bindings...`)
+    await Promise.all( Object.keys(bindings).map( async name => {
+        const binding = bindings[name]
+        const cacheKey = JSON.stringify(binding)
+        if (!cache[cacheKey]) {
+            cache[cacheKey] = config.requires[name] = await resolveBinding(name, binding)
+            LOG[output](`bound ${name} to Cloud Foundry service instance ${binding.instance}`)
+        } else {
+            config.requires[name] = cache[cacheKey]
+        }
+    } ));
+
+    // Add kind to result, so that it can be applied to old @sap/cds versions that do not read `.cdsrc-private.json`
+    for (const name in config.requires) {
+        if (bindings[name].kind) config.requires[name].kind = bindings[name].kind
+    }
+
+    return config
+}
+
+let cfKeyProvider
+
+async function resolveBinding(name, binding) {
+    switch (binding.type) {
+        case 'cf':
+            if (!cfKeyProvider) {
+                cfKeyProvider = require('./cfKeyProvider');
+                cfKeyProvider.setLogger(LOG);
+            }
+            return cfKeyProvider.resolve(name, binding);
+        default:
+            throw new Error(`Unsupported binding type "${binding.type}" for service "${name}".`)
+    }
+}
+
+async function applyTo(options) {
+    const config = await resolveBindings(options)
+    if (!config) return
+    const {env} = options
+    for (const name in config.requires) {
+        const service = config.requires[name]
+        const { binding, credentials } = service
+        Object.assign(env.requires[name], { binding, credentials })
+    }
+
+    if (Config._emulate_vcap_services) {
+        Config._emulate_vcap_services()
+    }
+}
+
+class BindingManager {
+    constructor(options) {
+        this.cache = {}
+        this.bindingsStr = ''
+        this.options = options
+    }
+
+    getBindings() {
+        const bindings = getUnresolvedBindings(this.options)
+        return bindings
+    }
+
+    async resolve(bindings) {
+        if (!bindings) {
+            bindings = this.getBindings(this.options)
+            this.bindingsStr = JSON.stringify(bindings)
+        }
+
+        const config = await resolveBindings({...this.options, bindings, cache: this.cache})
+        if (config && Object.keys(config.requires || {}).length > 0) return config;
+    }
+
+    async update({ onBeforeUpdate, onAfterUpdate } = {}) {
+        const oldBindingsStr = this.bindingsStr
+        const bindings = this.getBindings()
+        const bindingsStr = JSON.stringify(bindings)
+        this.bindingsStr = bindingsStr
+
+        if (this.bindingsStr === oldBindingsStr) return // No change
+        if (onBeforeUpdate) await onBeforeUpdate()
+
+        try {
+            if (this.pendingUpdate) await this.pendingUpdate
+        } catch(error) {
+            // ignore
+        }
+        this.pendingUpdate = undefined
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+
+        let resolvedBindings
+        try {
+            this.pendingUpdate = this.resolve(bindings)
+            resolvedBindings = await this.pendingUpdate
+        } catch(error) {
+            LOG.error(error.message)
+            return
+        }
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+        if (onAfterUpdate) onAfterUpdate(resolvedBindings)
+    }
+}
+
+function feature(env) {
+    return env.features && env.features.dk && env.features.dk.resolveBindingsForTesting
+}
+
+module.exports = {
+    applyTo,
+    bindingManager: function(options) {
+        return new BindingManager(options)
+    }
+}

package/lib/bind/cfKeyProvider.js

@@ -0,0 +1,353 @@
+const cp = require('child_process');
+const os = require('os');
+const util = require('util');
+
+const axios = require('axios');
+const { URL } = require('url');
+
+const execAsync = util.promisify(cp.exec);
+const IS_WIN = os.platform() === 'win32';
+
+const KindToRequiresNameMap = {
+    xsuaa: 'uaa',
+    hana: 'db',
+    destinations: 'destinations',
+    connectivity: 'connectivity',
+    'audit-log': 'audit-log',
+    'enterprise-messaging': 'messaging',
+    'enterprise-messaging-amqp': 'messaging',
+    'enterprise-messaging-http': 'messaging',
+    'enterprise-messaging-shared': 'messaging'
+}
+
+class CFKeyProvider {
+
+    constructor() {
+        this.logger = console;
+    }
+
+    async _cfRead(...args) {
+        this.logger.debug(`_cfRead: cf ${args}`);
+
+        const result = await execAsync(`cf ${args}`, {
+            shell: IS_WIN,
+            stdio: ['inherit', 'pipe', 'inherit'],
+        });
+
+        return result.stdout.toString().trim();
+    }
+
+    async _req(target, urlPath) {
+        const url = new URL(urlPath, target.apiEndpoint);
+
+        this.logger.debug(`_req: ${url.toString()}`);
+
+        const result = await axios.get(url.toString(), {
+            headers: {
+                authorization: target.authorization
+            }
+        });
+
+        return result.data;
+    }
+
+    extract(string, pattern, defaultValue) {
+        const array = string.split(/[\n\r]+/);
+        for (let line of array) {
+            const match = line.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+
+        if (typeof defaultValue === 'undefined') {
+            throw Error(`Pattern not found: ${pattern}`);
+        } else {
+            return defaultValue;
+        }
+    }
+
+    async getCfTargetFromCli() {
+        const result = await this._cfRead('target');
+
+        return {
+            apiEndpoint: this.extract(result, /^api endpoint:\s+(.*)$/i),
+            user: this.extract(result, /^user:\s+(.*)$/i),
+            org: this.extract(result, /^org:\s+(.*)$/i),
+            space: this.extract(result, /^space:\s+(.*)$/i),
+        };
+    }
+
+    async getCfSpaceInfo() {
+        this.logger.debug('getting space info');
+
+        const target = await this.getCfTargetFromCli();
+        const authorization = await this.getCfAuthorization();
+        const targetWithAuth = Object.assign({}, target, { authorization });
+
+
+        const { org, space } = target;
+        const orgs = await this._req(targetWithAuth, `/v3/organizations?names=${org}`);
+        if (!(orgs && orgs.resources.length === 1)) {
+            throw new Error(`CF org ${org} not found!`);
+        }
+
+        const orgGuid = orgs.resources[0].guid;
+        const spaces = await this._req(targetWithAuth, `/v3/spaces?names=${space}&organization_guids=${orgGuid}`)
+        if (!(spaces && spaces.resources.length === 1)) {
+            throw new Error(`CF space ${space} not found in org ${org}!`);
+        }
+
+        const spaceGuid = spaces.resources[0].guid;
+
+        return Object.assign({}, target, { orgGuid, spaceGuid, authorization });
+    }
+
+    async getCfAuthorization() {
+        this.logger.debug('getting authorization');
+        return this._cfRead('oauth-token');
+    }
+
+    setLogger(logger) {
+        this.logger = logger;
+    }
+
+    async init() {
+        const target = this.target = await this.getCfSpaceInfo();
+        const logger = this.logger;
+        this.getOrg = BatchRequest.create({logger, target, url: '/v3/organizations'});
+        this.getSpace = BatchRequest.create({logger, target, url: '/v3/spaces', extractors: {
+            organization_guids: resource => resource.relationships.organization.data.guid
+        }});
+        this.getInstance = BatchRequest.create({logger, target, url: '/v3/service_instances', extractors: {
+            space_guids: resource => resource.relationships.space.data.guid
+        }});
+        this.getKey = BatchRequest.create({logger, target, url: '/v3/service_credential_bindings', extractors: {
+            service_instance_guids: resource => resource.relationships.service_instance.data.guid
+        }});
+        this.getPlans = BatchRequest.create({logger, target, url: '/v3/service_plans' });
+        this.getOfferings = BatchRequest.create({logger, target, url: '/v3/service_offerings' });
+    }
+
+    async resolve(name, binding) {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        await this.initPromise;
+
+        const target = this.target;
+
+        let {instance, key, apiEndpoint, org, space} = binding;
+        key = key || `${instance}-key`;
+        name = name || `${instance}:${key}`;
+
+        if (apiEndpoint && apiEndpoint !== target.apiEndpoint) {
+            throw new Error(`Current Cloud Foundry api endpoint "${target.apiEndpoint}" doesn't match with requested api endpoint "${apiEndpoint}" for service binding "${name}".`);
+        }
+
+        let spaceGuid;
+        if (org && space) {
+            const orgObj = await this.getOrg({ names: org });
+            const spaceObj = await this.getSpace({ names: space, organization_guids: orgObj.guid });
+            spaceGuid = spaceObj.guid;
+        } else {
+            org = target.org;
+            space = target.space;
+            spaceGuid = target.spaceGuid;
+        }
+
+        let instanceObj;
+        try {
+            instanceObj = await this.getInstance({ names: instance, space_guids: spaceGuid });
+        } catch(error) {
+            throw new Error(`Service instance "${instance}" not found.`);
+        }
+        let keyObj;
+        try {
+            keyObj = await this.getKey({names: key, service_instance_guids: instanceObj.guid });
+        } catch(error) {
+            throw new Error(`No service key "${key}" found for service instance "${instance}".`);
+        }
+        const planObj = await this.getPlans({guids: instanceObj.relationships.service_plan.data.guid});
+        const offeringObj = await this.getOfferings({guids: planObj.relationships.service_offering.data.guid });
+        const keyCredentialsObj = await req(this.logger, target, `/v3/service_credential_bindings/${encodeURIComponent(keyObj.guid)}/details`);
+        const resolvedBinding = {
+            binding: {
+                type: "cf",
+                apiEndpoint: target.apiEndpoint,
+                org: org,
+                space: space,
+                instance: instance,
+                key: key,
+                vcap: {
+                    label: offeringObj.name,
+                    plan: planObj.name,
+                },
+                resolved: true,
+            },
+            credentials: keyCredentialsObj.credentials
+        };
+
+        return resolvedBinding;
+    }
+
+    getRequiresNameFromKind(service, kind) {
+        const requiresName = KindToRequiresNameMap[kind];
+        if (!requiresName) throw new Error(`Unknown CDS service name for service "${service}". Please specify as argument for "cds bind".`)
+        return requiresName;
+    }
+
+    /**
+     * Determine kind value for services based on VCAP binding
+     * information in the configuration.
+     */
+    determineKinds(services) {
+        const vcapServices = {}
+
+        const getIndex = service => {
+            const { credentials } = service;
+            return credentials && credentials.binding && credentials.binding.index;
+        }
+
+        // Build VCAP_SERVICES
+        for (let index = 0; index<services.length; index++) {
+            const service = services[index];
+            const { label, name, tags } = service.binding.vcap;
+            if (!vcapServices[label]) vcapServices[label] = [];
+            vcapServices[label].push({ credentials: { binding: { index } }, label, name, tags });
+
+            service.kindCandidates = [ ]
+            service.nameCandidates = [ ]
+        }
+
+        // Auto configure services based on VCAP_SERVICES
+        const cds = require('@sap/cds/lib');
+        const VCAP_SERVICES = process.env.VCAP_SERVICES;
+        try {
+            process.env.VCAP_SERVICES = JSON.stringify(vcapServices);
+            const env = cds.env.for('cds', '.');
+
+            // Extract "kind" from auto configured services
+            for (const kind of Object.keys(env.requires)) {
+                const requireService = env.requires[kind];
+                const superKind = requireService.kind;
+                const index = getIndex(requireService);
+                if (!Number.isInteger(index)) continue;
+
+                const superRequireService = env.requires[superKind];
+                if (superRequireService) {
+                    const superIndex = getIndex(superRequireService);
+                    if (index === superIndex) continue;
+                }
+
+                services[index].kindCandidates.push(kind);
+            }
+
+            // Check if one "kind" per service was found
+            for (const service of services) {
+                if (service.kindCandidates.length !== 1) {
+                    throw new Error(`Unknown kind for service "${service.binding.instance}". Please specify with "--kind" option.`);
+                }
+
+                service.kind = service.kindCandidates[0];
+                delete service.kindCandidates;
+            }
+        } finally {
+            process.env.VCAP_SERVICES = VCAP_SERVICES;
+        }
+    }
+}
+
+class BatchRequest {
+    constructor({logger, target, url, extractors = {}}) {
+        this.logger = logger;
+        this.target = target;
+        this.url = url;
+        this.filters = [];
+        this.timeout = undefined;
+        this.extractors = Object.assign({ names: resource => resource.name, guids: resource => resource.guid }, extractors);
+    }
+
+    static create(options) {
+        const obj = new BatchRequest(options);
+        return (...args) => obj.request(...args);
+    }
+
+    async request(filter) {
+        let resolve;
+        let reject;
+        const promise = new Promise( (_resolve, _reject) => {
+            resolve = _resolve;
+            reject  = _reject;
+        });
+        this.filters.push({ filter, resolve, reject });
+
+        if (this.timeout) clearTimeout(this.timeout);
+        this.timeout = setTimeout(() => this.executeRequest(), 0);
+
+        return promise;
+    }
+
+    async executeRequest() {
+        const filters = this.filters;
+        this.filters = [];
+        const filterParams = {};
+        for (const filter of filters) {
+            for (const name of Object.keys(filter.filter)) {
+                if (!filterParams[name]) filterParams[name] = [];
+                filterParams[name].push(filter.filter[name]);
+            }
+        }
+
+        const params = Object.keys(filterParams).map(
+            name => `${name}=${filterParams[name].map( value => encodeURIComponent(value) ).join(',')}`
+        ).join("&");
+
+        const url = this.url + (this.url.match(/\?/) ? '&' : '?') + params;
+
+        let data;
+        try {
+            data = await this.httpRequest(url);
+        } catch (error) {
+            for (const filter of filters) {
+                filter.reject(error);
+            }
+            return;
+        }
+        const fmt = filter => Object.keys(filter).map( key => `${key}: ${filter[key]}` ).join(', ');
+        const resources = data.resources;
+        for (const filter of filters) {
+            let filteredResources = resources;
+            for (const name of Object.keys(filter.filter)) {
+                filteredResources = filteredResources.filter( resource => this.extractors[name](resource) === filter.filter[name] );
+            }
+            if (filteredResources.length === 1) {
+                filter.resolve(filteredResources[0]);
+            } else if (filteredResources.length === 0) {
+                filter.reject(new Error(`Couldn't find resource for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+            } else {
+                filter.reject(new Error(`Found more than one resources for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+            }
+        }
+    }
+
+    async httpRequest(urlPath) {
+        return req(this.logger, this.target, urlPath);
+    }
+}
+
+async function req(logger, target, urlPath) {
+    const url = new URL(urlPath, target.apiEndpoint);
+
+    logger.debug(`_req: ${url.toString()}`);
+
+    const result = await axios.get(url.toString(), {
+        headers: {
+            authorization: target.authorization
+        }
+    });
+
+    return result.data;
+}
+
+module.exports = new CFKeyProvider();

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -0,0 +1,144 @@
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+
+const { fse } = require('@sap/cds-foss');
+const { highlight, warn } = require('../util/term');
+
+const commandUtil = require('../init/util/commandUtil');
+
+const CDSRC_FILENAME = '.cdsrc-private.json';
+const GIT_IGNORE_FILE = '.gitignore';
+
+class UserCdsrcJsonStorageProvider {
+
+    async askBooleanQuestion(question) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        question = question.trim() + ' ';
+        return new Promise(resolve => {
+            rl.question(question, answer => {
+                if (answer === 'y' || answer === 'Y') {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+                rl.close();
+            });
+        });
+    }
+
+    async ensureFileIsGitignored(file, logger = console) {
+        try {
+            await commandUtil.spawnCommand('git', ['check-ignore', '-n', '-v', file], {}, undefined, true);
+            return; // file is git ignored
+        } catch (err) {
+            if (err.code === 'ENOENT') {   // git command not found
+                logger.debug('git command not found');
+                return;
+            }
+
+            if (!err.stdLog.match(/::/)) {   // included or not a git repo
+                logger.debug(err);
+                return;
+            }
+        }
+
+        logger.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
+        let gitignore = await this.readFileSafely(GIT_IGNORE_FILE);
+        gitignore = gitignore + `
+# added by cds bind
+${file}
+`;
+        await fse.writeFile(GIT_IGNORE_FILE, gitignore, 'utf8');
+    }
+
+    async readFileSafely(file) {
+        try {
+            return await fse.readFile(file, 'utf8');
+        } catch (err) {
+            return '';
+        }
+    }
+
+    async storeServices(services, options = {}) {
+        let jsonPath = options['output-file'] || CDSRC_FILENAME;
+
+        if (jsonPath === CDSRC_FILENAME) {
+            await this.ensureFileIsGitignored(CDSRC_FILENAME, options.logger);
+        }
+
+        jsonPath = jsonPath.replace(/~/g, os.homedir());
+        // const stat = await fse.stat(jsonPath);
+        if (path.extname(jsonPath) !== '.json') {
+            jsonPath = path.join(jsonPath, '.cdsrc.json');
+        }
+
+        // if (options['save-credentials'] && services.find(service => service.credentials) && process.stdin.isTTY) {
+        //     const answer = await this.askBooleanQuestion(warn(`IF YOU CONTINUE, SENSITIVE DATA WILL BE WRITTEN TO AN UNENCRYPTED FILE [${jsonPath}]! Do you want to continue [y/N] ?`));
+        //     if (!answer) {
+        //         options.logger.log(`aborting cds bind; not writing any sensitive data to file [${jsonPath}]`);
+        //         return;
+        //     }
+        // }
+
+        const jsonObject = await this.readJsonSafely(jsonPath);
+        let cdsRoot;
+        if (path.basename(jsonPath) === 'package.json') {
+            jsonObject.cds = jsonObject.cds || {};
+            cdsRoot = jsonObject.cds;
+        } else {
+            cdsRoot = jsonObject;
+        }
+
+        const profileKey = `[${options.profile}]`;
+        cdsRoot.features = cdsRoot.features || {};
+        cdsRoot.features[profileKey] = cdsRoot.features[profileKey] || {};
+        cdsRoot.features[profileKey].emulate_vcap_services = true;
+
+        cdsRoot.requires = cdsRoot.requires || {};
+        let section;
+        if (options.profile) {
+            section = cdsRoot.requires[profileKey] = cdsRoot.requires[profileKey] || {};
+        } else {
+            section = cdsRoot.requires;
+        }
+
+        for (const service of services) {
+            const { name, kind, binding, credentials } = service;
+            const requireService = section[name] = section[name] || {};
+
+            Object.assign(requireService, { kind, binding, credentials });
+
+            options.logger.log(`Binding ${highlight(name)} to Cloud Foundry service ${highlight(binding.instance)} key ${highlight(binding.key)} with kind ${highlight(kind)}.`);
+        }
+
+        await this.writeJsonFile(jsonPath, jsonObject, options.logger);
+        if (options.profile) {
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.profile)} .`);
+        } else {
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)}.`);
+        }
+    }
+
+    async readJsonSafely(filePath) {
+        try {
+            return await fse.readJSON(filePath) || {};
+        } catch (err) {
+            return {};
+        }
+    }
+
+    async writeJsonFile(filePath, content) {
+        await fse.outputJSON(filePath, content, {
+            spaces: 2
+        });
+
+        await fse.chmod(filePath, 0o600); // -rw-------
+    }
+}
+
+module.exports = new UserCdsrcJsonStorageProvider();

package/lib/client/activate.js

@@ -20,11 +20,7 @@ const JOB_STATUS = {
 };
 
 async function checkFinished(jobId, statusUrl, params, finisher) {
-    const requestOptions = Object.assign({
-        method: 'GET'
-    }, params.get('reqAuth'));
-
-    const { status, error } = (await axios(statusUrl, requestOptions)).data;
+    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;
@@ -170,7 +166,6 @@ module.exports = class Activate extends BaseCommand {
 
             activationUrl = Activate.getMtxApiUrl(params.get('appUrl'), COMMAND_URL_SUFFIX);
             const requestOptions = Object.assign({
-                method: 'POST',
                 headers: {},
                 data: {
                     extension: [...allFiles],
@@ -179,7 +174,7 @@ module.exports = class Activate extends BaseCommand {
             }, params.get('reqAuth'));
             requestOptions.headers['Content-Type'] = 'application/json';
 
-            return axios(activationUrl, requestOptions);
+            return axios.post(activationUrl, requestOptions);
         })
         .then(response => {
             if (response === null) {
@@ -227,7 +222,6 @@ module.exports = class Activate extends BaseCommand {
 
         const customFileUrl = Activate.getMtxApiUrl(params.get('appUrl'), Activate.UPDATE_CUSTOM_FILE_URL_SUFFIX);
         const requestOptions = Object.assign({
-            method: 'POST',
             headers: {},
             data: {
                 content: customFilesSerialized
@@ -235,7 +229,7 @@ module.exports = class Activate extends BaseCommand {
         }, params.get('reqAuth'));
         requestOptions.headers['Content-Type'] = 'application/json';
 
-        await axios(customFileUrl, requestOptions);
+        await axios.post(customFileUrl, requestOptions);
 
         Logger.log('Custom file upload finished');
     }