@benshawmean/envedit 1.1.0 → 1.1.2

package/cmd/variable/edit.ts

@@ -0,0 +1,161 @@
+import { confirm, input, password, select, checkbox } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'edit',
+    describe: 'Edit an environment variable',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        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) {
+            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.configuration.environments) {
+                    const envFile = new EnvironmentFile(env.file).load();
+
+                    logger
+                        .debug(`Editing variable "${name}" in environment file: ${env.file}`);
+
+                    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,
+                });
+
+                logger
+                    .debug(`Editing variable type for "${name}" to "${updatedVariable.type}"`);
+            }
+
+            config
+                .editVariable(name, updatedVariable)
+                .saveConfigurationFile();
+        } else {
+            logger
+                .debug(`Adding editing variable value for: ${name}`);
+
+            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);
+
+                logger
+                    .debug(`Setting variable "${variableConfiguration.name}" with global value "${globalValue}" for all environments`);
+
+                valuesToSet.forEach((envValue) => { envValue.value = globalValue });
+            } else {
+                const envsToEdit = await checkbox({
+                    message: "Select the environments to edit the variable value for:",
+                    choices: config.configuration.environments.map(env => ({
+                        name: env.name,
+                        value: env.name,
+                    })),
+                });
+
+                logger
+                    .debug(`Selected environments for editing: ${envsToEdit.join(", ")}`);
+
+                valuesToSet = valuesToSet.filter(envValue => envsToEdit.includes(envValue.envName));
+
+                if (valuesToSet.length === 0) {
+                    console.log("No environments selected. Exiting.");
+                    return;
+                }
+
+                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}`);
+                }
+
+                logger
+                    .debug(`Setting variable "${variableConfiguration.name}" with value "${envValue.value}" in environment file: ${env.file}`);
+
+                EnvironmentFile.quickUpdate(env.file, variableConfiguration.name, envValue.value);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/variable/list.ts

@@ -0,0 +1,43 @@
+import type { CommandModule } from "yargs";
+
+import { Configuration, EnvironmentFile, VariableType } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'list',
+    describe: 'List all environment variables',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        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 envFile = new EnvironmentFile(activeEnv.file).load();
+
+        const mappedVariables: Array<{ name: string; value: string; type: VariableType }> = [];
+
+        for (const [key, value] of Object.entries(envFile.content)) {
+            const variableConfiguration = config.getVariable(key);
+            if (variableConfiguration) {
+                logger.debug(`Mapping variable "${key}" with value "${value}" and type "${variableConfiguration.type}"`);
+
+                const data = {
+                    name: key,
+                    value: variableConfiguration.type === VariableType.Private ? value.replaceAll(/./gm, '*') : value,
+                    type: variableConfiguration.type,
+                };
+
+                mappedVariables.push(data);
+            }
+        }
+
+        console.log(
+            JSON.stringify(mappedVariables, null, 2)
+        )
+    }
+} satisfies CommandModule;

package/cmd/variable/remove.ts

@@ -0,0 +1,44 @@
+import { select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+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 (_args) => {
+        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}`);
+        }
+
+        logger
+            .debug(`Removing variable "${name}" from configuration and all environment files`);
+
+        config
+            .removeVariable(name)
+            .saveConfigurationFile();
+
+        for (const env of config.configuration.environments) {
+            const envFile = new EnvironmentFile(env.file).load();
+
+            if (envFile.content[name] !== undefined) {
+                logger
+                    .debug(`Removing variable "${name}" from environment file: ${env.file}`);
+                envFile.removeVariable(name).save();
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/variable.ts

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