contensis-cli 1.0.0-beta.5

package/dist/services/ContensisCliService.js

@@ -0,0 +1,1110 @@
+"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 = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+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 ContensisCliService_exports = {};
+__export(ContensisCliService_exports, {
+  cliCommand: () => cliCommand,
+  default: () => ContensisCliService_default
+});
+module.exports = __toCommonJS(ContensisCliService_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_await_to_js = __toESM(require("await-to-js"));
+var import_util = require("../util");
+var import_SessionCacheProvider = __toESM(require("../providers/SessionCacheProvider"));
+var import_ContensisAuthService = __toESM(require("./ContensisAuthService"));
+var import_CredentialProvider = __toESM(require("../providers/CredentialProvider"));
+var import_logger = require("../util/logger");
+var import_en_GB = require("../localisation/en-GB");
+var import_migratortron = require("migratortron");
+var import_csv = require("../util/csv.formatter");
+var import_xml = require("../util/xml.formatter");
+var import_json = require("../util/json.formatter");
+var import_console = require("../util/console.printer");
+var import_file_provider = require("../providers/file-provider");
+class ContensisCli {
+  static quit = (error) => {
+    process.removeAllListeners("exit");
+    const exitCode = error ? 1 : 0;
+    console.info(`
+Exiting contensis-cli with exit code: ${exitCode}
+`);
+    process.exit(exitCode);
+  };
+  cache;
+  contensis;
+  contensisOpts;
+  contentTypes;
+  components;
+  currentEnv;
+  currentProject;
+  env;
+  sourceEnv;
+  targetEnv;
+  urls;
+  command;
+  format;
+  output;
+  log = import_logger.Logger;
+  messages = import_en_GB.LogMessages;
+  session;
+  verb;
+  noun;
+  thirdArg;
+  constructor(args, outputOpts, contensisOpts = {}) {
+    const [exe, script, verb = "", noun = "", ...restArgs] = args;
+    this.verb = verb == null ? void 0 : verb.toLowerCase();
+    this.noun = noun == null ? void 0 : noun.toLowerCase();
+    this.thirdArg = restArgs == null ? void 0 : restArgs[0];
+    const commandText = `${this.verb} ${this.noun} ${restArgs ? restArgs.join(" ") : ""}`.trim();
+    this.session = new import_SessionCacheProvider.default();
+    this.cache = this.session.Get();
+    this.contensisOpts = contensisOpts;
+    this.format = outputOpts == null ? void 0 : outputOpts.format;
+    this.output = (outputOpts == null ? void 0 : outputOpts.output) && import_path.default.join(process.cwd(), outputOpts.output);
+    const currentEnvironment = (outputOpts == null ? void 0 : outputOpts.alias) || this.cache.currentEnvironment || "";
+    const environments = this.cache.environments || {};
+    if (!currentEnvironment)
+      this.env = {};
+    else if (!!environments[currentEnvironment])
+      this.env = environments[currentEnvironment];
+    else {
+      this.env = {
+        history: [],
+        lastUserId: "",
+        projects: [],
+        versionStatus: "latest"
+      };
+    }
+    const env = this.env;
+    if (outputOpts == null ? void 0 : outputOpts.projectId)
+      env.currentProject = outputOpts.projectId;
+    if (outputOpts == null ? void 0 : outputOpts.user)
+      env.lastUserId = outputOpts.user;
+    if (outputOpts == null ? void 0 : outputOpts.password)
+      env.passwordFallback = outputOpts.password;
+    if (outputOpts == null ? void 0 : outputOpts.clientId)
+      env.lastUserId = outputOpts.clientId;
+    if (outputOpts == null ? void 0 : outputOpts.sharedSecret)
+      env.passwordFallback = outputOpts.sharedSecret;
+    this.currentEnv = currentEnvironment;
+    this.currentProject = (env == null ? void 0 : env.currentProject) || "null";
+    this.sourceEnv = (outputOpts == null ? void 0 : outputOpts.sourceEnv) || currentEnvironment;
+    if (currentEnvironment) {
+      this.urls = (0, import_util.url)(currentEnvironment, (env == null ? void 0 : env.currentProject) || "website");
+    }
+    this.command = {
+      commandText,
+      createdDate: new Date().toISOString(),
+      createdUserId: env == null ? void 0 : env.lastUserId
+    };
+    if (currentEnvironment) {
+      env.history = [this.command];
+      if (commandText) {
+        environments[currentEnvironment] = this.env;
+        this.session.Update({
+          currentEnvironment,
+          environments,
+          history: [commandText]
+        });
+      }
+    }
+  }
+  PrintEnvironments = () => {
+    const { log, messages } = this;
+    const { currentEnvironment, environments = {} } = this.cache;
+    const envKeys = Object.keys(environments);
+    log.success(messages.envs.found(envKeys.length));
+    this.HandleFormattingAndOutput(envKeys, () => {
+      for (const env of envKeys) {
+        console.log(`  - ${currentEnvironment === env ? "* " : ""}${env}`);
+      }
+    });
+    if (envKeys.length === 0 || !currentEnvironment) {
+      log.help(messages.envs.tip());
+    }
+  };
+  Connect = async (environment) => {
+    var _a;
+    const { cache, log, messages, session } = this;
+    if (environment) {
+      const envCache = cache.environments[environment];
+      if (!envCache)
+        cache.environments[environment] = {
+          versionStatus: "published",
+          history: [],
+          lastUserId: "",
+          projects: [],
+          ...!this.currentEnv ? this.env : {}
+        };
+      this.env = cache.environments[environment];
+      this.currentEnv = environment;
+      this.urls = (0, import_util.url)(environment, "website");
+      const [fetchErr, response] = await (0, import_await_to_js.default)((0, import_node_fetch.default)(this.urls.cms));
+      if (response && (response == null ? void 0 : response.status) < 400) {
+        log.success(messages.connect.connected(environment));
+        if ((_a = this.env) == null ? void 0 : _a.lastUserId) {
+          await this.ConnectContensis();
+          await this.PrintProjects();
+        } else {
+          log.warning(messages.projects.noList());
+          log.help(messages.connect.tip());
+        }
+        session.Update({
+          currentEnvironment: environment,
+          environments: cache.environments
+        });
+      } else {
+        log.error(
+          messages.connect.unreachable(this.urls.cms, (response == null ? void 0 : response.status) || 0)
+        );
+      }
+    } else {
+      log.error(messages.connect.noEnv());
+    }
+  };
+  ConnectContensis = async ({ commit = false } = {}) => {
+    var _a, _b, _c;
+    const { contensisOpts, currentEnv, env, log, messages } = this;
+    const userId = env == null ? void 0 : env.lastUserId;
+    const isGuidId = userId && (0, import_util.isUuid)(userId);
+    if (currentEnv && userId) {
+      const [credentialError, credentials] = await new import_CredentialProvider.default(
+        {
+          userId,
+          alias: currentEnv
+        },
+        env.passwordFallback
+      ).Init();
+      if (credentialError && !credentials.current) {
+        log.error(credentialError);
+        return;
+      }
+      const cachedPassword = (_a = credentials == null ? void 0 : credentials.current) == null ? void 0 : _a.password;
+      if (cachedPassword) {
+        this.contensis = new import_migratortron.ContensisMigrationService(
+          {
+            ...contensisOpts,
+            source: {
+              url: ((_b = this.urls) == null ? void 0 : _b.cms) || "",
+              username: !isGuidId ? userId : void 0,
+              password: !isGuidId ? cachedPassword : void 0,
+              clientId: isGuidId ? userId : void 0,
+              sharedSecret: isGuidId ? cachedPassword : void 0,
+              project: (env == null ? void 0 : env.currentProject) || "",
+              assetHostname: (_c = this.urls) == null ? void 0 : _c.previewWeb
+            },
+            concurrency: typeof contensisOpts.concurrency !== "undefined" ? contensisOpts.concurrency : 3,
+            outputProgress: true
+          },
+          !commit
+        );
+      }
+    } else {
+      if (!currentEnv)
+        log.help(messages.connect.help());
+      if (!userId)
+        log.help(messages.connect.tip());
+    }
+  };
+  ConnectContensisImport = async ({
+    commit,
+    source,
+    fileData,
+    fileDataType
+  }) => {
+    var _a, _b, _c, _d, _e, _f;
+    const { contensisOpts, currentEnv, env, log, messages, sourceEnv } = this;
+    const environments = this.cache.environments || {};
+    const sourceEnvironment = environments[sourceEnv || ""] || {};
+    const sourceCms = "source" in contensisOpts && contensisOpts.source || {};
+    const sourceUserId = sourceCms.clientId || sourceCms.username || sourceEnvironment.lastUserId;
+    const sourceProjectId = sourceCms.project || sourceEnvironment.currentProject || "website";
+    const isSourceGuidId = sourceUserId && (0, import_util.isUuid)(sourceUserId);
+    const sourceUrls = (0, import_util.url)(sourceEnv || "", sourceProjectId);
+    const sourcePassword = sourceCms.sharedSecret || sourceCms.password || sourceEnvironment.passwordFallback;
+    const targetUserId = env == null ? void 0 : env.lastUserId;
+    const isTargetGuidId = targetUserId && (0, import_util.isUuid)(targetUserId);
+    if (sourceUserId && currentEnv && targetUserId) {
+      const [sourceCredentialError, sourceCredentials] = await new import_CredentialProvider.default(
+        {
+          userId: sourceUserId,
+          alias: currentEnv
+        },
+        sourcePassword
+      ).Init();
+      if (sourceCredentialError && !sourceCredentials.current) {
+        (0, import_logger.logError)(sourceCredentialError);
+        return;
+      }
+      const cachedSourcePassword = (_a = sourceCredentials == null ? void 0 : sourceCredentials.current) == null ? void 0 : _a.password;
+      const [targetCredentialError, targetCredentials] = await new import_CredentialProvider.default(
+        {
+          userId: targetUserId,
+          alias: currentEnv
+        },
+        env.passwordFallback
+      ).Init();
+      if (targetCredentialError && !targetCredentials.current) {
+        log.error(targetCredentialError);
+        return;
+      }
+      const cachedTargetPassword = (_b = targetCredentials == null ? void 0 : targetCredentials.current) == null ? void 0 : _b.password;
+      if (cachedSourcePassword && cachedTargetPassword) {
+        if (source === "file" || source === "input") {
+          this.contensis = new import_migratortron.ContensisMigrationService(
+            {
+              concurrency: 3,
+              outputProgress: true,
+              ...contensisOpts,
+              target: {
+                url: ((_c = this.urls) == null ? void 0 : _c.cms) || "",
+                username: !isTargetGuidId ? targetUserId : void 0,
+                password: !isTargetGuidId ? cachedTargetPassword : void 0,
+                clientId: isTargetGuidId ? targetUserId : void 0,
+                sharedSecret: isTargetGuidId ? cachedTargetPassword : void 0,
+                targetProjects: [env.currentProject || ""],
+                assetHostname: (_d = this.urls) == null ? void 0 : _d.previewWeb
+              },
+              ...fileDataType ? { [fileDataType]: fileData } : {}
+            },
+            !commit
+          );
+        }
+        if (source === "contensis") {
+          this.contensis = new import_migratortron.ContensisMigrationService(
+            {
+              concurrency: 3,
+              outputProgress: true,
+              ...contensisOpts,
+              source: {
+                url: sourceUrls.cms || "",
+                username: !isSourceGuidId ? sourceUserId : void 0,
+                password: !isSourceGuidId ? cachedSourcePassword : void 0,
+                clientId: isSourceGuidId ? sourceUserId : void 0,
+                sharedSecret: isSourceGuidId ? cachedSourcePassword : void 0,
+                project: sourceProjectId,
+                assetHostname: sourceUrls.previewWeb
+              },
+              target: {
+                url: ((_e = this.urls) == null ? void 0 : _e.cms) || "",
+                username: !isTargetGuidId ? targetUserId : void 0,
+                password: !isTargetGuidId ? cachedTargetPassword : void 0,
+                clientId: isTargetGuidId ? targetUserId : void 0,
+                sharedSecret: isTargetGuidId ? cachedTargetPassword : void 0,
+                targetProjects: [env.currentProject || ""],
+                assetHostname: (_f = this.urls) == null ? void 0 : _f.previewWeb
+              }
+            },
+            !commit
+          );
+        }
+      }
+    } else {
+      if (!currentEnv)
+        log.help(messages.connect.help());
+      if (!targetUserId)
+        log.help(messages.connect.tip());
+    }
+  };
+  Login = async (userId, {
+    password = (0, import_util.isPassword)(this.env.passwordFallback),
+    promptPassword = true,
+    sharedSecret = (0, import_util.isSharedSecret)(this.env.passwordFallback),
+    silent = false
+  }) => {
+    var _a, _b, _c, _d;
+    let inputPassword = password;
+    const { log, messages } = this;
+    if (userId) {
+      const { cache, currentEnv, env } = this;
+      if (currentEnv) {
+        const [credentialError, credentials] = await new import_CredentialProvider.default(
+          { userId, alias: currentEnv },
+          inputPassword || sharedSecret
+        ).Init();
+        if (credentialError && !credentials.current) {
+          log.error(credentialError);
+          return;
+        }
+        if (credentials.remarks.secure !== true)
+          log.warning(messages.login.insecurePassword());
+        const cachedPassword = (0, import_util.isPassword)((_a = credentials == null ? void 0 : credentials.current) == null ? void 0 : _a.password);
+        const cachedSecret = (0, import_util.isSharedSecret)((_b = credentials == null ? void 0 : credentials.current) == null ? void 0 : _b.password);
+        if (!sharedSecret && !inputPassword && !cachedPassword && !cachedSecret && promptPassword) {
+          ({ inputPassword } = await import_inquirer.default.prompt([
+            {
+              type: "password",
+              message: messages.login.passwordPrompt(currentEnv, userId),
+              name: "inputPassword",
+              mask: "*",
+              prefix: void 0
+            }
+          ]));
+        }
+        if (sharedSecret || cachedSecret || inputPassword || cachedPassword) {
+          const authService = new import_ContensisAuthService.default({
+            username: userId,
+            password: inputPassword || cachedPassword,
+            projectId: (env == null ? void 0 : env.currentProject) || "website",
+            rootUrl: ((_c = this.urls) == null ? void 0 : _c.cms) || "",
+            clientId: userId,
+            clientSecret: sharedSecret || cachedSecret
+          });
+          const [authError, bearerToken] = await (0, import_await_to_js.default)(authService.BearerToken());
+          if (bearerToken) {
+            env.authToken = bearerToken;
+            env.lastUserId = userId;
+            env.passwordFallback = credentials.remarks.secure !== true ? (_d = credentials.current) == null ? void 0 : _d.password : void 0;
+            if (!silent) {
+              import_logger.Logger.success(messages.login.success(currentEnv, userId));
+              await this.PrintProjects();
+            }
+            if (inputPassword)
+              await credentials.Save(inputPassword);
+            if (sharedSecret)
+              await credentials.Save(sharedSecret);
+          } else if (authError) {
+            import_logger.Logger.error(authError.toString());
+            env.authToken = "";
+            env.lastUserId = "";
+            env.passwordFallback = void 0;
+            if ((cachedPassword || cachedSecret) && credentials.remarks.secure) {
+              await credentials.Delete();
+              return await this.Login(userId, { password, sharedSecret });
+            } else {
+              throw new Error(messages.login.failed(currentEnv, userId));
+            }
+          }
+          this.session.Update({
+            environments: cache.environments
+          });
+          return env.authToken;
+        } else {
+          import_logger.Logger.error(messages.login.passwordPrompt(currentEnv, userId));
+        }
+      } else {
+        import_logger.Logger.error(messages.login.noEnv());
+      }
+    } else {
+      import_logger.Logger.error(messages.login.noUserId());
+    }
+  };
+  PrintProjects = async () => {
+    const { cache, currentEnv, currentProject, log, messages, session } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [projectsErr, projects] = await (0, import_await_to_js.default)(
+        this.contensis.projects.GetSourceProjects()
+      );
+      if (Array.isArray(projects)) {
+        const currentVals = cache.environments[currentEnv] || {};
+        const nextCurrentProject = currentProject && currentProject !== "null" ? currentProject : projects.some((p) => p.id === "website") ? "website" : void 0;
+        cache.environments[currentEnv] = {
+          ...currentVals,
+          projects: projects.map((p) => p.id),
+          currentProject: nextCurrentProject
+        };
+        log.success(messages.projects.list());
+        this.HandleFormattingAndOutput(projects, () => {
+          for (const project of projects) {
+            console.log(
+              `  - ${nextCurrentProject === project.id ? "* " : ""}[${project.primaryLanguage}] ${project.id}`
+            );
+          }
+        });
+        session.Update({
+          environments: cache.environments
+        });
+        if (nextCurrentProject) {
+          this.env = cache.environments[currentEnv];
+          this.SetProject(nextCurrentProject);
+        }
+      }
+      if (projectsErr) {
+        log.error(messages.projects.noList());
+        log.error(projectsErr.message);
+      }
+    }
+  };
+  SetProject = async (projectId = "") => {
+    const { cache, env, log, messages, session } = this;
+    let nextProjectId;
+    if ((env == null ? void 0 : env.projects.length) > 0 && (env == null ? void 0 : env.lastUserId)) {
+      nextProjectId = env.projects.find(
+        (p) => p.toLowerCase() === projectId.toLowerCase()
+      );
+      if (nextProjectId) {
+        env.currentProject = nextProjectId;
+        session.Update({
+          environments: cache.environments
+        });
+        log.success(messages.projects.set(projectId));
+      } else {
+        log.error(messages.projects.failedSet(projectId));
+      }
+    } else {
+      log.warning(messages.projects.noList());
+      log.help(messages.connect.tip());
+    }
+    return nextProjectId;
+  };
+  SetVersion = async (versionStatus) => {
+    const { cache, env, log, messages, session } = this;
+    if (!["latest", "published"].includes(versionStatus)) {
+      log.error(messages.version.invalid(versionStatus));
+      return false;
+    }
+    if (!env) {
+      log.help(messages.version.noEnv());
+      return false;
+    }
+    if ((env == null ? void 0 : env.projects.length) > 0 && (env == null ? void 0 : env.lastUserId)) {
+      env.versionStatus = versionStatus;
+      session.Update({
+        environments: cache.environments
+      });
+      log.success(messages.version.set(this.currentEnv, versionStatus));
+      return true;
+    } else {
+      log.warning(messages.projects.noList());
+      log.help(messages.connect.tip());
+      return false;
+    }
+  };
+  HydrateContensis = async () => {
+    const { log } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [contensisErr, models] = await (0, import_await_to_js.default)(
+        this.contensis.models.HydrateContensisRepositories()
+      );
+      if (contensisErr) {
+        log.error(contensisErr.message);
+        return contensisErr;
+      }
+    }
+  };
+  PrintApiKeys = async () => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [keysErr, apiKeys] = await this.contensis.apiKeys.GetKeys();
+      if (Array.isArray(apiKeys)) {
+        log.success(messages.keys.list(currentEnv));
+        this.HandleFormattingAndOutput(apiKeys, () => {
+          for (const {
+            id,
+            sharedSecret,
+            name,
+            description,
+            dateModified,
+            modifiedBy
+          } of apiKeys) {
+            console.log(
+              `  - ${name}${description ? ` (${description})` : ""} [${dateModified.toString().substring(0, 10)} ${modifiedBy}]`
+            );
+            console.log(`      ${id}`);
+            console.log(`      ${sharedSecret}`);
+          }
+        });
+      }
+      if (keysErr) {
+        log.error(messages.keys.noList(currentEnv));
+        log.error((0, import_json.jsonFormatter)(keysErr));
+      }
+    }
+  };
+  CreateApiKey = async (name, description) => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [err, key] = await this.contensis.apiKeys.CreateKey(
+        name,
+        description
+      );
+      if (key) {
+        log.success(messages.keys.created(currentEnv, name));
+        console.log(
+          `  - ${key.name}${key.description ? ` (${key.description})` : ""} [${key.dateModified.toString().substring(0, 10)} ${key.modifiedBy}]`
+        );
+        console.log(`  - id: ${key.id}`);
+        console.log(`  - sharedSecret: ${key.sharedSecret}`);
+      }
+      console.log("");
+      if (err) {
+        log.error(messages.keys.failedCreate(currentEnv, name), err);
+      }
+    }
+  };
+  RemoveApiKey = async (id) => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis({ commit: true });
+    if (this.contensis) {
+      const [err, key] = await this.contensis.apiKeys.RemoveKey(id);
+      if (!err) {
+        log.success(messages.keys.removed(currentEnv, id));
+        console.log("");
+      } else {
+        log.error(messages.keys.failedRemove(currentEnv, id), err);
+      }
+    }
+  };
+  GetContentTypes = async () => {
+    const { currentProject, log, messages } = this;
+    let err;
+    if (!this.contensis)
+      err = await this.HydrateContensis();
+    if (err)
+      log.error(messages.contenttypes.noList(currentProject));
+    if (this.contensis) {
+      this.contentTypes = this.contensis.models.contentTypes();
+      this.components = this.contensis.models.components();
+    } else {
+      log.warning(messages.contenttypes.noList(currentProject));
+    }
+  };
+  PrintContentTypes = async () => {
+    const { currentProject, log, messages } = this;
+    await this.GetContentTypes();
+    if (this.contensis) {
+      const { contentTypes } = this;
+      if (Array.isArray(contentTypes)) {
+        log.success(messages.contenttypes.list(currentProject));
+        this.HandleFormattingAndOutput(contentTypes, () => {
+          var _a;
+          for (const contentType of contentTypes) {
+            const fieldsLength = ((_a = contentType.fields) == null ? void 0 : _a.length) || 0;
+            console.log(
+              `  - ${contentType.id} [${fieldsLength} field${fieldsLength !== 1 ? "s" : ""}]`
+            );
+          }
+        });
+      }
+    }
+  };
+  PrintContentType = async (contentTypeId) => {
+    const { currentProject, log, messages } = this;
+    await this.GetContentTypes();
+    if (this.contensis) {
+      const { contentTypes } = this;
+      if (Array.isArray(contentTypes)) {
+        const contentType = contentTypes.find(
+          (c) => c.id.toLowerCase() === contentTypeId.toLowerCase()
+        );
+        if (contentType) {
+          log.success(
+            messages.contenttypes.get(currentProject, contentType.id)
+          );
+          this.HandleFormattingAndOutput(contentType, log.object);
+        } else {
+          log.error(
+            messages.contenttypes.failedGet(currentProject, contentTypeId)
+          );
+        }
+      }
+    }
+  };
+  RemoveContentTypes = async (contentTypeIds, commit = false) => {
+    const { currentProject, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensisImport({
+        source: "input",
+        commit
+      });
+    if (this.contensis) {
+      const [err, result] = await this.contensis.DeleteContentTypes(
+        contentTypeIds
+      );
+      if (err) {
+        log.error(
+          messages.contenttypes.failedRemove(
+            currentProject,
+            contentTypeIds.join('", "')
+          ),
+          err
+        );
+      } else {
+        log.success(
+          messages.contenttypes.removed(
+            currentProject,
+            contentTypeIds.join('", "'),
+            !this.contensis.isPreview
+          )
+        );
+        this.HandleFormattingAndOutput(
+          result,
+          () => log.object((0, import_json.jsonFormatter)(result))
+        );
+      }
+    }
+  };
+  ImportContentTypes = async ({
+    commit,
+    fromFile
+  }, contentTypeIds = []) => {
+    const { currentProject, log, messages } = this;
+    let fileData = fromFile ? (0, import_file_provider.readJsonFile)(fromFile) || [] : [];
+    if (typeof fileData === "string")
+      throw new Error(`Import file format must be of type JSON`);
+    if (!Array.isArray(fileData))
+      fileData = [fileData];
+    await this.ConnectContensisImport({
+      commit,
+      source: fromFile ? "file" : "contensis"
+    });
+    if (this.contensis) {
+      for (const contentType of fileData) {
+        contentType.projectId = currentProject;
+        delete contentType.uuid;
+        const [err, created, createStatus] = await this.contensis.models.targetRepos[currentProject].repo.UpsertContentType(false, contentType);
+        if (err)
+          log.error(err.message, err);
+        if (createStatus) {
+          log.success(
+            messages.contenttypes.created(
+              currentProject,
+              contentType.id,
+              createStatus
+            )
+          );
+          this.HandleFormattingAndOutput(contentType, () => {
+          });
+        }
+      }
+    }
+  };
+  PrintComponents = async () => {
+    const { currentProject, log, messages } = this;
+    await this.GetContentTypes();
+    if (this.contensis) {
+      const { components } = this;
+      if (Array.isArray(components)) {
+        log.success(messages.components.list(currentProject));
+        this.HandleFormattingAndOutput(components, () => {
+          var _a;
+          for (const component of components) {
+            const fieldsLength = ((_a = component.fields) == null ? void 0 : _a.length) || 0;
+            console.log(
+              `  - ${component.id} [${fieldsLength} field${fieldsLength !== 1 ? "s" : ""}]`
+            );
+          }
+        });
+      }
+    }
+  };
+  PrintComponent = async (componentId) => {
+    const { currentProject, log, messages } = this;
+    await this.GetContentTypes();
+    if (this.contensis) {
+      const { components } = this;
+      if (Array.isArray(components)) {
+        const component = components.find(
+          (c) => c.id.toLowerCase() === componentId.toLowerCase()
+        );
+        if (component) {
+          log.success(messages.components.get(currentProject, component.id));
+          this.HandleFormattingAndOutput(component, log.object);
+        } else {
+          log.error(messages.components.failedGet(currentProject, componentId));
+        }
+      }
+    }
+  };
+  RemoveComponents = async (componentIds, commit = false) => {
+    const { currentProject, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensisImport({
+        source: "input",
+        commit
+      });
+    if (this.contensis) {
+      const [err, result] = await this.contensis.DeleteContentTypes(
+        void 0,
+        componentIds
+      );
+      if (err) {
+        log.error(
+          messages.components.failedRemove(
+            currentProject,
+            componentIds.join('", "')
+          ),
+          err
+        );
+      } else {
+        log.success(
+          messages.components.removed(
+            currentProject,
+            componentIds.join('", "'),
+            !this.contensis.isPreview
+          )
+        );
+        this.HandleFormattingAndOutput(
+          result,
+          () => log.info((0, import_json.jsonFormatter)(result))
+        );
+      }
+    }
+  };
+  ImportComponents = async ({
+    commit,
+    fromFile
+  }, componentIds = []) => {
+    const { currentProject, log, messages } = this;
+    let fileData = fromFile ? (0, import_file_provider.readJsonFile)(fromFile) || [] : [];
+    if (typeof fileData === "string")
+      throw new Error(`Import file format must be of type JSON`);
+    if (!Array.isArray(fileData))
+      fileData = [fileData];
+    await this.ConnectContensisImport({
+      commit,
+      source: fromFile ? "file" : "contensis"
+    });
+    if (this.contensis) {
+      for (const component of fileData) {
+        component.projectId = currentProject;
+        delete component.uuid;
+        const [err, created, createStatus] = await this.contensis.models.targetRepos[currentProject].repo.UpsertComponent(false, component);
+        if (err)
+          log.error(err.message, err);
+        if (createStatus) {
+          log.success(
+            messages.components.created(
+              currentProject,
+              component.id,
+              createStatus
+            )
+          );
+          this.HandleFormattingAndOutput(component, () => {
+          });
+        }
+      }
+    }
+  };
+  RemoveEntry = async (id, commit = false) => {
+    var _a, _b, _c;
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensisImport({
+        source: "input",
+        commit
+      });
+    if (this.contensis) {
+      if (this.contensis.isPreview) {
+        console.log(log.successText(` -- PREVIEW -- `));
+      } else {
+        console.log(log.warningText(` *** COMMITTING DELETE *** `));
+      }
+      const [err, result] = await this.contensis.DeleteEntries();
+      if (result)
+        this.HandleFormattingAndOutput(result, () => {
+          (0, import_console.printMigrateResult)(this, result, { action: "delete" });
+        });
+      if (!err && (!commit && ((_a = Object.values(result.entriesToMigrate)) == null ? void 0 : _a[0].totalCount) > 0 || commit && ((_b = result.migrateResult) == null ? void 0 : _b.deleted))) {
+        log.success(messages.entries.removed(currentEnv, id, commit));
+        if (!commit)
+          log.help(messages.entries.commitTip());
+      } else {
+        log.error(messages.entries.failedRemove(currentEnv, id), err);
+        if (!((_c = Object.values(result.entriesToMigrate)) == null ? void 0 : _c[0].totalCount))
+          log.help(messages.entries.notFound(id));
+      }
+    }
+  };
+  GetEntries = async ({
+    withDependents = false
+  }) => {
+    const { currentProject, log, messages } = this;
+    await this.ConnectContensis();
+    if (this.contensis) {
+      log.line();
+      const entries = await this.contensis.GetEntries({ withDependents });
+      this.HandleFormattingAndOutput(
+        entries,
+        () => {
+          var _a, _b;
+          return (0, import_migratortron.logEntriesTable)(
+            entries,
+            currentProject,
+            (_b = (_a = this.contensis) == null ? void 0 : _a.payload.query) == null ? void 0 : _b.fields
+          );
+        }
+      );
+    } else {
+      log.warning(messages.contenttypes.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+  ImportEntries = async ({
+    commit,
+    fromFile
+  }) => {
+    const { currentProject, log, messages } = this;
+    const fileData = fromFile ? (0, import_file_provider.readJsonFile)(fromFile) || [] : [];
+    if (typeof fileData === "string")
+      throw new Error(`Import file format must be of type JSON`);
+    await this.ConnectContensisImport({
+      commit,
+      source: fromFile ? "file" : "contensis",
+      fileData,
+      fileDataType: "entries"
+    });
+    if (this.contensis) {
+      log.line();
+      if (this.contensis.isPreview) {
+        console.log(log.successText(` -- IMPORT PREVIEW -- `));
+      } else {
+        console.log(log.warningText(` *** COMMITTING IMPORT *** `));
+      }
+      const [migrateErr, migrateResult] = await this.contensis.MigrateEntries();
+      if (migrateErr)
+        (0, import_logger.logError)(migrateErr);
+      else
+        this.HandleFormattingAndOutput(migrateResult, () => {
+          (0, import_console.printMigrateResult)(this, migrateResult);
+        });
+    } else {
+      log.warning(messages.contenttypes.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+  PrintWebhookSubscriptions = async (subscriptionIds, name) => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [webhooksErr, webhooks] = await this.contensis.subscriptions.webhooks.GetSubscriptions();
+      const filteredResults = typeof name === "string" ? webhooks.filter(
+        (w) => {
+          var _a;
+          return (_a = w.name) == null ? void 0 : _a.toLowerCase().includes(name.toLowerCase());
+        }
+      ) : Array.isArray(subscriptionIds) ? webhooks.filter((w) => subscriptionIds == null ? void 0 : subscriptionIds.some((id) => id === w.id)) : webhooks;
+      if (Array.isArray(filteredResults)) {
+        this.HandleFormattingAndOutput(filteredResults, () => {
+          log.success(messages.webhooks.list(currentEnv));
+          for (const {
+            id,
+            description,
+            method,
+            name: name2,
+            version,
+            url: url2
+          } of filteredResults) {
+            console.log(
+              `  - ${name2}${description ? ` (${description})` : ""} [${version.modified.toString().substring(0, 10)} ${version.modifiedBy}]`
+            );
+            console.log(`      ${id}`);
+            console.log(`      [${method}] ${url2}`);
+          }
+          console.log("");
+        });
+      }
+      if (webhooksErr) {
+        log.error(messages.webhooks.noList(currentEnv));
+        log.error((0, import_json.jsonFormatter)(webhooksErr));
+      }
+    }
+  };
+  PrintBlocks = async () => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [err, blocks] = await this.contensis.blocks.GetBlocks();
+      if (Array.isArray(blocks)) {
+        this.HandleFormattingAndOutput(blocks, () => {
+          log.success(messages.blocks.list(currentEnv));
+          for (const {
+            id,
+            description,
+            branches,
+            liveVersion,
+            madeLive,
+            versionsSinceLive
+          } of blocks) {
+            console.log(
+              `  - ${id}${description ? ` (${description})` : ""}${madeLive ? ` [${madeLive.toString().substring(0, 10)} v${liveVersion}]` : ""}${versionsSinceLive ? log.warningText(` +${versionsSinceLive}`) : ""}`
+            );
+            for (const branch of branches)
+              console.log(
+                log.infoText(`      [${branch.id}]: ${branch.status}`)
+              );
+          }
+        });
+      }
+      if (err) {
+        log.error(messages.blocks.noList(currentEnv));
+        log.error((0, import_json.jsonFormatter)(err));
+      }
+    }
+  };
+  PrintBlockVersions = async (blockId, branch, version) => {
+    const { currentEnv, env, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [err, blocks] = await this.contensis.blocks.GetBlockVersions(
+        blockId,
+        branch,
+        version
+      );
+      if (blocks) {
+        this.HandleFormattingAndOutput(blocks, () => {
+          log.success(
+            messages.blocks.get(`${currentEnv}:${env.currentProject}`)
+          );
+          for (const block of blocks)
+            (0, import_console.printBlockVersion)(
+              this,
+              block,
+              !version ? {
+                showImage: false,
+                showSource: true,
+                showStaticPaths: false,
+                showStatus: false
+              } : void 0
+            );
+        });
+      }
+      if (err) {
+        log.error(messages.blocks.noList(currentEnv, env.currentProject));
+        log.error((0, import_json.jsonFormatter)(err));
+      }
+    }
+  };
+  PushBlock = async (block) => {
+    const { currentEnv, env, log, messages } = this;
+    messages.blocks.tryPush(
+      block.id,
+      block.source.branch,
+      currentEnv,
+      env.currentProject
+    );
+    console.log((0, import_json.jsonFormatter)(block));
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [err, blockVersion] = await this.contensis.blocks.PushBlockVersion(
+        block
+      );
+      if (!err) {
+        log.success(
+          messages.blocks.pushed(
+            block.id,
+            block.source.branch,
+            currentEnv,
+            env.currentProject
+          )
+        );
+        console.log((0, import_json.jsonFormatter)(blockVersion));
+      }
+      if (blockVersion) {
+        this.HandleFormattingAndOutput(blockVersion, () => {
+          (0, import_console.printBlockVersion)(this, blockVersion);
+        });
+      }
+      if (err)
+        throw new Error(
+          messages.blocks.failedPush(block.id, currentEnv, env.currentProject)
+        );
+    }
+  };
+  PrintBlockLogs = async (blockId, branch, version, dataCenter) => {
+    const { currentEnv, log, messages } = this;
+    if (!this.contensis)
+      await this.ConnectContensis();
+    if (this.contensis) {
+      const [err, blockLogs] = await this.contensis.blocks.GetBlockLogs({
+        blockId,
+        branchId: branch,
+        version,
+        dataCenter
+      });
+      if (blockLogs) {
+        this.HandleFormattingAndOutput(blockLogs, () => {
+          log.success(messages.blocks.list(currentEnv));
+          console.log(
+            `  - ${blockId} ${branch} ${Number(version) ? `v${version}` : version} [${dataCenter}]`
+          );
+          log.line();
+          console.log(log.infoText(blockLogs));
+          log.line();
+        });
+      }
+      if (err) {
+        log.error(messages.blocks.noList(currentEnv));
+        log.error((0, import_json.jsonFormatter)(err));
+      }
+    }
+  };
+  HandleFormattingAndOutput = (obj, logFn) => {
+    const { format, log, messages, output } = this;
+    if (output) {
+      let writeString = "";
+      if (format === "csv") {
+        writeString = (0, import_csv.csvFormatter)(obj);
+      } else if (format === "xml") {
+        writeString = (0, import_xml.xmlFormatter)(obj);
+      } else
+        writeString = (0, import_json.jsonFormatter)(obj);
+      if (writeString) {
+        import_fs.default.writeFileSync(output, writeString);
+        log.success(messages.app.fileOutput(format, output));
+      } else {
+        log.info(messages.app.noFileOutput());
+      }
+    } else {
+      if (!format) {
+        logFn(obj);
+      } else if (format === "csv") {
+        log.raw("");
+        log.raw(log.infoText((0, import_csv.csvFormatter)(obj)));
+      } else if (format === "xml") {
+        log.raw("");
+        log.raw(log.infoText((0, import_xml.xmlFormatter)(obj)));
+      } else if (format === "json") {
+        log.raw("");
+        log.raw(log.infoText((0, import_json.jsonFormatter)(obj)));
+      }
+      log.raw("");
+    }
+  };
+}
+const cliCommand = (commandArgs, outputOpts = {}, contensisOpts = {}) => {
+  return new ContensisCli(["", "", ...commandArgs], outputOpts, contensisOpts);
+};
+var ContensisCliService_default = ContensisCli;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cliCommand
+});
+//# sourceMappingURL=ContensisCliService.js.map