@getik-public/cli 1.4.1 → 1.5.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+### v1.5.0
+- Added build scripts for WEB projects
+
+
+### v1.4.1
+- FIXED: when `--syncOnly` option was run without `--platform` parameter the files with version where not created and updated
+
+
 ### v1.4.0
 - Parameter `--platform` is now optional, but only when used with `--syncOnly`.
 - Parameter `--syncOnly` now will run `cap sync` for all platforms if `--platform` parameter is missing.

package/README.md

@@ -11,6 +11,7 @@ Add next line in your `package.json` file under `devDependencies`:
 
 # Available scripts
 - [`mobile-build`](#mobile-build)
+- [`web-build`](#web-build)
 - [`upload-to-getik-cloud`](#upload-to-getik-cloud)
 
 
@@ -31,6 +32,17 @@ Example: `getik-cli mobile-build --platform ios --environment getik --upload`
 
 
 
+## <a name="web-build" href="#web-build">`web-build`</a>
+### Usage: `getik-cli web-build [-e, --environment] [--syncOnly]`  
+Example: `getik-cli web-build -e getik --syncOnly`  
+Example: `getik-cli web-build -e getik`  
+
+| Option              | Required | Values                      | Description                                                                                                                                                                                                                                                                         |
+|---------------------|----------|-----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `-e`, `--environment` | YES      | `<string>` | While environment can be any name, be consistent and use these: `getik`, `vbox`, `qa`, `preprod`, `prod`.                                                                                                                                                                           |
+| `--syncOnly`        | NO       | `-`                         | For development only, it will create a file named `version.ts` with version found in `package.json`. Use this version in all `environment.ts` files. This will not go further to trigger the actual build script. |
+
+
 ## <a name="upload-to-getik-cloud" href="#upload-to-getik-cloud">`upload-to-getik-cloud`</a>
 ### Usage: `getik-cli upload-to-getik-cloud ./path/to/my-file.apk`  
 Use this command to upload apk files to getik cloud. If successful, in command line you will find a direct link to fresh uploaded file alongside a link to the full list.  

package/bin/index.js

@@ -6,11 +6,13 @@ import figlet from 'figlet';
 
 import { mobileBuild } from '../src/mobile-build.js';
 import { uploadToGetikCloud } from '../src/upload-to-getik-cloud.js';
+import { webBuild } from '../src/web-build.js';
 
 
 console.log(chalk.green(figlet.textSync('Getik CLI', {horizontalLayout: 'full'})));
 
 mobileBuild();
+webBuild();
 uploadToGetikCloud();
 
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getik-public/cli",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "publishConfig": {
     "access": "public"
   },

package/src/lib.js

@@ -0,0 +1,272 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+
+
+export const readVersionsFromPackageJson = () => {
+  console.log('Checking versions in package.json file...');
+  const packageJsonBuffer = fs.readFileSync(path.join(process.cwd(), 'package.json'));
+  const packageJson = JSON.parse(packageJsonBuffer);
+
+  const versionName = packageJson.version;
+
+  if (!versionName) {
+    throw new Error(`Missing properties in "package.json". Make sure you have defined next properties: "version".`);
+  }
+  const splitVersion = versionName.split('.');
+  const x = parseInt(splitVersion[0], 10);
+  const y = parseInt(splitVersion[1], 10);
+  const z = parseInt(splitVersion[2], 10);
+
+  if (y > 99 || z > 99) {
+    throw new Error(`Second and last number in versionName can't be bigger than 99.`);
+  }
+
+  const yTransformed = (y < 10) ? `0${y}` : y;
+  const zTransformed = (z < 10) ? `0${z}` : z;
+  const versionCode = `${x}${yTransformed}${zTransformed}`;
+
+  console.log(`Extracted versions: versionName = \x1b[32m${versionName}\x1b[0m, versionCode = \x1b[32m${versionCode}\x1b[0m.`);
+
+  return {
+    versionName: versionName,
+    versionCode: versionCode,
+  }
+}
+
+
+export const runCliCommand = (command, callback, path) => {
+  console.log('COMMAND: ', '\x1b[96m', command, '\x1b[0m');
+  callback = callback || function() {};
+  const ls = spawn(command, [], {shell: true, env: { ...process.env, FORCE_COLOR: true }, cwd: path || ''});
+
+  ls.stdout.on('data', data => {
+    console.log(data.toString());
+  });
+
+  ls.stderr.on('data', data => {
+    console.log(data.toString());
+  });
+
+  ls.on('error', (error) => {
+    console.log(error.message);
+  });
+
+  ls.on('close', code => {
+    console.log(`child process exited with code ${code}`);
+    if (code !== 0) {
+      console.log('\x1b[31m');
+      throw new Error(`Command FAILED: ${command}`);
+    }
+    callback();
+  });
+}
+
+
+export const runCliCommandSilent = (command, callback, path) => {
+  callback = callback || function() {};
+  const ls = spawn(command, [], {shell: true, env: { ...process.env, FORCE_COLOR: true }, cwd: path || ''});
+  const output = [];
+  ls.stdout.on('data', (data) => {
+    output.push(data);
+  });
+
+  ls.on('close', (code) => {
+    callback(code, output.toString());
+  });
+}
+
+
+export const applyReleaseBuildChecks = (versions, options, callback) => {
+  console.log('----------------------------------------------------------------------------------------------------------------------');
+  if (options.force) {
+    console.log('\x1b[31mWARNING: All checks before release build are skipped! Never use "--force" when deploying build! \x1b[0m');
+    console.log('----------------------------------------------------------------------------------------------------------------------');
+    callback();
+
+    return;
+  }
+
+  console.log('RUNNING CHECKS BEFORE PRODUCTION BUILD...');
+  let checkFailed = false;
+
+  console.log('');
+  checkForUncommitedFiles((checkForUncommitedFilesStatus) => {
+    checkFailed = (checkFailed || checkForUncommitedFilesStatus);
+
+    console.log('');
+    checkRemoteBranch((checkRemoteBranchStatus) => {
+      checkFailed = (checkFailed || checkRemoteBranchStatus);
+
+      console.log('');
+      checkEnvironmentToBranchScheme(versions, options, (checkEnvironmentToBranchSchemeStatus) => {
+        checkFailed = (checkFailed || checkEnvironmentToBranchSchemeStatus);
+
+        console.log('');
+        checkVersionInCommit(versions, (checkVersionInCommitStatus) => {
+          checkFailed = (checkFailed || checkVersionInCommitStatus);
+
+          console.log('');
+          checkLintErrors((checkLintErrorsStatus) => {
+            checkFailed = (checkFailed || checkLintErrorsStatus);
+
+            console.log('');
+            console.log('END "RUNNING CHECKS BEFORE PRODUCTION BUILD..."');
+            console.log('----------------------------------------------------------------------------------------------------------------------');
+            if (checkFailed) {
+              throw new Error('Some prebuild checks failed, see logs to find out which ones.');
+            }
+            callback();
+          });
+        });
+      });
+    });
+  });
+}
+
+
+export const checkForUncommitedFiles = (callback) => {
+  console.log('- Check if branch is clear. No uncommited changes are allowed.');
+  const cliCommand = 'git status -u --porcelain';
+  runCliCommandSilent(cliCommand, (code, output) => {
+    let checkFailed = false;
+    if (code !== 0) {
+      console.log('\x1b[31m FAILED! "git status" command failed. \x1b[0m');
+      checkFailed = true;
+    } else if (output.length > 0) {
+      console.log('\x1b[31m FAILED! You have uncommited changes. \x1b[0m');
+      checkFailed = true;
+    } else {
+      console.log('\x1b[32m PASSED! \x1b[0m');
+    }
+    callback(checkFailed);
+  });
+}
+
+
+export const checkRemoteBranch = (callback) => {
+  console.log('- Check if local branch is up to date with remote branch.');
+  const cliGetCurrentBranchName = 'git rev-parse --abbrev-ref HEAD';
+  runCliCommandSilent(cliGetCurrentBranchName, (code, branchName) => {
+    if (code !== 0) {
+      console.log('\x1b[31m FAILED! "git rev-parse" command failed. \x1b[0m');
+      callback(true);
+    } else {
+      branchName = branchName.trim();
+      const cliGitFetch = `git fetch origin ${branchName}`;
+      runCliCommandSilent(cliGitFetch, (code) => {
+        if (code !== 0) {
+          console.log('\x1b[31m FAILED! "git fetch" command failed. \x1b[0m');
+          callback(true);
+        } else {
+          const cliGitDiff = `git diff origin/${branchName} ${branchName} --name-only`;
+          runCliCommandSilent(cliGitDiff, (code, diffData) => {
+            if (code !== 0) {
+              console.log('\x1b[31m FAILED! "git diff" command failed. \x1b[0m');
+              callback(true);
+            } else if (diffData.length > 0) {
+              console.log('\x1b[31m FAILED! Local branch is not up to date with remote branch. \x1b[0m');
+              callback(true);
+            } else {
+              console.log('\x1b[32m PASSED! \x1b[0m');
+              callback(false);
+            }
+          });
+        }
+      });
+    }
+  });
+}
+
+
+export const checkEnvironmentToBranchScheme = (versions, options, callback) => {
+  console.log('- Check if build for selected environment can be made from current branch.');
+
+  const cliGetCurrentBranchName = 'git rev-parse --abbrev-ref HEAD';
+  runCliCommandSilent(cliGetCurrentBranchName, (code, branchName) => {
+    if (code !== 0) {
+      console.log('\x1b[31m FAILED! "git rev-parse" command failed. \x1b[0m');
+      callback(true);
+    } else {
+      branchName = branchName.trim();
+      if (options.environment === 'getik') {
+        if (branchName === 'develop') {
+          console.log('\x1b[32m PASSED! \x1b[0m');
+          callback(false);
+        } else {
+          console.log('\x1b[31m FAILED! You can build for "getik" environment only from "develop". \x1b[0m');
+          callback(true);
+        }
+      } else if (options.environment === 'qa') {
+        const splitVersionName = versions.versionName.split('.');
+        const requiredBranchName = `release/${splitVersionName[0]}.${splitVersionName[1]}.x`;
+        if (branchName === requiredBranchName) {
+          console.log('\x1b[32m PASSED! \x1b[0m');
+          callback(false);
+        } else {
+          console.log(`\x1b[31m FAILED! You can build for "qa" environment only from "${requiredBranchName}". \x1b[0m`);
+          callback(true);
+        }
+      } else if (options.environment === 'preprod' || options.environment === 'prod') {
+        if (branchName === 'master') {
+          console.log('\x1b[32m PASSED! \x1b[0m');
+          callback(false);
+        } else {
+          console.log(`\x1b[31m FAILED! You can build for "${options.environment}" environment only from "master". \x1b[0m`);
+          callback(true);
+        }
+      } else {
+        console.log('\x1b[32m PASSED! \x1b[0m');
+        callback(false);
+      }
+    }
+  });
+}
+
+
+export const checkVersionInCommit = (versions, callback) => {
+  console.log('- Check if latest commit is a version update commit and it is the same as in "package.json".');
+  const cliCommand = 'git log -1 --pretty=%B';
+  runCliCommandSilent(cliCommand, (code, commitMessage) => {
+    commitMessage = commitMessage.trim();
+    let checkFailed = false;
+    if (code !== 0) {
+      console.log('\x1b[31m FAILED! "git log" command failed. \x1b[0m');
+      checkFailed = true;
+    } else {
+      const expectedMessage = `APP VERSION UPDATE: versionName: ${versions.versionName}`;
+      if (commitMessage && commitMessage.indexOf(expectedMessage) === 0) {
+        console.log('\x1b[32m PASSED! \x1b[0m');
+        checkFailed = false;
+      } else {
+        console.log('\x1b[31m FAILED! Version in "package.json" is not the same as in commit message. \x1b[0m');
+        checkFailed = true;
+      }
+    }
+    callback(checkFailed);
+  });
+}
+
+
+export const checkLintErrors = (callback) => {
+  console.log('- Check for lint errors.');
+  const P = ['\\', '|', '/', '-'];
+  let x = 0;
+  const ref = setInterval(() => {
+    process.stdout.write('\r' + P[x++]);
+    x &= 3;
+  }, 250);
+  const cliCommand = 'npm run lint';
+  runCliCommandSilent(cliCommand, (code, output) => {
+    clearInterval(ref);
+    process.stdout.write('\r');
+    let checkFailed = false;
+    if (code !== 0) {
+      console.log('\x1b[31m FAILED! There are "lint" errors. \x1b[0m');
+      checkFailed = true;
+    } else {
+      console.log('\x1b[32m PASSED! \x1b[0m');
+    }
+    callback(checkFailed);
+  });
+}

package/src/web-build.js

@@ -0,0 +1,73 @@
+import { program } from 'commander';
+import fs from 'fs';
+import path from 'path';
+
+import {
+  readVersionsFromPackageJson,
+  runCliCommand,
+  applyReleaseBuildChecks,
+} from './lib.js';
+
+
+const buildFolder = 'build';
+
+
+function applyVersion(versions) {
+  const pathToVersionsProperties = path.join(process.cwd(), 'src', 'environments', 'version.ts');
+
+  if (fs.existsSync(pathToVersionsProperties)) {
+    fs.rmSync(pathToVersionsProperties);
+  }
+
+  fs.writeFileSync(pathToVersionsProperties, (
+`export const version = {
+  name: '${versions.versionName}',
+  code: ${versions.versionCode},
+};
+`
+  ));
+}
+
+
+function cleanBuildFolder(folder) {
+  if (fs.existsSync(folder)) {
+    fs.rmSync(folder, {recursive: true});
+  }
+  fs.mkdirSync(folder, {recursive: true});
+}
+
+
+function buildApp(environmentName, callback) {
+  cleanBuildFolder('dist');
+  runCliCommand(`ng build --configuration=${environmentName}`, function() {
+    runCliCommand(`zip -q -r ../../${buildFolder}/${environmentName}.zip .`, function() {
+      callback();
+    }, './dist/browser');
+  });
+}
+
+
+export const webBuild = () => {
+  program
+    .command('web-build')
+    .option('-e, --environment <type>', 'Environment: getik, vbox, qa, preprod, prod')
+    .option('--syncOnly', 'Generates the version.ts file only so no errors when running app locally')
+    .option('--force', 'Skip all checks for builds of type release')
+    .action((options) => {
+      console.log('INPUT OPTIONS: ', options);
+      cleanBuildFolder(buildFolder);
+      const versions = readVersionsFromPackageJson();
+      applyVersion(versions);
+      if (options.sync) {
+        return;
+      }
+      applyReleaseBuildChecks(versions, options, () => {
+        buildApp(options.environment, () => {
+          const demoEnvName = `${options.environment}Demo`;
+          buildApp(demoEnvName, () => {
+            console.log('\x1b[32m SUCCESS! \x1b[0m');
+          });
+        });
+      });
+    });
+};