@sap/cds-dk 4.6.4 → 4.8.0

package/lib/util/exec.js

@@ -0,0 +1,210 @@
+const { spawn, spawnSync } = require('child_process');
+
+const cds = require('@sap/cds/lib');
+const log = cds.log('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);
+
+    log.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 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 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
+}

package/lib/watch/livereload-server.js

@@ -14,46 +14,58 @@ module.exports = class LiveReload {
     app.use('/livereload.js', express.static(require.resolve('livereload-js')))
 
     return new Promise ((resolve, reject) => {
-      // start server
-      const server = app.listen (port,'localhost')
-      server.on('error', reject)
-      server.on('listening', async () => {
+      let server
+      const listening = async () => {
         const {address,port} = server.address()
+        startWs(server)
         this.url = await livereloadURL(address, port)
         debug && debug(`[cds] - live reload available at ${this.url}`)
         resolve(this.url)
+      }
+        // start server
+      server = app.listen (port,'localhost')
+      server.once('listening', listening)
+      server.on('error', e => {
+        // try once more w/ ephemeral port 0
+        if (e.code === 'EADDRINUSE') {
+          server = app.listen (0,'localhost')
+          server.once('listening', listening)
+          server.on('error', reject)
+        }
+        else reject(e)
       })
 
       // start websocket
-      this.wsServer = new ws.Server({ server })
-      this.wsServer.on('connection', (socket) => {
-        debug && debug('Client connected')
-        socket.on('message', (msg) => {
-          debug && debug('Client message', msg)
-          const request = JSON.parse(msg)
+      const startWs = (server) => {
+        this.wsServer = new ws.Server({ server })
+        this.wsServer.on('connection', (socket) => {
+          debug && debug('Client connected')
+          socket.on('message', (msg) => {
+            debug && debug('Client message', msg)
+            const request = JSON.parse(msg)
 
-          if (request.command === 'hello') {
-            debug && debug('Client handshake')
-            const data = JSON.stringify({
-              command: 'hello',
-              protocols: [
-                'http://livereload.com/protocols/official-7',
-                'http://livereload.com/protocols/official-8',
-                'http://livereload.com/protocols/official-9',
-                'http://livereload.com/protocols/2.x-origin-version-negotiation',
-                'http://livereload.com/protocols/2.x-remote-control',
-              ],
-              serverName: 'cds-watch',
-            })
-            socket.send(data)
-          } else if (request.command === 'info') {
-            debug && debug('Server received client data. Not sending response.')
-          }
+            if (request.command === 'hello') {
+              debug && debug('Client handshake')
+              const data = JSON.stringify({
+                command: 'hello',
+                protocols: [
+                  'http://livereload.com/protocols/official-7',
+                  'http://livereload.com/protocols/official-8',
+                  'http://livereload.com/protocols/official-9',
+                  'http://livereload.com/protocols/2.x-origin-version-negotiation',
+                  'http://livereload.com/protocols/2.x-remote-control',
+                ],
+                serverName: 'cds-watch',
+              })
+              socket.send(data)
+            } else if (request.command === 'info') {
+              debug && debug('Server received client data. Not sending response.')
+            }
+          })
         })
-      })
-      this.wsServer.on('close', () => { debug && debug('Socket closed') })
-      this.wsServer.on('error', (e) => debug && debug(e))
-
+        this.wsServer.on('close', () => { debug && debug('Socket closed') })
+        this.wsServer.on('error', (e) => debug && debug(e))
+      }
     })
   }
 

package/lib/watch/node-watch.js

@@ -1,3 +1,5 @@
+const DEBUG = /\bwatch\b/.test(process.env.DEBUG) && console.debug
+
 module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, options={} })=>{
 
   let child
@@ -5,19 +7,23 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
   // Phoning home...
   const EventEmitter = require('events')
   const emitter = new EventEmitter
-  process.on('exit', () => { gracefullyKill (child);  emitter.emit('quit') })
+  process.on('exit', () => { _kill (child);  emitter.emit('quit') })
 
   // Re-starting child process...
   const { fork } = require('child_process')
-  const restart = (evt, name)=>{
-    gracefullyKill (child, () => {
+  const restart = _coalesceEvents(delay, (events) => {
+    DEBUG && DEBUG('>> Events:', events)
+    _kill (child, () => {
       const execArgv = [...process.execArgv]
-      if (evt && evt.startsWith('--')) execArgv.push(evt)
-      if (name && name.startsWith('--')) execArgv.push(name)
+      events.forEach(evt => {
+        if (evt.type && evt.type.startsWith('--')) execArgv.push(evt.type)
+        if (evt.name && evt.name.startsWith('--')) execArgv.push(evt.name)
+      })
       if (options.debug) execArgv.push('--inspect')
       if (options['debug-brk']) execArgv.push('--inspect-brk')
-      const files = evt === "update" ? [ name ] : undefined
-      emitter.emit ('restart', files)
+
+      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)
       })
@@ -26,14 +32,16 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
         emitter.emit('message', msg)
       })
     })
-  }
+
+  })
+
   restart()
 
   // Watching for touched files...
   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 }, restart)
