@botpress/cli 0.0.3 → 0.0.5

package/dist/app/api-utils.js

@@ -71,7 +71,7 @@ class ApiUtils {
       throw errors.BotpressCLIError.wrap(thrown, "Authentication failed. Please check your credentials");
     }
   }
-  async listAllPages(lister, key) {
+  async listAllPages(lister, map) {
     let nextToken;
     const all = [];
     do {
@@ -79,17 +79,18 @@ class ApiUtils {
       all.push(r);
       nextToken = meta.nextToken;
     } while (nextToken);
-    if (!key) {
+    if (!map) {
       return all;
     }
-    return all.flatMap((r) => r[key]);
+    const mapped = all.flatMap((r) => map(r));
+    return mapped;
   }
   async validateStatus(fn, allowedStatuses) {
     try {
       const v = await fn();
       return v;
     } catch (thrown) {
-      const err = errors.mapThrown(thrown);
+      const err = errors.BotpressCLIError.map(thrown);
       const allowedStatusesArray = import_lodash.default.isArray(allowedStatuses) ? allowedStatuses : [allowedStatuses];
       const isAllowed = err instanceof errors.HTTPError && err.status && allowedStatusesArray.includes(err.status);
       if (isAllowed) {

package/dist/app/base.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,19 +17,55 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var base_exports = {};
 __export(base_exports, {
   BaseCommands: () => BaseCommands
 });
 module.exports = __toCommonJS(base_exports);
+var bpclient = __toESM(require("@botpress/client"));
+var import_prompts = __toESM(require("prompts"));
+var import_api_utils = require("./api-utils");
+var errors = __toESM(require("./errors"));
 class BaseCommands {
-  constructor(_logger) {
+  constructor(_props, _userCache, _logger) {
+    this._props = _props;
+    this._userCache = _userCache;
     this._logger = _logger;
   }
   teardown() {
     this._logger.cleanup();
   }
+  async _ensureLoginAndCreateClient(argv) {
+    const token = await this._userCache.get("token");
+    const workspaceId = argv.workspaceId ?? await this._userCache.get("workspaceId");
+    const host = argv.host ?? await this._userCache.get("host");
+    if (!(token && workspaceId && host)) {
+      throw new errors.NotLoggedInError();
+    }
+    const client = new bpclient.Client({ host, token, workspaceId });
+    return new import_api_utils.ApiUtils(client, host, token, workspaceId, this._logger);
+  }
+  async _confirm(message) {
+    if (this._props.confirm) {
+      this._logger.debug(`Confirming automatically: ${message}`);
+      return true;
+    }
+    const { confirm } = await (0, import_prompts.default)({
+      type: "confirm",
+      name: "confirm",
+      message,
+      initial: false
+    });
+    if (!confirm) {
+      return false;
+    }
+    return true;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/app/errors.js

@@ -32,30 +32,30 @@ __export(errors_exports, {
   NoBotsFoundError: () => NoBotsFoundError,
   NoBundleFoundError: () => NoBundleFoundError,
   NotLoggedInError: () => NotLoggedInError,
-  ParamRequiredError: () => ParamRequiredError,
-  mapThrown: () => mapThrown
+  ParamRequiredError: () => ParamRequiredError
 });
 module.exports = __toCommonJS(errors_exports);
 var import_client = require("@botpress/client");
 var import_axios = __toESM(require("axios"));
 var import_verror = require("verror");
-var consts = __toESM(require("../const"));
-const mapThrown = (thrown) => {
-  if ((0, import_client.isApiError)(thrown)) {
-    return HTTPError.fromApi(thrown);
-  }
-  if (import_axios.default.isAxiosError(thrown)) {
-    return HTTPError.fromAxios(thrown);
-  }
-  if (thrown instanceof Error) {
-    return thrown;
-  }
-  return new BotpressCLIError(`${thrown}`);
-};
+var consts = __toESM(require("../consts"));
 class BotpressCLIError extends import_verror.VError {
   static wrap(thrown, message) {
-    const err = mapThrown(thrown);
-    return new BotpressCLIError(err, message);
+    const err = BotpressCLIError.map(thrown);
+    return new BotpressCLIError(err, message ?? "");
+  }
+  static map(thrown) {
+    if ((0, import_client.isApiError)(thrown)) {
+      return HTTPError.fromApi(thrown);
+    }
+    if (import_axios.default.isAxiosError(thrown)) {
+      return HTTPError.fromAxios(thrown);
+    }
+    if (thrown instanceof Error) {
+      const { message } = thrown;
+      return new BotpressCLIError(message);
+    }
+    return new BotpressCLIError(`${thrown}`);
   }
 }
 class ExclusiveBotFeatureError extends BotpressCLIError {
@@ -140,6 +140,5 @@ class InvalidIntegrationReferenceError extends BotpressCLIError {
   NoBotsFoundError,
   NoBundleFoundError,
   NotLoggedInError,
-  ParamRequiredError,
-  mapThrown
+  ParamRequiredError
 });

package/dist/app/file-paths.js

@@ -0,0 +1,82 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var file_paths_exports = {};
+__export(file_paths_exports, {
+  ProjectPaths: () => ProjectPaths,
+  UserPaths: () => UserPaths
+});
+module.exports = __toCommonJS(file_paths_exports);
+var import_lodash = __toESM(require("lodash"));
+var consts = __toESM(require("../consts"));
+var pathutils = __toESM(require("../path-utils"));
+class ProjectPaths {
+  abs;
+  rel;
+  constructor({ workDir, definition, entryPoint: entrypoint, outDir }) {
+    const absWorkdir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
+    const absDefinition = pathutils.absoluteFrom(absWorkdir, definition);
+    const absEntrypoint = pathutils.absoluteFrom(absWorkdir, entrypoint);
+    const absOutdir = pathutils.absoluteFrom(absWorkdir, outDir);
+    this.abs = {
+      workDir: absWorkdir,
+      definition: absDefinition,
+      entryPoint: absEntrypoint,
+      outDir: absOutdir,
+      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.absoluteFrom(absOutdir, p))
+    };
+    const relDefinition = pathutils.relativeFrom(this.abs.workDir, this.abs.definition);
+    const relEntrypoint = pathutils.relativeFrom(this.abs.workDir, this.abs.entryPoint);
+    const relOutdir = pathutils.relativeFrom(this.abs.workDir, this.abs.outDir);
+    const relWorkdir = ".";
+    this.rel = {
+      workDir: relWorkdir,
+      definition: relDefinition,
+      entryPoint: relEntrypoint,
+      outDir: relOutdir,
+      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.relativeFrom(this.abs.outDir, p))
+    };
+  }
+}
+class UserPaths {
+  abs;
+  rel;
+  constructor({ botpressHome }) {
+    const absBotpressHome = pathutils.absoluteFrom(pathutils.cwd(), botpressHome);
+    this.abs = {
+      botpressHome: absBotpressHome,
+      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.absoluteFrom(absBotpressHome, p))
+    };
+    const relBotpressHome = ".";
+    this.rel = {
+      botpressHome: relBotpressHome,
+      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.relativeFrom(this.abs.botpressHome, p))
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectPaths,
+  UserPaths
+});

package/dist/app/generator/module.js

@@ -29,7 +29,7 @@ __export(module_exports, {
 });
 module.exports = __toCommonJS(module_exports);
 var import_path = require("path");
-var pathutils = __toESM(require("../../paths"));
+var pathutils = __toESM(require("../../path-utils"));
 var import_const = require("./const");
 class Module {
   constructor(_def) {

package/dist/app/index.js

@@ -31,13 +31,14 @@ __export(app_exports, {
 module.exports = __toCommonJS(app_exports);
 var import_chalk = __toESM(require("chalk"));
 var import_fs = __toESM(require("fs"));
-var consts = __toESM(require("../const"));
+var consts = __toESM(require("../consts"));
 var import_logger = require("../logger");
 var import_cache = require("./cache");
+var import_file_paths = require("./file-paths");
 var import_project = require("./project");
 var import_user = require("./user");
 var errors = __toESM(require("./errors"));
-const logVersion = (logger, props) => {
+const logBootInfo = (logger, props) => {
   const versionText = import_chalk.default.bold(`v${props.version}`);
   logger.log(`Botpress CLI ${versionText}`, { prefix: "\u{1F916}" });
   if (props.botpressHome !== consts.defaultBotpressHome) {
@@ -46,18 +47,22 @@ const logVersion = (logger, props) => {
 };
 const forProject = async (props) => {
   const logger = new import_logger.Logger(props);
-  logVersion(logger, props);
-  const paths = new import_project.ProjectPaths(props);
-  const projectCachePath = consts.projectCache(paths.abs.outDir);
+  logBootInfo(logger, props);
+  const projectPaths = new import_file_paths.ProjectPaths(props);
+  const projectCachePath = projectPaths.abs.projectCacheFile;
   const projectCache = await import_cache.FSConfigCache.loadFrom(projectCachePath);
-  const userCache = await import_cache.FSConfigCache.loadFrom(consts.userCache(props.botpressHome));
-  await import_fs.default.promises.mkdir(consts.dist(paths.abs.outDir), { recursive: true });
-  return new import_project.ProjectCommands(props, paths, projectCache, userCache, logger);
+  const userPaths = new import_file_paths.UserPaths(props);
+  const userCacheFile = userPaths.abs.userCacheFile;
+  const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
+  await import_fs.default.promises.mkdir(projectPaths.abs.distDir, { recursive: true });
+  return new import_project.ProjectCommands(props, projectPaths, projectCache, userCache, logger);
 };
 const forUser = async (props) => {
   const logger = new import_logger.Logger(props);
-  logVersion(logger, props);
-  const userCache = await import_cache.FSConfigCache.loadFrom(consts.userCache(props.botpressHome));
+  logBootInfo(logger, props);
+  const userPaths = new import_file_paths.UserPaths(props);
+  const userCacheFile = userPaths.abs.userCacheFile;
+  const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
   return new import_user.UserCommands(props, userCache, logger);
 };
 // Annotate the CommonJS export names for ESM import in node: