@sap/cds-dk 4.9.6 → 6.0.2

package/lib/k8s/wrapFeature.js

@@ -0,0 +1,55 @@
+function wrapFeature(name, impl) {
+    return async function (context) {
+
+        const isRequired = once(async function () {
+            const features = await context.get('features');
+            const isRequired = impl.isRequired ? (context => impl.isRequired(context)) : (() => false);
+
+            return features.has(name) || await isRequired(context);
+        });
+
+        const init = once(async function () {
+            const enabled = await isRequired();
+            if (enabled && impl.init) await impl.init(context);
+            return enabled;
+        });
+
+        const handler = {
+            get(target, prop) {
+                if (typeof impl[prop] !== 'function') return undefined;
+
+                switch (prop) {
+                    case 'addToChart':
+                        return async (builder, values) => {
+                            if (impl.addToChart && values[name] && values[name].enabled !== false)
+                                return impl.addToChart(builder, values);
+                        }
+
+                    default:
+                        return async (...args) => {
+                            if (await init()) {
+                                return impl[prop](...args);
+                            }
+                        }
+                }
+            },
+        };
+
+        return new Proxy(impl, handler);
+    }
+}
+
+function once(func) {
+    let result;
+    let called;
+
+    return function () {
+        if (!called) {
+            result = func();
+            called = true;
+        }
+        return result;
+    }
+}
+
+module.exports = wrapFeature;

package/lib/k8s/xsuaa/index.js

@@ -0,0 +1,64 @@
+const { renderXsSecurityJson } = require('./lib');
+const wrapFeature = require('../wrapFeature');
+
+module.exports = wrapFeature('xsuaa', {
+    async getXsuaaRequiresServiceName(context) {
+        const env = await context.get('env');
+        if (env.requires.auth && env.requires.auth.kind === 'xsuaa') return 'auth';
+        else if (env.requires.uaa && env.requires.uaa.kind === 'xsuaa') return 'uaa';
+        else undefined;
+    },
+
+    async isRequired(context) {
+        return !!await this.getXsuaaRequiresServiceName(context)
+    },
+
+    async init(context) {
+        const model = await context.get('model');
+        const { services } = model;
+        delete services.auth;
+        delete services.xsuaa;
+        delete services.uaa;
+        // remove database bindings as they need a workaround
+        delete services.db;
+        delete services['db-mt'];
+
+        this.bindingName = await this.getXsuaaRequiresServiceName(context)
+    },
+
+    async getChartCapabilities(context) {
+        const model = await context.get('model');
+
+        return {
+            xsuaa: {
+                serviceOfferingName: 'xsuaa',
+                servicePlanName: 'application',
+                parameters: {
+                    xsappname: model.app.name
+                },
+                config: 'xs-security.json'
+            }
+        }
+    },
+
+    // eslint-disable-next-line no-unused-vars
+    async getServiceBindings(context) {
+        return {
+            [this.bindingName || 'auth']: {
+                serviceInstanceName: 'xsuaa'
+            }
+        }
+    },
+
+    async addToChart(builder, { xsuaa }) {
+        await builder.addAllTemplates(__dirname);
+
+        const { config } = xsuaa;
+        if (config) {
+            if (!await builder.addChartFile(config, { optional: true })) {
+                const xsSecurityJson = await renderXsSecurityJson(builder.rootPath, config);
+                await builder.writeChartFile(config, xsSecurityJson);
+            }
+        }
+    }
+});

package/lib/k8s/xsuaa/lib.js

@@ -0,0 +1,14 @@
+const { exec } = require("../../util/exec");
+
+async function renderXsSecurityJson(projectPath) {
+  const result = await exec({
+    cwd: projectPath,
+    stdio: ["inherit", "pipe", "inherit"],
+  })`cds compile srv -2 xsuaa`;
+  const xsSecurityJson = result.stdout;
+  return xsSecurityJson;
+}
+
+module.exports = {
+  renderXsSecurityJson
+};

package/lib/k8s/xsuaa/templates/xsuaa.yaml

@@ -0,0 +1 @@
+{{- include "cap.service-instance" . }}

package/lib/util/exec.js

@@ -1,6 +1,6 @@
 const { spawn, spawnSync } = require('child_process');
 
