contensis-cli 1.0.0-beta.82 → 1.0.0-beta.84

package/src/commands/index.ts

@@ -3,6 +3,7 @@ import { Logger } from '~/util/logger';
 import { LIB_VERSION } from '~/version';
 import { makeConnectCommand } from './connect';
 import { makeCreateCommand } from './create';
+import { makeDevCommand } from './dev';
 import { makeDiffCommand } from './diff';
 import { makeExecuteCommand } from './execute';
 import { makeGetCommand } from './get';
@@ -49,6 +50,11 @@ const commands = () => {
   program.addCommand(
     addGlobalOptions(makeCreateCommand()).copyInheritedSettings(program)
   );
+  program.addCommand(
+    addConnectOptions(
+      addAuthenticationOptions(makeDevCommand())
+    ).copyInheritedSettings(program)
+  );
   program.addCommand(
     addGlobalOptions(makeExecuteCommand()).copyInheritedSettings(program)
   );

package/src/localisation/en-GB.ts

@@ -4,7 +4,9 @@ import {
   MigrateModelsResult,
   MigrateStatus,
 } from 'migratortron';
+import { GitHelper } from '~/util/git';
 import { Logger } from '~/util/logger';
+import { winSlash } from '~/util/os';
 
 export const LogMessages = {
   app: {
@@ -411,4 +413,87 @@ export const LogMessages = {
         id
       )}`,
   },
+  devinit: {
+    intro: () => `Contensis developer environment initialisation`,
+    //`This will initialise your local working directory to develop with the current connected Contensis project`,
+    projectDetails: (
+      name: string,
+      env: string,
+      projectId: string,
+      git: GitHelper
+    ) =>
+      `Project: ${Logger.highlightText(name)} set arg --name to override
+  - Home: ${Logger.standardText(process.cwd())}
+  - Repository: ${git.home} 
+    
+Connect to Contensis instance: ${Logger.standardText(env)}
+  - Project id: ${Logger.standardText(projectId)}`,
+    developmentKey: (name: string, existing: boolean) =>
+      `  - ${
+        !existing ? 'Create development API key' : 'Development API key found'
+      }: ${Logger[!existing ? 'highlightText' : 'standardText'](name)}`,
+    deploymentKey: (name: string, existing: boolean) =>
+      `  - ${
+        !existing ? 'Create deployment API key' : 'Deployment API key found'
+      }: ${Logger[!existing ? 'highlightText' : 'standardText'](name)}`,
+    ciIntro: (git: GitHelper) =>
+      `We will create API keys with permissions to use this project with Contensis, and add a job to your CI that will deploy a container build. We will ask you to add secrets/variables to your git repository to give your workflow permission to push a Block to Contensis.
+
+You could visit ${git.secretsUri} to check that you can see repository settings`,
+    ciDetails: (filename: string) =>
+      `Add push-block job to CI file: ${Logger.highlightText(filename)}\n`,
+    confirm: () =>
+      `Confirm these details are correct so we can make changes to your project`,
+    accessTokenPrompt: () =>
+      `Please supply the access token for the Delivery API (optional)`,
+    createDevKey: (keyName: string, existing: boolean) =>
+      `${
+        !existing ? 'Created' : 'Checked permissions for'
+      } development API key ${Logger.standardText(keyName)}`,
+    createDeployKey: (keyName: string, existing: boolean) =>
+      `${
+        !existing ? 'Created' : 'Checked permissions for'
+      } deployment API key ${Logger.standardText(keyName)}`,
+    createKeyFail: (keyName: string, existing: boolean) =>
+      `Failed to ${
+        !existing ? 'create' : 'update'
+      } API key ${Logger.highlightText(keyName)}`,
+    writeEnvFile: () => `Written .env file to project home directory`,
+    useEnvFileTip: () =>
+      `You should alter existing project code that connects a Contensis client to use the variables from this file`,
+    writeCiFile: (ciFilePath: string) =>
+      `Updated CI file ${Logger.standardText(winSlash(ciFilePath))}`,
+    ciBlockTip: (blockId: string, env: string, projectId: string) =>
+      `A job is included to deploy your built container image to ${Logger.standardText(
+        projectId
+      )} at ${Logger.standardText(env)} in a block called ${Logger.standardText(
+        blockId
+      )}`,
+    addGitSecretsIntro: () =>
+      `We have ceated an API key that allows you to deploy your app image to a Contensis Block but we need you to add these details to your GitLab repository.`,
+    addGitSecretsHelp: (git: GitHelper, id: string, secret: string) =>
+      `Add secrets or variables in your repository's settings page\n\nGo to ${Logger.highlightText(
+        git.secretsUri
+      )}\n\n${
+        git.type === 'github'
+          ? `Add a "New repository secret"`
+          : `Expand "Variables" and hit "Add variable"`
+      }\n\n    ${
+        git.type === 'github' ? `Secret name:` : `Key:`
+      } ${Logger.highlightText(`CONTENSIS_CLIENT_ID`)}\n    ${
+        git.type === 'github' ? `Secret:` : `Value:`
+      } ${Logger.highlightText(
+        id
+      )}\n\n ${`Add one more secret/variable to the repository`}\n\n    ${
+        git.type === 'github' ? `Secret name:` : `Key:`
+      } ${Logger.highlightText(`CONTENSIS_SHARED_SECRET`)}\n    ${
+        git.type === 'github' ? `Secret:` : `Value:`
+      } ${Logger.highlightText(secret)}`,
+    success: () => `Contensis developer environment initialisation complete`,
+    partialSuccess: () =>
+      `Contensis developer environment initialisation completed with errors`,
+    failed: () => `Contensis developer environment initialisation failed`,
+    startProjectTip: () =>
+      `Start up your project in the normal way for development`,
+  },
 };

package/src/models/JsModules.d.ts

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

package/src/providers/file-provider.ts

@@ -25,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;
   }
 };
 

package/src/services/ContensisCliService.ts

@@ -4,20 +4,9 @@ import fetch from 'node-fetch';
 import inquirer from 'inquirer';
 import to from 'await-to-js';
 import chalk from 'chalk';
+
 import { Component, ContentType, Project } from 'contensis-core-api';
-import {
-  isPassword,
-  isSharedSecret,
-  isUuid,
-  tryParse,
-  tryStringify,
-  url,
-} from '~/util';
-import SessionCacheProvider from '../providers/SessionCacheProvider';
-import ContensisAuthService from './ContensisAuthService';
-import CredentialProvider from '~/providers/CredentialProvider';
-import { logError, Logger } from '~/util/logger';
-import { LogMessages } from '~/localisation/en-GB';
+import { Entry, Role } from 'contensis-management-api/lib/models';
 import {
   ContensisMigrationService,
   MigrateRequest,
@@ -29,20 +18,36 @@ import {
   MigrateModelsResult,
   BlockActionType,
 } from 'migratortron';
-import { Entry, Role } from 'contensis-management-api/lib/models';
 
-import { csvFormatter } from '~/util/csv.formatter';
-import { xmlFormatter } from '~/util/xml.formatter';
-import { jsonFormatter } from '~/util/json.formatter';
-import { diffLogStrings } from '~/util/diff';
-import { promiseDelay } from '~/util/timers';
+import ContensisAuthService from './ContensisAuthService';
+
+import { LogMessages } from '~/localisation/en-GB';
+
+import { readJsonFile } from '~/providers/file-provider';
+import SessionCacheProvider from '../providers/SessionCacheProvider';
+import CredentialProvider from '~/providers/CredentialProvider';
+
+import {
+  isPassword,
+  isSharedSecret,
+  isUuid,
+  tryParse,
+  tryStringify,
+  url,
+} from '~/util';
 import {
   printBlockVersion,
   printMigrateResult,
   printModelMigrationAnalysis,
   printModelMigrationResult,
 } from '~/util/console.printer';
-import { readJsonFile } from '~/providers/file-provider';
+import { csvFormatter } from '~/util/csv.formatter';
+import { xmlFormatter } from '~/util/xml.formatter';
+import { jsonFormatter } from '~/util/json.formatter';
+import { diffLogStrings } from '~/util/diff';
+import { logError, Logger } from '~/util/logger';
+import { promiseDelay } from '~/util/timers';
+
 
 type OutputFormat = 'json' | 'csv' | 'xml';
 
@@ -68,6 +73,17 @@ interface IImportOptions {
   sourceProjectId?: string;
 }
 
+export type OutputOptionsConstructorArg = OutputOptions &
+  IConnectOptions &
+  IImportOptions;
+
+export interface ContensisCliConstructor {
+  new (
+    args: string[],
+    outputOpts?: OutputOptionsConstructorArg,
+    contensisOpts?: Partial<MigrateRequest>
+  ): ContensisCli;
+}
 let insecurePasswordWarningShown = false;
 
 class ContensisCli {
@@ -138,7 +154,12 @@ class ContensisCli {
 
   constructor(
     args: string[],
-    outputOpts?: OutputOptions & IConnectOptions & IImportOptions,
+    outputOpts?: OutputOptionsConstructorArg,
+    contensisOpts?: Partial<MigrateRequest>
+  );
+  constructor(
+    args: string[],
+    outputOpts?: OutputOptionsConstructorArg,
     contensisOpts: Partial<MigrateRequest> = {}
   ) {
     // console.log('args: ', JSON.stringify(args, null, 2));
@@ -1834,6 +1855,8 @@ class ContensisCli {
               );
           }
         });
+
+        return blocks;
       }
 
       if (err) {
@@ -1878,6 +1901,8 @@ class ContensisCli {
                 : undefined
             );
         });
+
+        return blocks;
       }
 
       if (err) {
@@ -2282,7 +2307,7 @@ class ContensisCli {
 
 export const cliCommand = (
   commandArgs: string[],
-  outputOpts: OutputOptions & IConnectOptions = {},
+  outputOpts: OutputOptionsConstructorArg,
   contensisOpts: Partial<MigrateRequest> = {}
 ) => {
   return new ContensisCli(['', '', ...commandArgs], outputOpts, contensisOpts);

package/src/services/ContensisDevService.ts

@@ -0,0 +1,243 @@
+import { execFile, spawn } from 'child_process';
+import inquirer from 'inquirer';
+import path from 'path';
+
+import { MigrateRequest } from 'migratortron';
+import { stringify } from 'yaml';
+
+import ContensisCli, {
+  OutputOptionsConstructorArg,
+} from './ContensisCliService';
+import { mapSiteConfigYaml } from '~/mappers/ContensisCliService-to-RequestHanderSiteConfigYaml';
+import { appRootDir, writeFile } from '~/providers/file-provider';
+import { jsonFormatter } from '~/util/json.formatter';
+import { GitHelper } from '~/util/git';
+
+class ContensisDev extends ContensisCli {
+  constructor(
+    args: string[],
+    outputOpts?: OutputOptionsConstructorArg,
+    contensisOpts: Partial<MigrateRequest> = {}
+  ) {
+    super(args, outputOpts, contensisOpts);
+  }
+
+  DevelopmentInit = async (projectHome: string, opts: any) => {
+    const { currentEnv, currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve keys list for env
+      const [keysErr, apiKeys] = await contensis.apiKeys.GetKeys();
+      if (keysErr) {
+        log.error(messages.keys.noList(currentEnv));
+        log.error(jsonFormatter(keysErr));
+        return;
+      }
+      const apiKeyExists = (findKey: string) =>
+        apiKeys?.find(
+          k => k.name.trim().toLowerCase() === findKey?.trim().toLowerCase()
+        );
+
+      // Retrieve git info
+      const git = new GitHelper(projectHome);
+
+      // Retrieve ci workflow info
+      const workflowFiles = git.workflows;
+
+      // Set variables for logging etc.
+      let ciFileName = git.ciFileName;
+
+      const devKey = `${git.name} development`;
+      const deployKey = `${git.name} deployment`;
+      const blockId = git.name;
+
+      // Start render console output
+      log.raw('');
+      log.success(messages.devinit.intro());
+      log.raw('');
+      log.raw(
+        log.infoText(
+          messages.devinit.projectDetails(
+            git.name,
+            currentEnv,
+            currentProject,
+            git
+          )
+        )
+      );
+      log.raw(
+        log.infoText(
+          messages.devinit.developmentKey(devKey, !!apiKeyExists(devKey))
+        )
+      );
+      log.raw(
+        log.infoText(
+          messages.devinit.deploymentKey(deployKey, !!apiKeyExists(deployKey))
+        )
+      );
+      log.raw('');
+
+      if (Array.isArray(workflowFiles) && workflowFiles.length > 1) {
+        // Choose GitHub workflow file (if multiple)
+        ({ ciFileName } = await inquirer.prompt([
+          {
+            type: 'list',
+            message: `Multiple GitHub workflow files found\n${log.infoText(
+              `Tell us which GitHub workflow builds the container image after each push:`
+            )}`,
+            name: 'ciFileName',
+            choices: workflowFiles,
+            default: workflowFiles.find(f => f.includes('docker')),
+          },
+        ]));
+        log.raw('');
+      }
+
+      log.raw(log.infoText(messages.devinit.ciDetails(ciFileName)));
+      log.help(messages.devinit.ciIntro(git));
+
+      // Confirm prompt
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          message: messages.devinit.confirm(),
+          name: 'confirm',
+          default: false,
+        },
+      ]);
+      log.raw('');
+      if (!confirm) return;
+
+      // Access token prompt
+      const { accessToken } = await inquirer.prompt([
+        {
+          type: 'input',
+          message: messages.devinit.accessTokenPrompt(),
+          name: 'accessToken',
+        },
+      ]);
+      log.raw('');
+
+      // Magic happens...
+
+      // Arrange API keys for development and deployment
+      log.success(messages.devinit.createDevKey(devKey, false));
+      log.success(messages.devinit.createDeployKey(deployKey, true));
+
+      // Update or create a file called .env in project home
+      log.success(messages.devinit.writeEnvFile());
+      // log.help(messages.devinit.useEnvFileTip());
+
+      // Update CI file -- different for GH/GL -- create a sample one with build?
+      log.success(messages.devinit.writeCiFile(`./${ciFileName}`));
+      log.info(
+        messages.devinit.ciBlockTip(blockId, currentEnv, currentProject)
+      );
+
+      // Echo Deployment API key to console, ask user to add secrets to repo
+      log.warning(messages.devinit.addGitSecretsIntro());
+      log.help(
+        messages.devinit.addGitSecretsHelp(git, '123-456', '789-012-345')
+      );
+
+      log.success(messages.devinit.success());
+      log.help(messages.devinit.startProjectTip());
+    }
+  };
+
+  ExecRequestHandler = async (blockIds: string[], overrideArgs?: string[]) => {
+    // if no request handler exe
+    // download it.
+
+    // if update arg, redownload it
+
+    const { log } = this;
+    // const getPrefixOld = log.getPrefix;
+    const exeHome = path.join(appRootDir, 'reqhan');
+    const exe = 'Zengenti.Contensis.RequestHandler.LocalDevelopment';
+    const exePath = path.join(exeHome, exe);
+    const siteConfigPath = path.join(appRootDir, 'site_config.yaml');
+
+    const siteConfig = await mapSiteConfigYaml(this);
+    writeFile('site_config.yaml', stringify(siteConfig));
+
+    const args = overrideArgs
+      ? typeof overrideArgs?.[0] === 'string' &&
+        overrideArgs[0].includes(' ', 2)
+        ? overrideArgs[0].split(' ')
+        : overrideArgs
+      : []; // args could be [ '-c .\\site_config.yaml' ] or [ '-c', '.\\site_config.yaml' ]
+
+    // Add required args
+    if (!args.find(a => a === '-c')) args.push('-c', siteConfigPath);
+
+    // const child = execFile(exePath, args);
+
+    const child = spawn(exePath, args, { stdio: 'inherit' });
+
+    // log.raw('');
+    log.info(`Launching request handler...`);
+    if (overrideArgs?.length)
+      this.log.warning(
+        `Spawning process with supplied args: ${JSON.stringify(
+          child.spawnargs,
+          null,
+          2
+        )}`
+      );
+
+    let isRunning = false;
+
+    // Log child output through event listeners
+    child?.stdout?.on('data', data => {
+      isRunning = true;
+      log.raw(data);
+    });
+
+    child?.stderr?.on('data', data => {
+      log.error(data);
+    });
+
+    child.on('spawn', () => {
+      isRunning = true;
+      log.help(
+        `You may see a firewall popup requesting network access, it is safe to approve`
+      );
+      // log.getPrefix = () => Logger.infoText(`[rqh]`);
+    });
+
+    child.on('exit', code => {
+      isRunning = false;
+
+      log[code === 0 ? 'success' : 'warning'](
+        `Request handler exited with code ${code}\n`
+      );
+    });
+
+    child.on('error', error => {
+      isRunning = false;
+      log.error(`Could not launch request handler due to error \n${error}`);
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // keep the method running until we can return
+    while (true === true) {
+      if (!isRunning) {
+        // log.getPrefix = getPrefixOld; // restore logger state
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  };
+}
+export const devCommand = (
+  commandArgs: string[],
+  outputOpts: OutputOptionsConstructorArg,
+  contensisOpts: Partial<MigrateRequest> = {}
+) => {
+  return new ContensisDev(['', '', ...commandArgs], outputOpts, contensisOpts);
+};
+
+export default ContensisDev;

package/src/shell.ts

@@ -258,7 +258,10 @@ export const shell = () => {
   // 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 { quit() {}, restart() {} } as any;
+    return {
+      quit: ContensisCli.quit,
+      restart() {},
+    } as any;
   if (!globalShell) globalShell = new ContensisShell();
   return globalShell;
 };
@@ -269,12 +272,14 @@ process.on('uncaughtException', function (err) {
 });
 
 process.on('SIGINT', () => {
-  console.log('catching SIGINT');
+  Logger.warning('received SIGINT');
   shell().quit();
+  // setTimeout(() => {
+  // }, 2000);
 });
 
 process.on('SIGTERM', () => {
-  console.log('catching SIGTERM');
+  Logger.warning('received SIGTERM');
   shell().quit();
 });
 

package/src/util/git.ts

@@ -0,0 +1,118 @@
+import giturl from 'giturl';
+import hostedGitInfo from 'hosted-git-info';
+import parseGitConfig from 'parse-git-config';
+import path from 'path';
+
+import { linuxSlash } from './os';
+import { readFile, readFiles } from '~/providers/file-provider';
+
+const GITLAB_CI_FILENAME = '.gitlab-ci.yml';
+
+type GitConfig = parseGitConfig.Config;
+
+export type GitTypes = hostedGitInfo.Hosts;
+
+export class GitHelper {
+  private gitRepoPath: string;
+  config = {} as GitConfig;
+  info: hostedGitInfo | undefined;
+  home: string | undefined;
+
+  get ciFileName() {
+    return this.workflows
+      ? this.type === 'github'
+        ? this.workflows.length > 1
+          ? '[multiple workflows]'
+          : this.workflows?.[0]
+        : GITLAB_CI_FILENAME
+      : '[unknown]';
+  }
+  get name() {
+    return (
+      this.info?.project || this.home?.split('/').pop() || '[set arg --name]'
+    );
+  }
+  get originUrl() {
+    return this.config.remote.origin.url;
+  }
+  get secretsUri() {
+    return `${
+      this.type === 'github'
+        ? `${this.home}/settings/secrets/actions`
+        : `${this.home}/-/settings/ci_cd`
+    }`;
+  }
+  get type() {
+    return this.info?.type || this.hostType();
+  }
+  get workflows() {
+    return this.type === 'github'
+      ? this.githubWorkflows()
+      : this.gitlabWorkflow();
+  }
+  constructor(gitRepoPath: string = process.cwd()) {
+    this.gitRepoPath = gitRepoPath;
+    this.config = this.gitConfig();
+    this.home = giturl.parse(this.originUrl);
+    this.info = this.gitInfo();
+    // console.log(this.config);
+    // console.log(this.home);
+    // console.log(this.info);
+  }
+  gitcwd = () => path.join(this.gitRepoPath);
+  gitInfo = (url: string = this.originUrl) => hostedGitInfo.fromUrl(url);
+  hostType = (url: string = this.originUrl): GitTypes => {
+    if (url.includes('github.com')) return 'github';
+    return 'gitlab';
+    // if (url.includes('gitlab.com')) return 'gl';
+    // if (url.includes('gitlab.zengenti.com')) return 'gl';
+  };
+  gitConfig = (cwd = this.gitRepoPath) => {
+    // Find .git/config in project cwd
+    const config = parseGitConfig.sync({
+      path: '.git/config',
+      expandKeys: true,
+    });
+    // console.log(cwd, config);
+    if (Object.keys(config || {}).length) return config;
+
+    // Recursively check the directory heirarchy for existance of a .git/config
+    const pathParts = linuxSlash(cwd).split('/');
+    for (let i = 1; i <= pathParts.length; i++) {
+      const relPath = `${Array(i).fill('..').join('/')}/.git/config`;
+      // Does not appear to work when using a shortened cwd, using relative path instead
+      const config = parseGitConfig.sync({
+        path: relPath,
+        expandKeys: true,
+      });
+      // console.log(relPath, config);
+      if (Object.keys(config || {}).length) {
+        this.gitRepoPath = path.join(
+          this.gitRepoPath,
+          Array(i).fill('..').join('/')
+        );
+        return config;
+      }
+    }
+    return config;
+  };
+  githubWorkflows = () => {
+    const workflowPath = path.join(this.gitcwd(), '.github/workflows');
+    const workflowFiles = readFiles(workflowPath, false);
+    // console.log('gh workflows: ', workflowFiles);
+    const addFolderSuffix = (files: string[]) =>
+      files.map(f => `.github/workflows/${f}`);
+
+    if (workflowFiles.some(f => f.includes('build')))
+      return addFolderSuffix(workflowFiles.filter(f => f.includes('build')));
+    return addFolderSuffix(workflowFiles);
+  };
+  gitlabWorkflow = (ciFileName = GITLAB_CI_FILENAME) => {
+    const workflowPath = this.gitcwd();
+    const workflowFilePath = path.join(workflowPath, ciFileName);
+    const workflowFile = readFile(workflowFilePath);
+    // console.log(ciFileName, workflowFile);
+
+    return workflowFile;
+  };
+}

package/src/util/os.ts

@@ -0,0 +1,7 @@
+import os from 'os';
+
+export const winSlash = (str: string) =>
+  os.platform() === 'win32' ? str.replaceAll('/', '\\') : str;
+
+export const linuxSlash = (str: string) =>
+  os.platform() === 'win32' ? str.replaceAll('\\', '/') : str;

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.82";
+export const LIB_VERSION = "1.0.0-beta.84";