@coderich/sandman 0.0.1

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./src/app');

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@coderich/sandman",
+  "version": "0.0.1",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "!__mocks__"
+  ],
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint ./",
+    "dev": "coderich-dev"
+  },
+  "dependencies": {
+    "@coderich/config": "2.2.4",
+    "@coderich/util": "2.1.3",
+    "chokidar": "4.0.3",
+    "lodash.merge": "4.6.2"
+  },
+  "devDependencies": {
+    "@coderich/dev": "0.5.3"
+  }
+}

package/src/ConfigClient.js

@@ -0,0 +1,25 @@
+const FS = require('fs');
+const Path = require('path');
+const Config = require('@coderich/config');
+
+module.exports = class ConfigClient extends Config {
+  mergeConfigDir(dir) {
+    const ignored = (parsed) => {
+      if (parsed.name.startsWith('.')) return true;
+      const stat = FS.statSync(Path.join(parsed.dir, `${parsed.name}${parsed.ext}`));
+      if (stat?.isDirectory()) return false;
+      return !['.yml', '.yaml'].includes(parsed.ext.toLowerCase());
+    };
+
+    const arr = Config.dirPaths(dir, ignored);
+
+    const yaml = arr.reduce((prev, { paths, data }) => {
+      const path = paths.join('.');
+      if (!path.length) return prev.concat(data);
+      const indented = data.split('\n').map(line => (line.trim() ? `  ${line}` : line)).join('\n');
+      return prev.concat(`${path}:\n${indented}`);
+    }, '');
+
+    return this.merge(Config.parseYaml(yaml));
+  }
+};

package/src/FetchService.js

@@ -0,0 +1,57 @@
+const Merge = require('lodash.merge');
+
+exports.fetch = (req) => {
+  return new Promise((resolve, reject) => {
+    const { url, ...params } = exports.normalizeRequest({ ...req });
+
+    fetch(url, params).then(async (res) => {
+      const ct = res.headers.get('content-type') || '';
+      const data = await (ct.includes('application/json') ? res.json() : res.text());
+      return { res, data };
+    }).then(resolve).catch(reject);
+  });
+};
+
+exports.normalizeRequest = (req) => {
+  req.method ??= 'get'; req.headers ??= {}; req.params ??= {};
+  req.url = Object.entries(req.params).reduce((url, [key, value]) => { url.searchParams.append(key, value); return url; }, new URL(req.url)).toString();
+  req.headers = Object.entries(req.headers).reduce((prev, [key, value]) => Object.assign(prev, { [key.toLowerCase()]: value }), {});
+  const [contentType] = req.headers['content-type']?.split(';') || [];
+  const { data } = req; delete req.data;
+  if (data == null) return req;
+
+  switch (contentType) {
+    case 'application/json': {
+      req.body = JSON.stringify(data);
+      break;
+    }
+    case 'application/x-www-form-urlencoded': {
+      req.body = new URLSearchParams(data).toString();
+      break;
+    }
+    case 'multipart/form-data': {
+      delete req.headers['content-type'];
+      // req.duplex = 'half';
+      req.body = Object.entries(data).reduce((form, [key, value]) => {
+        form.append(key, value);
+        return form;
+      }, new FormData());
+      break;
+    }
+    default: {
+      req.body = data;
+      break;
+    }
+  }
+
+  return req;
+};
+
+exports.decorateRequest = (mergeData, key, request) => {
+  const toMerge = key.split('.').reduce((prev, k, i, arr) => {
+    const $key = arr.slice(0, i).join('.');
+    return Merge(prev, mergeData[$key]?.request);
+  }, { ...mergeData.request });
+
+  return Merge(toMerge, request);
+};

package/src/Sandman.js

