@getik-public/cli 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,2 @@
+### v1.0.0
+First stable version.

package/README.md

@@ -0,0 +1,38 @@
+# Getik CLI
+`@getik-public/cli` is a collection of scripts meant to ease the development flow. For available scripts read further.
+
+
+
+# How to use the cli
+Add next line in your `package.json` file under `devDependencies`:  
+`"@getik-public/cli": "X.Y.Z"` or simply run `npm i @getik-public/cli@latest --save-dev`.
+
+
+
+# Available scripts
+- [`mobile-build`](#mobile-build)
+- [`upload-to-getik-cloud`](#upload-to-getik-cloud)
+
+
+
+## <a name="mobile-build" href="#mobile-build">`mobile-build`</a>
+### Usage: `getik-cli mobile-build [-p, --platform] [-e, --environment] [--syncOnly] [--aab] [--upload]`  
+Example: `getik-cli mobile-build -p android -e getikDebug --syncOnly`  
+Example: `getik-cli mobile-build --platform ios --environment getik --upload`  
+
+| Option                | Required | Values                      | Description                                                                                                                                                                                                                                   |
+|-----------------------|----------|-----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `-p`, `--platform`    | YES      | `android`, `ios`            | Platform to build for.                                                                                                                                                                                                                        |
+| `-e`, `--environment` | YES      | `<string>`, `<string>Debug` | While environment can be any name, be consistent and use these: `getik`, `vbox`, `qa`, `prod`. Every environment must have a pair for debug build, so have these environments also defined: `getikDebug`, `vboxDebug`, `qaDebug`, `prodDebug` |
+| `--syncOnly`          | NO       | `-`                         | For development only, if you need to apply javascript build, or a new plugin was added. This will not go further to trigger an build script.                                                                                                  |
+| `--aab`               | NO       | `-`                         | For `--platform android` only. Build `aab` file instead of `apk` file.                                                                                                                                                                        |
+| `--upload`            | NO       | `-`                         | For `--platform ios` only. Instant upload to store after build, if successful.                                                                                                                                                                |
+
+
+
+## <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.  
+Run this command from the root of the project, as it tries to look for project name in `package.json` file. Project name will be used as file name.  
+
+

package/bin/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+
+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'})));
+
+mobileBuild();
+uploadToGetikCloud();
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@getik-public/cli",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.js",
+  "scripts": {
+  },
+  "bin": {
+    "getik-cli": "./bin/index.js"
+  },
+  "type": "module",
+  "description": "Getik CLI",
+  "author": "Getik",
+  "license": "Getik",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "figlet": "^1.7.0",
+    "inquirer": "^9.2.14",
+    "ora": "^8.0.1"
+  }
+}

package/src/mobile-build.js

