@ben-studios/envedit 0.0.0-stage → 1.0.0

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;

package/cli/cmd/variableCmd/edit.ts

@@ -0,0 +1,150 @@
+import { confirm, input, password, select, checkbox } from "@inquirer/prompts";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'edit',
+    describe: 'Edit an environment variable',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the variable to edit:",
+            choices: Array.from(config.vars.keys()),
+        });
+
+        const variableConfiguration = config.vars.get(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) {
+            logger.debug(`Editing variable configuration for: ${name}`);
+
+            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.envs) {
+                    const envFile = new EnvironmentFile(env.file);
+
+                    logger.debug(`Editing variable "${name}" in environment file: ${env.file}`);
+
+                    if (envFile.vars.has(name)) {
+                        const value = envFile.vars.get(name) || '';
+
+                        envFile.vars.delete(name);
+                        envFile.vars.set(updatedVariable.name, value);
+                    };
+
+                    envFile.save();
+                }
+
+                config.vars.delete(name);
+            }
+
+            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,
+                });
+
+                logger.debug(`Editing variable type for "${name}" to "${updatedVariable.type}"`);
+            }
+
+            config.vars.set(updatedVariable.name, updatedVariable);
+            config.save();
+        } else {
+            logger.debug(`Adding edited variable value for: ${name}`);
+
+            let valuesToSet = Array.from(config.envs.values()).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);
+
+                logger.debug(`Setting variable "${variableConfiguration.name}" with global value "${globalValue}" for all environments`);
+
+                for (const [_, env] of config.envs) {
+                    const envFile = new EnvironmentFile(env.file);
+
+                    logger.debug(`Setting variable "${variableConfiguration.name}" with value "${globalValue}" in environment file: ${env.file}`);
+                    
+                    envFile.vars.set(variableConfiguration.name, globalValue);
+                    envFile.save();
+                }
+            } else {
+                const envsToEdit = await checkbox({
+                    message: "Select the environments to edit the variable value for:",
+                    choices: Array.from(config.envs.keys()),
+                });
+
+                logger.debug(`Selected environments for editing: ${envsToEdit.join(", ")}`);
+
+                for (const selectedEnv of envsToEdit) {
+                    const env = config.envs.get(selectedEnv);
+
+                    if (!env) {
+                        throw new NotFoundError(`Environment not found: ${selectedEnv}`);
+                    }
+
+                    const envFile = new EnvironmentFile(env.file);
+
+                    const request = {
+                        message: `Enter the value for ${variableConfiguration.name} in environment ${selectedEnv}:`,
+                        mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
+                    };
+
+                    const newValue = variableConfiguration.type === VariableType.Private
+                        ? await password(request)
+                        : await input(request);
+
+                    envFile.vars.set(variableConfiguration.name, newValue);
+                    envFile.save();
+                }
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/variableCmd/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/variableCmd/list.ts

@@ -0,0 +1,35 @@
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'list',
+    describe: 'List all environment variables',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const activeEnv = config.active ? config.envs.get(config.active)! : undefined;
+
+        if (!activeEnv) {
+            throw new NotFoundError(`No active environment found. Please set an active environment using the "use" command.`);
+        }
+
+        const envFile = new EnvironmentFile(activeEnv.file);
+
+        for (const [key, value] of envFile.vars) {
+            const variableConfiguration = config.vars.get(key);
+            if (variableConfiguration) {
+                const type = Configuration.getTypeDetails(variableConfiguration.type);
+
+                const maskedValue = type.value === VariableType.Private ? value.replaceAll(/./gm, '*') : value;
+
+                logger
+                    .info(`Name: ${key}`)
+                    .info(`Value: ${maskedValue}`)
+                    .info(`Type: ${type.name} (${type.value})`);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/cmd/variableCmd/remove.ts

@@ -0,0 +1,39 @@
+import { select } from "@inquirer/prompts";
+
+import { Configuration, EnvironmentFile } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { Logger } from "#lib/logger";
+
+export default {
+    command: 'remove',
+    describe: 'Remove an environment variable',
+    builder: (yargs) => yargs,
+    handler: async (argv) => {
+        const config = new Configuration();
+        const logger = new Logger(argv.level);
+
+        const name = await select({
+            message: "Select the variable to remove:",
+            choices: Array.from(config.vars.keys()),
+        });
+
+        if (!config.vars.has(name)) {
+            throw new NotFoundError(`Variable not found: ${name}`);
+        }
+
+        logger.debug(`Removing variable "${name}" from configuration and all environment files`);
+
+        config.vars.delete(name);
+        config.save();
+
+        for (const [_, env] of config.envs) {
+            const envFile = new EnvironmentFile(env.file);
+
+            if (envFile.vars.has(name)) {
+                logger.debug(`Removing variable "${name}" from environment file: ${env.file}`);
+                envFile.vars.delete(name);
+                envFile.save();
+            }
+        }
+    }
+} satisfies CommandModule;

package/cli/index.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+if (!process.isBun) {
+    const [red, reset] = process.stdout.isTTY && process.env.TERM !== "dumb" ? ["\x1b[31m", "\x1b[0m"] : ["", ""];
+    console.error(`${red}This script is intended to be run with Bun.${reset}`);
+    process.exit(1);
+}
+
+await yargs(hideBin(process.argv))
+    .option("level", {
+        alias: "l",
+        type: "string",
+        description: "Set the log level",
+        default: process.env.LOG_LEVEL || "info",
+    })
+    .env('ENVEDIT')
+    .scriptName("envedit")
+    .usage("Usage: $0 <command>")
+    .command(await import("./cmd/index.ts").then((mod) => mod.default))
+    .showHelpOnFail(false)
+    .demandCommand()
+    .version()
+    .alias("h", "help")
+    .alias("v", "version")
+    .strict()
+    .parseAsync();

package/coverage/.lcov.info.133d8750bda2c350.tmp

@@ -0,0 +1,139 @@
+TN:
+SF:lib/config.ts
+FNF:12
+FNH:12
+DA:1,46
+DA:2,50
+DA:3,48
+DA:4,52
+DA:5,48
+DA:8,62
+DA:10,86
+DA:12,133
+DA:13,108
+DA:14,114
+DA:39,1
+DA:41,27
+DA:42,81
+DA:43,10
+DA:44,94
+DA:45,22
+DA:46,9
+DA:48,154
+DA:50,39
+DA:52,103
+DA:54,124
+DA:55,118
+DA:59,20
+DA:60,12
+DA:61,42
+DA:62,52
+DA:63,56
+DA:64,102
+DA:65,90
+DA:66,26
+DA:67,26
+DA:68,12
+DA:70,33
+DA:73,22
+DA:74,160
+DA:76,99
+DA:79,28
+DA:80,70
+DA:81,61
+DA:82,9
+DA:84,123
+DA:85,136
+DA:86,9
+DA:88,32
+DA:91,43
+DA:92,123
+DA:93,122
+DA:94,9
+DA:96,43
+DA:99,38
+DA:100,72
+DA:102,127
+DA:103,104
+DA:104,72
+DA:105,9
+DA:107,28
+DA:108,76
+DA:109,30
+DA:110,8
+DA:112,2
+DA:114,62
+DA:115,33
+DA:116,91
+DA:117,42
+DA:118,42
+DA:119,36
+DA:121,60
+DA:122,32
+DA:123,5
+DA:124,9
+DA:127,20
+DA:128,50
+DA:129,109
+DA:130,86
+DA:131,8
+DA:133,2
+LF:76
+LH:76
+end_of_record
+TN:
+SF:lib/error.ts
+FNF:1
+FNH:1
+DA:1,42
+DA:2,15
+DA:3,19
+DA:4,31
+LF:4
+LH:4
+end_of_record
+TN:
+SF:lib/logger.ts
+FNF:6
+FNH:6
+DA:1,47
+DA:14,1
+DA:16,177
+DA:17,61
+DA:20,43
+DA:21,69
+DA:22,32
+DA:24,41
+DA:25,68
+DA:26,32
+DA:28,41
+DA:29,68
+DA:30,32
+DA:32,43
+DA:33,69
+DA:34,32
+DA:36,43
+DA:37,69
+DA:38,30
+DA:40,2
+LF:20
+LH:20
+end_of_record
+TN:
+SF:test/util.ts
+FNF:2
+FNH:2
+DA:1,21
+DA:2,21
+DA:3,23
+DA:4,24
+DA:7,30
+DA:8,47
+DA:9,22
+DA:10,24
+DA:11,17
+DA:12,2
+DA:13,4
+LF:11
+LH:11
+end_of_record