@benshawmean/envedit 1.1.1 → 1.1.2

package/index.ts

@@ -1,566 +1,25 @@
 #!/usr/bin/env bun
-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";
+import { logger } from "#lib/logger";
 
 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}`);
-                    }
-                }
+    .usage("Usage: $0 <command>")
+    .commandDir(
+        `${import.meta.dir}/cmd`,
+        {
+            extensions: ['ts'],
+            visit: (commandObject, commandPath, filename) => {
+                logger.debug(`Loading command: ${commandPath}`);
+
+                logger.debug(`Command Name: ${commandObject.command}`);
+                logger.debug(`Command Description: ${commandObject.describe}`);
+
+                return commandObject;
             }
-        }
-    )
-    .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

@@ -2,11 +2,11 @@ import fs from 'fs';
 
 import { parse } from 'dotenv';
 
-import { NotFoundError } from './error';
+import { NotFoundError } from '#lib/error';
 
 export enum VariableType {
-    Public = 'public',
-    Private = 'private',
+    Public,
+    Private,
 }
 
 export interface VariableConfiguration {
@@ -22,12 +22,13 @@ export interface EnviornmentConfiguration {
 }
 
 export interface GeneralConfiguration {
+    version: number;
     environments: EnviornmentConfiguration[];
     variables: VariableConfiguration[];
 }
 
 export class Configuration {
-    private config: GeneralConfiguration = { environments: [], variables: [] };
+    private config: GeneralConfiguration = { version: 1, environments: [], variables: [] };
     private readonly configFilePath: string = 'env.config.yaml';
     constructor(config: Partial<GeneralConfiguration> = {}) {
         if (config.environments) {
@@ -37,9 +38,13 @@ export class Configuration {
         if (config.variables) {
             this.config.variables = config.variables;
         }
+        if (config.version) {
+            this.config.version = config.version;
+        }
     }
     public get configuration(): GeneralConfiguration {
         return {
+            version: this.config.version,
             environments: this.config.environments || [],
             variables: this.config.variables || [],
         };
@@ -68,7 +73,11 @@ export class Configuration {
     }
 
     public saveConfigurationFile() {
-        fs.writeFileSync(this.configFilePath, Bun.YAML.stringify(this.configuration, null, 2));
+        fs.writeFileSync(
+            this.configFilePath,
+            Bun.YAML.stringify(this.configuration, null, 2),
+            { mode: 0o600 },
+        );
 
         return this;
     }
@@ -181,7 +190,7 @@ export class EnvironmentFile {
 
     public load() {
         if (!fs.existsSync(this.path)) {
-            fs.writeFileSync(this.path, '');
+            fs.writeFileSync(this.path, '', { mode: 0o600 });
         }
 
         this.rawContent = fs.readFileSync(this.path, "utf-8");

package/lib/logger.ts

@@ -0,0 +1,15 @@
+import pino from 'pino';
+
+const level = process.env.LOG_LEVEL || 'info';
+
+export const logger = pino({
+    level,
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            translateTime: 'SYS:standard',
+            ignore: 'pid,hostname',
+        },
+    },
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@benshawmean/envedit",
   "module": "index.ts",
   "type": "module",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "license": "GPL-3.0-only",
   "bin": {
     "envedit": "index.ts"
@@ -25,6 +25,8 @@
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
     "dotenv": "^17.4.2",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
     "yargs": "^18.1.0"
   }
 }

package/tsconfig.json

@@ -29,6 +29,7 @@
 
     "paths": {
       "@/*": ["./*"],
+      "#lib/*": ["./lib/*"]
     }
   }
 }