@benshawmean/envedit 1.3.0 → 1.3.2-0

package/{cmd → cli/cmd}/environmentCmd/add.ts

@@ -1,4 +1,8 @@
-import fs from "node:fs";
+import {
+    existsSync as exists,
+    unlinkSync as unlink,
+    symlinkSync as symlink,
+} from "node:fs";
 
 import { confirm, input, password, select } from "@inquirer/prompts";
 
@@ -11,7 +15,7 @@ export default {
     describe: 'Add a new environment',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await input({
@@ -20,7 +24,7 @@ export default {
                 if (!input) {
                     return "Environment name cannot be empty";
                 }
-                if (config.getEnvironment(input)) {
+                if (config.envs.has(input)) {
                     return "Environment name already exists";
                 }
                 return true;
@@ -38,20 +42,17 @@ export default {
 
         const isActive = await confirm({
             message: "Is this environment active?",
+            default: !config.active,
         });
 
-        logger
-            .debug(`Adding new environment "${name}" with prefix "${prefix}" and file: "${file}"`);
+        logger.debug(`Adding new environment "${name}" with prefix "${prefix}" and file: "${file}"`);
 
-        config
-            .addEnvironment({ name, prefix, file, isActive })
-            .save();
+        config.envs.set(name, { name, prefix, file, isActive });
+        config.save();
+        
+        const envFile = new EnvironmentFile(file);
 
-        const envFile = new EnvironmentFile(file).load();
-
-        const valuesToSet: Array<[string, string]> = []
-
-        if (!fs.existsSync(file)) {
+        if (!exists(file)) {
             logger.debug(`Environment file not found: ${file}`);
 
             const shouldClone = await confirm({
@@ -63,25 +64,22 @@ export default {
 
                 const clonedEnv = await select({
                     message: "Select the environment to clone from:",
-                    choices: config.configuration.environments.map(env => ({
-                        name: env.name,
-                        value: env.name,
-                    })),
+                    choices: Array.from(config.envs.keys()),
                 });
 
-                const selectedEnv = config.getEnvironment(clonedEnv);
+                const selectedEnv = config.envs.get(clonedEnv);
 
                 if (!selectedEnv) {
                     throw new NotFoundError(`Environment not found: ${clonedEnv}`);
                 }
 
-                const selectedEnvFile = new EnvironmentFile(selectedEnv.file).load();
+                const envSpecificFile = new EnvironmentFile(selectedEnv.file);
 
-                for (const [key, value] of Object.entries(selectedEnvFile.content)) {
-                    valuesToSet.push([key, value]);
+                for (const [key, value] of Object.entries(envSpecificFile.vars)) {
+                    envFile.vars.set(key, value);
                 }
             } else {
-                for (const variable of config.configuration.variables) {
+                for (const [_, variable] of config.vars) {
                     const request = {
                         message: `Enter the value for ${variable.name} in environment ${name}:`,
                         mask: variable.type === VariableType.Private ? "*" : undefined,
@@ -94,17 +92,22 @@ export default {
                     logger
                         .debug(`Setting variable "${variable.name}" with value "${value}" in environment "${name}"`);
 
-                    valuesToSet.push([variable.name, value]);
+                    envFile.vars.set(variable.name, value);
                 }
             }
 
-            for (const [key, value] of valuesToSet) {
-                logger
-                    .debug(`Setting variable "${key}" with value "${value}" in environment file: ${file}`);
-                envFile.setVariable(key, value);
+            envFile.save();
+        }
+
+        if (isActive) {
+            config.active = name;
+
+            if (exists('.env')) {
+                unlink('.env');
             }
 
-            envFile.save();
+            const properEnv = config.envs.get(name)!;
+            symlink(properEnv.file, '.env', 'file');
         }
     }
 } satisfies CommandModule;

package/{cmd → cli/cmd}/environmentCmd/edit.ts

@@ -1,6 +1,9 @@
-import fs from "node:fs";
+import {
+    renameSync as rename,
+    existsSync as exists,
+} from "node:fs";
 
-import { confirm, input, select, checkbox } from "@inquirer/prompts";
+import { input, select, checkbox } from "@inquirer/prompts";
 
 import { Configuration } from "#lib/config";
 import { NotFoundError } from "#lib/error";
@@ -11,18 +14,15 @@ export default {
     describe: 'Edit an environment',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await select({
             message: "Select the environment to edit:",
-            choices: config.configuration.environments.map(env => ({
-                name: env.name,
-                value: env.name,
-            })),
+            choices: Array.from(config.envs.keys()),
         });
 
-        const selectedEnv = config.getEnvironment(name);
+        const selectedEnv = config.envs.get(name);
 
         if (!selectedEnv) {
             throw new NotFoundError(`Environment not found: ${name}`);
@@ -63,20 +63,12 @@ export default {
             });
         }
 
-        config
-            .editEnvironment(name, updatedEnv)
-            .save();
+        config.envs.set(name, updatedEnv);
+        config.save();
 
-        if (itemsToEdit.includes("file") && fs.existsSync(selectedEnv.file)) {
-            logger.debug(`Old environment file found: ${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) {
-                logger.debug(`Renaming environment file from "${selectedEnv.file}" to "${updatedEnv.file}"`);
-                fs.renameSync(selectedEnv.file, updatedEnv.file);
-            }
+        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/{cmd → cli/cmd}/environmentCmd/list.ts

@@ -6,13 +6,11 @@ export default {
     describe: 'List all environments',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         logger.debug(`Listing all environments`);
 
-        console.log(
-            JSON.stringify(config.configuration.environments, null, 2)
-        )
+        console.log(JSON.stringify(Array.from(config.envs.values()), null, 2));
     }
 } satisfies CommandModule;

package/{cmd → cli/cmd}/environmentCmd/remove.ts

@@ -1,4 +1,7 @@
-import fs from "node:fs";
+import {
+    existsSync as exists,
+    unlinkSync as unlink,
+} from "node:fs";
 
 import { confirm, select } from "@inquirer/prompts";
 
@@ -11,18 +14,15 @@ export default {
     describe: 'Remove an environment',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await select({
             message: "Select the environment to remove:",
-            choices: config.configuration.environments.map(env => ({
-                name: env.name,
-                value: env.name,
-            })),
+            choices: Array.from(config.envs.keys()),
         });
 
-        const selectedEnv = config.getEnvironment(name);
+        const selectedEnv = config.envs.get(name);
 
         if (!selectedEnv) {
             throw new NotFoundError(`Environment not found: ${name}`);
@@ -30,18 +30,17 @@ export default {
 
         logger.debug(`Removing environment "${name}" with file: "${selectedEnv.file}"`);
 
-        config
-            .removeEnvironment(name)
-            .save();
+        config.envs.delete(name);
+        config.save();
 
-        if (fs.existsSync(selectedEnv.file)) {
+        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}`);
-                fs.unlinkSync(selectedEnv.file);
+                unlink(selectedEnv.file);
             }
         }
     }

package/{cmd → cli/cmd}/index.ts

@@ -1,6 +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, Setup];
+export default [Environment, Variable, Use, Init, Setup];

package/{cmd/setup.ts → cli/cmd/init.ts}

@@ -1,4 +1,9 @@
-import fs from "node:fs";
+import {
+    existsSync as exists,
+    readFileSync as read,
+    writeFileSync as write,
+    appendFileSync as append,
+} from "node:fs";
 
 import { confirm } from "@inquirer/prompts";
 
@@ -6,41 +11,36 @@ import { Configuration } from "#lib/config";
 import { Logger } from "#lib/logger";
 
 export default {
-    command: 'setup',
-    describe: 'Setup the project for use with envedit',
+    command: 'init',
+    describe: 'Initialize the project for use with envedit',
     builder: (yargs) => yargs
-        .usage('Usage: envedit setup'),
+        .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();
 
-        new Configuration().load();
-
-        if (fs.existsSync('.git')) {
+        if (exists('.git')) {
             logger.debug(`Git repository found. Checking for git ignore file.`);
 
             const gitignorePath = '.gitignore';
 
-            if (!fs.existsSync(gitignorePath)) {
-                logger.debug(`Git ignore file not found: ${gitignorePath}`);
-
+            if (!exists('.gitignore')) {
                 const toCreate = await confirm({
-                    message: `Git Repository without a git ignore file not found: ${gitignorePath}. Do you want to create it?`
+                    message: `Git Repository without a git ignore file not found. Do you want to create it?`
                 });
 
                 if (toCreate) {
-                    console.error(`Git Repository without a git ignore file not found: ${gitignorePath}`);
-                    process.exit(1);
+                    write('.gitignore', "");
                 }
-
-                fs.writeFileSync(gitignorePath, "");
             }
 
-            const expectedItems = ['.env', '.env.*', 'env.config.yaml'];
+            const expectedItems = ['.env', '.env.*'];
 
             logger.debug(`Checking for expected items in git ignore file: ${expectedItems.join(", ")}`);
 
             for (const item of expectedItems) {
-                if (!fs.readFileSync(gitignorePath, "utf-8").includes(item)) {
+                if (read(gitignorePath, "utf-8").includes(item)) {
                     logger.debug(`Item not found in git ignore file: ${item}`);
 
                     const toAdd = await confirm({
@@ -52,7 +52,7 @@ export default {
                         process.exit(1);
                     }
 
-                    fs.appendFileSync(gitignorePath, `\n${item}`);
+                    append(gitignorePath, `\n${item}`);
                 }
             }
         }

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/{cmd → cli/cmd}/use.ts

@@ -1,4 +1,9 @@
-import fs from "node:fs";
+import {
+    lstatSync as lstat,
+    existsSync as exists,
+    unlinkSync as unlink,
+    symlinkSync as symlink,
+} from 'node:fs';
 
 import { select } from "@inquirer/prompts";
 
@@ -13,19 +18,18 @@ export default {
         .usage('Usage: envedit use'),
     handler: async (argv) => {
         const logger = new Logger(argv.level);
-
-        const config = new Configuration().load();
+        const config = new Configuration();
 
         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,
+            choices: Array.from(config.envs.keys()).map(env => ({
+                name: env + (config.envs.get(env)?.isActive ? " (active)" : ""),
+                value: env,
             })),
-            default: config.getActiveEnvironment()?.name,
+            default: config.active,
         });
 
-        const selectedEnv = config.getEnvironment(name);
+        const selectedEnv = config.envs.get(name);
 
         if (!selectedEnv) {
             throw new NotFoundError(`Environment not found: ${name}`);
@@ -36,9 +40,7 @@ export default {
         if (!selectedEnv.isActive) {
             logger.debug(`Updating active environment in configuration file to "${name}"`);
 
-            for (const env of config.configuration.environments) {
-                env.isActive = env.name === name;
-            }
+            config.active = selectedEnv.name;
 
             config.save();
         }
@@ -47,12 +49,12 @@ export default {
 
         const envFilePath = selectedEnv.file;
 
-        if (fs.existsSync('.env')) {
+        if (exists('.env')) {
             logger.debug(`Removing existing symlink or file: .env`);
 
-            fs.unlinkSync('.env');
+            unlink('.env');
         }
 
-        fs.symlinkSync(envFilePath, '.env', 'file');
+        symlink(envFilePath, '.env', 'file');
     }
 } as CommandModule;

package/{cmd → cli/cmd}/variableCmd/add.ts

@@ -9,7 +9,7 @@ export default {
     describe: 'Add a new environment variable',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await input({
@@ -18,7 +18,7 @@ export default {
                 if (!input) {
                     return "Variable name cannot be empty";
                 }
-                if (config.getVariable(input)) {
+                if (config.vars.has(input)) {
                     return "Variable name already exists";
                 }
                 return true;
@@ -35,15 +35,14 @@ export default {
 
         logger.debug(`Adding new variable "${name}" with type "${type}"`);
 
-        config
-            .addVariable({ name, type })
-            .save();
+        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 = config.configuration.environments.map(env => ({
+        const valuesToSet = Array.from(config.envs.values()).map(env => ({
             envName: env.name,
             value: '',
         }));
@@ -77,14 +76,17 @@ export default {
         }
 
         for (const envValue of valuesToSet) {
-            const env = config.getEnvironment(envValue.envName);
+            const env = config.envs.get(envValue.envName);
             logger.debug(`Retrieving environment: ${envValue.envName}`);
 
             if (!env) {
                 throw new NotFoundError(`Environment not found: ${envValue.envName}`);
             }
 
-            EnvironmentFile.quickUpdate(env.file, name, envValue.value);
+            const envFile = new EnvironmentFile(env.file);
+
+            envFile.vars.set(name, envValue.value);
+            envFile.save();
         }
     }
 } satisfies CommandModule;

package/{cmd → cli/cmd}/variableCmd/edit.ts

@@ -9,18 +9,15 @@ export default {
     describe: 'Edit an environment variable',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await select({
             message: "Select the variable to edit:",
-            choices: config.configuration.variables.map(variable => ({
-                name: variable.name,
-                value: variable.name,
-            })),
+            choices: Array.from(config.vars.keys()),
         });
 
-        const variableConfiguration = config.getVariable(name);
+        const variableConfiguration = config.vars.get(name);
 
         if (!variableConfiguration) {
             throw new NotFoundError(`Variable not found: ${name}`);
@@ -53,18 +50,22 @@ export default {
                     default: variableConfiguration.name,
                 });
 
-                for (const env of config.configuration.environments) {
-                    const envFile = new EnvironmentFile(env.file).load();
+                for (const [_, env] of config.envs) {
+                    const envFile = new EnvironmentFile(env.file);
 
                     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 (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")) {
@@ -80,13 +81,12 @@ export default {
                 logger.debug(`Editing variable type for "${name}" to "${updatedVariable.type}"`);
             }
 
-            config
-                .editVariable(name, updatedVariable)
-                .save();
+            config.vars.set(updatedVariable.name, updatedVariable);
+            config.save();
         } else {
-            logger.debug(`Adding editing variable value for: ${name}`);
+            logger.debug(`Adding edited variable value for: ${name}`);
 
-            let valuesToSet = config.configuration.environments.map(env => ({
+            let valuesToSet = Array.from(config.envs.values()).map(env => ({
                 envName: env.name,
                 value: '',
             }));
@@ -107,47 +107,43 @@ export default {
 
                 logger.debug(`Setting variable "${variableConfiguration.name}" with global value "${globalValue}" for all environments`);
 
-                valuesToSet.forEach((envValue) => { envValue.value = globalValue });
+                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: config.configuration.environments.map(env => ({
-                        name: env.name,
-                        value: env.name,
-                    })),
+                    choices: Array.from(config.envs.keys()),
                 });
 
                 logger.debug(`Selected environments for editing: ${envsToEdit.join(", ")}`);
 
-                valuesToSet = valuesToSet.filter(envValue => envsToEdit.includes(envValue.envName));
+                for (const selectedEnv of envsToEdit) {
+                    const env = config.envs.get(selectedEnv);
 
-                if (valuesToSet.length === 0) {
-                    console.log("No environments selected. Exiting.");
-                    return;
-                }
+                    if (!env) {
+                        throw new NotFoundError(`Environment not found: ${selectedEnv}`);
+                    }
+
+                    const envFile = new EnvironmentFile(env.file);
 
-                for (const envValue of valuesToSet) {
                     const request = {
-                        message: `Enter the value for ${variableConfiguration.name} in environment ${envValue.envName}:`,
+                        message: `Enter the value for ${variableConfiguration.name} in environment ${selectedEnv}:`,
                         mask: variableConfiguration.type === VariableType.Private ? "*" : undefined,
                     };
 
-                    envValue.value = variableConfiguration.type === VariableType.Private
+                    const newValue = 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}`);
+                    envFile.vars.set(variableConfiguration.name, newValue);
+                    envFile.save();
                 }
-
-                logger.debug(`Setting variable "${variableConfiguration.name}" with value "${envValue.value}" in environment file: ${env.file}`);
-
-                EnvironmentFile.quickUpdate(env.file, variableConfiguration.name, envValue.value);
             }
         }
     }

package/{cmd → cli/cmd}/variableCmd/list.ts

@@ -7,19 +7,19 @@ export default {
     describe: 'List all environment variables',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
-        const activeEnv = config.getActiveEnvironment();
+        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).load();
+        const envFile = new EnvironmentFile(activeEnv.file);
 
-        for (const [key, value] of Object.entries(envFile.content)) {
-            const variableConfiguration = config.getVariable(key);
+        for (const [key, value] of envFile.vars) {
+            const variableConfiguration = config.vars.get(key);
             if (variableConfiguration) {
                 const type = Configuration.getTypeDetails(variableConfiguration.type);
 

package/{cmd → cli/cmd}/variableCmd/remove.ts

@@ -9,33 +9,30 @@ export default {
     describe: 'Remove an environment variable',
     builder: (yargs) => yargs,
     handler: async (argv) => {
-        const config = new Configuration().load();
+        const config = new Configuration();
         const logger = new Logger(argv.level);
 
         const name = await select({
             message: "Select the variable to remove:",
-            choices: config.configuration.variables.map(variable => ({
-                name: variable.name,
-                value: variable.name,
-            })),
+            choices: Array.from(config.vars.keys()),
         });
 
-        if (!config.getVariable(name)) {
+        if (!config.vars.has(name)) {
             throw new NotFoundError(`Variable not found: ${name}`);
         }
 
         logger.debug(`Removing variable "${name}" from configuration and all environment files`);
 
-        config
-            .removeVariable(name)
-            .save();
+        config.vars.delete(name);
+        config.save();
 
-        for (const env of config.configuration.environments) {
-            const envFile = new EnvironmentFile(env.file).load();
+        for (const [_, env] of config.envs) {
+            const envFile = new EnvironmentFile(env.file);
 
-            if (envFile.content[name] !== undefined) {
+            if (envFile.vars.has(name)) {
                 logger.debug(`Removing variable "${name}" from environment file: ${env.file}`);
-                envFile.removeVariable(name).save();
+                envFile.vars.delete(name);
+                envFile.save();
             }
         }
     }

package/{index.ts → cli/index.ts}

@@ -9,13 +9,13 @@ await yargs(hideBin(process.argv))
         alias: "l",
         type: "string",
         description: "Set the log level",
-        choices: ['debug', 'info', 'warn', 'error', 'fatal'],
         default: process.env.LOG_LEVEL || "info",
     })
     .env('ENVEDIT')
     .scriptName("envedit")
     .usage("Usage: $0 <command>")
     .command(Commands)
+    .showHelpOnFail(false)
     .demandCommand()
     .strict()
     .parseAsync();

package/lib/config.ts

@@ -1,11 +1,13 @@
-import fs from 'fs';
+import {
+    existsSync as exists,
+    readFileSync as read,
+    writeFileSync as write,
+    appendFileSync as append,
+} from 'fs';
 
 import { parse } from 'dotenv';
 
 import { NotFoundError } from '#lib/error';
-import { Logger } from '#lib/logger';
-
-const logger = new Logger(process.env.LOG_LEVEL || 'info');
 
 export enum VariableType {
     Public,
@@ -31,218 +33,101 @@ export interface GeneralConfiguration {
 }
 
 export class Configuration {
-    private config: GeneralConfiguration = { version: 1, environments: [], variables: [] };
+    public readonly vars: Map<string, VariableConfiguration> = new Map();
+    public readonly envs: Map<string, EnviornmentConfiguration> = new Map();
+    public readonly version: number = 1;
     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;
+    constructor() {
+        if (!exists(this.configFilePath)) {
+            this
+                .importFromEnv(exists('.env') ? read('.env', "utf-8") : '')
+                .save();
         }
-        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 || [],
-        };
-    }
-
-    public load() {
-        if (!fs.existsSync(this.configFilePath)) {
-            logger.info(`Configuration file not found: ${this.configFilePath}`);
-            logger.info(`Creating a new configuration file`);
 
-            const config = new Configuration();
+        const configContent = Bun.YAML.parse(read(this.configFilePath, "utf-8")) as GeneralConfiguration;
 
-            if (fs.existsSync('.env')) {
-                config.importFromEnv(fs.readFileSync('.env', "utf-8"));
-            }
-
-            this.save();
-        }
-
-        const configContent = Bun.YAML.parse(fs.readFileSync(this.configFilePath, "utf-8")) as GeneralConfiguration;
+        const setWrapper = <
+            K extends EnviornmentConfiguration | VariableConfiguration
+        >(map: Map<string, K>): ((item: K) => void) => (item: K) => void map.set(item.name, item);
 
-        this.config.environments = configContent.environments || [];
-        this.config.variables = configContent.variables || [];
+        configContent.environments.forEach(setWrapper(this.envs))
+        configContent.variables.forEach(setWrapper(this.vars))
 
-        return this;
     }
 
     public save() {
-        fs.writeFileSync(
+        write(
             this.configFilePath,
-            Bun.YAML.stringify(this.configuration, null, 2),
+            Bun.YAML.stringify({
+                version: this.version,
+                environments: Array.from(this.envs.values()),
+                variables: Array.from(this.vars.values()),
+            }, null, 2),
             { mode: 0o600 },
         );
 
         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;
-        });
+    public get active() {
+        const activeEnv = Array.from(this.envs.values()).find(env => env.isActive);
 
-        return this;
+        return activeEnv ? activeEnv.name : undefined;
     }
 
-    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}`);
+    public set active(env: string | undefined) {
+        if (env && !this.envs.has(env)) {
+            throw new NotFoundError(`Environment not found: ${env}`)
         }
 
-        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}`);
+        for (const [name, environment] of this.envs.entries()) {
+            this.envs.set(name, { ...environment, isActive: name === env });
         }
 
-        this.config.variables = this.config.variables.map(v => v.name === name ? { ...v, ...variable } : v);
-        return this;
+        this.save();
     }
 
-    public removeVariable(name: string) {
-        if (!this.config.variables.find(v => v.name === name)) {
-            throw new NotFoundError(`Variable not found: ${name}`);
+    public importFromEnv(content: string): Configuration {
+        for (const [key, _] of Object.entries(parse(content))) {
+            this.vars.set(key, { name: key, type: VariableType.Private });
         }
 
-        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 static getTypeDetails(type: VariableType) {
+        const VariableTypeMap = new Map<number, keyof typeof VariableType>();
 
-    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,
-                });
-            }
+        for (const [key, value] of Object.entries(VariableType)) {
+            if (typeof value !== "number") continue;
+            VariableTypeMap.set(value, key as keyof typeof VariableType);
         }
 
-        return config;
-    }
-
-    public static getTypeDetails(type: VariableType): { name: keyof typeof VariableType, value: VariableType } {
-        const VariableTypeMap = Object.entries(VariableType).reduce((acc, [key, value]) => {
-            if (typeof value === "number") {
-                acc[value] = key as keyof typeof VariableType;
-            }
-            return acc;
-        }, {} as Record<number, keyof typeof VariableType>);
-
         return {
-            name: VariableTypeMap[type]!,
+            name: VariableTypeMap.get(type)!,
             value: type
         };
     }
 }
 
 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, '', { mode: 0o600 });
+    public readonly vars: Map<string, string> = new Map();
+    constructor(public readonly path: string) {
+        if (exists(path)) {
+            const content = read(path, "utf-8");
+            const parsed = parse(content);
+
+            for (const [key, value] of Object.entries(parsed)) {
+                this.vars.set(key, value);
+            }
         }
-
-        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}'`);
+        write(this.path, '')
+        for (const [key, value] of this.vars.entries()) {
+            append(this.path, `${key}='${value}'\n`);
         }
-        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/logger.ts

@@ -2,39 +2,39 @@ import pino from 'pino';
 import type { LevelWithSilentOrString, Logger as PinoLogger } from 'pino';
 
 export class Logger {
-    private readonly logger: PinoLogger<never, boolean>;
-    constructor(public readonly level: LevelWithSilentOrString) {
-        this.logger = pino({
-            level,
-            transport: {
-                target: 'pino-pretty',
-                options: {
-                    colorize: true,
-                    translateTime: 'SYS:standard',
-                    ignore: 'pid,hostname',
-                },
+    private readonly logger: PinoLogger<never, boolean> = pino({
+        transport: {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
             },
-        });
+        },
+    });
+
+    constructor(public readonly level: LevelWithSilentOrString, private testMode: boolean = false) {
+        this.logger.level = level;
     }
 
     public readonly debug = (msg: string) => {
-        this.logger.debug(msg);
+        this.testMode ? '' : this.logger.debug(msg);
         return this;
     }
     public readonly info = (msg: string) => {
-        this.logger.info(msg);
+        this.testMode ? '' : this.logger.info(msg);
         return this;
     }
     public readonly warn = (msg: string) => {
-        this.logger.warn(msg);
+        this.testMode ? '' : this.logger.warn(msg);
         return this;
     }
     public readonly error = (msg: string) => {
-        this.logger.error(msg);
+        this.testMode ? '' : this.logger.error(msg);
         return this;
     }
     public readonly fatal = (msg: string) => {
-        this.logger.fatal(msg);
+        this.testMode ? '' : this.logger.fatal(msg);
         return this;
     }
 }

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@benshawmean/envedit",
-  "module": "index.ts",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.2-0",
   "license": "GPL-3.0-only",
   "bin": {
-    "envedit": "index.ts"
+    "envedit": "cli/index.ts"
   },
   "repository": {
     "url": "https://gitlab.com/benshawmean/envedit.git"