-const cds = require('@sap/cds/lib');
+const cds = require('../cds');
 const log = cds.log('exec');
 
 function* commandIterator(strs, args) {

package/lib/util/write.js

@@ -21,7 +21,7 @@ const USAGE = ()=>{ //NOSONAR
 	.then (write.to ('some/folder'))
 }
 
-const cds = require ('@sap/cds/lib')
+const cds = require('../cds')
 const { mkdirp, path, fs:{promises:fs} } = cds.utils, { join, dirname } = path
 
 

package/lib/watch/node-watch.js

@@ -9,9 +9,8 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   const emitter = new EventEmitter
 
   const killAndExit = (sig) => {
-    DEBUG && DEBUG('Signal:', sig)
-    emitter.emit('quit')
-    _kill (child, () => process.exit())
+    DEBUG && DEBUG('\nreceived signal:', sig)
+    _kill (child, process.exit)
   }
   process.on('SIGTERM', killAndExit)
   process.on('SIGINT', killAndExit)
@@ -21,6 +20,7 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   const restart = _coalesceEvents(delay, (events) => {
     DEBUG && DEBUG('>> Events:', events)
     _kill (child, () => {
+      DEBUG && console.trace('Restart')
       const execArgv = [...process.execArgv]
       events.forEach(evt => {
         if (evt.type && evt.type.startsWith('--')) execArgv.push(evt.type)
@@ -32,7 +32,7 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
       const updated = events.filter(evt => evt.type && evt.type === 'update').map(evt => evt.name)
       emitter.emit ('restart', updated)
       child = fork (script, { cwd, env, stdio:'inherit', execArgv }, (err)=>{
-        if (err) console.error (err)
+        if (err)  console.error (err)
       })
       child.on('message', msg => {
         if (msg === 'restart') return restart()
@@ -48,7 +48,7 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   const watch = require('node-watch')
   const include = RegExp(`\\.(${ext.replace(/,/g,'|')})$`)
   const filter = f => !ignore.test(f) && include.test(f)
-  watch (process.cwd(),{ recursive:true, filter, delay:0 }, restart)
+  watch (cwd||process.cwd(),{ recursive:true, filter, delay:0 }, restart)
 
   // Live commands...
   const readline = require('readline')
@@ -64,8 +64,8 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   })
 
   emitter.restart = restart
-  emitter.stop    = () => { _kill(child, () => false); child = undefined; }
-  emitter.setEnv = (name, value) => {
+  emitter.stop    = () => _kill(child, () => false)
+  emitter.setEnv  = (name, value) => {
     if (typeof value === "undefined") {
       delete env[name]
     } else {
@@ -98,16 +98,45 @@ function _coalesceEvents(delay, fn) {
   }
 }
 
-function _kill (proc, fn=()=>{}) {
-  if (!proc)  return fn()
+/*
+ * Ensures the given child process gets killed in different environments
+ */
+function _kill (proc, cb=()=>{}) {
+  if (!proc)  return cb()
+  if (proc[_pending])  return // safeguard against repeated calls for the same process
+  proc[_pending] = true
+  const fn = () => { delete proc[_pending]; return cb(); }
 
+  const waitTime = parseInt(process.env.CDS_WATCH_KILL_DELAY) || 500
   // On Windows, child_process.kill() abruptly kills the process (https://nodejs.org/api/child_process.html#subprocesskillsignal)
   // Server has cleanup code to run, so send a custom message and give it a bit time.
   if (process.platform === 'win32') {
-    proc.send({ exit: true }, () => {})
-    const waitTime = parseInt(process.env.CDS_WATCH_KILL_DELAY) || 500
-    setTimeout(()=> { proc.kill(); fn() }, waitTime)
-  } else {
-    proc.kill(); fn()
+    proc.send({ close: true }, () => {})  // see @sap/cds/bin/serve.js
+    setTimeout(()=> {
+      proc.kill()
+      DEBUG && DEBUG('Killed process', proc.pid)
+      fn()
+    }, waitTime)
+    return
   }
+
+  // first kill normally (using SIGTERM)
+  let killed = false
+  proc.on('exit',() => {
+    if (!killed) { killed = true
+      DEBUG && DEBUG('Killed process', proc.pid)
+      fn()
+    }
+  }).kill()
+
+  // fallback for misbehaving processes: SIGKILL it after some time
+  setTimeout(()=> {
+    if (!killed) { killed = true
+      proc.kill('SIGKILL')
+      DEBUG && DEBUG('Killed process (forcefully)', proc.pid)
+      fn()
+    }
+  }, waitTime)
 }
+
+const _pending = Symbol.for('sap.cds.watch.pendingKill')