@kumologica/sdk 3.1.0-alpha2 → 3.1.0-beta2

package/cli/KumologicaError.js

@@ -0,0 +1,17 @@
+'use strict';
+
+class KumologicaError extends Error {
+  constructor(message, code, options = {}) {
+    super(message);
+    this.code = code;
+    this.decoratedMessage = options.decoratedMessage;
+  }
+}
+
+Object.defineProperty(KumologicaError.prototype, 'name', {
+  value: KumologicaError.name,
+  configurable: true,
+  writable: true,
+});
+
+module.exports = KumologicaError;

package/cli/cli.js

@@ -1,6 +1,7 @@
 require('yargs/yargs')(process.argv.slice(2))
   .commandDir('commands')
   .demandCommand()
-  .help()
+  .help('help', 'Show usage information & exit')
+  .alias('help', 'h')
  // .epilog("copyright 2021")
   .argv

package/cli/commands/create-commands/create-project-iteratively.js

@@ -0,0 +1,42 @@
+const pathlib = require('path');
+const { prompt, Select } = require('enquirer');
+const { logNotice, logError } = require('../../utils/logger');
+const { downloadTemplateFromRepo, listAvailableTemplates } = require('../../utils/download-template-from-repo');
+
+async function createProjectIteratively(){
+    const availableTemplates = await listAvailableTemplates();
+    // Project name
+    const projectNameResponse = await prompt({
+        type: 'input',
+        name: 'projectName',
+        message: 'Enter the name for the project'
+    });
+    let aProjectName = projectNameResponse.projectName;
+
+    // Target Path
+    const directoryResponse = await prompt({
+        type: 'input',
+        name: 'directory',
+        message: 'Enter the path where the project will be created '
+    });
+    let aProjectPath = directoryResponse.directory;
+
+    // Template name
+    const promptTemplate = new Select({
+        name: 'template',
+        message: 'Pick one of the available templates',
+        choices: availableTemplates
+      });
+
+    let aTemplateName = await promptTemplate.run();
+
+    try{
+        await downloadTemplateFromRepo(undefined, aTemplateName, aProjectPath, aProjectName);
+        logNotice(`Successfully created project: ${pathlib.join(aProjectPath, aProjectName)}`)
+    } catch (err){
+        logError(`Error found while creating project due to: ${err.message}`)
+    }
+}
+    
+
+module.exports = createProjectIteratively;

package/cli/commands/create-commands/index.js

@@ -0,0 +1,5 @@
+const createProjectIteratively  = require('./create-project-iteratively');
+
+module.exports = {
+    createProjectIteratively
+}

package/cli/commands/create.js

@@ -1,32 +1,65 @@
 const pathlib = require('path');
-const { logNotice, logError } = require('./utils');
 const { codegen } = require('@kumologica/builder');
 
-exports.command = "create"
+const { logNotice, logError } = require('../utils/logger');
+const { downloadTemplateFromRepo, isPlainGitURL } = require('../utils/download-template-from-repo');
+const { createProjectIteratively } = require('./create-commands');
+
+exports.command = 'create [options]'
 exports.builder = (yargs) => {
     yargs.option(`path`, {
-        describe: "The path where project will be created.",
-        demandOption: "The path is required.",
-		type: 'string',
-		alias: 'p',
-		nargs: 1
-	});
+        describe: "The project path where the project will be created",
+        // demandOption: "The path is required.",
+        type: 'string',
+        alias: 'p',
+        nargs: 1
+    })
+    yargs.option(`template`, {
+        describe: `Template for the project`,
+        type: 'string',
+        alias: 't',
+        nargs: 1
+    })
 }
 
