at-builder 1.1.0 → 1.1.2

package/src/constants/config.ts

@@ -2,31 +2,110 @@ const path = require("path");
 const fs = require("fs");
 var clc = require("cli-color");
 
-
-export const getVersion = () => {
+/**
+ * Reads and returns the version from package.json
+ * @returns {Promise<string>} The version of the package
+ */
+export const getVersion = async () => {
     const packageJSONPath = path.resolve(__dirname, "../../package.json");
-    const content = fs.readFileSync(packageJSONPath, { encoding: "utf8" });
-    const config = JSON.parse(content);
-    return config.version;
+    try {
+        const content = await fs.promises.readFile(packageJSONPath, { encoding: "utf8" });
+        const config = JSON.parse(content);
+        return config.version;
+    } catch (error) {
+        console.error(clc.red("Error reading package.json or parsing JSON"));
+        process.exit(1);  // Exit the process if package.json is not found or malformed
+    }
+};
+
+exports.getVersion = getVersion;
+
+/**
+ * Helper function for formatting colorized text
+ * @param {string} text The text to format
+ * @param {string} color The color for the text
+ * @param {boolean} bold Whether to make the text bold
+ * @param {boolean} underline Whether to underline the text
+ * @returns {string} The formatted text
+ */
+const formatText = (text, color = "white", bold = false, underline = false) => {
+    let formattedText = clc[color](text);
+    if (bold) formattedText = clc.bold(formattedText);
+    if (underline) formattedText = clc.underline(formattedText);
+    return formattedText;
 };
 
-const version = getVersion();
+/**
+ * Returns help information with commands and usage
+ * @returns {Promise<string>} The help text
+ */
+export const getHelpInfo = async () => {
+    const version = await getVersion();
 
-export const getHelpInfo = () => `
-${clc.green.underline(`at-builder (version: ${version})`)}
+    return `
+${formatText(`at-builder (version: ${version})`, 'green', false, true)}
 
-${clc.white.bold("A simple command to run adobe target builder.")}
+${formatText("A simple command to run Adobe Target builder.", 'white', true)}
 
-$ atb
+Usage: \`atb\`
 
 Available Commands:
 
-${clc.blue.underline.bold("new")} Creates a new activity
-${clc.blue.underline.bold("build")} Create build
+${formatText("new", 'blue', true, true)}  Creates a new activity
+${formatText("build", 'blue', true, true)}  Create build
+${formatText("build -p", 'blue', true, true)}  Create production build
 
 Example:
 
-atb -c new
-atb -c 
-`;
+atb -c new  # Creates a new activity
+atb -c build  # Creates a build
+atb -p -c build  # Creates a build for production
+
+For more information on a specific command, run \`atb <command> --help\`
+    `;
+};
+
+
+export const setupEnv = async (basePath) => {
+    // Path to the .env file
+    const envPath = path.join(basePath, '.env');
+
+    // Check if the .env file exists
+    if (!fs.existsSync(envPath)) {
+        // Define the content of the .env file
+        const envContent = `
+ACTIVITY_FOLDER_NAME=""
+PUPPETEER_LANDING_PAGE=""
+TARGET_URL=""
+LOGIN_URL=""
+VARIATION="Variation-1"
+NODE_ENV="development"
+    `;
+        // Write the content to the .env file
+        fs.writeFileSync(envPath, envContent.trim(), 'utf8');
+        console.log('.env file created successfully!');
+    } else {
+        console.log('.env file already exists!');
+    }
+    createWatchConfig(basePath);
+}
+
+
+const createWatchConfig = (basePath ) => {
+    
+    // Path to the watch-config.json file
+    const watchConfigPath = path.join(basePath, 'watch-config.json');
+
+    // Default content for watch-config.json
+    const watchConfigContent = {
+        "VARIATION": "Variation-1"
+    };
 
+    // Check if the watch-config.json file already exists
+    if (!fs.existsSync(watchConfigPath)) {
+        fs.writeFileSync(watchConfigPath, JSON.stringify(watchConfigContent, null, 2), 'utf8');
+        console.log('watch-config.json file created successfully!');
+    } else {
+        console.log('watch-config.json file already exists!');
+    }
+}

package/src/index.ts

@@ -1,118 +1,199 @@
 #!/usr/bin/env node
-
 import { spawn } from "child_process";
-import { getHelpInfo } from "./constants/config";
-const path = require("path");
-const fs = require("fs");
-const readline = require('readline');
+import path from "path";
+import fs from "fs";
+import inquirer  from 'inquirer';
+import { Command } from 'commander';
+import { getVersion, getHelpInfo, setupEnv } from "./constants/config";
 
-import * as inquirer from 'inquirer';
+/**
+ * Checks if the .env file exists at the current working directory
+ *
+ * @throws {Error} If the .env file is not found
+ */
+const checkEnvFile = () => {
+    console.log("Checking if .env file exists at current working directory");
+    try {
+        // Check if the file exists and is readable
+        fs.accessSync(path.join(process.cwd(), ".env"), fs.constants.R_OK);
+        console.log(".env file found");
+    } catch (error) {
+        // If the file does not exist, throw an error
+        console.log(`Error: Couldn't find .env file at location ${process.cwd()}`);
+        throw error;
+    }
+};
 
+// Prepare environment for spawning processes
+const productionEnv = {
+    ...process.env,
+    executionPath: process.cwd()
+};
 
-// inquirer
-//   .prompt([
-    
-//   ])
-//   .then((answers) => {
-//     // Use user feedback for... whatever!!
-//   })
-//   .catch((error) => {
-//     if (error.isTtyError) {
-//       // Prompt couldn't be rendered in the current environment
-//     } else {
-//       // Something else went wrong
-//     }
-//   });
-
-
-try {
-    fs.accessSync(path.join(process.cwd(), ".env"), fs.constants.R_OK);
-} catch (error) {
-    throw `Error : Couldn't find .env file at location ${process.cwd()}`;
-}
+// Commander setup
+const setupCommander = async () => {
+    console.log("Setting up commander");
+    const version = await getVersion();
+    console.log(`Version: ${version}`);
+    const program = new Command();
+    program
+        .version(version, "-V, --version")
+        .usage("[OPTIONS]...")
+        .option("-c, --command <value>")
+        .option("-p, --prod")
+        .option("-v, --verbose", "Enable verbose logging")
+        .parse(process.argv);
 
-const commander = require("commander");
-commander
-    .version("1.0.0", "-v, --version")
-    .usage("[OPTIONS]...")
-    .option("-c, --command <value>")
-    .option("-p, --prod")
-    .parse(process.argv);
-
-const options = commander.opts();
-let userChoice = '';
-var productionEnv = Object.create(process.env);
-productionEnv.executionPath = process.cwd();
-
-console.log("OPTIONS COmmand", options.command)
-switch (options.command) {
-    case "new": {
-        spawn("npm", ["run", "new-activity"], {
-            // env: { NODE_ENV: process.cwd() },
-            env: productionEnv,
-            cwd: path.join(__dirname, "../"),
-            shell: true,
-            stdio: "inherit",
-        });
-        break;
-    }
-    case "build": {
-        if (options.prod) {
-            process.env['NODE_ENV'] = 'production';
-        }
+    console.log("Commander setup complete");
+    return program.opts();
+};
+
+
+
+/**
+ * Spawn a command using `npm` with the given command array and environment object.
+ *
+ * @param commandArr - The array of command strings to pass to `npm`.
+ * @param env - The environment object to pass to the spawned process.
+ */
+const runCommand = (commandArr: string[], env: NodeJS.ProcessEnv): void => {
+    console.log(`Running npm command [${commandArr.join(", ")}]`);
+    console.log(`Current working directory: ${process.cwd()}`);
+    // console.log(`Environment variables: ${JSON.stringify(env, null, 2)}`);
+
+    // Spawn the command using `npm` with the given environment and current working directory.
+    spawn("npm", commandArr, {
+        cwd: path.join(__dirname, "../"),
+        env,
+        shell: true,
+        stdio: "inherit",
+    });
+};
+
+/**
+ * Handles the build process based on the given options.
+ *
+ * @param {boolean} prod - If true, runs the build with production environment.
+ *                          If false, runs the build with development environment.
+ */
+const handleBuild = async (prod: boolean): Promise<void> => {
+    console.log(`Handling build with options: production=${prod}`);
+    if (prod) {
+        // Set production environment
+        process.env['NODE_ENV'] = 'production';
+        console.log("Running build with production environment");
+        // Run the build command
+        runCommand(['run', 'build-prod'], productionEnv);
+    } else {
+        console.log("Running build with development environment");
+        // Prompt the user to ask if they want to open the build in a browser tab
+        const { openInBrowser } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'openInBrowser',
+                message: 'Do you want to open your build in a browser tab?',
+                default: false,
+            },
+        ]);
 
-        if (!options.prod) {
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            rl.question('Do you want open your build in a browser tab: Y/N ? ', function (ans) {
-                console.log(`ANSWER ${ans}`)
-                userChoice = ans;
-                rl.close();
-            });
-
-            rl.on('close', function () {
-                const commandArr = ['run', 'dev'];
-                if (userChoice !== 'Y' && userChoice !== 'N') {
-                    return;
-                }
-                if (userChoice === 'Y') {
-                    const devIndex = commandArr.findIndex((val) => val === 'dev');
-                    commandArr[devIndex] = 'dev-puppeteer';
-                }
-                spawn("npm", commandArr, {
-                    cwd: path.join(__dirname, "../"),
-                    env: productionEnv,
-                    shell: true,
-                    stdio: "inherit",
-                });
-                process.exit(0);
-            });
-        } else {
-            spawn("npm", ['run', 'dev'], {
-                cwd: path.join(__dirname, "../"),
-                env: productionEnv,
-                shell: true,
-                stdio: "inherit",
-            });
+        console.log(`User opted for opening in browser: ${openInBrowser}`);
+        const commandArr = ['run', 'dev'];
+        if (openInBrowser) {
+            // If the user wants to open the build in a browser, run the build with
+            // puppeteer
+            commandArr[1] = 'dev-puppeteer';
         }
+
+        console.log(`Running command: ${commandArr.join(', ')}`);
+        // Run the build command
+        runCommand(commandArr, productionEnv);
     }
-}
+};
 
