contensis-cli 1.0.0-beta.9 → 1.0.0-beta.91

package/src/mappers/DevInit-to-CIWorkflow.ts

@@ -0,0 +1,150 @@
+import { JSONPath, JSONPathOptions } from 'jsonpath-plus';
+import { readFile } from '~/providers/file-provider';
+import ContensisDev from '~/services/ContensisDevService';
+import { diffFileContent } from '~/util/diff';
+import { GitHelper } from '~/util/git';
+import { logError } from '~/util/logger';
+import { parseYamlDocument, validateWorkflowYaml } from '~/util/yaml';
+
+type MappedWorkflowOutput = {
+  existingWorkflow: string;
+  newWorkflow: string;
+  diff: string;
+};
+
+export const mapCIWorkflowContent = (
+  cli: ContensisDev,
+  git: GitHelper
+): MappedWorkflowOutput | undefined => {
+  // get existing workflow file
+  const workflowFile = readFile(git.ciFilePath);
+  if (!workflowFile) return undefined;
+
+  const blockId = git.name;
+  if (git.type === 'github') {
+    const addGitHubActionJobStep = {
+      name: 'Push block to Contensis',
+      id: 'push-block',
+      uses: 'contensis/block-push@v1',
+      with: {
+        'block-id': blockId,
+        // 'image-uri': '${{ steps.build.outputs.image-uri }}',
+        alias: cli.currentEnv,
+        'project-id': cli.currentProject,
+        'client-id': '${{ secrets.CONTENSIS_CLIENT_ID }}',
+        'shared-secret': '${{ secrets.CONTENSIS_SHARED_SECRET }}',
+      },
+    };
+
+    // parse yaml to js
+    const workflowDoc = parseYamlDocument(workflowFile);
+    const workflow = workflowDoc.toJS();
+    const setWorkflowElement = (path: string | any[], value: any) => {
+      const findPath =
+        typeof path === 'string' && path.includes('.')
+          ? path
+              .split('.')
+              .map(p => (Number(p) || Number(p) !== 0 ? p : Number(p)))
+          : path;
+
+      if (workflowDoc.hasIn(findPath)) {
+        workflowDoc.setIn(findPath, value);
+      } else {
+        workflowDoc.addIn(findPath, value);
+        // }
+      }
+    };
+    const findExistingJobSteps = (
+      resultType: JSONPathOptions['resultType']
+    ) => {
+      // look for line in job
+      //   jobs.x.steps[uses: contensis/block-push]
+      const path =
+        git.type === 'github'
+          ? '$.jobs..steps.*[?(@property === "uses" && @.match(/^contensis\\/block-push/i))]^'
+          : // TODO: add jsonpath for gitlab file
+            '';
+
+      const existingJobStep = JSONPath({
+        path,
+        json: workflow,
+        resultType: resultType,
+      });
+
+      return existingJobStep;
+    };
+
+    const existingJobStep = findExistingJobSteps('all');
+
+    // update job step
+    if (existingJobStep.length) {
+      //cli.log.json(existingJobStep);
+
+      // The [0] index means we're only looking at updating the first instance in the file
+      const step = existingJobStep[0];
+
+      // Path looks like this "$['jobs']['build']['steps'][3]"
+      // We want it to look like this "jobs.build.steps.3"
+      const stepPath = step.path
+        .replace('$[', '')
+        .replaceAll('][', '.')
+        .replace(']', '')
+        .replaceAll("'", '');
+
+      cli.log.info(
+        `Found existing Job step: ${stepPath}
+          - name: ${step.value.name}
+            id: ${step.value.id}\n`
+      );
+
+      setWorkflowElement(`${stepPath}.with.alias`, cli.currentEnv);
+      setWorkflowElement(`${stepPath}.with.project-id`, cli.currentProject);
+      setWorkflowElement(`${stepPath}.with.block-id`, blockId);
+      setWorkflowElement(
+        `${stepPath}.with.client-id`,
+        '${{ secrets.CONTENSIS_CLIENT_ID }}'
+      );
+      setWorkflowElement(
+        `${stepPath}.with.shared-secret`,
+        '${{ secrets.CONTENSIS_SHARED_SECRET }}'
+      );
+    } else {
+      // create job with push step
+      workflowDoc.addIn(['jobs'], {
+        key: 'deploy',
+        value: {
+          name: 'Push image to Contensis',
+          'runs-on': 'ubuntu-latest',
+          steps: [addGitHubActionJobStep],
+        },
+      });
+    }
+
+    // Workflow validation provided by @action-validator/core package
+    const workflowIsValid = validateWorkflowYaml(workflowDoc.toString());
+
+    if (workflowIsValid === true) {
+      cli.log.debug(
+        `New file content to write to ${git.ciFilePath}\n\n${workflowDoc}`
+      );
+    } else if (Array.isArray(workflowIsValid)) {
+      // Errors
+      logError(
+        [
+          ...workflowIsValid.map(
+            res => new Error(`${res.code}: ${res.detail || res.title}`)
+          ),
+          workflowDoc.toString(),
+        ],
+        `GitHub workflow YAML did not pass validation check`
+      );
+    }
+    const newWorkflow = workflowDoc.toString({ lineWidth: 0 });
+
+    return {
+      existingWorkflow: workflowFile,
+      newWorkflow,
+      diff: diffFileContent(workflowFile, newWorkflow),
+    };
+  }
+};