-exports.desc = 'Create a kumologica project'
-exports.handler = ({ path }) => {
+
+exports.desc = 'Create a kumologica project. Do not pass any options to create iteratively.'
+exports.handler = async ({ path, template }) => {
     const { version } = require('../../package.json');
-    try{
-        codegen.generateBoilerplateProject({ 
-            basePath :process.cwd(), 
-            projectName: path,
-            runtimeVersion: version });
-       
-        logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), path)}`);
-    } catch(e) {
-        logError(e.toString());
-        process.exit(1);
+
+    if (!path && !template) {
+        await createProjectIteratively();
+    } else if (!path && template) {
+        try{
+            await downloadTemplateFromRepo(undefined, template, process.cwd(), template);
+            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), template)}`);
+        }catch(e){
+            logError(e.message);
+        }
+    } else if (path && !template){
+        try{
+            codegen.generateBoilerplateProject({ 
+                basePath :process.cwd(), 
+                projectName: path,
+                runtimeVersion: version });
+            logNotice(`Successfully created project: ${ pathlib.join(process.cwd(), path)}`);
+        }catch(e){
+            logError(e.message);
+        }
+    } else if (path && template) {
+        path = pathlib.resolve(path);
+        let projectPath = pathlib.dirname(path);
+        let projectName = pathlib.basename(path);
+        try{
+            if (isPlainGitURL(template)){
+                await downloadTemplateFromRepo(template, undefined, projectPath, projectName);
+            } else {
+                await downloadTemplateFromRepo(undefined, template, projectPath, projectName);
+            }
+            logNotice(`Successfully created project: ${path}`);
+        }catch(e){
+            logError(e.message);
+        }
     }
-   
-    
+        
 }

package/cli/commands/list-templates.js

@@ -0,0 +1,24 @@
+const { listAvailableTemplates } = require('../utils/download-template-from-repo');
+const { logNotice, logError, logInfo } = require('../utils/logger');
+
+exports.command = 'list-templates'
+exports.desc = 'List of available templates'
+exports.handler = async function (argv) {
+    try {
+        logInfo('List of available templates:');
+        let templates = await readerFriendly(listAvailableTemplates())
+        logNotice(templates);
+    }catch(e){
+        logError(e.message);
+    }
+}
+
+// Utils
+async function readerFriendly(templates) {
+    let result = [];
+    templates = await templates;
+    templates.forEach(t => {
+        result.push(`"${t}"`);
+    });
+    return result.join(',')
+}

package/cli/commands/open.js

@@ -1,5 +1,5 @@
 const path = require('path');
-const { logError } = require('./utils');
+const { logError } = require('../utils/logger');
 
 const rootPath = path.join(__dirname, '..', '..',);
 

package/cli/commands/test-utils/TestSuiteController.js

@@ -5,7 +5,6 @@ const path = require('path');
 const chalk = require('chalk');
 const { error } = require('./util/output');
 const got = require('got');
-const { logError } = require('../utils');
 const log = console.log;
 
 

package/cli/commands/test.js

@@ -1,14 +1,15 @@
 const chalk = require('chalk');
 const { Select } = require('enquirer');
 const fs = require('fs');
-const { logError } = require('./utils');
 const path = require('path');
 const wcmatch = require('wildcard-match');
 
 const { AppServer } = require('@kumologica/runtime');
-const { TestSuiteController } = require('./test-utils/TestSuiteController');
 const { codegen } = require('@kumologica/builder');
 
+const { TestSuiteController } = require('./test-utils/TestSuiteController');
+const { logError } = require('../utils/logger');
+
 const log = console.log;
 const APP_SERVER_PORT = 1990;
 		

package/cli/utils/download-template-from-repo.js

