@benshawmean/envedit 1.0.0

package/README.md

@@ -0,0 +1,15 @@
+# envedit
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.14. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/index.ts

@@ -0,0 +1,565 @@
+import fs from "node:fs";
+
+import { input, password, select, checkbox, confirm } from "@inquirer/prompts";
+import { parse } from "dotenv";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+import { NotFoundError } from "./lib/error";
+import { Configuration, EnvironmentFile, VariableType } from "./lib/config";
+
+await yargs(hideBin(process.argv))
+    .scriptName("envedit")
+    .command(
+        "environment",
+        "Manage environments",
+        (yargs) => yargs
+            .command(
+                "list",
+                "List all environments",
+                () => { },
+                async () => {
+                    const config = new Configuration().loadConfigurationFile();
+
+                    for (const env of config.configuration.environments) {
+                        console.dir(env);
+                    }
+                }
+            )
+            .command(
+                "add",
+                "Add a new environment",
+                () => { },
+                async () => {
+                    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.configuration.environments.find(env => env.name === 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?",
+                    });
+
+                    config
+                        .addEnvironment({ name, prefix, file, isActive })
+                        .saveConfigurationFile();
+
+                    const envFile = new EnvironmentFile(file).load();
+
+                    if (!fs.existsSync(file)) {
+                        const shouldClone = await confirm({
+                            message: "Do you want to clone a pre-existing environment into the new file?",
+                        });
+
+                        if (shouldClone) {
+                            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);
+
+                            selectedEnvFile.load();
+
+                            for (const [key, value] of Object.entries(selectedEnvFile.content)) {
+                                envFile.setVariable(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);
+
+                                envFile.setVariable(variable.name, value);
+                            }
+                        }
+
+                        envFile.save();
+                    }
+                }
+            )
+            .command(
+                "remove",
+                "Remove an environment",
+                () => { },
+                async () => {
+                    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}`);
+                    }
+
+                    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) {
+                            fs.unlinkSync(selectedEnv.file);
+                        }
+                    }
+                }
+            )
+            .command(
+                "edit",
+                "Edit an environment",
+                () => { },
+                async () => {
+                    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")) {
+                        updatedEnv.name = await input({
+                            message: "Enter the new environment name:",
+                            default: selectedEnv.name,
+                        });
+                    }
+
+                    if (itemsToEdit.includes("prefix")) {
+                        updatedEnv.prefix = await input({
+                            message: "Enter the new environment prefix:",
+                            default: selectedEnv.prefix,
+                        });
+                    }
+
+                    if (itemsToEdit.includes("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)) {
+                        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) {
+                            fs.renameSync(selectedEnv.file, updatedEnv.file);
+                        }
+                    }
+                }
+            )
+            .demandCommand(),
+    )
+    .command(
+        "variable",
+        "Manage environment variables",
+        (yargs) => yargs
+            .command(
+                "list",
+                "List all environment variables",
+                () => { },
+                async () => {
+                    const config = new Configuration().loadConfigurationFile();
+
+                    const activeEnv = config.getActiveEnvironment();
+
+                    if (!activeEnv) {
+                        throw new NotFoundError(`No active environment found. Please set an active environment using the "use" command.`);
+                    }
+
+                    const envContent = fs.readFileSync(activeEnv.file, "utf-8");
+
+                    const parsedEnv = parse(envContent);
+
+                    for (const [key, value] of Object.entries(parsedEnv)) {
+                        const variableConfiguration = config.getVariable(key);
+                        if (variableConfiguration) {
+                            const data = {
+                                name: key,
+                                value: variableConfiguration.type === VariableType.Private ? value.replaceAll(/./gm, '*') : value,
+                                type: variableConfiguration.type,
+                            };
+
+                            console.dir(data);
+                        }
+                    }
+                }
+            )
+            .command(
+                "add",
+                "Add a new environment variable",
+                () => { },
+                async () => {
+                    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 },
+                        ],
+                    });
+
+                    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);
+
+                        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);
+                        }
+                    }
+
+                    for (const envValue of valuesToSet) {
+                        const env = config.getEnvironment(envValue.envName);
+
+                        if (!env) {
+                            throw new NotFoundError(`Environment not found: ${envValue.envName}`);
+                        }
+
+                        EnvironmentFile.quickUpdate(env.file, name, envValue.value);
+                    }
+                }
+            )
+            .command(
+                "remove",
+                "Remove an environment variable",
+                () => { },
+                async () => {
+                    const config = new Configuration().loadConfigurationFile();
+
+                    const name = await select({
+                        message: "Select the variable to remove:",
+                        choices: config.configuration.variables.map(variable => ({
+                            name: variable.name,
+                            value: variable.name,
+                        })),
+                    });
+
+                    if (!config.getVariable(name)) {
+                        throw new NotFoundError(`Variable not found: ${name}`);
+                    }
+
+                    config
+                        .removeVariable(name)
+                        .saveConfigurationFile();
+
+                    for (const env of config.configuration.environments) {
+                        const envFile = new EnvironmentFile(env.file).load();
+
+                        if (envFile.content[name] !== undefined) {
+                            envFile.removeVariable(name).save();
+                        }
+                    }
+                }
+            )
+            .command(
+                "edit",
+                "Edit an environment variable",
+                () => { },
+                async () => {
+                    const config = new Configuration().loadConfigurationFile();
+
+                    const name = await select({
+                        message: "Select the variable to edit:",
+                        choices: config.configuration.variables.map(variable => ({
+                            name: variable.name,
+                            value: variable.name,
+                        })),
+                    });
+
+                    const variableConfiguration = config.getVariable(name);
+
+                    if (!variableConfiguration) {
+                        throw new NotFoundError(`Variable not found: ${name}`);
+                    }
+
+                    const isEditingConfig = await select({
+                        message: "Are you editing the variable configuration (name/type) or the variable value?",
+                        choices: [
+                            { name: "Configuration", value: true },
+                            { name: "Value", value: false },
+                        ],
+                    });
+
+                    if (isEditingConfig) {
+                        const itemsToEdit = await checkbox({
+                            message: "Select the items to edit:",
+                            choices: [
+                                { name: "Name", value: "name" },
+                                { name: "Type", value: "type" },
+                            ],
+                        });
+
+                        const updatedVariable = { ...variableConfiguration };
+
+                        if (itemsToEdit.includes("name")) {
+                            updatedVariable.name = await input({
+                                message: "Enter the new variable name:",
+                                default: variableConfiguration.name,
+                            });
+
+                            for (const env of config.configuration.environments) {
+                                const envFile = new EnvironmentFile(env.file).load();
+
+                                if (envFile.content[name] !== undefined) {
+                                    const value = envFile.content[name];
+                                    envFile.removeVariable(name);
+                                    envFile.setVariable(updatedVariable.name, value);
+                                    envFile.save();
+                                }
+                            }
+                        }
+
+                        if (itemsToEdit.includes("type")) {
+                            updatedVariable.type = await select({
+                                message: "Select the new variable type:",
+                                choices: [
+                                    { name: "Public", value: VariableType.Public },
+                                    { name: "Private", value: VariableType.Private },
+                                ],
+                                default: variableConfiguration.type,
+                            });
+                        }
+
+                        config
+                            .editVariable(name, updatedVariable)
+                            .saveConfigurationFile();
+                    } else {
+                        let valuesToSet = config.configuration.environments.map(env => ({
+                            envName: env.name,
+                            value: '',
+                        }));
+
+                        const shouldGloballySet = await confirm({
+                            message: "Do you want to set this variable for all environments?",
+                        });
+
+                        if (shouldGloballySet) {
+                            const request = {
+                                message: `Enter the global value for ${variableConfiguration.name}:`,
+                                mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
+                            };
+
+                            const globalValue = variableConfiguration.type === VariableType.Private
+                                ? await password(request)
+                                : await input(request);
+
+                            valuesToSet.forEach((envValue) => { envValue.value = globalValue });
+                        } else {
+                            for (const envValue of valuesToSet) {
+                                const request = {
+                                    message: `Enter the value for ${variableConfiguration.name} in environment ${envValue.envName}:`,
+                                    mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
+                                };
+
+                                envValue.value = variableConfiguration.type === VariableType.Private
+                                    ? await password(request)
+                                    : await input(request);
+                            }
+                        }
+
+                        for (const envValue of valuesToSet) {
+                            const env = config.getEnvironment(envValue.envName);
+
+                            if (!env) {
+                                throw new NotFoundError(`Environment not found: ${envValue.envName}`);
+                            }
+
+                            EnvironmentFile.quickUpdate(env.file, variableConfiguration.name, envValue.value);
+                        }
+                    }
+                }
+            )
+            .demandCommand(),
+    )
+    .command(
+        "setup",
+        "Setup the environment",
+        () => { },
+        async () => {
+            new Configuration().loadConfigurationFile();
+
+            if (fs.existsSync('.git')) {
+                const gitignorePath = '.gitignore';
+
+                if (!fs.existsSync(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'];
+
+                for (const item of expectedItems) {
+                    if (!fs.readFileSync(gitignorePath, "utf-8").includes(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}`);
+                    }
+                }
+            }
+        }
+    )
+    .command(
+        "use",
+        "Set the current environment",
+        () => { },
+        async () => {
+            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}`);
+            }
+
+            if (!selectedEnv.isActive) {
+                for (const env of config.configuration.environments) {
+                    env.isActive = env.name === name;
+                }
+
+                config.saveConfigurationFile();
+            }
+
+            const envFilePath = selectedEnv.file;
+
+            if (fs.existsSync('.env')) {
+                fs.unlinkSync('.env');
+            }
+
+            fs.symlinkSync(envFilePath, '.env', 'file');
+        }
+    )
+    .demandCommand()
+    .parseAsync();

package/lib/config.ts

@@ -0,0 +1,222 @@
+import fs from 'fs';
+
+import { parse } from 'dotenv';
+
+import { NotFoundError } from './error';
+
+export enum VariableType {
+    Public = 'public',
+    Private = 'private',
+}
+
+export interface VariableConfiguration {
+    name: string;
+    type: VariableType;
+}
+
+export interface EnviornmentConfiguration {
+    name: string;
+    prefix: string;
+    file: string;
+    isActive: boolean;
+}
+
+export interface GeneralConfiguration {
+    environments: EnviornmentConfiguration[];
+    variables: VariableConfiguration[];
+}
+
+export class Configuration {
+    private config: GeneralConfiguration = { environments: [], variables: [] };
+    private readonly configFilePath: string = 'env.config.yaml';
+    constructor(config: Partial<GeneralConfiguration> = {}) {
+        if (config.environments) {
+            this.config.environments = config.environments;
+        }
+
+        if (config.variables) {
+            this.config.variables = config.variables;
+        }
+    }
+    public get configuration(): GeneralConfiguration {
+        return {
+            environments: this.config.environments || [],
+            variables: this.config.variables || [],
+        };
+    }
+
+    public loadConfigurationFile() {
+        if (!fs.existsSync(this.configFilePath)) {
+            console.log(`Configuration file not found: ${this.configFilePath}`);
+            console.log(`Creating a new configuration file`);
+
+            const config = new Configuration();
+
+            if (fs.existsSync('.env')) {
+                config.importFromEnv(fs.readFileSync('.env', "utf-8"));
+            }
+
+            this.saveConfigurationFile();
+        }
+
+        const configContent = Bun.YAML.parse(fs.readFileSync(this.configFilePath, "utf-8")) as GeneralConfiguration;
+
+        this.config.environments = configContent.environments || [];
+        this.config.variables = configContent.variables || [];
+
+        return this;
+    }
+
+    public saveConfigurationFile() {
+        fs.writeFileSync(this.configFilePath, Bun.YAML.stringify(this.configuration, null, 2));
+
+        return this;
+    }
+
+    public setActiveEnvironment(name: string) {
+        const index = this.config.environments!.findIndex(e => e.name === name);
+        if (index === -1) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        this.config.environments.forEach((env, i) => {
+            env.isActive = i === index;
+        });
+
+        return this;
+    }
+
+    public getActiveEnvironment(): EnviornmentConfiguration | undefined {
+        return this.config.environments.find(env => env.isActive);
+    }
+
+    public addEnvironment(env: EnviornmentConfiguration) {
+        this.config.environments.push(env);
+        return this;
+    }
+
+    public editEnvironment(name: string, env: Partial<EnviornmentConfiguration>) {
+        const index = this.config.environments!.findIndex(e => e.name === name);
+        if (index === -1) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        this.config.environments[index] = {
+            name: env.name || this.config.environments[index]!.name,
+            prefix: env.prefix || this.config.environments[index]!.prefix,
+            file: env.file || this.config.environments[index]!.file,
+            isActive: env.isActive !== undefined ? env.isActive : this.config.environments[index]!.isActive,
+        };
+        return this;
+    }
+
+    public removeEnvironment(name: string) {
+        const index = this.config.environments!.findIndex(e => e.name === name);
+        if (index === -1) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        this.config.environments.splice(index, 1);
+        return this;
+    }
+
+    public getEnvironment(name: string): EnviornmentConfiguration | undefined {
+        return this.config.environments.find(env => env.name === name);
+    }
+
+    public addVariable(variable: VariableConfiguration) {
+        this.config.variables.push(variable);
+        return this;
+    }
+
+    public editVariable(name: string, variable: Partial<VariableConfiguration>) {
+        if (!this.config.variables.find(v => v.name === name)) {
+            throw new NotFoundError(`Variable not found: ${name}`);
+        }
+
+        this.config.variables = this.config.variables.map(v => v.name === name ? { ...v, ...variable } : v);
+        return this;
+    }
+
+    public removeVariable(name: string) {
+        if (!this.config.variables.find(v => v.name === name)) {
+            throw new NotFoundError(`Variable not found: ${name}`);
+        }
+
+        this.config.variables = this.config.variables.filter(v => v.name !== name);
+        return this;
+    }
+
+    public getVariable(name: string): VariableConfiguration | undefined {
+        return this.config.variables.find(v => v.name === name);
+    }
+
+    public importFromEnv(content: string): Configuration {
+        const config = new Configuration();
+
+        const env = parse(content);
+
+        for (const [key, _] of Object.entries(env)) {
+            if (key.includes('PRIVATE')) {
+                config.addVariable({
+                    name: key,
+                    type: VariableType.Private,
+                });
+            } else {
+                config.addVariable({
+                    name: key,
+                    type: VariableType.Public,
+                });
+            }
+        }
+
+        return config;
+    }
+}
+
+export class EnvironmentFile {
+    public content: Record<string, string> = {};
+    public rawContent: string = '';
+    constructor(public readonly path: string) { }
+
+    public load() {
+        if (!fs.existsSync(this.path)) {
+            fs.writeFileSync(this.path, '');
+        }
+
+        this.rawContent = fs.readFileSync(this.path, "utf-8");
+        this.content = parse(this.rawContent);
+
+        return this;
+    }
+
+    public save() {
+        const lines: string[] = [];
+        for (const [key, value] of Object.entries(this.content)) {
+            lines.push(`${key}='${value}'`);
+        }
+        this.rawContent = lines.join('\n');
+        fs.writeFileSync(this.path, this.rawContent);
+
+        return this;
+    }
+
+    public setVariable(name: string, value: string) {
+        this.content[name] = value;
+
+        return this;
+    }
+
+    public removeVariable(name: string) {
+        delete this.content[name];
+
+        return this;
+    }
+
+    public static quickUpdate(path: string, name: string, value: string) {
+        const envFile = new EnvironmentFile(path).load();
+        envFile.setVariable(name, value).save();
+
+        return envFile;
+    }
+}

package/lib/error.ts

@@ -0,0 +1,6 @@
+export class NotFoundError extends Error {
+    constructor(message?: string) {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@benshawmean/envedit",
+  "module": "index.ts",
+  "type": "module",
+  "version": "1.0.0",
+  "bin": {
+    "envedit": "index.ts"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "tag": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/yargs": "^17.0.35"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "dotenv": "^17.4.2",
+    "yargs": "^18.1.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}