contensis-cli 1.0.0-beta.52 → 1.0.0-beta.53

package/src/models/Cache.d.ts

@@ -1,25 +1,25 @@
-type SessionCache = {
-  currentEnvironment?: string;
-  currentTimestamp: string;
-  environments: {
-    [alias: string]: EnvironmentCache;
-  };
-  history: string[];
-};
-
-type EnvironmentCache = {
-  lastUserId: string;
-  passwordFallback?: string;
-  authToken?: string;
-  currentProject?: string;
-  projects: string[];
-  history: CliCommand[];
-  versionStatus: 'latest' | 'published';
-};
-
-type CliCommand = {
-  createdDate: string;
-  createdUserId: string;
-  commandText: string;
-  result?: any;
-};
+type SessionCache = {
+  currentEnvironment?: string;
+  currentTimestamp: string;
+  environments: {
+    [alias: string]: EnvironmentCache;
+  };
+  history: string[];
+};
+
+type EnvironmentCache = {
+  lastUserId: string;
+  passwordFallback?: string;
+  authToken?: string;
+  currentProject?: string;
+  projects: string[];
+  history: CliCommand[];
+  versionStatus: 'latest' | 'published';
+};
+
+type CliCommand = {
+  createdDate: string;
+  createdUserId: string;
+  commandText: string;
+  result?: any;
+};

package/src/models/JsModules.d.ts

@@ -1 +1 @@
-declare module 'inquirer-command-prompt';
+declare module 'inquirer-command-prompt';

package/src/providers/CredentialProvider.ts

@@ -1,121 +1,121 @@
-import keytar from 'keytar';
-import to from 'await-to-js';
-import { Logger } from '~/util/logger';
-
-const SERVICE_NAME = 'contensis-cli';
-
-interface Remarks {
-  secure: boolean;
-}
-
-class CredentialProvider {
-  private serviceId: string;
-  private keytar!: typeof keytar;
-  private userId: string = '';
-  private passwordFallback?: string;
-
-  current: {
-    account: string;
-    password: string;
-  } | null = null;
-  remarks: Remarks = { secure: false };
-
-  constructor(
-    { userId, alias }: { userId: string; alias?: string },
-    passwordFallback?: string
-  ) {
-    this.serviceId =
-      typeof alias !== 'undefined' ? `${SERVICE_NAME}_${alias}` : SERVICE_NAME;
-    this.userId = userId;
-    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(
-      this.keytar.findCredentials(this.serviceId)
-    )) as [
-      Error,
-      {
-        account: string;
-        password: string;
-      }[]
-    ];
-    if (err && this.passwordFallback) {
-      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 (!this.current && this.passwordFallback) {
-        await this.Save(this.passwordFallback);
-        return await this.Init();
-      }
-    }
-    return [err, this];
-  };
-
-  Save = async (password: string) => {
-    const [err] = await to(
-      this.keytar.setPassword(this.serviceId, this.userId, password)
-    );
-
-    // if (!err) Logger.info(`${this.serviceId} - credentials saved`);
-    return err && !this.passwordFallback ? err : true;
-  };
-
-  Delete = async () => {
-    if (this.passwordFallback) {
-      this.passwordFallback = undefined;
-      return true;
-    } else {
-      const [err] = await to(
-        this.keytar.deletePassword(this.serviceId, this.userId)
-      );
-
-      Logger.warning(`${this.serviceId} - invalid credentials removed`);
-      return err || true;
-    }
-  };
-
-  // GetPassword = async () => {
-  //   const [err, password] = await to(
-  //     keytar.getPassword(this.serviceId, this.userId)
-  //   );
-
-  //   return err || password;
-  // };
-}
-
-export default CredentialProvider;
+import keytar from 'keytar';
+import to from 'await-to-js';
+import { Logger } from '~/util/logger';
+
+const SERVICE_NAME = 'contensis-cli';
+
+interface Remarks {
+  secure: boolean;
+}
+
+class CredentialProvider {
+  private serviceId: string;
+  private keytar!: typeof keytar;
+  private userId: string = '';
+  private passwordFallback?: string;
+
+  current: {
+    account: string;
+    password: string;
+  } | null = null;
+  remarks: Remarks = { secure: false };
+
+  constructor(
+    { userId, alias }: { userId: string; alias?: string },
+    passwordFallback?: string
+  ) {
+    this.serviceId =
+      typeof alias !== 'undefined' ? `${SERVICE_NAME}_${alias}` : SERVICE_NAME;
+    this.userId = userId;
+    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(
+      this.keytar.findCredentials(this.serviceId)
+    )) as [
+      Error,
+      {
+        account: string;
+        password: string;
+      }[]
+    ];
+    if (err && this.passwordFallback) {
+      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 (!this.current && this.passwordFallback) {
+        await this.Save(this.passwordFallback);
+        return await this.Init();
+      }
+    }
+    return [err, this];
+  };
+
+  Save = async (password: string) => {
+    const [err] = await to(
+      this.keytar.setPassword(this.serviceId, this.userId, password)
+    );
+
+    // if (!err) Logger.info(`${this.serviceId} - credentials saved`);
+    return err && !this.passwordFallback ? err : true;
+  };
+
+  Delete = async () => {
+    if (this.passwordFallback) {
+      this.passwordFallback = undefined;
+      return true;
+    } else {
+      const [err] = await to(
+        this.keytar.deletePassword(this.serviceId, this.userId)
+      );
+
+      Logger.warning(`${this.serviceId} - invalid credentials removed`);
+      return err || true;
+    }
+  };
+
+  // GetPassword = async () => {
+  //   const [err, password] = await to(
+  //     keytar.getPassword(this.serviceId, this.userId)
+  //   );
+
+  //   return err || password;
+  // };
+}
+
+export default CredentialProvider;

