@alkimia/framework 0.1.0

package/components/mocked-services/node_modules/node-dev/README.md

@@ -0,0 +1,178 @@
+[![Build Status](https://secure.travis-ci.org/fgnass/node-dev.png)](http://travis-ci.org/fgnass/node-dev)
+
+### node-dev (1)
+
+Node-dev is a development tool for [Node.js](http://nodejs.org) that
+automatically restarts the node process when a file is modified.
+
+In contrast to tools like [supervisor](https://github.com/isaacs/node-supervisor) or [nodemon](https://github.com/remy/nodemon) it doesn't scan the filesystem for files to be watched. Instead it hooks into Node's `require()` function to watch only the files that have been _actually required_.
+
+This means that you don't have to configure any include- or exclude rules. If you modify a JS file that is solely used on the client-side but never run on the server, **node-dev will know** this and won't restart the process.
+
+This also means that you **don't have to** configure any file extensions. Just require a `.json` file or a `.ts` script for example and it will be watched. Automatically.
+
+# Usage
+
+Just run `node-dev` as you would normally run `node`:
+
+```
+node-dev server.js
+```
+
+## TypeScript support
+
+You can use node-dev to watch and restart TypeScript projects. Install [ts-node](https://www.npmjs.com/package/ts-node) as dev-dependency, then use node-dev to run your script:
+
+```
+node-dev src/server.ts
+```
+
+## Command-line options
+
+There are a couple of command-line options that can be used to control which files are watched and what happens when they change:
+
+- `--clear` - Clear the screen on restart
+- `--debounce` - Debounce change events by time in milliseconds (non-polling mode, default: 10)
+- `--dedupe` - [Dedupe dynamically](https://www.npmjs.org/package/dynamic-dedupe)
+- `--deps`:
+  - `-1` - Watch the whole dependency tree
+  - `0` - Watch only the project's own files and linked modules (via `npm link`)
+  - `1` (_Default_) - Watch all first level dependencies
+  - `<number> ` - Number of levels to watch
+- `--fork` - Hook into child_process.fork
+- `--graceful_ipc <msg>` - Send 'msg' as an IPC message instead of SIGTERM for restart/shutdown
+- `--ignore` - A file whose changes should not cause a restart
+- `--interval` - Polling interval in milliseconds (default: 1000)
+- `--notify=false` - Disable desktop notifications
+- `--poll` - Force polling for file changes (Caution! CPU-heavy!)
+- `--respawn` - Keep watching for changes after the script has exited
+- `--timestamp` - The timestamp format to use for logging restarts
+- `--vm` - Load files using Node's VM
+
+## Passing arguments to node
+
+All command-line arguments that are not `node-dev` options are passed on to the `node` process.
+
+Please note: you may need to separate your script from other command line options with `--`, for example:
+
+`node-dev --some-node-args -- my-script.js`
+
+# Installation
+
+`node-dev` can be installed via `npm`. Installing it with the `-g` option will allow you to use it anywhere you would use `node`.
+
+```
+npm install -g node-dev
+```
+
+### Desktop Notifications
+
+Status and error messages can be displayed as desktop notification using
+[node-notifier](https://www.npmjs.org/package/node-notifier):
+
+![Screenshot](./images/node-dev.png)
+
+![Screenshot](./images/node-dev-linux.png)
+
+**Requirements:**
+
+- Mac OS X: >= 10.8
+- Linux: `notify-osd` or `libnotify-bin` installed (Ubuntu should have this by default)
+- Windows: >= 8, or task bar balloons for Windows < 8
+
+# Config file
+
+Upon startup node-dev looks for a `.node-dev.json` file in the following directories:
+
+- the user's home directory
+- the current working directory
+- the same directory as the script to run
+
+Settings found later in the list will overwrite previous options.
+
+## Configuration options
+
+Usually node-dev doesn't require any configuration at all, but there are some options you can set to tweak its behaviour:
+
+- `clear` – Whether to clear the screen upon restarts. _Default:_ `false`
+- `dedupe` – Whether modules should by [dynamically deduped](https://www.npmjs.org/package/dynamic-dedupe). _Default:_ `false`
+- `deps` – How many levels of dependencies should be watched. _Default:_ `1`
+- `fork` – Whether to hook into [child_process.fork](http://nodejs.org/docs/latest/api/child_process.html#child_process_child_process_fork_modulepath_args_options) (required for [clustered](http://nodejs.org/docs/latest/api/cluster.html) programs). _Default:_ `true`
+- `graceful_ipc` - Send the argument provided as an IPC message instead of SIGTERM during restart events. _Default:_ `""` (off)
+- `ignore` - A single file or an array of files to ignore. _Default:_ `[]`
+- `notify` – Whether to display desktop notifications. _Default:_ `true`
+- `poll` - Force polling for file changes, this can be CPU-heavy. _Default:_ `false`
+- `respawn` - Keep watching for changes after the script has exited. _Default:_ `false`
+- `timestamp` – The timestamp format to use for logging restarts. _Default:_ `"HH:MM:ss"`
+- `vm` – Whether to watch files loaded via Node's [VM](http://nodejs.org/docs/latest/api/vm.html) module. _Default:_ `true`
+
+### ESModules
+
+When using ESModule syntax and `.mjs` files, `node-dev` will automatically use a loader to know which files to watch.
+
+### Dedupe linked modules
+
+Sometimes you need to make sure that multiple modules get _exactly the same instance_ of a common (peer-) dependency. This can usually be achieved by running `npm dedupe` – however this doesn't work when you try to `npm link` a dependency (which is quite common during development). Therefore `node-dev` provides a `--dedupe` switch that will inject the [dynamic-dedupe](https://www.npmjs.org/package/dynamic-dedupe) module into your app.
+
+### Transpilers
+
+You can use `node-dev` to run transpiled languages like TypeScript. You can either use a `.js` file as entry point to your application that registers your transpiler as a require-extension manually, for example by calling `CoffeeScript.register()` or you can let node-dev do this for you.
+
+There is a config option called `extensions` which maps file extensions to compiler module names. By default the map looks like this:
+
+```json
+{
+  "coffee": "coffee-script/register",
+  "ls": "LiveScript",
+  "ts": "ts-node/register"
+}
+```
+
+This means that if you run `node-dev server.ts` node-dev will do a
+`require("ts-node/register")` before running your script. You need
+to have `ts-node` installed as a dependency of your package.
+
+Options can be passed to a transpiler by providing an object containing `name` and `options` attributes:
+
+```json
+{
+  "js": {
+    "name": "babel-core/register",
+    "options": {
+      "only": ["lib/**", "node_modules/es2015-only-module/**"]
+    }
+  }
+}
+```
+
+### Graceful restarts
+
+Node-dev sends a `SIGTERM` signal to the child-process if a restart is required. If your app is not listening for these signals `process.exit(0)` will be called immediately. If a listener is registered, node-dev assumes that your app will exit on its own once it is ready.
+
+Windows does not handle POSIX signals, as such signals such as `SIGTERM` cause the process manager to unconditionally terminate the application with no chance of cleanup. In this case, the option `graceful_ipc` may be used. If this option is defined, the argument provided to the option will be sent as an IPC message via `child.send("<graceful_ipc argument>")`. The child process can listen and
+handle this event with:
+
+```javascript
+process.on('message', function (msg) {
+  if (msg === '<graceful_ipc argument>') {
+    // Gracefully shut down here
+    doGracefulShutdown();
+  }
+});
+```
+
+### Ignore paths
+
+If you’d like to ignore certain paths or files from triggering a restart, list them in the `.node-dev.json` configuration under `"ignore"` like this:
+
+```json
+{
+  "ignore": ["client/scripts", "shared/module.js"]
+}
+```
+
+This can be useful when you are running an isomorphic web app that shares modules between the server and the client.
+
+## License
+
+MIT

package/components/mocked-services/node_modules/node-dev/bin/node-dev

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+const dev = require('../lib');
+const cli = require('../lib/cli');
+
+const {
+  script,
+  scriptArgs,
+  nodeArgs,
+  opts
+} = cli(process.argv);
+
+dev(script, scriptArgs, nodeArgs, opts);

package/components/mocked-services/node_modules/node-dev/lib/cfg.js

@@ -0,0 +1,47 @@
+const { existsSync, readFileSync } = require('fs');
+const { dirname, resolve } = require('path');
+
+const resolveMain = require('./resolve-main');
+
+const defaultConfig = {
+  clear: false,
+  debounce: 10,
+  dedupe: false,
+  deps: 1,
+  extensions: {
+    coffee: 'coffeescript/register',
+    ls: 'LiveScript',
+    ts: 'ts-node/register'
+  },
+  fork: true,
+  graceful_ipc: '',
+  ignore: [],
+  interval: 1000,
+  notify: true,
+  poll: false,
+  respawn: false,
+  timestamp: 'HH:MM:ss',
+  vm: true
+};
+
+function read(dir) {
+  const f = resolve(dir, '.node-dev.json');
+  return existsSync(f) ? JSON.parse(readFileSync(f)) : {};
+}
+
+function getConfig(script) {
+  const main = resolveMain(script);
+  const dir = main ? dirname(main) : '.';
+
+  return Object.assign(
+    defaultConfig,
+    read(process.env.HOME || process.env.USERPROFILE),
+    read(process.cwd()),
+    read(dir)
+  );
+}
+
+module.exports = {
+  defaultConfig,
+  getConfig
+};

package/components/mocked-services/node_modules/node-dev/lib/clear.js

@@ -0,0 +1,4 @@
+const control = '\u001bc';
+const clearFactory = clear => (clear ? () => process.stdout.write(control) : () => {});
+
+module.exports = { clearFactory, control };

package/components/mocked-services/node_modules/node-dev/lib/cli.js

@@ -0,0 +1,79 @@
+const assert = require('assert');
+const minimist = require('minimist');
+const { resolve } = require('path');
+
+const { getConfig } = require('./cfg');
+
+const arrayify = v => (Array.isArray(v) ? [...v] : [v]);
+const argify = key => ({ arg: `--${key}`, key });
+
+const resolvePath = p => resolve(process.cwd(), p);
+
+const nodeAlias = { require: 'r' };
+const nodeBoolean = ['expose_gc', 'preserve-symlinks'];
+const nodeCustom = ['inspect', 'inspect-brk', 'no-warnings'];
+const nodeString = ['require'];
+
+const nodeDevBoolean = ['clear', 'dedupe', 'fork', 'notify', 'poll', 'respawn', 'vm'];
+const nodeDevNumber = ['debounce', 'deps', 'interval'];
+const nodeDevString = ['graceful_ipc', 'ignore', 'timestamp'];
+
+const alias = Object.assign({}, nodeAlias);
+const boolean = [...nodeBoolean, ...nodeDevBoolean];
+const string = [...nodeString, ...nodeDevString];
+
+const nodeArgsReducer =
+  opts =>
+  (out, { arg, key }) => {
+    const value = opts[key];
+
+    if (typeof value === 'boolean') {
+      value && out.push(arg);
+    } else if (typeof value !== 'undefined') {
+      arrayify(value).forEach(v => {
+        if (arg.includes('=')) {
+          out.push(`${arg.split('=')[0]}=${v}`);
+        } else {
+          out.push(`${arg}=${v}`);
+        }
+      });
+    }
+
+    delete opts[key];
+
+    return out;
+  };
+
+const nodeCustomFactory = args => arg => {
+  const isNodeCustom = nodeCustom.includes(arg.substring(2));
+  if (isNodeCustom) args.push(arg);
+  return !isNodeCustom;
+};
+
+const unknownFactory = args => arg => {
+  const [, key] = Object.keys(minimist([arg]));
+  key && !nodeDevNumber.includes(key) && args.push({ arg, key });
+};
+
+module.exports = argv => {
+  const nodeCustomArgs = [];
+  const args = argv.slice(2).filter(nodeCustomFactory(nodeCustomArgs));
+
+  const unknownArgs = [];
+  const unknown = unknownFactory(unknownArgs);
+
+  const {
+    _: [script, ...scriptArgs]
+  } = minimist(args, { alias, boolean, string, unknown });
+
+  assert(script, 'Could not parse command line arguments');
+
+  const opts = minimist(args, { alias, boolean, default: getConfig(script) });
+  const nodeArgs = [...nodeBoolean.map(argify), ...nodeString.map(argify), ...unknownArgs]
+    .sort((a, b) => a.key - b.key)
+    .reduce(nodeArgsReducer(opts), [...nodeCustomArgs]);
+
+  opts.ignore = arrayify(opts.ignore).map(resolvePath);
+
+  return { nodeArgs, opts, script, scriptArgs };
+};

package/components/mocked-services/node_modules/node-dev/lib/dedupe.js

@@ -0,0 +1 @@
+require('dynamic-dedupe').activate();

package/components/mocked-services/node_modules/node-dev/lib/hook.js

@@ -0,0 +1,60 @@
+const vm = require('vm');
+
+module.exports = (patchVM, callback) => {
+  // Hook into Node's `require(...)`
+  updateHooks();
+
+  // Patch the vm module to watch files executed via one of these methods:
+  if (patchVM) {
+    patch(vm, 'createScript', 1);
+    patch(vm, 'runInThisContext', 1);
+    patch(vm, 'runInNewContext', 2);
+    patch(vm, 'runInContext', 2);
+  }
+
+  /**
+   * Patch the specified method to watch the file at the given argument
+   * index.
+   */
+  function patch(obj, method, optionsArgIndex) {
+    const orig = obj[method];
+    if (!orig) return;
+    obj[method] = function () {
+      const opts = arguments[optionsArgIndex];
+      let file = null;
+      if (opts) {
+        file = typeof opts === 'string' ? opts : opts.filename;
+      }
+      if (file) callback(file);
+      return orig.apply(this, arguments);
+    };
+  }
+
+  /**
+   * (Re-)install hooks for all registered file extensions.
+   */
+  function updateHooks() {
+    Object.keys(require.extensions).forEach(ext => {
+      const fn = require.extensions[ext];
+      if (typeof fn === 'function' && fn.name !== 'nodeDevHook') {
+        require.extensions[ext] = createHook(fn);
+      }
+    });
+  }
+
+  /**
+   * Returns a function that can be put into `require.extensions` in order to
+   * invoke the callback when a module is required for the first time.
+   */
+  function createHook(handler) {
+    return function nodeDevHook(module, filename) {
+      if (!module.loaded) callback(module.filename);
+
+      // Invoke the original handler
+      handler(module, filename);
+
+      // Make sure the module did not hijack the handler
+      updateHooks();
+    };
+  }
+};

package/components/mocked-services/node_modules/node-dev/lib/ignore.js

@@ -0,0 +1,24 @@
+const n = 'node_modules';
+
+/**
+ * Returns the nesting-level of the given module.
+ * Will return 0 for modules from the main package or linked modules,
+ * a positive integer otherwise.
+ */
+const getLevel = mod => getPrefix(mod).split(n).length - 1;
+
+/**
+ * Returns the path up to the last occurence of `node_modules` or an
+ * empty string if the path does not contain a node_modules dir.
+ */
+const getPrefix = mod => {
+  const i = mod.lastIndexOf(n);
+  return i !== -1 ? mod.slice(0, i + n.length) : '';
+};
+
+const isPrefixOf = value => prefix => value.startsWith(prefix);
+
+const configureDeps = deps => required => deps !== -1 && getLevel(required) > deps;
+const configureIgnore = ignore => required => ignore.some(isPrefixOf(required));
+
+module.exports = { configureDeps, configureIgnore };

package/components/mocked-services/node_modules/node-dev/lib/index.js

@@ -0,0 +1,161 @@
+const { fork } = require('child_process');
+const filewatcher = require('filewatcher');
+const { join } = require('path');
+const semver = require('semver');
+const { pathToFileURL } = require('url');
+
+const { clearFactory } = require('./clear');
+const { configureDeps, configureIgnore } = require('./ignore');
+const ipc = require('./ipc');
+const localPath = require('./local-path');
+const logFactory = require('./log');
+const notifyFactory = require('./notify');
+const resolveMain = require('./resolve-main');
+
+module.exports = function (
+  script,
+  scriptArgs,
+  nodeArgs,
+  {
+    clear,
+    debounce,
+    dedupe,
+    deps,
+    graceful_ipc: gracefulIPC,
+    ignore,
+    interval,
+    notify: notifyEnabled,
+    poll: forcePolling,
+    respawn,
+    timestamp
+  }
+) {
+  if (!script) {
+    console.log('Usage: node-dev [options] script [arguments]\n');
+    process.exit(1);
+  }
+
+  if (typeof script !== 'string' || script.length === 0) {
+    throw new TypeError('`script` must be a string');
+  }
+
+  if (!Array.isArray(scriptArgs)) {
+    throw new TypeError('`scriptArgs` must be an array');
+  }
+
+  if (!Array.isArray(nodeArgs)) {
+    throw new TypeError('`nodeArgs` must be an array');
+  }
+
+  const clearOutput = clearFactory(clear);
+
+  const log = logFactory({ timestamp });
+  const notify = notifyFactory(notifyEnabled, log);
+
+  const isIgnored = configureIgnore(ignore);
+  const isTooDeep = configureDeps(deps);
+
+  // Run ./dedupe.js as preload script
+  if (dedupe) process.env.NODE_DEV_PRELOAD = localPath('dedupe');
+
+  const watcher = filewatcher({ debounce, forcePolling, interval });
+  let isPaused = false;
+
+  // The child_process
+  let child;
+
+  watcher.on('change', file => {
+    clearOutput();
+    notify('Restarting', `${file} has been modified`);
+    watcher.removeAll();
+    isPaused = true;
+    if (child) {
+      // Child is still running, restart upon exit
+      child.on('exit', start);
+      stop();
+    } else {
+      // Child is already stopped, probably due to a previous error
+      start();
+    }
+  });
+
+  watcher.on('fallback', limit => {
+    log.warn('node-dev ran out of file handles after watching %s files.', limit);
+    log.warn('Falling back to polling which uses more CPU.');
+    log.info('Run ulimit -n 10000 to increase the file descriptor limit.');
+    if (deps) log.info('... or add `--deps=0` to use fewer file handles.');
+  });
+
+  /**
+   * Run the wrapped script.
+   */
+  function start() {
+    isPaused = false;
+
+    const args = nodeArgs.slice();
+
+    args.push(`--require=${resolveMain(localPath('wrap'))}`);
+
+    const loaderName = semver.satisfies(process.version, '>=16.12.0') ? 'load' : 'get-format';
+
+    const loaderURL = pathToFileURL(resolveMain(localPath(join('loaders', `${loaderName}.mjs`))));
+
+    args.push(`--experimental-loader=${loaderURL.href}`);
+
+    child = fork(script, scriptArgs, {
+      cwd: process.cwd(),
+      env: process.env,
+      execArgv: args
+    });
+
+    if (respawn) {
+      child.respawn = true;
+    }
+
+    child.once('exit', code => {
+      if (!child.respawn) process.exit(code);
+      child.removeAllListeners();
+      child = undefined;
+    });
+
+    // Listen for `required` messages and watch the required file.
+    ipc.on(child, 'required', ({ required }) => {
+      if (!isPaused && !isIgnored(required) && !isTooDeep(required)) watcher.add(required);
+    });
+
+    // Upon errors, display a notification and tell the child to exit.
+    ipc.on(child, 'error', ({ error, message, willTerminate }) => {
+      notify(error, message, 'error');
+      stop(willTerminate);
+    });
+  }
+
+  function stop(willTerminate) {
+    child.respawn = true;
+    if (!willTerminate) {
+      if (gracefulIPC) {
+        log.info('Sending IPC: ' + JSON.stringify(gracefulIPC));
+        child.send(gracefulIPC);
+      } else {
+        child.kill('SIGTERM');
+      }
+    }
+  }
+
+  // Relay SIGTERM
+  process.on('SIGTERM', () => {
+    if (child && child.connected) {
+      if (gracefulIPC) {
+        log.info('Sending IPC: ' + JSON.stringify(gracefulIPC));
+        child.send(gracefulIPC);
+      } else {
+        child.kill('SIGTERM');
+      }
+    }
+
+    process.exit(0);
+  });
+
+  clearOutput();
+  start();
+};

package/components/mocked-services/node_modules/node-dev/lib/ipc.js

@@ -0,0 +1,17 @@
+const cmd = 'NODE_DEV';
+
+exports.on = (src, prop, cb) => {
+  src.on('internalMessage', m => {
+    if (m.cmd === cmd && prop in m) cb(m);
+  });
+};
+
+exports.relay = src => {
+  src.on('internalMessage', m => {
+    if (process.connected && m.cmd === cmd) process.send(m);
+  });
+};
+
+exports.send = m => {
+  if (process.connected) process.send({ ...m, cmd });
+};

package/components/mocked-services/node_modules/node-dev/lib/loaders/get-format.mjs

@@ -0,0 +1,21 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { send } from './ipc.mjs';
+
+const require = createRequire(import.meta.url);
+
+export async function getFormat(url, context, defaultGetFormat) {
+  const required = url.startsWith('file://') ? fileURLToPath(url) : url;
+
+  send({ required });
+
+  try {
+    return await defaultGetFormat(url, context, defaultGetFormat);
+  } catch (error) {
+    if (error.code !== 'ERR_UNKNOWN_FILE_EXTENSION') throw error;
+    return require('get-package-type')(required).then(format => {
+      if (!['builtin', 'commonjs'].includes(format)) throw error;
+      return { format };
+    });
+  }
+}

package/components/mocked-services/node_modules/node-dev/lib/loaders/ipc.mjs

@@ -0,0 +1,5 @@
+const cmd = 'NODE_DEV';
+
+export const send = m => {
+  if (process.connected) process.send({ ...m, cmd });
+};

package/components/mocked-services/node_modules/node-dev/lib/loaders/load.mjs

@@ -0,0 +1,21 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { send } from './ipc.mjs';
+
+const require = createRequire(import.meta.url);
+
+export async function load(url, context, defaultLoad) {
+  const required = url.startsWith('file://') ? fileURLToPath(url) : url;
+
+  send({ required });
+
+  try {
+    return await defaultLoad(url, context, defaultLoad);
+  } catch (error) {
+    if (error.code !== 'ERR_UNKNOWN_FILE_EXTENSION') throw error;
+    return require('get-package-type')(required).then(format => {
+      if (!['builtin', 'commonjs'].includes(format)) throw error;
+      return { format };
+    });
+  }
+}

package/components/mocked-services/node_modules/node-dev/lib/local-path.js

@@ -0,0 +1,2 @@
+const { join } = require('path');
+module.exports = f => join(__dirname, f);