package/src/mappers/DevInit-to-RolePermissions.ts

@@ -0,0 +1,33 @@
+import { Role } from 'contensis-management-api/lib/models';
+
+export const devKeyPermissions = { blocks: [] } as Partial<Role['permissions']>;
+
+export const deployKeyPermissions = { blocks: ['push', 'release'] } as Partial<
+  Role['permissions']
+>;
+
+export const devKeyRole = (
+  keyName: string,
+  description: string
+): Partial<Role> => ({
+  name: keyName,
+  description,
+  assignments: {
+    apiKeys: [keyName],
+  },
+  permissions: devKeyPermissions,
+  enabled: true,
+});
+
+export const deployKeyRole = (
+  keyName: string,
+  description: string
+): Partial<Role> => ({
+  name: keyName,
+  description,
+  assignments: {
+    apiKeys: [keyName],
+  },
+  permissions: deployKeyPermissions,
+  enabled: true,
+});

package/src/mappers/DevRequests-to-RequestHanderSiteConfigYaml.ts

@@ -0,0 +1,44 @@
+import ContensisCli from '~/services/ContensisCliService';
+
+interface ISiteConfigYaml {
+  alias: string;
+  projectId: string;
+  accessToken: string;
+  clientId: string;
+  sharedSecret: string;
+  blocks: {
+    id: string;
+    baseUri: string;
+  }[];
+}
+
+export const mapSiteConfigYaml = async (cli: ContensisCli) => {
+  const credentials = await cli.GetCredentials(cli.env.lastUserId);
+
+  const blocks = [];
+  const blocksRaw = await cli.PrintBlocks();
+
+  for (const block of blocksRaw || []) {
+    const versions = await cli.PrintBlockVersions(
+      block.id,
+      'default',
+      'latest'
+    );
+    if (versions?.[0]) {
+      blocks.push({
+        id: versions[0].id,
+        baseUri: versions[0].previewUrl,
+      });
+    }
+  }
+
+  const siteConfig: ISiteConfigYaml = {
+    alias: cli.currentEnv,
+    projectId: cli.currentProject,
+    accessToken: '',
+    clientId: credentials?.current?.account || '',
+    sharedSecret: credentials?.current?.password || '',
+    blocks,
+  };
+  return siteConfig;
+};

package/src/models/CliService.d.ts

@@ -0,0 +1,36 @@
+
+export type OutputFormat = 'json' | 'csv' | 'xml';
+
+export type OutputOptions = {
+  format?: OutputFormat;
+  output?: string;
+};
+
+export interface IConnectOptions extends IAuthOptions {
+  alias?: string;
+  projectId?: string;
+}
+
+export interface IAuthOptions {
+  user?: string;
+  password?: string;
+  clientId?: string;
+  sharedSecret?: string;
+}
+
+export interface IImportOptions {
+  sourceAlias?: string;
+  sourceProjectId?: string;
+}
+
+export type OutputOptionsConstructorArg = OutputOptions &
+  IConnectOptions &
+  IImportOptions;
+
+export interface ContensisCliConstructor {
+  new (
+    args: string[],
+    outputOpts?: OutputOptionsConstructorArg,
+    contensisOpts?: Partial<MigrateRequest>
+  ): ContensisCli;
+}

package/src/models/DevService.d.ts

@@ -0,0 +1,5 @@
+export type EnvContentsToAdd = {
+  ALIAS: string;
+  PROJECT: string;
+  ACCESS_TOKEN?: string;
+}

package/src/models/JsModules.d.ts

@@ -1 +1,2 @@
+declare module 'giturl';
 declare module 'inquirer-command-prompt';

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);