@wavemaker/angular-codegen 12.0.0-next.142016 → 12.0.0-next.28533

package/download-packages.js

@@ -0,0 +1,197 @@
+const fs = require('fs');
+const { executeSyncCmd } = require('./build-util');
+const os = require('os');
+const path = require('path');
+const rimraf = require('rimraf');
+
+
+/**
+ *  To check the npm package installation successs or not
+ * @param {*} path  File path where installation success message was written
+ * @param {*} msg   Success messsage to confirm that package was installed
+ * @returns boolean true/false
+ */
+const isNPMPackageExist = (path, msg) => {
+    if (fs.existsSync(path)) {
+        const successMsg = fs.readFileSync(path, { encoding: 'utf8', flag: 'r' });
+        if (successMsg == msg) {
+            return true;
+        }
+    } else {
+        return false;
+    }
+}
+
+/**
+ *  Check  node modules package were installed or not
+ *  Create dir for  packages with the version name
+ *  Copy the generated angular app package.json to PATH_NPM_PACKAGE folder
+ *  Run npm install
+ *  Write  success file to be make sure it was installed successfully.
+ */
+const downloadNPMPackage = async (packageInfo) => {
+    const HOME_DIR = os.homedir();
+    const PATH_NPM_PACKAGE = (packageInfo.baseDir || HOME_DIR + '/.wm/node_modules/') + packageInfo.name + '/' + packageInfo.version;
+    const PATH_NPM_PACKAGE_SUCCESS = PATH_NPM_PACKAGE + '/.SUCCESS', LOCK_FILE = path.join(PATH_NPM_PACKAGE, ".LOCK");
+    let isError = false;
+    try {
+        if (!packageInfo.baseDir) { // going to install in the .wm folder if baseDir is not defined(optimizeUIBuild true)
+            // To check node modules.
+            if (!isNPMPackageExist(PATH_NPM_PACKAGE_SUCCESS, packageInfo.successMsg)) {
+                fs.mkdirSync(PATH_NPM_PACKAGE, { recursive: true });
+                // Check if another process is already installing
+                if (fs.existsSync(LOCK_FILE)) {
+                    console.log(`Waiting for another build to complete npm install... for package ${packageInfo.name}`);
+                    await waitForLock(LOCK_FILE, 20 * 60 * 1000); // Wait for 20 minutes (timeout in milliseconds)
+                    // After waiting, check if installation completed
+                    if (!isNPMPackageExist(PATH_NPM_PACKAGE_SUCCESS, packageInfo.successMsg)) {
+                        console.log(`[LOCK] Previous install for ${packageInfo.name} was incomplete. Re-installing...`);
+                        createPidLock(LOCK_FILE);
+                        await processPackage(packageInfo, PATH_NPM_PACKAGE);
+                        fs.writeFileSync(PATH_NPM_PACKAGE_SUCCESS, packageInfo.successMsg);
+                    }
+                } else {
+                    // Create PID lock and Acquire the lock
+                    createPidLock(LOCK_FILE);
+
+                    await processPackage(packageInfo, PATH_NPM_PACKAGE);
+
+                    //only create a .SUCCESS file when there is no error
+                    if(!isError) {
+                        isError = false;
+                        fs.writeFileSync(PATH_NPM_PACKAGE_SUCCESS, packageInfo.successMsg);
+                    }
+                }
+            } else {
+                console.log(packageInfo.infoMsg + ` Node packages already installed! for package ${packageInfo.name}`);
+            }
+        } else {
+            await processPackage(packageInfo, PATH_NPM_PACKAGE);
+        }
+    } catch (err) {
+        deleteFiles([PATH_NPM_PACKAGE_SUCCESS, LOCK_FILE])
+        console.log(`Something went wrong while installing - for package ${packageInfo.name}`, err);
+        process.exit(err.code || err.pid);
+    } finally {
+        //cleanup : in windows / optimizeUIBuild is false, we need to delete the temp downloaded package
+        if (!packageInfo.baseDir) {
+            deleteFiles([LOCK_FILE]);
+        }
+    }
+    return PATH_NPM_PACKAGE;
+}
+
+const processPackage = (packageInfo, PATH_NPM_PACKAGE) => {
+    let npmInstallCMD = 'npm install --legacy-peer-deps ';
+    if (packageInfo.packageJsonFile && fs.existsSync(packageInfo.packageJsonFile)) {
+        fs.copyFileSync(packageInfo.packageJsonFile, PATH_NPM_PACKAGE + '/package.json');
+        try {
+            //expecting this lock file to be present for exact versions to be downloaded from private registry
+            fs.copyFileSync(`${path.dirname(packageInfo.packageJsonFile)} + /package-lock.json`, `${PATH_NPM_PACKAGE} + /package-lock.json`);
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                console.error(`Info: package-lock.json file not found at ${path.dirname(packageInfo.packageJsonFile)}`);
+            }
+        }
+    } else {
+        npmInstallCMD = 'npm init -y && ' + npmInstallCMD;
+        npmInstallCMD += packageInfo.skipPackageVersion === true
+        ? packageInfo.name
+        : (packageInfo.scope ? packageInfo.scope + '/' : '') + packageInfo.name + '@' + packageInfo.version;
+    }
+
+    fs.mkdirSync(PATH_NPM_PACKAGE, { recursive: true });
+    executeSyncCmd('cd ' + PATH_NPM_PACKAGE + ' && ' + npmInstallCMD, (errMsg) => {
+        console.log(packageInfo.infoMsg + ' Something wrong with npm installation ', errMsg);
+        throw Error(errMsg);
+    },  packageInfo.infoMsg);
+}
+
+/**
+ *
+ */
+const deleteFiles = (files) => {
+    files.forEach(file => {
+        try {
+            rimraf.sync(file);
+            console.log(`Successfully deleted file - ${file}`);
+        } catch (err) {
+            console.error(`Error while deleting file ${file}`, err);
+            throw new Error(`Error while deleting file: ${file}, Error: ${err}`);
+        }
+    });
+}
+
+/**
+ * Check if a process with given PID is still running.
+ * @param {number} pid  Process ID to verify
+ * @returns {boolean}   True if process is alive, false otherwise
+ */
+const isProcessRunning = (pid) => {
+    try {
+        process.kill(pid, 0);   // check only, does NOT kill
+        return true;
+    } catch {
+        return false;  // PID not running
+    }
+}
+
+
+/**
+ * Create a lock file containing the current process PID.
+ * @param {string} lockFile  Full path to the .LOCK file
+ */
+const createPidLock = (lockFile) => {
+    fs.mkdirSync(path.dirname(lockFile), { recursive: true });
+    fs.writeFileSync(lockFile, String(process.pid));
+    console.log(`[LOCK] Created lock for PID ${process.pid}`);
+}
+
+/**
+ *
+ * @param lockFile
+ * @param timeout
+ * @returns {Promise<void>}
+ */
+const waitForLock = async (lockFile, timeout) => {
+    timeout = timeout || 20 * 60 * 1000 // Wait for 20 minutes (timeout in milliseconds)
+    // Helper function to wait for the lock to be released with a timeout
+    const startTime = Date.now();
+    while (true) {
+        if (!fs.existsSync(lockFile)) return; // lock free
+        let pid = null;
+        try {
+            pid = Number(fs.readFileSync(lockFile, "utf8"));
+        } catch {
+            // corrupt lock → remove
+            fs.unlinkSync(lockFile);
+            return;
+        }
+        // stale lock → PID dead
+        if (!isProcessRunning(pid)) {
+            console.log(`[LOCK] Removing stale lock from PID ${pid}`);
+            fs.unlinkSync(lockFile);
+            return;
+        }
+        // still locked → wait
+        if (Date.now() - startTime > timeout) {
+            console.error(`[LOCK] Timeout!! - waiting for the lock for PID ${pid} to be released. Exiting...`);
+            process.exit(1); // Terminate the process with an error code
+        }
+        await sleep(1000); // Wait for 1 second before checking again
+    }
+};
+
+/**
+ *
+ * @param ms
+ * @returns {Promise<unknown>}
+ */
+const sleep = (ms) => {
+    // Helper function to sleep for a given time
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+module.exports = {
+    downloadNPMPackage
+}

{angular-codegen → package}/generate-angular-app.js

@@ -12,6 +12,7 @@
  */
 
 const {args, executeSyncCmd, MSG_CODEGEN_LOG, getArgs} = require('./build-util');
+const { generateRandomHash } = require('./src/wm-utils');
 
 /**
  * From codegen-cli generate angular app into the target directory
@@ -19,7 +20,8 @@ const {args, executeSyncCmd, MSG_CODEGEN_LOG, getArgs} = require('./build-util')
 const generateAngularApp = () => {
     console.log(MSG_CODEGEN_LOG + 'Generating the angular App...');
     let buildArgs = getArgs(args.ngBuildParams.split(' '));
-    let deployUrl = 'ng-bundle/';
+    global.randomHash = global.randomHash ? global.randomHash : generateRandomHash();
+    let deployUrl = `ng-bundle/${global.randomHash}/`;
     if(buildArgs && buildArgs["deploy-url"]){
         deployUrl = buildArgs["deploy-url"];
     }