@ben-studios/envedit 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# ![EnvEdit Icon](https://cdn.benshawmean.com/icons/envedit-icon.png){width=32} envedit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`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 add @benshawmean/envedit
+```
+
+or you can install it globally using the following command:
+
+```bash
+bun add -g @benshawmean/envedit
+```
+
+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
+```
+
+## Schema
+
+I have released a JSON Schema spec. file for the outputted file. It can be found at <https://benshawmean.com/api/schema/envedit>.
+
+
+### IDE Support for Schema
+
+To add validation and description support for the schema, please try the following things:
+
+#### VSCode
+
+For VSCode (and/or VSCode Insiders), add the following to your `settings.json` file:
+
+```json
+"json.schemaDownload.trustedDomains": {
+    "https://benshawmean.com/": true,
+},
+"json.schemas": [
+    {
+        "fileMatch": ["**/env.config.yaml"],
+        "url": "https://benshawmean.com/api/schema/envedit",
+    }
+],
+"yaml.schemas": {
+    "https://benshawmean.com/api/schema/envedit": "**/env.config.yaml"
+}
+```
+
+#### JetBrains IDEs
+
+For JetBrains IDEs, you can do this by doing these steps:
+
+1. In Settings, head to Languages & Frameworks > Schemas and DTDs > JSON Schema Mappings
+2. Click the + (Add) icon
+3. Name your mapping "EnvEdit"
+4. Provide the URL `https://benshawmean.com/api/schema/envedit`
+5. Define the file path pattern `**/env.config.yaml`
+6. Click OK
+
+Do note that this is on a project level, so you will need to do this for each project you want to use the schema in.
+
+## 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/ci/npm.sh

@@ -0,0 +1,4 @@
+#! /usr/bin/env bash
+
+echo "//${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/:_authToken=${CI_JOB_TOKEN}" > .npmrc
+echo "@${CI_PROJECT_ROOT_NAMESPACE}:registry=https://${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/" >> .npmrc

package/cli/cmd/environment.ts

@@ -0,0 +1,10 @@
+import Commands from "./environmentCmd";
+
+export default {
+    command: 'environment',
+    describe: 'Manage environments',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit environment <command> [options]')
+        .command(Commands)
+        .demandCommand(),
+} as CommandModule;

package/cli/cmd/environmentCmd/add.ts

