@benshawmean/envedit 1.1.0 → 1.1.2

package/README.md

@@ -1,15 +1,57 @@
 # envedit
 
-To install dependencies:
+`envedit` is a simple CLI application used to manage environments.
+It allows you to create, edit, and delete custom environments, as well as
+control the variables within them. It is designed to be a simple and easy-to-use tool for managing environments.
+
+## Installation
+
+To install `envedit`, you must have [Bun](https://bun.sh/) installed.
+Once you have Bun installed, you can install `envedit` using the following command:
 
 ```bash
-bun install
+bun add @benshawmean/envedit
 ```
 
-To run:
+or you can install it globally using the following command:
 
 ```bash
-bun run index.ts
+bun add -g @benshawmean/envedit
 ```
 
-This project was created using `bun init` in bun v1.3.14. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+After installation, you can run `envedit` from the command line.
+
+## Setup
+
+Setting up the application is simple. You first run the setup command,
+which will create a configuration file in your current working directory.
+All you need to do is run the following command:
+
+```bash
+envedit setup
+```
+
+After that, you should see a new file called `env.config.yaml` in your current working directory.
+You can then add a new environment by running the following command and following the prompts:
+
+```bash
+envedit environment add
+```
+
+To add a new variable to an environment, you can run the following command and follow the prompts:
+
+```bash
+envedit variable add
+```
+
+After you have completed that, you can use the environment by running the following command
+and selecting the environment you want to use from the list of available environments:
+
+```bash
+envedit use
+```
+
+## License
+
+This project is licensed under the GNU General Public License version 3.
+See the [LICENSE](https://benshawmean.com/legal/global/license/gpl3) file for more details.

package/cmd/environment/add.ts

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+
+import { confirm, input, password, select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'add',
+    describe: 'Add a new environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await input({
+            message: "Enter the environment name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Environment name cannot be empty";
+                }
+                if (config.getEnvironment(input)) {
+                    return "Environment name already exists";
+                }
+                return true;
+            },
+        });
+
+        const prefix = await input({
+            message: "Enter the environment prefix:",
+        });
+
+        const file = await input({
+            message: "Enter the environment file path:",
+            default: `.env.${prefix}`,
+        });
+
+        const isActive = await confirm({
+            message: "Is this environment active?",
+        });
+
+        logger
+            .debug(`Adding new environment "${name}" with prefix "${prefix}" and file: "${file}"`);
+
+        config
+            .addEnvironment({ name, prefix, file, isActive })
+            .saveConfigurationFile();
+
+        const envFile = new EnvironmentFile(file).load();
+
+        const valuesToSet: Array<[string, string]> = []
+
+        if (!fs.existsSync(file)) {
+            logger.debug(`Environment file not found: ${file}`);
+
+            const shouldClone = await confirm({
+                message: "Do you want to clone a pre-existing environment into the new file?",
+            });
+
+            if (shouldClone) {
+                logger.debug(`Cloning a pre-existing environment into the new file: ${file}`);
+
+                const clonedEnv = await select({
+                    message: "Select the environment to clone from:",
+                    choices: config.configuration.environments.map(env => ({
+                        name: env.name,
+                        value: env.name,
+                    })),
+                });
+
+                const selectedEnv = config.getEnvironment(clonedEnv);
+
+                if (!selectedEnv) {
+                    throw new NotFoundError(`Environment not found: ${clonedEnv}`);
+                }
+
+                const selectedEnvFile = new EnvironmentFile(selectedEnv.file).load();
+
+                for (const [key, value] of Object.entries(selectedEnvFile.content)) {
+                    valuesToSet.push([key, value]);
+                }
+            } else {
+                for (const variable of config.configuration.variables) {
+                    const request = {
+                        message: `Enter the value for ${variable.name} in environment ${name}:`,
+                        mask: variable.type === VariableType.Private ? "*" : undefined,
+                    };
+
+                    const value = variable.type === VariableType.Private
+                        ? await password(request)
+                        : await input(request);
+
+                    logger
+                        .debug(`Setting variable "${variable.name}" with value "${value}" in environment "${name}"`);
+
+                    valuesToSet.push([variable.name, value]);
+                }
+            }
+
+            for (const [key, value] of valuesToSet) {
+                logger
+                    .debug(`Setting variable "${key}" with value "${value}" in environment file: ${file}`);
+                envFile.setVariable(key, value);
+            }
+
+            envFile.save();
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment/edit.ts

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+
+import { confirm, input, select, checkbox } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'edit',
+    describe: 'Edit an environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await select({
+            message: "Select the environment to edit:",
+            choices: config.configuration.environments.map(env => ({
+                name: env.name,
+                value: env.name,
+            })),
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        const itemsToEdit = await checkbox({
+            message: "Select the items to edit:",
+            choices: [
+                { name: "Name", value: "name" },
+                { name: "Prefix", value: "prefix" },
+                { name: "File", value: "file" },
+            ],
+        });
+
+        const updatedEnv = { ...selectedEnv };
+
+        if (itemsToEdit.includes("name")) {
+            logger.debug(`Editing environment name from "${selectedEnv.name}" to "${updatedEnv.name}"`);
+            updatedEnv.name = await input({
+                message: "Enter the new environment name:",
+                default: selectedEnv.name,
+            });
+        }
+
+        if (itemsToEdit.includes("prefix")) {
+            logger.debug(`Editing environment prefix from "${selectedEnv.prefix}" to "${updatedEnv.prefix}"`);
+            updatedEnv.prefix = await input({
+                message: "Enter the new environment prefix:",
+                default: selectedEnv.prefix,
+            });
+        }
+
+        if (itemsToEdit.includes("file")) {
+            logger.debug(`Editing environment file from "${selectedEnv.file}" to "${updatedEnv.file}"`);
+            updatedEnv.file = await input({
+                message: "Enter the new environment file path:",
+                default: selectedEnv.file,
+            });
+        }
+
+        config
+            .editEnvironment(name, updatedEnv)
+            .saveConfigurationFile();
+
+        if (itemsToEdit.includes("file") && fs.existsSync(selectedEnv.file)) {
+            logger.debug(`Old environment file found: ${selectedEnv.file}`);
+            const toRename = await confirm({
+                message: `Old environment file found: ${selectedEnv.file}. Do you want to rename it to the new file path: ${updatedEnv.file}?`
+            });
+
+            if (toRename) {
+                logger.debug(`Renaming environment file from "${selectedEnv.file}" to "${updatedEnv.file}"`);
+                fs.renameSync(selectedEnv.file, updatedEnv.file);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment/list.ts

@@ -0,0 +1,19 @@
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'list',
+    describe: 'List all environments',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        logger.debug(`Listing all environments`);
+
+        console.log(
+            JSON.stringify(config.configuration.environments, null, 2)
+        )
+    }
+} satisfies CommandModule;

package/cmd/environment/remove.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+
+import { confirm, select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'remove',
+    describe: 'Remove an environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await select({
+            message: "Select the environment to remove:",
+            choices: config.configuration.environments.map(env => ({
+                name: env.name,
+                value: env.name,
+            })),
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        logger
+            .debug(`Removing environment "${name}" with file: "${selectedEnv.file}"`);
+
+        config
+            .removeEnvironment(name)
+            .saveConfigurationFile();
+
+        if (fs.existsSync(selectedEnv.file)) {
+            const toDelete = await confirm({
+                message: `Environment file found: ${selectedEnv.file}. Do you want to delete it?`
+            });
+
+            if (toDelete) {
+                logger
+                    .debug(`Deleting environment file: ${selectedEnv.file}`);
+                fs.unlinkSync(selectedEnv.file);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment.ts

@@ -0,0 +1,21 @@
+import type { CommandModule } from "yargs";
+
+import Add from "./environment/add";
+import Edit from "./environment/edit";
+import List from "./environment/list";
+import Remove from "./environment/remove";
+
+const data = {
+    command: 'environment',
+    describe: 'Manage environments',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit environment <command> [options]')
+        .command([Add, Edit, List, Remove])
+        .demandCommand(),
+    handler: async (_args) => {}
+} satisfies CommandModule;
+
+export const command = data.command;
+export const describe = data.describe;
+export const builder = data.builder;
+export const handler = data.handler;

package/cmd/setup.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+
+import { confirm } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { logger } from "#lib/logger";
+
+const data = {
+    command: 'setup',
+    describe: 'Setup the project for use with envedit',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit setup'),
+    handler: async (_args) => {
+        new Configuration().loadConfigurationFile();
+
+        if (fs.existsSync('.git')) {
+            logger.debug(`Git repository found. Checking for git ignore file.`);
+
+            const gitignorePath = '.gitignore';
+
+            if (!fs.existsSync(gitignorePath)) {
+                logger.debug(`Git ignore file not found: ${gitignorePath}`);
+
+                const toCreate = await confirm({
+                    message: `Git Repository without a git ignore file not found: ${gitignorePath}. Do you want to create it?`
+                });
+
+                if (toCreate) {
+                    console.error(`Git Repository without a git ignore file not found: ${gitignorePath}`);
+                    process.exit(1);
+                }
+
+                fs.writeFileSync(gitignorePath, "");
+            }
+
+            const expectedItems = ['.env', '.env.*', 'env.config.yaml'];
+
+            logger.debug(`Checking for expected items in git ignore file: ${expectedItems.join(", ")}`);
+
+            for (const item of expectedItems) {
+                if (!fs.readFileSync(gitignorePath, "utf-8").includes(item)) {
+                    logger.debug(`Item not found in git ignore file: ${item}`);
+
+                    const toAdd = await confirm({
+                        message: `The item ${item} is not in the git ignore file. Do you want to add it?`
+                    });
+
+                    if (!toAdd) {
+                        console.error(`The item ${item} is not in the git ignore file.`);
+                        process.exit(1);
+                    }
+
+                    fs.appendFileSync(gitignorePath, `\n${item}`);
+                }
+            }
+        }
+    }
+} satisfies CommandModule;
+
+export const command = data.command;
+export const describe = data.describe;
+export const builder = data.builder;
+export const handler = data.handler;

package/cmd/use.ts

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+
+import { select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+const data = {
+    command: 'use',
+    describe: 'Set the current environment to use',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit use'),
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await select({
+            message: "Select the environment to use",
+            choices: config.configuration.environments.map(env => ({
+                name: env.name + (env.isActive ? " (active)" : ""),
+                value: env.name,
+            })),
+            default: config.getActiveEnvironment()?.name,
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        logger.debug(`Setting current environment to "${name}" with file: "${selectedEnv.file}"`);
+
+        if (!selectedEnv.isActive) {
+            logger.debug(`Updating active environment in configuration file to "${name}"`);
+
+            for (const env of config.configuration.environments) {
+                env.isActive = env.name === name;
+            }
+
+            config.saveConfigurationFile();
+        }
+
+        logger.debug(`Creating symlink to environment file: ${selectedEnv.file}`);
+
+        const envFilePath = selectedEnv.file;
+
+        if (fs.existsSync('.env')) {
+            logger.debug(`Removing existing symlink or file: .env`);
+
+            fs.unlinkSync('.env');
+        }
+
+        fs.symlinkSync(envFilePath, '.env', 'file');
+    }
+} satisfies CommandModule;
+
+export const command = data.command;
+export const describe = data.describe;
+export const builder = data.builder;
+export const handler = data.handler;

package/cmd/variable/add.ts

@@ -0,0 +1,94 @@
+import { confirm, input, password, select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'add',
+    describe: 'Add a new environment variable',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await input({
+            message: "Enter the variable name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Variable name cannot be empty";
+                }
+                if (config.getVariable(input)) {
+                    return "Variable name already exists";
+                }
+                return true;
+            },
+        });
+
+        const type = await select({
+            message: "Select the variable type:",
+            choices: [
+                { name: "Public", value: VariableType.Public },
+                { name: "Private", value: VariableType.Private },
+            ],
+        });
+
+        logger
+            .debug(`Adding new variable "${name}" with type "${type}"`);
+
+        config
+            .addVariable({ name, type })
+            .saveConfigurationFile();
+
+        const shouldGloballySet = await confirm({
+            message: "Do you want to set this variable with a global value for all environments?",
+        });
+
+        const valuesToSet = config.configuration.environments.map(env => ({
+            envName: env.name,
+            value: '',
+        }));
+
+        if (shouldGloballySet) {
+            const request = {
+                message: `Enter the global value for ${name}:`,
+                mask: type === VariableType.Private ? "*" : undefined,
+            };
+
+            const globalValue = type === VariableType.Private
+                ? await password(request)
+                : await input(request);
+
+            logger
+                .debug(`Setting variable "${name}" with global value "${globalValue}" for all environments`);
+
+            valuesToSet.forEach((envValue) => { envValue.value = globalValue });
+        } else {
+            for (const envValue of valuesToSet) {
+                const request = {
+                    message: `Enter the value for ${name} in environment ${envValue.envName}:`,
+                    mask: type === VariableType.Private ? "*" : undefined,
+                };
+
+                envValue.value = type === VariableType.Private
+                    ? await password(request)
+                    : await input(request);
+
+                logger
+                    .debug(`Setting variable "${name}" with value "${envValue.value}" for environment "${envValue.envName}"`);
+            }
+        }
+
+        for (const envValue of valuesToSet) {
+            const env = config.getEnvironment(envValue.envName);
+            logger
+                .debug(`Retrieving environment: ${envValue.envName}`);
+
+            if (!env) {
+                throw new NotFoundError(`Environment not found: ${envValue.envName}`);
+            }
+
+            EnvironmentFile.quickUpdate(env.file, name, envValue.value);
+        }
+    }
+} satisfies CommandModule;