@benshawmean/envedit 1.3.1 → 1.3.2-2

package/.gitlab-ci.yml

@@ -65,6 +65,8 @@ publish:
       export PACKAGE_NAME=$(jq -r '.name' package.json)
       export CURR_VER=$(jq -r '.version' package.json)
       export LIVE_VER=$(bun info $PACKAGE_NAME version)
+      export IS_PRE_RELEASE=$(echo $CURR_VER | grep -E '[-+]')
+      export PUBLISH_FLAGS=( "--silent" )
 
     - | # Check if the current version is already published
       if [ "$LIVE_VER" == "$CURR_VER" ]; then
@@ -73,9 +75,14 @@ publish:
       fi
 
     - bun pm pack --filename package.tgz
-    - bunx npm publish -q package.tgz
+    - |
+      if [ $IS_PRE_RELEASE ]; then
+        echo "Pre-release version detected. Publishing with 'next' tag."
+        PUBLISH_FLAGS+=( "--tag=next" )
+      fi
+    - bunx npm publish ${PUBLISH_FLAGS[*]} package.tgz
     - sh ci/npm.sh
-    - bun publish --silent package.tgz
+    - bun publish ${PUBLISH_FLAGS[*]} package.tgz
     - rm package.tgz .npmrc
 
   allow_failure:

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,18 +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 valuesToSet: Array<[string, string]> = []
-
-        if (!fs.existsSync(file)) {
+        if (!exists(file)) {
             logger.debug(`Environment file not found: ${file}`);
 
             const shouldClone = await confirm({
@@ -61,13 +64,10 @@ 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}`);
@@ -75,11 +75,11 @@ export default {
 
                 const envSpecificFile = new EnvironmentFile(selectedEnv.file);
 
-                for (const [key, value] of Object.entries(envSpecificFile.data)) {
-                    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,
@@ -92,19 +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);
                 }
             }
 
-            const envFile = new EnvironmentFile(file);
-
+            envFile.save();
+        }
 
-            for (const [key, value] of valuesToSet) {
-                logger
-                    .debug(`Setting variable "${key}" with value "${value}" in environment file: ${file}`);
+        if (isActive) {
+            config.active = name;
 
-                envFile.setVariable(key, value);
+            if (exists('.env')) {
+                unlink('.env');
             }
+
+            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,33 +11,28 @@ 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.*'];
@@ -40,7 +40,7 @@ export default {
             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.active,
         });
 
-        const selectedEnv = config.getEnvironment(name);
+        const selectedEnv = config.envs.get(name);
 
         if (!selectedEnv) {
             throw new NotFoundError(`Environment not found: ${name}`);
@@ -45,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,17 +50,22 @@ export default {
                     default: variableConfiguration.name,
                 });
 
-                for (const env of config.configuration.environments) {
+                for (const [_, env] of config.envs) {
                     const envFile = new EnvironmentFile(env.file);
 
                     logger.debug(`Editing variable "${name}" in environment file: ${env.file}`);
 
-                    if (envFile.data[name] !== undefined) {
-                        envFile
-                            .removeVariable(name)
-                            .setVariable(updatedVariable.name, envFile.data[name]);
-                    }
+                    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")) {
@@ -79,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: '',
             }));
@@ -106,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,10 +7,10 @@ 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.active ? config.getEnvironment(config.active) : undefined;
+        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.`);
@@ -18,8 +18,8 @@ export default {
 
         const envFile = new EnvironmentFile(activeEnv.file);
 
-        for (const [key, value] of Object.entries(envFile.data)) {
-            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) {
+        for (const [_, env] of config.envs) {
             const envFile = new EnvironmentFile(env.file);
 
-            if (envFile.data[name] !== undefined) {
+            if (envFile.vars.has(name)) {
                 logger.debug(`Removing variable "${name}" from environment file: ${env.file}`);
-                envFile.removeVariable(name);
+                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,4 +1,9 @@
-import fs, { existsSync as exists, readFileSync as read, writeFileSync as write } from 'fs';
+import {
+    existsSync as exists,
+    readFileSync as read,
+    writeFileSync as write,
+    appendFileSync as append,
+} from 'fs';
 
 import { parse } from 'dotenv';
 
@@ -33,15 +38,7 @@ export class Configuration {
     public readonly version: number = 1;
     private readonly configFilePath: string = 'env.config.yaml';
 
-    public get configuration(): GeneralConfiguration {
-        return {
-            version: this.version,
-            environments: Array.from(this.envs.values()) || [],
-            variables: Array.from(this.vars.values()) || [],
-        };
-    }
-
-    public load() {
+    constructor() {
         if (!exists(this.configFilePath)) {
             this
                 .importFromEnv(exists('.env') ? read('.env', "utf-8") : '')
@@ -57,13 +54,16 @@ export class Configuration {
         configContent.environments.forEach(setWrapper(this.envs))
         configContent.variables.forEach(setWrapper(this.vars))
 
-        return this;
     }
 
     public save() {
         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 },
         );
 
@@ -88,64 +88,9 @@ export class Configuration {
         this.save();
     }
 
-    public addEnvironment(env: EnviornmentConfiguration) {
-        this.envs.set(env.name, env);
-
-        return this;
-    }
-
-    public editEnvironment(name: string, env: Partial<EnviornmentConfiguration>) {
-        if (!this.envs.has(name)) {
-            throw new NotFoundError(`Environment not found: ${name}`);
-        }
-
-        this.envs.set(name, { ...this.envs.get(name)!, ...env });
-
-        return this;
-    }
-
-    public removeEnvironment(name: string) {
-        this.envs.delete(name);
-
-        return this;
-    }
-
-    public getEnvironment(name: string): EnviornmentConfiguration | undefined {
-        return this.envs.get(name);
-    }
-
-    public addVariable(variable: VariableConfiguration) {
-        this.vars.set(variable.name, variable);
-
-        return this;
-    }
-
-    public editVariable(name: string, variable: Partial<VariableConfiguration>) {
-        if (!this.vars.has(name)) {
-            throw new NotFoundError(`Variable not found: ${name}`);
-        }
-
-        this.vars.set(name, { ...this.vars.get(name)!, ...variable });
-
-        return this;
-    }
-
-    public removeVariable(name: string) {
-        this.vars.delete(name);
-
-        return this;
-    }
-
-    public getVariable(name: string): VariableConfiguration | undefined {
-        return this.vars.get(name);
-    }
-
     public importFromEnv(content: string): Configuration {
         for (const [key, _] of Object.entries(parse(content))) {
-            this.addVariable({
-                name: key,
-                type: key.includes('PRIVATE') ? VariableType.Private : VariableType.Public,
-            });
+            this.vars.set(key, { name: key, type: VariableType.Private });
         }
 
         return this;
@@ -167,37 +112,22 @@ export class Configuration {
 }
 
 export class EnvironmentFile {
-    constructor(public readonly path: string) { }
-    public get data() {
-        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);
+            }
         }
-        return parse(fs.readFileSync(this.path, "utf-8"));
     }
 
-    public set data(content: Record<string, string>) {
-        const lines: string[] = [];
-        for (const [key, value] of Object.entries(content)) {
-            lines.push(`${key}='${value}'`);
+    public save() {
+        write(this.path, '')
+        for (const [key, value] of this.vars.entries()) {
+            append(this.path, `${key}='${value}'\n`);
         }
-        fs.writeFileSync(this.path, lines.join('\n'));
-    }
-
-    public setVariable(name: string, value: string) {
-        this.data = { ...this.data, [name]: value };
-        return this;
-    }
-
-    public removeVariable(name: string) {
-        const tmpData = Object.assign({}, this.data);
-        delete tmpData[name];
-        this.data = tmpData;
-        return this;
-    }
-
-    public static quickUpdate(path: string, name: string, value: string) {
-        const envFile = new EnvironmentFile(path);
-        envFile.setVariable(name, value);
-        return envFile;
     }
 }

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "@benshawmean/envedit",
-  "module": "index.ts",
   "type": "module",
-  "version": "1.3.1",
+  "version": "1.3.2-2",
   "license": "GPL-3.0-only",
   "bin": {
-    "envedit": "index.ts"
+    "envedit": "cli/index.ts"
   },
   "repository": {
     "url": "https://gitlab.com/benshawmean/envedit.git"
   },
   "publishConfig": {
     "access": "public",
-    "provenance": true,
-    "tag": "latest"
+    "provenance": true
   },
   "devDependencies": {
     "@types/bun": "^1.3.14",