@@ -0,0 +1,197 @@
+const Path = require('path');
+const Readline = require('readline');
+const Chokidar = require('chokidar');
+const EventEmitter = require('events');
+const { get, flatten } = require('@coderich/util');
+const FetchService = require('./FetchService');
+const ConfigClient = require('./ConfigClient');
+
+module.exports = class Sandman extends EventEmitter {
+  #configClient; #configDir; #options; #watcher; #readline; #mergeData = {}; #cli;
+
+  constructor(configDir, options) {
+    super();
+    this.#configDir = configDir;
+    this.#options = options;
+    this.#configClient = new ConfigClient().merge(ConfigClient.parseDir(configDir, arg => this.#ignore(arg)));
+    this.#createInterface();
+    this.#createWatcher();
+    this.#createCLI();
+    this.#prompt();
+
+    this.#readline.on('line', async (line) => {
+      if (!line) return this.#readline.prompt();
+      const [cmd, ...args] = line.trim().split(' ');
+      const info = this.#cli[cmd] ? { cmd, args } : { cmd: 'run', args: [cmd, ...args] };
+      const value = await Promise.resolve(this.#cli[info.cmd](...info.args)).catch(e => e);
+      return this.emit(cmd, value);
+    });
+  }
+
+  cli() {
+    return this.#cli;
+  }
+
+  #run(key) {
+    const api = this.#get(key, {});
+    if (!api?.request) return this.emit('error', { key, error: `Request "${key}" Not Found` });
+    this.emit('request', { key, api });
+
+    return FetchService.fetch(api.request).then(({ res, data }) => {
+      this.emit('response', { key, api, res, data });
+      return { key, api, res, data };
+    }).catch((error) => {
+      this.emit('error', { key, api, error });
+      return Promise.reject(error);
+    }).then((results) => {
+      return results.res.ok ? results : Promise.reject(results);
+    });
+  }
+
+  #prompt() {
+    this.#readline.setPrompt(this.#configClient.get('prompt'));
+    this.#readline.prompt();
+    return this;
+  }
+
+  #get(key, ...rest) {
+    const { config } = this.#configClient.toObject();
+    const value = get(config, key);
+
+    if (value?.request) {
+      const request = FetchService.decorateRequest(this.#mergeData, key, value.request);
+      this.#configClient.merge({ [key]: { request } });
+    }
+
+    return this.#configClient.get(key, ...rest);
+  }
+
+  #createCLI() {
+    const self = this;
+
+    this.#cli = new Proxy({
+      run: (...args) => this.#run(...args),
+      get: (...args) => this.#get(...args),
+      set: (key = '', value = null) => this.#configClient.set(key, value),
+      del: (key = '') => this.#configClient.del(key),
+      quit: () => process.exit(),
+    }, {
+      get(obj, prop, receiver) {
+        const value = Reflect.get(obj, prop, receiver);
+
+        if (typeof value === 'function') {
+          return (...args) => {
+            const result = value(...args);
+            setImmediate(() => self.#prompt());
+            return result;
+          };
+        }
+
+        return value;
+      },
+    });
+  }
+
+  #createInterface() {
+    this.#readline = Readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      completer: (line) => {
+        // Show available CLI commands
+        if (!line) return [Object.keys(this.#cli), line];
+
+        const tokens = line.split(' ');
+        const lastToken = tokens.at(-1);
+        const paths = lastToken.split('.');
+        const path = paths.at(-1);
+
+        // Specific request data selector
+        if (lastToken.startsWith('.')) {
+          const api = this.#get(tokens.at(-2));
+          if (!api?.request) return [[], path];
+          const dataPath = ['request'].concat(paths.slice(1, -1)).join('.');
+          const data = get(api, dataPath, {});
+          return [Object.keys(data).filter(k => k.toLowerCase().startsWith(path.toLowerCase())), path];
+        }
+
+        //
+        const flatKeys = Object.keys(flatten(this.#configClient.get()));
+
+        // These keys follow the typing of the user
+        const startsWithCandidates = Array.from(new Set(flatKeys.map((flatKey) => {
+          return flatKey.split('.').slice(0, paths.length).join('.'); // So we can pluck off the last one
+        }))).filter((c) => {
+          return c.toLowerCase().startsWith(lastToken.toLowerCase());
+        }).map(p => p.split('.').at(-1)); // Here!
+
+        // These are shortcut keys to requests
+        const requestKeyCandidates = Array.from(new Set(flatKeys.map((flatKey) => {
+          const keys = flatKey.split('.');
+          const index = keys.indexOf('request');
+          const typedPath = keys.slice(0, paths.length - 1).join('.');
+          const autocompletePath = keys.slice(paths.length - 1, index).join('.');
+          return index > 0 && lastToken.toLowerCase().startsWith(typedPath.toLowerCase()) && autocompletePath;
+        }).filter(Boolean))).filter((c) => {
+          return c.toLowerCase().includes(path.toLowerCase());
+        });
+
+        const candidates = Array.from(new Set(startsWithCandidates.concat(requestKeyCandidates)));
+
+        return [candidates, path];
+      },
+    });
+
+    process.stdin.on('keypress', (ch, key) => {
+      if (key && key.name === 'escape') {
+        this.#readline.line = '';
+        Readline.cursorTo(process.stdout, 0);
+        Readline.clearLine(process.stdout, 0);
+        this.#readline.prompt();
+      }
+    });
+  }
+
+  #createWatcher() {
+    this.#watcher = Chokidar.watch(this.#configDir, {
+      awaitWriteFinish: true,
+      ignoreInitial: true,
+      ignored: filepath => this.#ignore(this.#normalizeWatcherPath(filepath)),
+    });
+
+    this.#watcher.on('all', (event, path) => {
+      const { key } = this.#normalizeWatcherPath(path);
+
+      if (['add', 'change'].includes(event)) {
+        const api = ConfigClient.parseFile(path);
+        if (key) this.#configClient.set(key, api);
+        else this.#configClient.merge(api);
+        if (api.request) this.emit('save', { key, api });
+      } else if (['unlink', 'unlinkDir'].includes(event)) {
+        this.#configClient.del(key);
+      }
+    });
+  }
+
+  #ignore({ name, filepath, paths }) {
+    if (name.startsWith('.')) return true;
+
+    if (name.startsWith('+')) {
+      const request = ConfigClient.parseFile(filepath);
+      const key = paths.slice(0, -1).join('.');
+      if (key) this.#mergeData[key] = { request };
+      else this.#mergeData.request = request;
+      return true;
+    }
+
+    return false;
+  }
+
+  #normalizeWatcherPath = (filepath) => {
+    const parsed = Path.parse(filepath);
+    const folder = filepath.substring(this.#configDir.length + 1, filepath.length - parsed.ext.length);
+    const paths = folder.split('/').filter(el => el && el !== 'index');
+    const key = paths.join('.');
+    return { ...parsed, filepath, paths, key };
+  };
+};

package/src/app.js

@@ -0,0 +1,5 @@
+const Sandman = require('./Sandman');
+
+module.exports = (configDir, options) => {
+  return new Sandman(configDir, options);
+};