contensis-cli 1.0.0-beta.11 → 1.0.0-beta.13

package/src/services/ContensisCliService.ts

@@ -58,14 +58,17 @@ class ContensisCli {
     process.exit(exitCode);
   };
 
-  cache: SessionCache;
+  private command: CliCommand;
+  private format?: OutputFormat;
+  private output?: string;
+  private session: SessionCacheProvider;
+
   contensis?: ContensisMigrationService;
   contensisOpts: Partial<MigrateRequest>;
   contentTypes?: ContentType[];
   components?: Component[];
-  currentEnv: string;
   currentProject: string;
-  env: EnvironmentCache;
+
   sourceEnv?: string;
   targetEnv?: string;
   urls:
@@ -78,17 +81,41 @@ class ContensisCli {
         iisPreviewWeb: string;
       }
     | undefined;
-  private command: CliCommand;
-  private format?: OutputFormat;
-  private output?: string;
   log = Logger;
   messages = LogMessages;
-  private session: SessionCacheProvider;
 
   verb: string;
   noun: string;
   thirdArg: string;
 
+  get cache() {
+    return this.session.Get();
+  }
+  get currentEnv() {
+    return this.cache.currentEnvironment || '';
+  }
+
+  set currentEnv(currentEnvironment: string) {
+    this.session.Update({ currentEnvironment });
+  }
+
+  get env() {
+    const currentEnvironment = this.currentEnv;
+    const environments = this.cache.environments || {};
+
+    if (!currentEnvironment) return {} as EnvironmentCache;
+    else if (!!environments[currentEnvironment])
+      return environments[currentEnvironment];
+    else {
+      return {
+        history: [],
+        lastUserId: '',
+        projects: [],
+        versionStatus: 'latest',
+      } as EnvironmentCache;
+    }
+  }
+
   constructor(
     args: string[],
     outputOpts?: OutputOptions & IConnectOptions & IImportOptions,
@@ -106,38 +133,26 @@ class ContensisCli {
     }`.trim();
 
     this.session = new SessionCacheProvider();
-    this.cache = this.session.Get();
+
     this.contensisOpts = contensisOpts;
     this.format = outputOpts?.format;
     this.output =
       outputOpts?.output && path.join(process.cwd(), outputOpts.output);
 
-    const currentEnvironment =
-      outputOpts?.alias || this.cache.currentEnvironment || '';
+    const currentEnvironment = outputOpts?.alias || this.currentEnv;
     const environments = this.cache.environments || {};
-
-    if (!currentEnvironment) this.env = {} as EnvironmentCache;
-    else if (!!environments[currentEnvironment])
-      this.env = environments[currentEnvironment];
-    else {
-      this.env = {
-        history: [],
-        lastUserId: '',
-        projects: [],
-        versionStatus: 'latest',
-      };
-    }
+    this.currentEnv = currentEnvironment;
 
     const env = this.env;
 
     if (outputOpts?.projectId) env.currentProject = outputOpts.projectId;
     if (outputOpts?.user) env.lastUserId = outputOpts.user;
+    // setting this in env means passwordFallback is written to environments.json
     if (outputOpts?.password) env.passwordFallback = outputOpts.password;
     if (outputOpts?.clientId) env.lastUserId = outputOpts.clientId;
     if (outputOpts?.sharedSecret)
       env.passwordFallback = outputOpts.sharedSecret;
 
-    this.currentEnv = currentEnvironment;
     this.currentProject = env?.currentProject || 'null';
     this.sourceEnv = outputOpts?.sourceEnv || currentEnvironment;
 
@@ -154,7 +169,7 @@ class ContensisCli {
     if (currentEnvironment) {
       env.history = [this.command];
       if (commandText) {
-        environments[currentEnvironment] = this.env;
+        environments[currentEnvironment] = env;
         this.session.Update({
           currentEnvironment,
           environments,
@@ -181,45 +196,24 @@ class ContensisCli {
   };
 
   Connect = async (environment: string) => {
-    const { cache, log, messages, session } = this;
+    const { 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 = url(environment, 'website');
 
       const [fetchErr, response] = await to(fetch(this.urls.cms));
       if (response && response?.status < 400) {
         log.success(messages.connect.connected(environment));
+        session.UpdateEnv(this.env, environment);
 
         if (this.env?.lastUserId) {
-          await this.ConnectContensis();
+          // await this.ConnectContensis();
           await this.PrintProjects();
         } else {
           log.warning(messages.projects.noList());
           log.help(messages.connect.tip());
-          // cache.environments[environment] = {
-          //   versionStatus: 'published',
-          //   history: [],
-          //   lastUserId: '',
-          //   projects: [],
-          // };
         }
-
-        session.Update({
-          currentEnvironment: environment,
-          environments: cache.environments,
-        });
       } else {
         // Cannot reach environment - status X
         log.error(
@@ -238,19 +232,11 @@ class ContensisCli {
     const isGuidId = userId && isUuid(userId);
 
     if (currentEnv && userId) {
-      const [credentialError, credentials] = await new CredentialProvider(
-        {
-          userId,
-          alias: currentEnv,
-        },
+      const credentials = await this.GetCredentials(
+        userId,
         env.passwordFallback
-      ).Init();
+      );
 
-      if (credentialError && !credentials.current) {
-        // Log problem with Credential Provider
-        log.error(credentialError as any);
-        return;
-      }
       const cachedPassword = credentials?.current?.password;
 
       if (cachedPassword) {
@@ -314,36 +300,19 @@ class ContensisCli {
     const isTargetGuidId = targetUserId && isUuid(targetUserId);
 
     if (sourceUserId && currentEnv && targetUserId) {
-      const [sourceCredentialError, sourceCredentials] =
-        await new CredentialProvider(
-          {
-            userId: sourceUserId,
-            alias: currentEnv,
-          },
-          sourcePassword
-        ).Init();
+      const sourceCredentials = await this.GetCredentials(
+        sourceUserId,
+        sourcePassword,
+        sourceEnv
+      );
 
-      if (sourceCredentialError && !sourceCredentials.current) {
-        // Log problem with Credential Provider
-        logError(sourceCredentialError);
-        return;
-      }
       const cachedSourcePassword = sourceCredentials?.current?.password;
 
-      const [targetCredentialError, targetCredentials] =
-        await new CredentialProvider(
-          {
-            userId: targetUserId,
-            alias: currentEnv,
-          },
-          env.passwordFallback
-        ).Init();
+      const targetCredentials = await this.GetCredentials(
+        targetUserId,
+        env.passwordFallback
+      );
 
-      if (targetCredentialError && !targetCredentials.current) {
-        // Log problem with Credential Provider
-        log.error(targetCredentialError as any);
-        return;
-      }
       const cachedTargetPassword = targetCredentials?.current?.password;
 
       if (cachedSourcePassword && cachedTargetPassword) {
@@ -402,6 +371,34 @@ class ContensisCli {
     }
   };
 
+  GetCredentials = async (
+    userId: string,
+    password?: string,
+    currentEnv = this.currentEnv
+  ): Promise<CredentialProvider | undefined> => {
+    const { env, log, messages } = this;
+    if (userId) {
+      const [credentialError, credentials] = await new CredentialProvider(
+        { userId, alias: currentEnv },
+        password
+      ).Init();
+
+      if (credentialError && !credentials.current) {
+        // Log problem with Credential Provider
+        log.error(credentialError as any);
+        return;
+      }
+
+      if (credentials.remarks.secure !== true) {
+        log.warning(messages.login.insecurePassword());
+      } else {
+        env.passwordFallback = undefined;
+        this.session.UpdateEnv(env, currentEnv);
+      }
+      return credentials;
+    }
+  };
+
   Login = async (
     userId: string,
     {
@@ -409,111 +406,101 @@ class ContensisCli {
       promptPassword = true,
       sharedSecret = isSharedSecret(this.env.passwordFallback),
       silent = false,
+      attempt = 1,
     }: {
       password?: string;
       promptPassword?: boolean;
       sharedSecret?: string;
       silent?: boolean;
-    }
+      attempt?: number;
+    } = {}
   ): Promise<string | undefined> => {
-    let inputPassword = password;
+    let inputPassword = password || sharedSecret;
     const { log, messages } = this;
 
     if (userId) {
-      const { cache, currentEnv, env } = this;
+      const { currentEnv, env } = this;
 
       if (currentEnv) {
-        const [credentialError, credentials] = await new CredentialProvider(
-          { userId, alias: currentEnv },
-          inputPassword || sharedSecret
-        ).Init();
-
-        if (credentialError && !credentials.current) {
-          // Log problem with Credential Provider
-          log.error(credentialError as any);
-          return;
-        }
+        const credentials = await this.GetCredentials(userId, inputPassword);
+
+        if (credentials) {
+          const cachedPassword = isPassword(credentials.current?.password);
+          const cachedSecret = isSharedSecret(credentials.current?.password);
+
+          if (!cachedPassword && !cachedSecret && promptPassword) {
+            // Password prompt
+            ({ inputPassword } = await inquirer.prompt([
+              {
+                type: 'password',
+                message: messages.login.passwordPrompt(currentEnv, userId),
+                name: 'inputPassword',
+                mask: '*',
+                prefix: undefined,
+              },
+            ]));
+          }
 
-        if (credentials.remarks.secure !== true)
-          log.warning(messages.login.insecurePassword());
-
-        const cachedPassword = isPassword(credentials?.current?.password);
-        const cachedSecret = isSharedSecret(credentials?.current?.password);
-
-        if (
-          !sharedSecret &&
-          !inputPassword &&
-          !cachedPassword &&
-          !cachedSecret &&
-          promptPassword
-        ) {
-          // Password prompt
-          ({ inputPassword } = await inquirer.prompt([
-            {
-              type: 'password',
-              message: messages.login.passwordPrompt(currentEnv, userId),
-              name: 'inputPassword',
-              mask: '*',
-              prefix: undefined,
-            },
-          ]));
-        }
+          if (inputPassword || cachedPassword || cachedSecret) {
+            const authService = new ContensisAuthService({
+              username: userId,
+              password: inputPassword || cachedPassword,
+              projectId: env?.currentProject || 'website',
+              rootUrl: this.urls?.cms || '',
+              clientId: userId,
+              clientSecret: sharedSecret || cachedSecret,
+            });
+
+            const [authError, bearerToken] = await to(
+              authService.BearerToken()
+            );
 
-        if (sharedSecret || cachedSecret || inputPassword || cachedPassword) {
-          const authService = new ContensisAuthService({
-            username: userId,
-            password: inputPassword || cachedPassword,
-            projectId: env?.currentProject || 'website',
-            rootUrl: this.urls?.cms || '',
-            clientId: userId,
-            clientSecret: sharedSecret || cachedSecret,
-          });
-
-          const [authError, bearerToken] = await to(authService.BearerToken());
-
-          // Login successful
-          if (bearerToken) {
-            // Set env vars
-            env.authToken = bearerToken;
-            env.lastUserId = userId;
-            env.passwordFallback =
-              credentials.remarks.secure !== true
-                ? credentials.current?.password
-                : undefined;
-
-            if (!silent) {
-              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) {
-            Logger.error(authError.toString());
-            // Clear env vars
-            env.authToken = '';
-            env.lastUserId = '';
-            env.passwordFallback = undefined;
-
-            // If the auth error was raised using a cached password
-            if (
-              (cachedPassword || cachedSecret) &&
-              credentials.remarks.secure
-            ) {
-              // Remove any bad stored credential and trigger login prompt again
-              await credentials.Delete();
-              return await this.Login(userId, { password, sharedSecret });
-            } else {
-              throw new Error(messages.login.failed(currentEnv, userId));
+            // Login successful
+            if (bearerToken) {
+              // Set env vars
+              env.authToken = bearerToken;
+              env.lastUserId = userId;
+              env.passwordFallback =
+                credentials.remarks.secure !== true
+                  ? credentials.current?.password
+                  : undefined;
+              // Persist env before finding projects or doing anything else
+              this.session.UpdateEnv(env);
+
+              if (!silent) {
+                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) {
+              Logger.error(authError.toString());
+              // Clear env vars
+              env.authToken = '';
+              env.lastUserId = '';
+              env.passwordFallback = undefined;
+              // Persist env to remove cleared values
+              this.session.UpdateEnv(env);
+
+              // If the auth error was raised using a cached password
+              if (
+                (cachedPassword || cachedSecret) &&
+                credentials.remarks.secure
+              ) {
+                // Remove any bad stored credential and trigger login prompt again
+                await credentials.Delete();
+                return await this.Login(userId, { password, sharedSecret });
+              } else {
+                throw new Error(messages.login.failed(currentEnv, userId));
+              }
             }
-          }
 
-          // Persist env
-          this.session.Update({
-            environments: cache.environments,
-          });
-          return env.authToken;
-        } else {
-          Logger.error(messages.login.passwordPrompt(currentEnv, userId));
+            return env.authToken;
+          } else {
+            Logger.error(messages.login.passwordPrompt());
+            if (attempt < 2)
+              return await this.Login(userId, { attempt: attempt + 1 });
+          }
         }
       } else {
         // No environment set, use `contensis connect {alias}` first
@@ -526,7 +513,7 @@ class ContensisCli {
   };
 
   PrintProjects = async () => {
-    const { cache, currentEnv, currentProject, log, messages, session } = this;
+    const { currentProject, log, messages, session } = this;
     if (!this.contensis) await this.ConnectContensis();
 
     if (this.contensis) {
@@ -537,7 +524,6 @@ class ContensisCli {
 
       if (Array.isArray(projects)) {
         // save these projects in cache
-        const currentVals = cache.environments[currentEnv] || {};
         const nextCurrentProject =
           currentProject && currentProject !== 'null'
             ? currentProject
@@ -545,11 +531,10 @@ class ContensisCli {
             ? 'website'
             : undefined;
 
-        cache.environments[currentEnv] = {
-          ...currentVals,
+        session.UpdateEnv({
           projects: projects.map(p => p.id),
           currentProject: nextCurrentProject,
-        };
+        });
 
         log.success(messages.projects.list());
         this.HandleFormattingAndOutput(projects, () => {
@@ -563,28 +548,19 @@ class ContensisCli {
           }
         });
 
-        session.Update({
-          environments: cache.environments,
-        });
-
-        if (nextCurrentProject) {
-          this.env = cache.environments[currentEnv];
-          this.SetProject(nextCurrentProject);
-        }
+        if (!this.SetProject(nextCurrentProject))
+          log.warning(messages.projects.tip());
       }
 
       if (projectsErr) {
         log.error(messages.projects.noList());
         log.error(projectsErr.message);
       }
-      // } else {
-      //   log.warning(messages.projects.noList());
-      //   log.help(messages.connect.tip());
     }
   };
 
-  SetProject = async (projectId = '') => {
-    const { cache, env, log, messages, session } = this;
+  SetProject = (projectId = 'website') => {
+    const { env, log, messages, session } = this;
     let nextProjectId: string | undefined;
     if (env?.projects.length > 0 && env?.lastUserId) {
       nextProjectId = env.projects.find(
@@ -592,9 +568,7 @@ class ContensisCli {
       );
       if (nextProjectId) {
         env.currentProject = nextProjectId;
-        session.Update({
-          environments: cache.environments,
-        });
+        session.UpdateEnv(env);
         log.success(messages.projects.set(projectId));
       } else {
         log.error(messages.projects.failedSet(projectId));
@@ -607,8 +581,8 @@ class ContensisCli {
     return nextProjectId;
   };
 
-  SetVersion = async (versionStatus: 'latest' | 'published') => {
-    const { cache, env, log, messages, session } = this;
+  SetVersion = (versionStatus: 'latest' | 'published') => {
+    const { env, log, messages, session } = this;
     if (!['latest', 'published'].includes(versionStatus)) {
       log.error(messages.version.invalid(versionStatus));
       return false;
@@ -618,10 +592,7 @@ class ContensisCli {
       return false;
     }
     if (env?.projects.length > 0 && env?.lastUserId) {
-      env.versionStatus = versionStatus;
-      session.Update({
-        environments: cache.environments,
-      });
+      session.UpdateEnv({ versionStatus });
       log.success(messages.version.set(this.currentEnv, versionStatus));
       return true;
     } else {

package/src/shell.ts

@@ -72,8 +72,13 @@ class ContensisShell {
     );
   }
 
+  restart = async () => {
+    this.firstStart = false;
+    this.log.line(); // add a line so we can see where the shell has been restarted
+    await this.start();
+  };
+
   start = async () => {
-    this.log.line();
     this.refreshEnvironment();
     this.userId = '';
     const { currentEnvironment, env, log, messages } = this;
@@ -98,7 +103,10 @@ class ContensisShell {
               silent: true,
             }
           );
-          if (token) this.userId = env.lastUserId;
+          if (token) {
+            this.userId = env.lastUserId;
+            if (!env.currentProject) log.warning(messages.projects.tip());
+          }
           this.firstStart = false;
           this.refreshEnvironment();
         } else {
@@ -221,7 +229,10 @@ class ContensisShell {
 let globalShell: ContensisShell;
 
 export const shell = () => {
-  if (typeof process.argv?.[2] !== 'undefined') return { start() {} } as any;
+  // Return a benign function for shell().restart() when used in cli context
+  // as some commands need to restart the shell to show an updated prompt
+  // after successful connect / login / set project
+  if (typeof process.argv?.[2] !== 'undefined') return { restart() {} } as any;
   if (!globalShell) globalShell = new ContensisShell();
   return globalShell;
 };

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.11";
+export const LIB_VERSION = "1.0.0-beta.13";