@@ -0,0 +1,308 @@
+import { program } from 'commander';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+
+const buildFolder = 'build';
+
+async function applyPatchersForExternalNpmPackages() {
+  const patchesFolderName = '.patchers-for-external-npm-packages';
+  const filenameEndsWith = '.patcher.js';
+  const patchAppliedMarker = '// PATCH_APPLIED_MARKER_BY_GETIK_CLI_BUILD';
+  if (!fs.existsSync(path.join(process.cwd(), patchesFolderName))) {
+    return;
+  }
+
+  const patchesInFolder = fs.readdirSync(path.join(process.cwd(), patchesFolderName));
+  let displayClosingSeparatorLine = false;
+  for (const filename of patchesInFolder) {
+    if (filename.indexOf(filenameEndsWith) === filename.length - filenameEndsWith.length) {
+      const pathToFile = path.join(process.cwd(), patchesFolderName, filename);
+      const patcherImport = await import(pathToFile);
+      const patcher = patcherImport.default;
+      console.log('----------------------------------------------------------------------------------------------------------------------');
+      displayClosingSeparatorLine = true;
+      console.log('PATCH FOUND FOR ->', patcher.name, ':', patcher.version);
+      if (!patcher.name || !patcher.version || !patcher.reason || !patcher.applyPatchFor?.length) {
+        showPatcherInvalidFormat()
+      }
+      checkPatcherForPackageMatch(patcher);
+      patcher.applyPatchFor.forEach((patchFile) => {
+        if (!patchFile.file || !patchFile.applyPatch) {
+          showPatcherInvalidFormat()
+        }
+        console.log('CHECK IF PATCH APPLIED ->', patcher.name, ':', patcher.version, '-> File:',  patchFile.file);
+        const filePath = path.join(process.cwd(), ...patchFile.file.split('/'));
+        if (!fs.existsSync(filePath)) {
+          throw new Error(`Can't apply PATCH for "${patchFile.file}". File not found.`);
+        }
+
+        const fileContent = fs.readFileSync(filePath).toString();
+        const patchApplied = (fileContent.indexOf(patchAppliedMarker) === 0);
+
+        if (patchApplied) {
+          console.log('PATCHED ALREADY APPLIED FOR ->', patcher.name, ':', patcher.version, '-> File:',  patchFile.file);
+          console.log('SKIPPING...');
+        } else {
+          console.log('APPLYING PATCH FOR ->', patcher.name, ':', patcher.version);
+          const patchedFileContent = patchFile.applyPatch(fileContent);
+          if (!patchedFileContent || typeof patchedFileContent !=='string') {
+            throw new Error(`"applyPatch" must return patched code as a "string". PATCH not applied for ${patchFile.file}`);
+          }
+          fs.writeFileSync(filePath, (patchAppliedMarker + '\r\n' + patchedFileContent));
+          console.log('PATCHED SUCCESSFULLY ->', patcher.name, ':', patcher.version);
+        }
+      });
+    }
+  }
+  if (displayClosingSeparatorLine) {
+    console.log('----------------------------------------------------------------------------------------------------------------------');
+  }
+}
+
+
+function showPatcherInvalidFormat() {
+  const message = `
+Invalid patcher, make sure you have the right format. Example:
+---------------------------------------------------------------------
+const patcher = {
+  name: '<PACKAGE_NAME>',
+  version: '<VERSION>',
+  reason: '<REASON>',
+  applyPatchFor: [{
+    file: '<PATH_TO_FILE>',
+    applyPatch: (fileContent) => {
+      const patchedFileContent = '...';
+
+      return patchedFileContent;
+    },
+  }],
+};
+
+module.exports = patcher;
+---------------------------------------------------------------------`;
+
+  throw new Error(message);
+}
+
+
+function checkPatcherForPackageMatch(patcher) {
+  const splitNameToFolder = patcher.name.split('/');
+  const pathToPackage = path.join('node_modules', ...splitNameToFolder);
+  const pathToPackageJson = path.join(pathToPackage, 'package.json');
+  const cantApplyErrorMessage = `Can't apply PATCH for "${patcher.name}:${patcher.version}"`;
+
+  if (!fs.existsSync(pathToPackage) || !fs.existsSync(pathToPackageJson)) {
+    throw new Error(`${cantApplyErrorMessage}. Package not FOUND in "node_modules".`);
+  }
+
+  const fileBuffer = fs.readFileSync(pathToPackageJson);
+  const packageJson = JSON.parse(fileBuffer);
+  if (packageJson.name !== patcher.name) {
+    throw new Error(`${cantApplyErrorMessage}. Name in patch is not the same is in "package.json".`);
+  }
+  if (packageJson.version !== patcher.version) {
+    const nextStepsMessage = `You have to check if existing PATCH applies to current version and either update version in patch, or remove path entirely if not required anymore.`;
+    throw new Error(`${cantApplyErrorMessage}. You have "${packageJson.version}" version set in "node_modules". ${nextStepsMessage}`);
+  }
+}
+
+
+function createCommandsForAndroid(options) {
+  const isWindows = (process.platform === 'win32');
+  const capitalizedEnvironment = (options.environment.charAt(0).toUpperCase() + options.environment.slice(1));
+  const buildType = (options.aab) ? 'bundle' : 'assemble';
+  const buildCommand = (isWindows ? `gradlew ${buildType}${capitalizedEnvironment}` : `sh ./gradlew ${buildType}${capitalizedEnvironment}`);
+
+  return [buildCommand];
+}
+
+
+function createCommandsForIos(options) {
+  const workspace = './App/App.xcworkspace';
+  const debugMode = (options.environment.indexOf("Debug") >= 0);
+  const config = (debugMode ? 'Debug' : 'Release');
+  const environment = (options.environment.split('Debug')[0]);
+  const archive = `./build/archive/${environment}.xcarchive`;
+  const exportPlist = `./${environment}-export-options.plist`;
+  const build = `./build/exported`;
+  const removeBuildFolderCommand = 'rm -rf ./build';
+  const archiveCommand = `xcodebuild -workspace ${workspace} -scheme ${environment} -sdk iphoneos -configuration ${config} archive -archivePath ${archive} -allowProvisioningUpdates -quiet`;
+  const exportCommand =  `xcodebuild -exportArchive -archivePath ${archive} -exportPath ${build} -exportOptionsPlist ${exportPlist} -allowProvisioningUpdates -quiet`;
+  const commands = [removeBuildFolderCommand, archiveCommand, exportCommand];
+
+  try {
+    const sensitiveDataBuffer = fs.readFileSync(path.join('ios', 'sensitive-data.json'));
+    const sensitiveData = JSON.parse(sensitiveDataBuffer);
+    const username = sensitiveData[environment].username;
+    const password = sensitiveData[environment].password;
+    const validateIpaCommand = `xcrun altool --validate-app -t ios -f ${build}/${environment}.ipa -u ${username} -p ${password}`;
+    commands.push(validateIpaCommand);
+
+    if (options.upload) {
+      const uploadAppCommand = `xcrun altool --upload-app -t ios -f ${build}/${environment}.ipa -u ${username} -p ${password}`;
+      commands.push(uploadAppCommand);
+    }
+  } catch(error) {
+    const message = `File "./ios/sensitive-data.json" not found or has an invalid JSON structure.`;
+    throw new Error(message);
+  }
+
+  return commands;
+}
+
+
+function cleanBuildFolder(options) {
+  const platformBuildFolder = `${buildFolder}/${options.platform}`;
+  if (fs.existsSync(buildFolder)) {
+    fs.rmSync(buildFolder, {recursive: true});
+  }
+  fs.mkdirSync(platformBuildFolder, {recursive: true});
+}
+
+
+function copyFinalBuildToRootFolder(options) {
+  const platformBuildFolder = `${buildFolder}/${options.platform}`;
+  const pathToAppBuild = (options.platform === 'ios') ? buildPathToIosBuildFile(options): buildPathToAndroidBuildFile(options);
+  fs.copyFileSync(pathToAppBuild.path, path.join(platformBuildFolder, pathToAppBuild.name));
+}
+
+
+function buildPathToIosBuildFile() {
+  const env = options.environment.toLowerCase().split('debug')[0];
+  const filename = `${env}.ipa`;
+
+  return {
+    name: filename,
+    path: path.join('ios', 'build', 'exported', filename),
+  };
+}
+
+
+function buildPathToAndroidBuildFile(options) {
+  const env = options.environment.toLowerCase().split('debug')[0];
+  let fileToCopy;
+
+  if ((options.aab)) {
+    const bundleFolder = ((options.environment.indexOf('Debug') >= 0) ? options.environment : (env + 'Release'));
+    const pathToBuild = path.join('android', 'app', 'build', 'outputs', 'bundle', bundleFolder);
+    const filesInFolder = fs.readdirSync(pathToBuild);
+    filesInFolder.forEach((filename) => {
+      if (filename.indexOf('.aab') === filename.length - 4) {
+        fileToCopy = {
+          name: filename,
+          path: path.join(pathToBuild, filename),
+        };
+      }
+    });
+  } else {
+    const buildType = (options.environment.indexOf('Debug') >= 0) ? `debug` : `release`;
+    const pathToBuild = path.join('android', 'app', 'build', 'outputs', 'apk', env, buildType);
+    const filesInFolder = fs.readdirSync(pathToBuild);
+    filesInFolder.forEach((filename) => {
+      if (filename.indexOf('.apk') === filename.length - 4) {
+        fileToCopy = {
+          name: filename,
+          path: path.join(pathToBuild, filename),
+        };
+      }
+    });
+  }
+
+  if (!fileToCopy) {
+    const message = `Built file not found. This could be because build failed.`;
+    throw new Error(message);
+  }
+
+  return fileToCopy;
+}
+
+
+function createCliCommands(options) {
+  cleanBuildFolder(options);
+  const buildAngular = `ng build --configuration=${options.environment}`;
+  const capacitorSync = () => {
+    process.env.NODE_ENV = options.environment;
+
+    return `cap sync ${options.platform}`;
+  };
+  const cliCommands = {
+    buildAngular: buildAngular,
+    capacitorSync: capacitorSync,
+    buildApp: [],
+  };
+  if (!options.syncOnly) {
+    cliCommands.buildApp = (options.platform === 'android') ? createCommandsForAndroid(options) : createCommandsForIos(options);
+  }
+
+  return cliCommands;
+}
+
+
+function 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();
+  });
+}
+
+
+function runCliCommandList(list, path, callback) {
+  if (list.length === 0) {
+    return;
+  }
+  const currentCommand = list.shift();
+  runCliCommand(currentCommand, () => {
+    if (list.length === 0) {
+      callback();
+    }
+    runCliCommandList(list, path, callback);
+  }, path);
+}
+
+
+export const mobileBuild = () => {
+  program
+    .command('mobile-build')
+    .requiredOption('-p, --platform <type>', 'Platform: android, ios')
+    .requiredOption('-e, --environment <type>', 'Environment: getik, getikDebug')
+    .option('--syncOnly', 'Apply capacitor sync only, without platform build')
+    .option('--aab', 'Android platform only, final build as AAB')
+    .option('--upload', 'iOS platform only, upload directly to AppStore')
+    .action((options) => {
+      console.log('INPUT OPTIONS: ', options);
+      const cliCommands = createCliCommands(options);
+
+      applyPatchersForExternalNpmPackages();
+      runCliCommand(cliCommands.buildAngular, function () {
+        runCliCommand(cliCommands.capacitorSync(), function () {
+          runCliCommandList(cliCommands.buildApp, options.platform, () => {
+            setTimeout(() => {
+              copyFinalBuildToRootFolder(options);
+            }, 100);
+          });
+        });
+      });
+    });
+};

