@sap/cds-dk 4.5.0 → 4.6.0

package/bin/watch.js

@@ -1,6 +1,7 @@
+const watchOnlyOptions = ['--ext', '--livereload', '--open']
 module.exports = Object.assign ( watch, {
   flags: [ '--debug', '--in-memory', '--in-memory?' ],
-  options: [ '--port', '--ext', '--livereload', '--open' ],
+  options: [ '--port', ...watchOnlyOptions ],
   help: `
 # SYNOPSIS
 
@@ -61,15 +62,16 @@ async function watch ([cwd], {
   ext = extDefaults,
   ...options
 }={}) {
-
   args.push (`--${Object.keys(options).find(a => /^in-memory\??$/.test(a)) || 'in-memory?'}`)
-  args.push (...process.argv.slice(3).filter(a => a !== cwd))
-  const env = Object.assign (process.env, {
+  args.push (...process.argv.slice(3)
+    .filter(removeArgsIn(watchOnlyOptions))  // remove all watch-only options, as `cds serve` would not accept them
+    .filter(a => a !== cwd))
+
+  let env = Object.assign (process.env, {
     _args: JSON.stringify(args),
     _options: JSON.stringify(options)
   })
   if (typeof ext !== 'string')  ext = extDefaults
-  if ('port' in options) env.PORT = options.port
   env.NODE_PATH = path.resolve (__dirname,'../node_modules') // allow global sqlite to be resolved
 
   let liveReload //= ...
@@ -98,8 +100,12 @@ async function watch ([cwd], {
   log (`watching: ${ext}...`)
   if (liveReload) log (`live reload enabled for browsers`)
 
+  const bindingManager = new require('../lib/bind/bindingResolver').bindingManager({cwd})
+  const bindings = await bindingManager.resolve()
+  if (bindings) env = {...env, CDS_CONFIG: JSON.stringify(bindings)}
+
   const nodemon = require('../lib/watch/node-watch')
-  return nodemon ({
+  const watcher = nodemon ({
     watch: ['*','.env','.cdsrc.json'],
     script:__filename, cwd, env, ext, ignore,
     delay: parseInt(process.env.CDS_WATCH_DELAY) || 200,
@@ -109,12 +115,18 @@ async function watch ([cwd], {
     if (liveReload) liveReload.markPending(files)
     if (this.delayed) clearTimeout (this.delayed)
     this.delayed = setTimeout(()=>{
+      bindingManager.update({
+        onBeforeUpdate: () => watcher.stop(),
+        onAfterUpdate: bindings => {
+          watcher.setEnv('CDS_CONFIG', bindings && JSON.stringify(bindings))
+          watcher.restart()
+        }
+      })
       log (`${t.bold}        _______________________\n`)
       FileHandlers.changed (files,cwd)
     }, 111)
   }).on('quit', ()=>{
     log (`${t.bold+t.green}\n[cds] - my watch has ended.\n`)
-    process.exit()
   }).on('message', async (msg) => { switch (msg.code) { // messages from child process
     case 'listening':
       env.PORT = (msg.address && msg.address.port) || msg.port
@@ -125,6 +137,8 @@ async function watch ([cwd], {
     case 'EADDRINUSE': env.PORT = 0; _addr_in_use(msg); break
     default: console.error (msg)
   }})
+
+  return watcher
 }
 
 
@@ -143,7 +157,20 @@ const FileHandlers = {
   },
 }
 
-
+function removeArgsIn (toRemove) {
+  let argRemoved = false
+  return arg => { // filter function
+    if (toRemove.includes(arg)) {
+      argRemoved = true
+      return false
+    }
+    else if (argRemoved) {  // if next arg is a value, skip it as well
+      argRemoved = false
+      if (!arg.startsWith('-'))  return false
+    }
+    return true
+  }
+}
 
 //
 // Child process impl launched by watch
@@ -153,8 +180,17 @@ if (!module.parent) (async()=>{ // launched by nodemon
   // run through cli in order to use its error handling
   const bootstrap = require('./cds')(...JSON.parse(process.env._args))
   const {cds} = global
+
+  cds.once('listening', ({server, url}) => {
+    process.send ({ code:'listening', port: server.address().port })
+    // Need to give bindings an explicit call to purge,
+    // as its .exit handler has no chance to execute on Windows.
+    process.on ('message', (msg)=> { if (msg && msg.exit) { // see node-watch
+      (new cds.service.bindings(url)).purge()
+    }})
+  })
+
   try {
-    cds.once('listening', ({server}) => process.send ({ code:'listening', port: server.address().port }))
     await bootstrap
     if (!cds.service.providers.length) return _no_services_found()
   } catch (e) { switch (e.code) {

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();