contensis-cli 1.0.0-beta.5

package/src/providers/SessionCacheProvider.ts

@@ -0,0 +1,74 @@
+import fs from 'fs';
+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 { Logger } from '~/util/logger';
+
+class SessionCacheProvider {
+  private localFilePath: string;
+  private cache = {} as SessionCache;
+
+  constructor() {
+    this.localFilePath = path.join(__dirname, '../../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();
+  };
+}
+
+export default SessionCacheProvider;

package/src/providers/file-provider.ts

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import { path as appRoot } from 'app-root-path';
+import { tryParse } from '~/util';
+
+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(appRoot, `${fromPath}${file}`);
+  const to = path.join(appRoot, `${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.join(appRoot, filePath);

package/src/services/ContensisAuthService.ts

@@ -0,0 +1,70 @@
+import { NodejsClient } from 'contensis-management-api/lib/client';
+import { ClientGrants, ClientGrantType } from 'contensis-core-api';
+
+class ContensisAuthService {
+  private client: NodejsClient;
+
+  constructor({
+    clientId = '',
+    clientSecret = '',
+    username,
+    password,
+    refreshToken,
+    projectId,
+    rootUrl,
+  }: {
+    clientId?: string;
+    clientSecret?: string;
+    username?: string;
+    password?: string;
+    refreshToken?: string;
+    projectId: string;
+    rootUrl: string;
+  }) {
+    let credentials: {
+      clientType: ClientGrantType;
+      clientDetails: ClientGrants;
+    };
+    if (username && password) {
+      credentials = {
+        clientType: 'contensis_classic',
+        clientDetails: {
+          username,
+          password,
+        },
+      };
+    } else if (refreshToken) {
+      credentials = {
+        clientType: 'contensis_classic_refresh_token',
+        clientDetails: {
+          refreshToken,
+        },
+      };
+    } else {
+      credentials = {
+        clientType: 'client_credentials',
+        clientDetails: {
+          clientId,
+          clientSecret,
+        },
+      };
+    }
+
+    this.client = NodejsClient.create({
+      ...credentials,
+      projectId,
+      rootUrl,
+    });
+  }
+
+  BearerToken = async () =>
+    this.client.bearerToken || (await this.client.ensureBearerToken());
+  RefreshToken = async () =>
+    !this.client.isRefreshTokenExpired() ? this.client.refreshToken : null;
+
+  /* PROJECTS */
+  ProjectId = () => this.client.clientConfig.projectId;
+  RootUrl = () => this.client.clientConfig.rootUrl;
+}
+
+export default ContensisAuthService;