@@ -0,0 +1,346 @@
+'use strict';
+
+const path = require('path');
+const URL = require('url');
+const BbPromise = require('bluebird');
+const fse = require('fs-extra');
+const qs = require('querystring');
+const spawn = require('child-process-ext/spawn');
+const renameService = require('./rename-service').renameService;
+const KumologicaError = require('../KumologicaError');
+const copyDirContentsSync = require('./fs/copy-dir-contents-sync');
+const dirExistsSync = require('./fs/dir-exists-sync');
+const walkDirSync = require('./fs/walk-dir-sync');
+const { getTmpDirPath, getBaseTmpDirPath } = require('./fs/get-tmp-dir-path');
+
+
+const OFFICAL_TEMPLATES_REPO = 'https://github.com/KumologicaHQ/kumologica-templates.git';
+/**
+ * Returns directory path
+ * @param {Number} length
+ * @param {Array} parts
+ * @returns {String} directory path
+ */
+function getPathDirectory(length, parts) {
+  if (!parts) {
+    return '';
+  }
+  return parts.slice(length).filter(Boolean).join(path.sep);
+}
+
+/**
+ * Validates URL
+ * @param {Object} url
+ * @param {String} hostname
+ * @param {String} service
+ * @param {String} owner
+ * @param {String} repo
+ */
+function validateUrl({ url, hostname, service, owner, repo }) {
+  // validate if given url is a valid url
+  if (url.hostname !== hostname || !owner || !repo) {
+    const errorMessage = `The URL must be a valid ${service} URL in the following format: https://${hostname}/serverless/serverless`;
+    throw new KumologicaError(errorMessage, 'INVALID_TEMPLATE_URL');
+  }
+}
+
+/**
+ * Check if the URL is pointing to a Git repository
+ * @param {String} url
+ */
+function isPlainGitURL(url) {
+  return (url.startsWith('https') || url.startsWith('git@')) && url.endsWith('.git');
+}
+
+/**
+ * @param {Object} url
+ * @returns {Object}
+ */
+function parseGitHubURL(url) {
+  const pathLength = 4;
+  const parts = url.pathname.split('/');
+  const isSubdirectory = parts.length > pathLength;
+  const owner = parts[1];
+  const repo = parts[2];
+  const branch = isSubdirectory ? parts[pathLength] : 'master';
+  const isGitHubEnterprise = url.hostname !== 'github.com';
+
+  if (!isGitHubEnterprise) {
+    // validate if given url is a valid GitHub url
+    validateUrl({ url, hostname: 'github.com', service: 'GitHub', owner, repo });
+  }
+
+  const downloadUrl = `https://${
+    isGitHubEnterprise ? url.hostname : 'github.com'
+  }/${owner}/${repo}/archive/${branch}.zip`;
+
+  return {
+    owner,
+    repo,
+    branch,
+    downloadUrl,
+    isSubdirectory,
+    pathToDirectory: getPathDirectory(pathLength + 1, parts),
+    username: url.username || '',
+    password: url.password || '',
+  };
+}
+
+/**
+ * @param {Object} url
+ * @returns {Object}
+ */
+function parseBitbucketURL(url) {
+  const pathLength = 4;
+  const parts = url.pathname.split('/');
+  const isSubdirectory = parts.length > pathLength;
+  const owner = parts[1];
+  const repo = parts[2];
+
+  const query = qs.parse(url.query);
+  const branch = 'at' in query ? query.at : 'master';
+
+  // validate if given url is a valid Bitbucket url
+  validateUrl({ url, hostname: 'bitbucket.org', service: 'Bitbucket', owner, repo });
+
+  const downloadUrl = `https://bitbucket.org/${owner}/${repo}/get/${branch}.zip`;
+
+  return {
+    owner,
+    repo,
+    branch,
+    downloadUrl,
+    isSubdirectory,
+    pathToDirectory: getPathDirectory(pathLength + 1, parts),
+    username: url.username || '',
+    password: url.password || '',
+  };
+}
+
+function parseBitbucketServerURL(url) {
+  const pathLength = 9;
+  const parts = url.pathname.split('/');
+  const isSubdirectory = parts.length > pathLength;
+  const owner = parts[5];
+  const repo = parts[7];
+
+  const query = qs.parse(url.query);
+  const branch = 'at' in query ? decodeURIComponent(query.at) : 'master';
+
+  const downloadUrl = `${url.protocol}//${url.hostname}/rest/api/latest/projects/${owner}/repos/${repo}/archive${url.search}&format=zip`;
+
+  return {
+    owner,
+    repo,
+    branch,
+    downloadUrl,
+    isSubdirectory,
+    pathToDirectory: getPathDirectory(pathLength + 1, parts),
+    username: url.username || '',
+    password: url.password || '',
+  };
+}
+
+/**
+ * Call `/rest/api/1.0/application-properties` to retrieve server info
+ * @param {Object} url
+ * @returns {Boolean}
+ */
+async function retrieveBitbucketServerInfo(url) {
+  let requestOpts = {
+    url: `${url.protocol}//${url.hostname}/rest/api/1.0/application-properties`,
+    method: 'GET',
+    throwHttpErrors: false,
+    retry: 0
+  }
+  try {
+    let resp = await got(requestOpts)
+    return resp.body.displayName === 'Bitbucket';
+  }catch(err){
+    throw err;
+  }
+  
+}
+
+/**
+ * @param {Object} url
+ * @returns {Object}
+ */
+function parseGitlabURL(url) {
+  const pathLength = 4;
+  const parts = url.pathname.split('/');
+  const isSubdirectory = parts.length > pathLength;
+  const owner = parts[1];
+  const repo = parts[2];
+
+  const branch = isSubdirectory ? parts[pathLength] : 'master';
+
+  // validate if given url is a valid GitLab url
+  validateUrl({ url, hostname: 'gitlab.com', service: 'Bitbucket', owner, repo });
+
+  const downloadUrl = `https://gitlab.com/${owner}/${repo}/-/archive/${branch}/${repo}-${branch}.zip`;
+
+  return {
+    owner,
+    repo,
+    branch,
+    downloadUrl,
+    isSubdirectory,
+    pathToDirectory: getPathDirectory(pathLength + 1, parts),
+    username: url.username || '',
+    password: url.password || '',
+  };
+}
+
+/**
+ * Parses a URL which points to a plain Git repository
+ * such as https://example.com/jdoe/project.git
+ *
+ * @param {String} url
+ * @returns {Object}
+ */
+function parsePlainGitURL(url) {
+  const branch = 'master';
+  const downloadUrl = url;
+  const isSubdirectory = false;
+  const repo = url.match(/.+\/(.+)\.git/)[1];
+  return {
+    repo,
+    branch,
+    downloadUrl,
+    isSubdirectory,
+    username: url.username || '',
+    password: url.password || '',
+  };
+}
+
+/**
+ * Parse URL and call the appropriate adaptor
+ *
+ * @param {string} inputUrl
+ * @throws {KumologicaError}
+ * @returns {Promise}
+ */
+async function parseRepoURL(inputUrl) {
+  return new BbPromise((resolve, reject) => {
+    if (!inputUrl) {
+      return reject(new KumologicaError('URL is required', 'MISSING_TEMPLATE_URL'));
+    }
+
+    const url = URL.parse(inputUrl.replace(/\/$/, ''));
+    if (url.auth) {
+      const [username, password] = url.auth.split(':');
+      url.username = username;
+      url.password = password;
+    }
+
+    // check if url parameter is a valid url
+    if (!url.host && !url.href.startsWith('git@')) {
+      return reject(new KumologicaError('The URL you passed is not valid', 'INVALID_TEMPLATE_URL'));
+    }
+
+    if (isPlainGitURL(url.href)) {
+      return resolve(parsePlainGitURL(inputUrl));
+    } else if (url.hostname === 'github.com' || url.hostname.indexOf('github.') !== -1) {
+      return resolve(parseGitHubURL(url));
+    } else if (url.hostname === 'bitbucket.org') {
+      return resolve(parseBitbucketURL(url));
+    } else if (url.hostname === 'gitlab.com') {
+      return resolve(parseGitlabURL(url));
+    }
+
+    const msg =
+      'The URL you passed is not one of the valid providers: "GitHub", "GitHub Entreprise", "Bitbucket", "Bitbucket Server" or "GitLab".';
+    const err = new KumologicaError(msg, 'INVALID_TEMPLATE_PROVIDER');
+    // test if it's a private bitbucket server
+    return retrieveBitbucketServerInfo(url)
+      .then((isBitbucket) => {
+        if (!isBitbucket) {
+          return reject(err);
+        }
+
+        // build download URL
+        return resolve(parseBitbucketServerURL(url));
+      })
+      .catch(() => reject(err));
+  });
+}
+
+/**
+ * Downloads the content of the template into the projectName directory
+ * @param {string} [repoUrl] - the git repository
+ * @param {string} [templateName] - the name of the project (optional), in case we are only interested in a particular directory within the repo
+ * @param {string} projectName - the local project name / directory to be created
+ * @returns {Promise}
+ */
+async function downloadTemplateFromRepo(repoUrl, templateName, projectPath, projectName) {
+  try{
+    repoUrl = repoUrl || OFFICAL_TEMPLATES_REPO;
+    const repoInformation = await parseRepoURL(repoUrl);
+    
+    const tempBaseDirectory = getBaseTmpDirPath();
+    // clean up temp directory
+    fse.removeSync(tempBaseDirectory);
+    const tempRepoDirectory = getTmpDirPath();
+    // const { username, password } = repoInformation;
+
+    const renamed = templateName !== projectName;
+
+    // Source project directory
+    const srcProjectDir = templateName? path.join(tempRepoDirectory, templateName) : tempRepoDirectory;
+
+    // Target project directory
+    const targetProjectDir = path.join(projectPath, projectName);
+
+    if (dirExistsSync(targetProjectDir)) {
+      const errorMessage = `A project already exist in path: "${targetProjectDir}".`;
+      throw new KumologicaError(errorMessage, 'TARGET_FOLDER_ALREADY_EXISTS');
+    }
+
+    if (isPlainGitURL(repoUrl)) {
+      return spawn('git', ['clone', repoUrl, tempRepoDirectory]).then(() => {
+        try {
+          copyDirContentsSync(srcProjectDir, targetProjectDir);
+          fse.removeSync(tempBaseDirectory);
+          if (renamed) renameService(targetProjectDir, projectName);
+        }catch(err){
+          throw new KumologicaError(`Template name: "${templateName}" does not exist. Run "kl list-templates" to see list of available templates.`);
+        }
+        return "";
+      });
+    } else {
+      throw new KumologicaError(`Git repo URL is incorrect`);
+    }
+  }catch(err){
+    throw new KumologicaError(err.message);
+  }
+}
+
+async function listAvailableTemplates() {
+  try{
+    const tempBaseDirectory = getBaseTmpDirPath();
+    const tempRepoDirectory = getTmpDirPath();
+
+    await parseRepoURL(OFFICAL_TEMPLATES_REPO);
+
+    const listTemplates = spawn('git', ['clone', OFFICAL_TEMPLATES_REPO, tempRepoDirectory]).then(() => {
+        try {
+          const projects = walkDirSync(tempRepoDirectory);
+          fse.removeSync(tempBaseDirectory);
+          return projects;
+        }catch(err){
+          throw new KumologicaError(err.message);
+        }
+      });
+      // ListTemplates: ["t1", "t2"]
+      return listTemplates;
+  } catch(err){
+    throw new KumologicaError(err.message);
+  }
+}
+
+module.exports = {
+  downloadTemplateFromRepo,
+  listAvailableTemplates,
+  isPlainGitURL
+};

package/cli/utils/download-test.js

@@ -0,0 +1,12 @@
+const { readerFriendly } = require('../commands/utils');
+const { downloadTemplateFromRepo, listAvailableTemplates } = require('./download-template-from-repo');
+
+(async()=> {
+    try{
+        // await downloadTemplateFromRepo(undefined, 'aws-api-helloworldWRONG', 'kk');
+        const result = await readerFriendly(listAvailableTemplates());
+        console.log(result);
+    } catch(err){
+        console.log('Error creating template due to: ', err.message);
+    }
+})();