+  watch (process.cwd(),{ recursive:true, filter, delay:0 }, restart)
 
   // Live commands...
   const readline = require('readline')
@@ -44,12 +52,12 @@ module.exports = ({ cwd, script, ext, ignore=RegExp(), env={}, delay=200, option
     else if (input === 'break' || input === 'brk')  restart('--inspect-brk')
     else if (input === 'debug-brk')  restart('--inspect-brk')
     else if (input === 'ps') ps(child,env)
-    else if (input === 'bye' || input.match(/^n$/i)) { gracefullyKill (child, () => process.exit())  }
+    else if (input === 'bye' || input.match(/^n$/i)) { _kill (child, () => process.exit())  }
     else console.log ('?\n')
   })
 
   emitter.restart = restart
-  emitter.stop    = () => { gracefullyKill(child, () => false); child = undefined; }
+  emitter.stop    = () => { _kill(child, () => false); child = undefined; }
   emitter.setEnv = (name, value) => {
     if (typeof value === "undefined") {
       delete env[name]
@@ -67,14 +75,32 @@ const ps = (child,env) => console.log (`\x1b[32m
   \x1b[0m`
 )
 
-// On Windows, kill() abruptly kills the child process (https://nodejs.org/api/child_process.html#subprocesskillsignal)
-// Send a custom message an wait a bit to give cleanup code a chance to execute.
-const isWindows = (process.platform === 'win32')
-const waitTime = parseInt(process.env.CDS_WATCH_KILL_DELAY) || (isWindows ? 500 : 0)
-function gracefullyKill (proc, fn=()=>{}) {
-  if (proc)  {
-    proc.send({ exit: true }, () => { /* ignore */ })
-    setTimeout(()=> { proc.kill(); fn()}, waitTime)
+// reduces mutiple node-watch events in a time frame into a bulk
+function _coalesceEvents(delay, fn) {
+  let timer, cache = []
+  function handle() {
+    fn(cache)
+    timer = null
+    cache = []
+  }
+  return function(type, name) { // node-watch callback signature
+    cache.push({type, name})
+    if (!timer) {
+      timer = setTimeout(handle, delay);
+    }
+  }
+}
+
+function _kill (proc, fn=()=>{}) {
+  if (!proc)  return fn()
+
+  // 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()
   }
-  else fn()
 }

package/lib/watch/open.js

@@ -19,7 +19,7 @@ function _open(args) {
   // http://stackoverflow.com/q/1480971/3191, but see below for Windows.
   let platform = process.platform
 
-  // Attempt to detect Windows Subystem for Linux (WSL). WSL  itself as Linux (which works in most cases), but in
+  // Attempt to detect Windows Subsystem for Linux (WSL). WSL  itself as Linux (which works in most cases), but in
   // this specific case we need to treat it as actually being Windows. The 'Windows-way' of opening things through
   // cmd.exe works just fine here, whereas using xdg-open does not, since there is no X Windows in WSL.
   if (platform === 'linux' && os.release().indexOf('Microsoft') !== -1) {