@@ -0,0 +1,115 @@
+import {
+    existsSync as exists,
+    unlinkSync as unlink,
+    symlinkSync as symlink,
+} from "node:fs";
+
+import { confirm, input, password, select } from "@inquirer/prompts";
+
+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 (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await input({
+            message: "Enter the environment name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Environment name cannot be empty";
+                }
+                if (config.envs.has(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?",
+            default: !config.active,
+        });
+
+        logger.debug(`Adding new environment "${name}" with prefix "${prefix}" and file: "${file}"`);
+
+        config.envs.set(name, { name, prefix, file, isActive });
+        config.save();
+        
+        const envFile = new EnvironmentFile(file);
+
+        if (!exists(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: Array.from(config.envs.keys()),
+                });
+
+                const selectedEnv = config.envs.get(clonedEnv);
+
+                if (!selectedEnv) {
+                    throw new NotFoundError(`Environment not found: ${clonedEnv}`);
+                }
+
+                const envSpecificFile = new EnvironmentFile(selectedEnv.file);
+
+                for (const [key, value] of Object.entries(envSpecificFile.vars)) {
+                    envFile.vars.set(key, value);
+                }
+
+                envFile.save();
+            } else {
+                for (const [_, variable] of config.vars) {
+                    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}"`);
+
+                    envFile.vars.set(variable.name, value);
+                }
+            }
+
+            envFile.save();
+        }
+
+        if (isActive) {
+            config.active = name;
+
+            if (exists('.env')) {
+                unlink('.env');
+            }
+
+            const properEnv = config.envs.get(name)!;
+            symlink(properEnv.file, '.env', 'file');
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/environmentCmd/edit.ts

@@ -0,0 +1,74 @@
+import {
+    renameSync as rename,
+    existsSync as exists,
+} from "node:fs";
+
+import { input, select, checkbox } from "@inquirer/prompts";
+
+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 (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the environment to edit:",
+            choices: Array.from(config.envs.keys()),
+        });
+
+        const selectedEnv = config.envs.get(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.envs.set(name, updatedEnv);
+        config.save();
+
+        if (itemsToEdit.includes("file") && exists(selectedEnv.file)) {
+            logger.debug(`Renaming environment file from "${selectedEnv.file}" to "${updatedEnv.file}"`);
+            rename(selectedEnv.file, updatedEnv.file);
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/environmentCmd/index.ts

@@ -0,0 +1,6 @@
+import Add from "./add";
+import Edit from "./edit";
+import List from "./list";
+import Remove from "./remove";
+
+export default [Add, Edit, List, Remove]

package/cli/cmd/environmentCmd/list.ts

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

package/cli/cmd/environmentCmd/remove.ts

@@ -0,0 +1,47 @@
+import {
+    existsSync as exists,
+    unlinkSync as unlink,
+} from "node:fs";
+
+import { confirm, select } from "@inquirer/prompts";
+
+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 (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the environment to remove:",
+            choices: Array.from(config.envs.keys()),
+        });
+
+        const selectedEnv = config.envs.get(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        logger.debug(`Removing environment "${name}" with file: "${selectedEnv.file}"`);
+
+        config.envs.delete(name);
+        config.save();
+
+        if (exists(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}`);
+                unlink(selectedEnv.file);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/index.ts

@@ -0,0 +1,7 @@
+import Environment from './environment';
+import Variable from './variable';
+import Use from './use';
+import Init from './init';
+import Setup from './setup';
+
+export default [Environment, Variable, Use, Init, Setup];

package/cli/cmd/init.ts

@@ -0,0 +1,60 @@
+import {
+    existsSync as exists,
+    readFileSync as read,
+    writeFileSync as write,
+    appendFileSync as append,
+} from "node:fs";
+
+import { confirm } from "@inquirer/prompts";
+
+import { Configuration } from "#lib/config";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'init',
+    describe: 'Initialize the project for use with envedit',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit init')
+        .epilogue("Note that this command is meant to be used when the project is FIRST setup, not to setup based on a pre-existing configuration. for that, please run the 'setup' command"),
+    handler: async (argv) => {
+        const logger = new Logger(argv.level);
+        new Configuration();
+
+        if (exists('.git')) {
+            logger.debug(`Git repository found. Checking for git ignore file.`);
+
+            const gitignorePath = '.gitignore';
+
+            if (!exists('.gitignore')) {
+                const toCreate = await confirm({
+                    message: `Git Repository without a git ignore file not found. Do you want to create it?`
+                });
+
+                if (toCreate) {
+                    write('.gitignore', "");
+                }
+            }
+
+            const expectedItems = ['.env', '.env.*'];
+
+            logger.debug(`Checking for expected items in git ignore file: ${expectedItems.join(", ")}`);
+
+            for (const item of expectedItems) {
+                if (read(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);
+                    }
+
+                    append(gitignorePath, `\n${item}`);
+                }
+            }
+        }
+    }
+} as CommandModule;

package/cli/cmd/setup.ts

@@ -0,0 +1,46 @@
+import {
+    lstatSync as lstat,
+    existsSync as exists,
+    copyFileSync as copy,
+    unlinkSync as unlink,
+    symlinkSync as symlink,
+} from 'node:fs';
+
+import { Configuration, EnvironmentFile } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+
+export default {
+    command: 'setup',
+    describe: 'Setup the project for use with envedit',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit setup')
+        .epilogue("Note that this command is meant to be used after the project has been setup. To make a clean start, please run the 'init' command instead."),
+    handler: async (_argv) => {
+        if (!exists('env.config.yaml')) {
+            throw new NotFoundError("Could not find configuration file. Did you run the init command?")
+        }
+
+        const config = new Configuration();
+
+        for (const environment of config.envs.values()) {
+            const envFile = new EnvironmentFile(environment.file);
+
+            if (environment.isActive) {
+                if (exists('.env') && !lstat('.env').isSymbolicLink()) {
+                    copy('.env', environment.file);
+                    unlink('.env');
+                }
+
+                symlink(environment.file, '.env', 'file');
+            }
+
+            for (const variable of config.vars.values()) {
+                if (!envFile.vars.has(variable.name)) {
+                    envFile.vars.set(variable.name, '');
+                }
+            }
+
+            envFile.save();
+        }
+    }
+} as CommandModule;

package/cli/cmd/use.ts

@@ -0,0 +1,60 @@
+import {
+    lstatSync as lstat,
+    existsSync as exists,
+    unlinkSync as unlink,
+    symlinkSync as symlink,
+} from 'node:fs';
+
+import { select } from "@inquirer/prompts";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'use',
+    describe: 'Set the current environment to use',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit use'),
+    handler: async (argv) => {
+        const logger = new Logger(argv.level);
+        const config = new Configuration();
+
+        const name = await select({
+            message: "Select the environment to use",
+            choices: Array.from(config.envs.keys()).map(env => ({
+                name: env + (config.envs.get(env)?.isActive ? " (active)" : ""),
+                value: env,
+            })),
+            default: config.active,
+        });
+
+        const selectedEnv = config.envs.get(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}"`);
+
+            config.active = selectedEnv.name;
+
+            config.save();
+        }
+
+        logger.debug(`Creating symlink to environment file: ${selectedEnv.file}`);
+
+        const envFilePath = selectedEnv.file;
+
+        if (exists('.env')) {
+            logger.debug(`Removing existing symlink or file: .env`);
+
+            unlink('.env');
+        }
+
+        symlink(envFilePath, '.env', 'file');
+    }
+} as CommandModule;

package/cli/cmd/variable.ts

@@ -0,0 +1,10 @@
+import Commands from "./variableCmd";
+
+export default {
+    command: 'variable',
+    describe: 'Manage environment variables',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit variable <command> [options]')
+        .command(Commands)
+        .demandCommand(),
+} as CommandModule;

package/cli/cmd/variableCmd/add.ts

@@ -0,0 +1,92 @@
+import { confirm, input, password, select } from "@inquirer/prompts";
+
+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 (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await input({
+            message: "Enter the variable name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Variable name cannot be empty";
+                }
+                if (config.vars.has(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.vars.set(name, { name, type });
+        config.save();
+
+        const shouldGloballySet = await confirm({
+            message: "Do you want to set this variable with a global value for all environments?",
+        });
+
+        const valuesToSet = Array.from(config.envs.values()).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.envs.get(envValue.envName);
+            logger.debug(`Retrieving environment: ${envValue.envName}`);
+
+            if (!env) {
+                throw new NotFoundError(`Environment not found: ${envValue.envName}`);
+            }
+
+            const envFile = new EnvironmentFile(env.file);
+
+            envFile.vars.set(name, envValue.value);
+            envFile.save();
+        }
+    }
+} satisfies CommandModule;