@getik-public/cli 1.2.0 → 1.3.0-beta1

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+### v1.3.0-beta1
+Added new features:
+- new script: `getik-cli increment-version`(only for mobile for now)
+- extended `getik-cli mobile-build` script to build only angular and zip it for OTA feature.
+
+
+### v1.2.1
+Fixed typo on versionCode extraction.
+
+
 ### v1.2.0
 FEATURE: Generate `versionCode` from `versionName`, so no longer needed to maintain `versionCode` in `package.json` file, only `version` needs to be updated.
 

package/bin/index.js

@@ -4,12 +4,14 @@ import { program } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
 
+import { incrementVersion } from '../src/increment-version.js';
 import { mobileBuild } from '../src/mobile-build.js';
 import { uploadToGetikCloud } from '../src/upload-to-getik-cloud.js';
 
 
 console.log(chalk.green(figlet.textSync('Getik CLI', {horizontalLayout: 'full'})));
 
+incrementVersion();
 mobileBuild();
 uploadToGetikCloud();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getik-public/cli",
-  "version": "1.2.0",
+  "version": "1.3.0-beta1",
   "publishConfig": {
     "access": "public"
   },

package/src/increment-version.js

@@ -0,0 +1,141 @@
+import { program } from 'commander';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+
+function incrementMobileVersions(type, environment) {
+  const packageJsonBuffer = fs.readFileSync(path.join(process.cwd(), 'package.json'));
+  const packageJson = JSON.parse(packageJsonBuffer);
+
+  const allPackageJsonProperties = Object.keys(packageJson);
+  const otaVersionProperties = [];
+  if (environment) {
+    const env = (environment.charAt(0).toUpperCase() + environment.slice(1));
+    const versionPropertyName = `otaVersion${env.split('Debug')[0]}`;
+    const found = allPackageJsonProperties.find((property) => {
+      return (property === versionPropertyName);
+    });
+    if (found) {
+      otaVersionProperties.push(versionPropertyName);
+    }
+  } else {
+    const filtered = allPackageJsonProperties.filter((property) => {
+      const name = 'otaVersion';
+
+      return (property.indexOf(name) === 0) && (property.length > name.length);
+    });
+    otaVersionProperties.push(...filtered);
+
+  }
+
+  if (otaVersionProperties.length === 0) {
+    console.log(`WARNING: OTA version${environment ? 'for ' + environment : ''} not found in package.json. If project doesn't have OTA update ignore this warning. If project has OTA update feature, then make sure every environment has specific property with version defined in package.json`);
+  } else {
+    otaVersionProperties.forEach((propertyName) => {
+      packageJson[propertyName]++;
+    });
+  }
+
+  if (type === 'ota') {
+    if (otaVersionProperties.length === 0) {
+      console.log(`OTA version not incremented, no property found in package.json.`);
+    }
+    fs.writeFileSync(path.join(process.cwd(), 'package.json'), JSON.stringify(packageJson, null, 2));
+    createCommit(packageJson, otaVersionProperties);
+
+    return;
+  }
+
+  const splitVersion = packageJson.version.split('.');
+  let x = parseInt(splitVersion[0], 10);
+  let y = parseInt(splitVersion[1], 10);
+  let z = parseInt(splitVersion[2], 10);
+
+  if (type === 'major') {
+    x++;
+    y = 0;
+    z = 0;
+  } else if (type === 'minor') {
+    y++;
+    z = 0;
+  } else if (type === 'patch') {
+    z++;
+  } else {
+    console.log('Invalid version increment type. Options available: major, minor, patch, ota');
+  }
+
+  packageJson.version = `${x}.${y}.${z}`;
+
+  fs.writeFileSync(path.join(process.cwd(), 'package.json'), JSON.stringify(packageJson, null, 2));
+
+  const packageLockJsonBuffer = fs.readFileSync(path.join(process.cwd(), 'package-lock.json'));
+  const packageLockJson = JSON.parse(packageLockJsonBuffer);
+  packageLockJson.version = `${x}.${y}.${z}`;
+  packageLockJson.packages[''].version = `${x}.${y}.${z}`;
+  fs.writeFileSync(path.join(process.cwd(), 'package-lock.json'), JSON.stringify(packageLockJson, null, 2));
+
+  createCommit(packageJson, otaVersionProperties);
+}
+
+
+function createCommit(packageJsonRef, otaVersionProperties) {
+  let otaVersionMessage = '';
+  otaVersionProperties.forEach((property) => {
+    otaVersionMessage += `; ${property}: ${packageJsonRef[property]}`;
+  });
+  const message = `APP VERSION UPDATE: versionName: ${packageJsonRef.version}${otaVersionMessage}.`;
+
+  const cliCommand = `git commit -a -m "${message}"`;
+  const ls = spawn(cliCommand, [], {shell: true, env: { ...process.env, FORCE_COLOR: true }, cwd: ''});
+
+  ls.on('close', (code) => {
+    if (code !== 0) {
+      console.log('\x1b[31m');
+      throw new Error(`Command FAILED: ${cliCommand}`);
+    } else {
+      console.log(`A new commit was added with message "${message}"`);
+    }
+  });
+}
+
+
+function gitCheckIfCleanRepo(callback) {
+  const cliCommand = 'git status --porcelain';
+  const ls = spawn(cliCommand, [], {shell: true, env: { ...process.env, FORCE_COLOR: true }, cwd: ''});
+  const output = [];
+  ls.stdout.on('data', (data) => {
+    output.push(data);
+  });
+
+  ls.on('close', (code) => {
+    if (code !== 0) {
+      console.log('\x1b[31m');
+      throw new Error(`Command FAILED: ${cliCommand}`);
+    } else if (output.length > 0) {
+      console.log('\x1b[31m');
+      throw new Error('You have uncommited changes. Commit or clear changes before running this command.');
+    } else {
+      callback();
+    }
+  });
+}
+
+
+export const incrementVersion = () => {
+  program
+    .command('increment-version')
+    .requiredOption('-t, --type <type>', 'Type: major - 3.x.x -> 4.x.x; minor - 3.1.x -> 3.2.x; patch - 3.1.0 -> 3.1.1; ota - this is done by default in other types.')
+    .requiredOption('-p, --project <type>', 'Project: mobile')
+    .option('-e, --environment <type>', 'Environment: getik, getikDebug')
+    .action((options) => {
+      console.log('INPUT OPTIONS: ', options);
+      gitCheckIfCleanRepo(function() {
+        if (options.project === 'mobile') {
+          incrementMobileVersions(options.type, options.environment);
+        } else {
+          console.log('Other project types are not supported yet, now only "mobile" is available.');
+        }
+      });
+    });
+};

