contensis-cli 1.0.0-beta.10 → 1.0.0-beta.100

package/src/providers/CredentialProvider.ts

@@ -10,6 +10,7 @@ interface Remarks {
 
 class CredentialProvider {
   private serviceId: string;
+  private keytar!: typeof keytar;
   private userId: string = '';
   private passwordFallback?: string;
 
@@ -29,36 +30,61 @@ class CredentialProvider {
     this.passwordFallback = passwordFallback;
   }
 
+  Import = async () => {
+    try {
+      this.keytar = (await import('keytar')).default;
+    } catch (ex) {
+      this.keytar = {
+        findCredentials: async () => {
+          throw ex;
+        },
+        getPassword: async () => {
+          throw ex;
+        },
+        findPassword: async () => {
+          throw ex;
+        },
+        setPassword: async () => {
+          throw ex;
+        },
+        deletePassword: async () => {
+          throw ex;
+        },
+      };
+    }
+  };
+
   Init = async (): Promise<[Error, CredentialProvider]> => {
+    await this.Import();
+
     const [err, stored] = (await to(
-      keytar.findCredentials(this.serviceId)
-    )) as [
-      Error,
-      {
-        account: string;
-        password: string;
-      }[]
-    ];
+      this.keytar.getPassword(this.serviceId, this.userId)
+    )) as [Error, string];
+
     if (err && this.passwordFallback) {
-      this.current = { account: this.userId, password: this.passwordFallback };
-      // this.remarks = { secure: false };
+      this.current = {
+        account: this.userId,
+        password: this.passwordFallback,
+      };
     }
     if (!err) {
       this.remarks = { secure: true };
-      this.current =
-        stored?.find(
-          u => u?.account?.toLowerCase() === this.userId.toLowerCase()
-        ) || null;
+      if (stored) this.current = { account: this.userId, password: stored };
+
+      if (!this.current && this.passwordFallback) {
+        await this.Save(this.passwordFallback);
+        return await this.Init();
+      }
     }
     return [err, this];
   };
 
   Save = async (password: string) => {
     const [err] = await to(
-      keytar.setPassword(this.serviceId, this.userId, password)
+      this.keytar.setPassword(this.serviceId, this.userId, password)
     );
 
-    if (!err) Logger.info(`${this.serviceId} - credentials saved`);
+    // if (!err) Logger.info(`${this.serviceId} - credentials saved`);
     return err && !this.passwordFallback ? err : true;
   };
 
@@ -68,10 +94,17 @@ class CredentialProvider {
       return true;
     } else {
       const [err] = await to(
-        keytar.deletePassword(this.serviceId, this.userId)
+        this.keytar.deletePassword(this.serviceId, this.userId)
       );
 
-      Logger.warning(`${this.serviceId} - invalid credentials removed`);
+      if (err)
+        Logger.warning(
+          `${this.serviceId} - could not remove invalid credentials for ${this.userId}`
+        );
+      else
+        Logger.warning(
+          `${this.serviceId} - invalid credentials removed for ${this.userId}`
+        );
       return err || true;
     }
   };

package/src/providers/SessionCacheProvider.ts

@@ -3,7 +3,8 @@ import path from 'path';
 import clone from 'lodash/cloneDeep';
 import mergeWith from 'lodash/mergeWith';
 import unionBy from 'lodash/unionBy';
-import { isJson, tryParse, tryStringify } from '~/util';
+import { appRootDir } from './file-provider';
+import { isJson, tryParse } from '~/util';
 import { Logger } from '~/util/logger';
 
 class SessionCacheProvider {
@@ -11,7 +12,7 @@ class SessionCacheProvider {
   private cache = {} as SessionCache;
 
   constructor() {
-    this.localFilePath = path.join(__dirname, '../../environments.json');
+    this.localFilePath = path.join(appRootDir, 'environments.json');
     this.cache = {
       currentTimestamp: new Date().toISOString(),
       environments: {},
@@ -69,6 +70,32 @@ class SessionCacheProvider {
     }
     return this.Get();
   };
+
+  UpdateEnv = (
+    updateContent: Partial<EnvironmentCache>,
+    env = this.cache.currentEnvironment,
+    setCurrentEnv = true
+  ) => {
+    try {
+      const environment = this.cache.environments[env || ''];
+
+      this.cache.environments[env || ''] = {
+        ...environment,
+        ...updateContent,
+      };
+      this.Update({
+        currentEnvironment: setCurrentEnv ? env : this.cache.currentEnvironment,
+        environments: this.cache.environments,
+      });
+    } catch (ex: any) {
+      // Problem merging cache data for update
+      Logger.error(
+        `Problem updating environment "${env}" in environments.json`
+      );
+      Logger.error(ex);
+    }
+    return this.Get();
+  };
 }
 
 export default SessionCacheProvider;

package/src/providers/file-provider.ts

@@ -1,8 +1,15 @@
 import fs from 'fs';
+import { homedir } from 'os';
 import path from 'path';
-import { path as appRoot } from 'app-root-path';
 import { tryParse } from '~/util';
 
+const userHomeDir = homedir();
+
+export const appRootDir =
+  process.env.CONTAINER_CONTEXT === 'true'
+    ? process.cwd()
+    : path.join(userHomeDir, '.contensis/');
+
 export const readJsonFile = <T>(filePath: string) => {
   const file = readFile(filePath);
   if (file) return tryParse(file) as T | string;
@@ -18,14 +25,17 @@ export const readFile = (filePath: string) => {
   }
 };
 
-export const readFiles = (directory: string) => {
+export const readFiles = (directory: string, createDirectory = true) => {
   const directoryPath = localPath(directory);
   if (fs.existsSync(directoryPath)) {
     const files = fs.readdirSync(directoryPath);
     return files;
-  } else {
+  } else if (createDirectory) {
     fs.mkdirSync(directoryPath, { recursive: true });
     return [];
+  } else {
+    throw new Error(`ENOENT: Directory does not exist ${directoryPath}`);
+    // return undefined;
   }
 };
 
@@ -42,8 +52,8 @@ export const removeFile = (filePath: string) => {
 };
 
 export const moveFile = (file: string, fromPath: string, toPath: string) => {
-  const from = path.join(appRoot, `${fromPath}${file}`);
-  const to = path.join(appRoot, `${toPath}${file}`);
+  const from = path.join(appRootDir, `${fromPath}${file}`);
+  const to = path.join(appRootDir, `${toPath}${file}`);
   if (fs.existsSync(from)) {
     checkDir(toPath);
     // if (!fs.existsSync(toPath)) fs.mkdirSync(toPath, { recursive: true });
@@ -69,4 +79,5 @@ export const checkDir = (filePath: string) => {
     fs.mkdirSync(directoryPath, { recursive: true });
 };
 
-export const localPath = (filePath: string) => path.join(appRoot, filePath);
+export const localPath = (filePath: string) =>
+  path.isAbsolute(filePath) ? filePath : path.join(appRootDir, filePath);