package/src/upload-to-getik-cloud.js

@@ -0,0 +1,78 @@
+import { execSync, spawn } from 'child_process';
+import { program } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+
+const upload = (pathToFile) => {
+  let projectName = '';
+  try {
+    const packageJsonBuffer = fs.readFileSync(path.join(process.cwd(), 'package.json'));
+    const packageJson = JSON.parse(packageJsonBuffer);
+    projectName = packageJson.name;
+  } catch (e) {
+    const message = 'Failed to read project name from "package.json" file. Make sure the script is run from inside the project(root) and there is a "package.json" file';
+    console.log(chalk.red(message));
+
+    return;
+  }
+
+  const normalizedPathToFile = path.join(process.cwd(), pathToFile);
+  const commit = execSync('git rev-parse HEAD').toString().trim();
+  let branch, splitBranchByFolder, splitBranchByName, issue;
+  try {
+    branch = execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+    if (branch === 'develop' || branch === 'master') {
+      issue = branch;
+    } else {
+      splitBranchByFolder = branch.split('/');
+      splitBranchByName = splitBranchByFolder[splitBranchByFolder.length - 1].split('-');
+      issue = `${splitBranchByName[0]}-${splitBranchByName[1]}`;
+    }
+  } catch (e) {
+    throw new Error(`You should be on a branch which contains issue id in it's name or be on master/develop branch`);
+  }
+  const splitFileName = normalizedPathToFile.split(path.sep);
+  const fileNameWithExtension = splitFileName[splitFileName.length - 1];
+  const fileNameOnly = fileNameWithExtension.split('.')[0];
+  const command = `curl -Ss -F "file=@${normalizedPathToFile}" "https://devs.getik.net/upload-apk/?name=${projectName}-${fileNameOnly}&appVersion=${issue}&commit=${commit}"`;
+
+  console.log('COMMAND: ', '\x1b[96m', command, '\x1b[0m');
+  const ls = spawn(command, [], {shell: true, env: { ...process.env, FORCE_COLOR: true }, cwd: ''});
+
+  ls.stdout.on('data', (data) => {
+    console.log('RESPONSE: ', data.toString());
+    try {
+      const parsedResponse = JSON.parse(data.toString());
+      if (parsedResponse && parsedResponse.status === 'success' && parsedResponse.fileName) {
+        console.log(chalk.green(`Link to uploaded file: https://devs.getik.net/vbox/apk/${parsedResponse.fileName}`));
+        console.log(chalk.green('Link to list: https://devs.getik.net/vbox/apk/?C=M;O=D'));
+      }
+    } catch (e) {
+      // console.log(e);
+    }
+  });
+
+  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}`);
+  });
+}
+
+
+export const uploadToGetikCloud = () => {
+  program
+    .command('upload-to-getik-cloud <source>')
+    .action((options) => {
+      console.log('INPUT OPTIONS: ', options);
+      upload(options);
+    });
+};