package/src/mobile-build.js

@@ -65,7 +65,7 @@ async function applyPatchersForExternalNpmPackages() {
 }
 
 
-function readVersionsFromPackageJson() {
+function readVersionsFromPackageJson(options) {
   console.log('Checking versions in package.json file...');
   const packageJsonBuffer = fs.readFileSync(path.join(process.cwd(), 'package.json'));
   const packageJson = JSON.parse(packageJsonBuffer);
@@ -85,15 +85,34 @@ function readVersionsFromPackageJson() {
   }
 
   const yTransformed = (y < 10) ? `0${y}` : y;
-  const zTransformed = (z < 10) ? `0${y}` : z;
+  const zTransformed = (z < 10) ? `0${z}` : z;
   const versionCode = `${x}${yTransformed}${zTransformed}`;
 
-  console.log(`Extracted versions: versionName = ${versionName}, versionCode = ${versionCode}.`);
+  const env = (options.environment.charAt(0).toUpperCase() + options.environment.slice(1));
+  const otaVersionPropertyName = `otaVersion${env.split('Debug')[0]}`;
+  const otaVersionMessage = packageJson[otaVersionPropertyName] ? ` , ${otaVersionPropertyName} = ${packageJson[otaVersionPropertyName]}.` : '.';
+
+  console.log(`Extracted versions: versionName = ${versionName}, versionCode = ${versionCode}${otaVersionMessage}`);
 
   return {
     versionName: versionName,
     versionCode: versionCode,
+    ota: packageJson[otaVersionPropertyName],
+  }
+}
+
+
+function makeVersionsFileInTypescript(versions) {
+  const pathToVersionsFile = path.join(process.cwd(), 'src', 'environments', 'versions.ts');
+  if (fs.existsSync(pathToVersionsFile)) {
+    fs.rmSync(pathToVersionsFile);
   }
+  const versionsFileContent = `export const versions = {
+  ota: ${versions.ota},
+  native: '${versions.versionName}',
+};
+`;
+  fs.writeFileSync(pathToVersionsFile, versionsFileContent);
 }
 
 
@@ -184,6 +203,19 @@ function checkPatcherForPackageMatch(patcher) {
 }
 
 
+function createCommandsForOTA(options, versions) {
+  cleanBuildFolder(options);
+  if (!versions.ota) {
+    throw new Error(`You are trying to build app for OTA but OTA version not found. Make sure you have defined properties "otaVersion<ENVIRONMENT>" for every environment in "package.json".`);
+  }
+  const buildAngular = `ng build --configuration=${options.environment}`;
+  const createZip = `zip -q -r ./${buildFolder}/ota/www-${versions.versionName}-${versions.ota}.zip ./www`;
+  const commands = [buildAngular, createZip];
+
+  return commands;
+}
+
+
 function createCommandsForAndroid(options) {
   const isWindows = (process.platform === 'win32');
   const capitalizedEnvironment = (options.environment.charAt(0).toUpperCase() + options.environment.slice(1));
@@ -229,7 +261,7 @@ function createCommandsForIos(options) {
 
 
 function cleanBuildFolder(options) {
-  const platformBuildFolder = `${buildFolder}/${options.platform}`;
+  const platformBuildFolder = `${buildFolder}/${options.ota ? 'ota' : options.platform}`;
   if (fs.existsSync(buildFolder)) {
     fs.rmSync(buildFolder, {recursive: true});
   }
@@ -360,16 +392,28 @@ function runCliCommandList(list, path, callback) {
 export const mobileBuild = () => {
   program
     .command('mobile-build')
-    .requiredOption('-p, --platform <type>', 'Platform: android, ios')
     .requiredOption('-e, --environment <type>', 'Environment: getik, getikDebug')
+    .option('-p, --platform <type>', 'Platform: android, ios')
     .option('--syncOnly', 'Apply capacitor sync only, without platform build')
+    .option('--ota', 'Only build files for OTA update, not full application build')
     .option('--aab', 'Android platform only, final build as AAB')
     .option('--upload', 'iOS platform only, upload directly to AppStore')
-    .action((options) => {
+    .action(async (options) => {
       console.log('INPUT OPTIONS: ', options);
+      const versions = readVersionsFromPackageJson(options);
+      makeVersionsFileInTypescript(versions);
+
+      if (options.ota) {
+        const otaCliCommands = createCommandsForOTA(options, versions);
+        runCliCommandList(otaCliCommands, undefined, () => {
+          console.log('ZIP file for OTA update created, check folder: ./build/ota/');
+        });
+
+        return;
+      }
+
       const cliCommands = createCliCommands(options);
 
-      const versions = readVersionsFromPackageJson();
       if (options.platform === 'android') {
         checkKeystorePropertiesFile();
         applyVersionForAndroid(versions);
@@ -377,7 +421,7 @@ export const mobileBuild = () => {
         checkSensitiveDataJsonFile();
         applyVersionForIos(versions);
       }
-      applyPatchersForExternalNpmPackages();
+      await applyPatchersForExternalNpmPackages();
       runCliCommand(cliCommands.buildAngular, function () {
         runCliCommand(cliCommands.capacitorSync(), function () {
           runCliCommandList(cliCommands.buildApp, options.platform, () => {