+// Command execution logic
 /**
- * Command Help
+ * Handles the command execution based on the given options.
+ *
+ * @returns {Promise<void>}
  */
-const printCommandHelp = () => {
-    const help = getHelpInfo();
+const executeCommand = async () => {
+    console.log("Entering executeCommand");
+    // Check if .env file is present
+    // Get the command options
+    const options = await setupCommander();
+    
+    if (options.command !== 'init')
+        checkEnvFile();
+    
+    console.log(`Options: ${JSON.stringify(options)}`);
+    /**
+     * Logs a message if verbose mode is enabled
+     * @param {string} message - The message to log
+     */
+    const verboseLog = (message: string) => {
+        if (options.verbose) {
+            console.log(`[VERBOSE] ${message}`);
+        }
+    };
+
+    switch (options.command) {
+        case "init":
+            // Initialize new .env file
+            verboseLog("Initializing new .env file");
+            runCommand(["init -y"], productionEnv);
+            setupEnv(process.cwd());
+            break;
+
+        case "new":
+            // Create new activity
+            verboseLog("Creating new activity");
+            runCommand(["run", "new-activity"], productionEnv);
+            break;
+
+        case "build":
+            // Build the application in production or development mode
+            verboseLog(`Building in ${options.prod ? 'production' : 'development'} mode`);
+            await handleBuild(options.prod);
+            break;
+
+        default:
+            // Print command help
+            printCommandHelp();
+            process.exit(0);
+            break;
+    }
+    console.log("Exiting executeCommand");
+};
+
+// Print command help
+const printCommandHelp = async () => {
+    const help = await getHelpInfo();
     console.log(help);
+    process.exit(0);
 };
 
-const symbols = Object.keys(options);
+/**
+ * Main program flow
+ *
+ * This function is the main entry point of the program. It attempts to execute
+ * the command specified by the user. If the command fails, it logs the error
+ * message and exits with code 1.
+ */
+const main = async () => {
+    try {
+        // Execute the command specified by the user
+        await executeCommand();
+    } catch (error) {
+        // Log the error message if the command fails
+        console.error(error.message);
+        // Exit with code 1 if the command fails
+        process.exit(1);
+    }
+};
 
 // Print help if no arguments
-if (symbols.length === 0) {
+if (process.argv.length <= 2) {
     printCommandHelp();
-    process.exit(0);
+} else {
+    main();
 }
-

package/tsconfig.json

@@ -1,11 +1,11 @@
 {
     "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2017",
+        "module": "CommonJS",
+        "moduleResolution": "Node",
+        "target": "ES2020",
         "lib": [
             "es2015"
         ],
-        "moduleResolution": "node",
         "sourceMap": false,
         "outDir": "bin",
         "baseUrl": ".",
@@ -20,7 +20,9 @@
         },
         "emitDecoratorMetadata": true,
         "experimentalDecorators": true,
-        "skipLibCheck": true
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
     },
     "include": [
         "src/**/*",

package/webpack.config.js

@@ -7,7 +7,7 @@ const TerserPlugin = require("terser-webpack-plugin");
 const ESLintPlugin = require('eslint-webpack-plugin');
 const postcssPresetEnv = require('postcss-preset-env');
 const AdobeTargetBuildGeneratorPlugin = require('./lib/at-build-generator');
-const commander = require("commander");
+// const commander = require("commander");
 
 console.log(process.env.ACTIVITY_FOLDER_NAME)
 
@@ -28,15 +28,15 @@ if (process.env.NODE_ENV === PRODUCTION) {
     console.log("\x1b[36m%s\x1b[0m", "------ Running Development Build ------")
 }
 
-/**
- * commander
- */
-commander
-    .version("1.0.0", "-v, --version")
-    .option("-p, --path <value>", "Overwriting value.", process.cwd())
-    .parse(process.argv);
+// /**
+//  * commander
+//  */
+// commander
+//     .version("1.0.0", "-v, --version")
+//     .option("-p, --path <value>", "Overwriting value.", process.cwd())
+//     .parse(process.argv);
 
-const options = commander.opts();
+// const options = commander.opts();
 
 /**
  * Update folder name here if wanted to skip while transpilation