@blitzjs/repl/dist/blitzjs-repl.cjs.prod.js

Repl package for Blitz CLI

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var config = require('@blitzjs/config');
var chokidar = require('chokidar');
var fs = require('fs');
var os = require('os');
var path = require('path');
var REPL = require('repl');
var display = require('@blitzjs/display');
var globby = require('globby');
var ProgressBar = require('progress');

function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }

var fs__default = /*#__PURE__*/_interopDefault(fs);
var os__default = /*#__PURE__*/_interopDefault(os);
var path__default = /*#__PURE__*/_interopDefault(path);
var globby__default = /*#__PURE__*/_interopDefault(globby);
var ProgressBar__default = /*#__PURE__*/_interopDefault(ProgressBar);

var projectRoot$2 = /*#__PURE__*/config.getProjectRoot();

var isTypeScript = /*#__PURE__*/require("fs").existsSync( /*#__PURE__*/require("path").join(projectRoot$2, "tsconfig.json"));

var invalidateCache = function invalidateCache(module) {
  delete require.cache[require.resolve(module)];
};

var forceRequire = function forceRequire(modulePath) {
  invalidateCache(modulePath);

  if (isTypeScript) {
    return require(modulePath);
  } else {
    var esmRequire = require("esm")(module);

    return esmRequire(modulePath);
  }
};

var debug$1 = /*#__PURE__*/require("debug")("blitz:repl");

var projectRoot$1 = /*#__PURE__*/config.getProjectRoot();
async function getBlitzModulePaths() {
  var paths = await globby__default['default'](["app/**/{queries,mutations}/*.{js,ts,tsx}", "utils/*.{js,ts,tsx}", "jobs/**/*.{js,ts,tsx}", "integrations/**/*.{js,ts,tsx}", "!**/*.test.*", "!**/*.spec.*"], {
    cwd: projectRoot$1,
    gitignore: true
  });
  paths.push("db");
  debug$1("Paths", paths);
  return [].concat(paths.map(function (p) {
    return path__default['default'].join(projectRoot$1, p);
  }));
}
var loadBlitz = async function loadBlitz() {
  var paths = await getBlitzModulePaths();
  var percentage = new ProgressBar__default['default']("Loading Modules :current/:total", {
    total: paths.length
  });
  var modules = Object.assign.apply(Object, [{}].concat(paths.map(function (modulePath) {
    var name = path__default['default'].parse(modulePath).name;

    if (name === "index") {
      var dirs = path__default['default'].dirname(modulePath).split(path__default['default'].sep);
      name = dirs[dirs.length - 1];
    }

    try {
      var _ref;

      debug$1("Loading", modulePath);
      var module = forceRequire(modulePath);
      var contextObj = module["default"] || module; // debug("ContextObj", contextObj)

      percentage.tick(); //TODO: include all exports here, not just default

      return _ref = {}, _ref[name] = contextObj, _ref;
    } catch (error) {
      display.log.error("Failed to load " + modulePath + ": " + error);
      debug$1("Failed to load module", error);
      return {};
    }
  })));
  percentage.terminate();
  return modules;
};

var debug = /*#__PURE__*/require("debug")("blitz:repl");

var projectRoot = /*#__PURE__*/config.getProjectRoot();

var loadBlitzModules = function loadBlitzModules(repl, modules) {
  Object.assign(repl.context, modules);
};

var loadModules = async function loadModules(repl) {
  // loadBlitzDependencies(repl)
  loadBlitzModules(repl, await loadBlitz());
};

var commands = {
  reload: {
    help: "Reload all modules",
    action: async function action() {
      this.clearBufferedCommand();
      console.log("Reloading all modules...");
      await loadModules(this);
      this.displayPrompt();
    }
  }
};

var defineCommands = function defineCommands(repl, commands) {
  Object.entries(commands).forEach(function (_ref) {
    var keyword = _ref[0],
        cmd = _ref[1];
    return repl.defineCommand(keyword, cmd);
  });
};

var setupSelfRolledHistory = function setupSelfRolledHistory(repl, path) {
  function init() {
    try {
      var _repl$history;

      var history = fs__default['default'].readFileSync(path, {
        encoding: "utf8"
      });
      var nonEmptyLines = history.split(os__default['default'].EOL).filter(function (line) {
        return line.trim();
      });

      (_repl$history = repl.history).push.apply(_repl$history, nonEmptyLines.reverse());
    } catch (err) {
      if (err.code !== "ENOENT") {
        throw err;
      }
    }
  }

  function onExit() {
    var addedHistory = repl.lines.join(os__default['default'].EOL);
    fs__default['default'].appendFileSync(path, addedHistory);
  }

  init();
  repl.on("exit", onExit);
};

var setupHistory = function setupHistory(repl) {
  var blitzConsoleHistoryPath = path__default['default'].join(projectRoot, ".blitz-console-history");

  if (repl.setupHistory) {
    repl.setupHistory(blitzConsoleHistoryPath, function () {});
  } else {
    setupSelfRolledHistory(repl, blitzConsoleHistoryPath);
  }
};

var initializeRepl = async function initializeRepl(replOptions) {
  debug("initializeRepl");
  var modules = await loadBlitz();
  debug("Starting REPL...");
  var repl = REPL.start(replOptions);
  loadBlitzModules(repl, modules);
  defineCommands(repl, commands);
  setupHistory(repl);
  return repl;
};

var setupFileWatchers = async function setupFileWatchers(repl) {
  debug("Setting up file watchers...");
  var watchers = [// watch('package.json').on('change', () => Console.loadDependencies(repl)),
  chokidar.watch(await getBlitzModulePaths(), {
    ignoreInitial: true
  }).on("all", function () {
    return loadModules(repl);
  })];
  repl.on("reset", async function () {
    debug("Reset, so reloading modules...");
    await loadModules(repl);
  });
  repl.on("exit", function () {
    return watchers.forEach(function (watcher) {
      return watcher.close();
    });
  });
};

var runRepl = async function runRepl(replOptions) {
  var repl = await initializeRepl(replOptions);
  repl.on("exit", function () {
    return process.exit();
  });
  await setupFileWatchers(repl);
}; // const loadBlitzDependencies = (repl: REPLServer) => {

exports.runRepl = runRepl;