package/src/providers/SessionCacheProvider.ts

@@ -1,101 +1,101 @@
-import fs from 'fs';
-import path from 'path';
-import clone from 'lodash/cloneDeep';
-import mergeWith from 'lodash/mergeWith';
-import unionBy from 'lodash/unionBy';
-import { appRootDir } from './file-provider';
-import { isJson, tryParse } from '~/util';
-import { Logger } from '~/util/logger';
-
-class SessionCacheProvider {
-  private localFilePath: string;
-  private cache = {} as SessionCache;
-
-  constructor() {
-    this.localFilePath = path.join(appRootDir, 'environments.json');
-    this.cache = {
-      currentTimestamp: new Date().toISOString(),
-      environments: {},
-      history: [],
-    };
-    this.ReadCacheFromDisk();
-  }
-
-  private ReadCacheFromDisk = () => {
-    try {
-      if (fs.existsSync(this.localFilePath)) {
-        const raw = fs.readFileSync(this.localFilePath, 'utf-8');
-        if (isJson(raw)) this.cache = tryParse(raw);
-      } else {
-        this.WriteCacheToDisk();
-      }
-    } catch (ex) {
-      // Problem reading or parsing cache file
-    }
-  };
-
-  private WriteCacheToDisk = () => {
-    try {
-      fs.writeFileSync(this.localFilePath, JSON.stringify(this.cache, null, 2));
-    } catch (ex) {
-      // Problem writing session cache to file
-    }
-  };
-
-  Get = () => clone(this.cache);
-
-  Update = (updateContent: Partial<SessionCache>) => {
-    try {
-      this.cache = mergeWith(this.cache, updateContent, (val, src, key) => {
-        if (
-          key === 'history' &&
-          ((src?.[0] &&
-            typeof src[0] === 'object' &&
-            'createdDate' in src[0]) ||
-            (val?.[0] && typeof val[0] === 'object' && 'createdDate' in val[0]))
-        ) {
-          return unionBy(val, src, 'createdDate');
-        }
-        if (key === 'projects')
-          return Array.isArray(val) ? [...new Set([...val, ...src])] : src;
-
-        if (Array.isArray(val)) return val.concat(src);
-      });
-      this.cache.currentTimestamp = new Date().toISOString();
-      this.WriteCacheToDisk();
-    } catch (ex: any) {
-      // Problem merging cache data for update
-      Logger.error(`Problem updating environments.json`);
-      Logger.error(ex);
-    }
-    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;
+import fs from 'fs';
+import path from 'path';
+import clone from 'lodash/cloneDeep';
+import mergeWith from 'lodash/mergeWith';
+import unionBy from 'lodash/unionBy';
+import { appRootDir } from './file-provider';
+import { isJson, tryParse } from '~/util';
+import { Logger } from '~/util/logger';
+
+class SessionCacheProvider {
+  private localFilePath: string;
+  private cache = {} as SessionCache;
+
+  constructor() {
+    this.localFilePath = path.join(appRootDir, 'environments.json');
+    this.cache = {
+      currentTimestamp: new Date().toISOString(),
+      environments: {},
+      history: [],
+    };
+    this.ReadCacheFromDisk();
+  }
+
+  private ReadCacheFromDisk = () => {
+    try {
+      if (fs.existsSync(this.localFilePath)) {
+        const raw = fs.readFileSync(this.localFilePath, 'utf-8');
+        if (isJson(raw)) this.cache = tryParse(raw);
+      } else {
+        this.WriteCacheToDisk();
+      }
+    } catch (ex) {
+      // Problem reading or parsing cache file
+    }
+  };
+
+  private WriteCacheToDisk = () => {
+    try {
+      fs.writeFileSync(this.localFilePath, JSON.stringify(this.cache, null, 2));
+    } catch (ex) {
+      // Problem writing session cache to file
+    }
+  };
+
+  Get = () => clone(this.cache);
+
+  Update = (updateContent: Partial<SessionCache>) => {
+    try {
+      this.cache = mergeWith(this.cache, updateContent, (val, src, key) => {
+        if (
+          key === 'history' &&
+          ((src?.[0] &&
+            typeof src[0] === 'object' &&
+            'createdDate' in src[0]) ||
+            (val?.[0] && typeof val[0] === 'object' && 'createdDate' in val[0]))
+        ) {
+          return unionBy(val, src, 'createdDate');
+        }
+        if (key === 'projects')
+          return Array.isArray(val) ? [...new Set([...val, ...src])] : src;
+
+        if (Array.isArray(val)) return val.concat(src);
+      });
+      this.cache.currentTimestamp = new Date().toISOString();
+      this.WriteCacheToDisk();
+    } catch (ex: any) {
+      // Problem merging cache data for update
+      Logger.error(`Problem updating environments.json`);
+      Logger.error(ex);
+    }
+    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,76 +1,76 @@
-import fs from 'fs';
-import { homedir } from 'os';
-import path from 'path';
-import { tryParse } from '~/util';
-
-const userHomeDir = homedir();
-export const appRootDir = path.join(userHomeDir, '.contensis/');
-
-export const readJsonFile = <T>(filePath: string) => {
-  const file = readFile(filePath);
-  if (file) return tryParse(file) as T | string;
-  return undefined;
-};
-export const readFile = (filePath: string) => {
-  const directoryPath = localPath(filePath);
-  if (fs.existsSync(directoryPath)) {
-    const file = fs.readFileSync(directoryPath, 'utf8');
-    return file;
-  } else {
-    return undefined;
-  }
-};
-
-export const readFiles = (directory: string) => {
-  const directoryPath = localPath(directory);
-  if (fs.existsSync(directoryPath)) {
-    const files = fs.readdirSync(directoryPath);
-    return files;
-  } else {
-    fs.mkdirSync(directoryPath, { recursive: true });
-    return [];
-  }
-};
-
-export const writeFile = (filePath: string, content: string) => {
-  const directoryPath = localPath(filePath);
-  fs.writeFileSync(directoryPath, content, { encoding: 'utf-8' });
-};
-
-export const removeFile = (filePath: string) => {
-  const directoryPath = localPath(filePath);
-  if (fs.existsSync(directoryPath)) {
-    fs.rmSync(directoryPath);
-  }
-};
-
-export const moveFile = (file: string, fromPath: string, toPath: string) => {
-  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 });
-
-    fs.rename(from, to, err => {
-      if (err)
-        console.error(
-          `Could not rename file "${file}" from: ${fromPath} to: ${toPath}`,
-          err
-        );
-      console.info(`Renamed file "${file}" from: ${fromPath} to: ${toPath}`);
-    });
-  } else {
-    console.error(
-      `Could not rename file "${file}" from: ${fromPath} to: ${toPath}\nFile does not exist!`
-    );
-  }
-};
-
-export const checkDir = (filePath: string) => {
-  const directoryPath = path.dirname(localPath(filePath));
-  if (!fs.existsSync(directoryPath))
-    fs.mkdirSync(directoryPath, { recursive: true });
-};
-
-export const localPath = (filePath: string) =>
-  path.isAbsolute(filePath) ? filePath : path.join(appRootDir, filePath);
+import fs from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+import { tryParse } from '~/util';
+
+const userHomeDir = homedir();
+export const appRootDir = path.join(userHomeDir, '.contensis/');
+
+export const readJsonFile = <T>(filePath: string) => {
+  const file = readFile(filePath);
+  if (file) return tryParse(file) as T | string;
+  return undefined;
+};
+export const readFile = (filePath: string) => {
+  const directoryPath = localPath(filePath);
+  if (fs.existsSync(directoryPath)) {
+    const file = fs.readFileSync(directoryPath, 'utf8');
+    return file;
+  } else {
+    return undefined;
+  }
+};
+
+export const readFiles = (directory: string) => {
+  const directoryPath = localPath(directory);
+  if (fs.existsSync(directoryPath)) {
+    const files = fs.readdirSync(directoryPath);
+    return files;
+  } else {
+    fs.mkdirSync(directoryPath, { recursive: true });
+    return [];
+  }
+};
+
+export const writeFile = (filePath: string, content: string) => {
+  const directoryPath = localPath(filePath);
+  fs.writeFileSync(directoryPath, content, { encoding: 'utf-8' });
+};
+
+export const removeFile = (filePath: string) => {
+  const directoryPath = localPath(filePath);
+  if (fs.existsSync(directoryPath)) {
+    fs.rmSync(directoryPath);
+  }
+};
+
+export const moveFile = (file: string, fromPath: string, toPath: string) => {
+  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 });
+
+    fs.rename(from, to, err => {
+      if (err)
+        console.error(
+          `Could not rename file "${file}" from: ${fromPath} to: ${toPath}`,
+          err
+        );
+      console.info(`Renamed file "${file}" from: ${fromPath} to: ${toPath}`);
+    });
+  } else {
+    console.error(
+      `Could not rename file "${file}" from: ${fromPath} to: ${toPath}\nFile does not exist!`
+    );
+  }
+};
+
+export const checkDir = (filePath: string) => {
+  const directoryPath = path.dirname(localPath(filePath));
+  if (!fs.existsSync(directoryPath))
+    fs.mkdirSync(directoryPath, { recursive: true });
+};
+
+export const localPath = (filePath: string) =>
+  path.isAbsolute(filePath) ? filePath : path.join(appRootDir, filePath);