@benshawmean/envedit 1.3.0 → 1.3.1

package/cmd/environmentCmd/add.ts

@@ -47,8 +47,6 @@ export default {
             .addEnvironment({ name, prefix, file, isActive })
             .save();
 
-        const envFile = new EnvironmentFile(file).load();
-
         const valuesToSet: Array<[string, string]> = []
 
         if (!fs.existsSync(file)) {
@@ -75,9 +73,9 @@ export default {
                     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)) {
+                for (const [key, value] of Object.entries(envSpecificFile.data)) {
                     valuesToSet.push([key, value]);
                 }
             } else {
@@ -98,13 +96,15 @@ export default {
                 }
             }
 
+            const envFile = new EnvironmentFile(file);
+
+
             for (const [key, value] of valuesToSet) {
                 logger
                     .debug(`Setting variable "${key}" with value "${value}" in environment file: ${file}`);
+
                 envFile.setVariable(key, value);
             }
-
-            envFile.save();
         }
     }
 } satisfies CommandModule;

package/cmd/setup.ts

@@ -35,7 +35,7 @@ export default {
                 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(", ")}`);
 

package/cmd/use.ts

@@ -22,7 +22,7 @@ export default {
                 name: env.name + (env.isActive ? " (active)" : ""),
                 value: env.name,
             })),
-            default: config.getActiveEnvironment()?.name,
+            default: config.active,
         });
 
         const selectedEnv = config.getEnvironment(name);
@@ -36,9 +36,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();
         }

package/cmd/variableCmd/edit.ts

@@ -54,15 +54,14 @@ export default {
                 });
 
                 for (const env of config.configuration.environments) {
-                    const envFile = new EnvironmentFile(env.file).load();
+                    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.data[name] !== undefined) {
+                        envFile
+                            .removeVariable(name)
+                            .setVariable(updatedVariable.name, envFile.data[name]);
                     }
                 }
             }

package/cmd/variableCmd/list.ts

@@ -10,15 +10,15 @@ export default {
         const config = new Configuration().load();
         const logger = new Logger(argv.level);
 
-        const activeEnv = config.getActiveEnvironment();
+        const activeEnv = config.active ? config.getEnvironment(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)) {
+        for (const [key, value] of Object.entries(envFile.data)) {
             const variableConfiguration = config.getVariable(key);
             if (variableConfiguration) {
                 const type = Configuration.getTypeDetails(variableConfiguration.type);

package/cmd/variableCmd/remove.ts

@@ -31,11 +31,11 @@ export default {
             .save();
 
         for (const env of config.configuration.environments) {
-            const envFile = new EnvironmentFile(env.file).load();
+            const envFile = new EnvironmentFile(env.file);
 
-            if (envFile.content[name] !== undefined) {
+            if (envFile.data[name] !== undefined) {
                 logger.debug(`Removing variable "${name}" from environment file: ${env.file}`);
-                envFile.removeVariable(name).save();
+                envFile.removeVariable(name);
             }
         }
     }

package/lib/config.ts

@@ -1,11 +1,8 @@
-import fs from 'fs';
+import fs, { existsSync as exists, readFileSync as read, writeFileSync as write } 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,52 +28,40 @@ 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;
-        }
-        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 || [],
+            version: this.version,
+            environments: Array.from(this.envs.values()) || [],
+            variables: Array.from(this.vars.values()) || [],
         };
     }
 
     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();
-
-            if (fs.existsSync('.env')) {
-                config.importFromEnv(fs.readFileSync('.env', "utf-8"));
-            }
-
-            this.save();
+        if (!exists(this.configFilePath)) {
+            this
+                .importFromEnv(exists('.env') ? read('.env', "utf-8") : '')
+                .save();
         }
 
-        const configContent = Bun.YAML.parse(fs.readFileSync(this.configFilePath, "utf-8")) as GeneralConfiguration;
+        const configContent = Bun.YAML.parse(read(this.configFilePath, "utf-8")) as GeneralConfiguration;
 
-        this.config.environments = configContent.environments || [];
-        this.config.variables = configContent.variables || [];
+        const setWrapper = <
+            K extends EnviornmentConfiguration | VariableConfiguration
+        >(map: Map<string, K>): ((item: K) => void) => (item: K) => void map.set(item.name, item);
+
+        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),
             { mode: 0o600 },
@@ -85,164 +70,134 @@ export class Configuration {
         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 set active(env: string | undefined) {
+        if (env && !this.envs.has(env)) {
+            throw new NotFoundError(`Environment not found: ${env}`)
+        }
+
+        for (const [name, environment] of this.envs.entries()) {
+            this.envs.set(name, { ...environment, isActive: name === env });
+        }
+
+        this.save();
     }
 
     public addEnvironment(env: EnviornmentConfiguration) {
-        this.config.environments.push(env);
+        this.envs.set(env.name, env);
+
         return this;
     }
 
     public editEnvironment(name: string, env: Partial<EnviornmentConfiguration>) {
-        const index = this.config.environments!.findIndex(e => e.name === name);
-        if (index === -1) {
+        if (!this.envs.has(name)) {
             throw new NotFoundError(`Environment not found: ${name}`);
         }
 
-        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,
-        };
+        this.envs.set(name, { ...this.envs.get(name)!, ...env });
+
         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.envs.delete(name);
 
-        this.config.environments.splice(index, 1);
         return this;
     }
 
     public getEnvironment(name: string): EnviornmentConfiguration | undefined {
-        return this.config.environments.find(env => env.name === name);
+        return this.envs.get(name);
     }
 
     public addVariable(variable: VariableConfiguration) {
-        this.config.variables.push(variable);
+        this.vars.set(variable.name, variable);
+
         return this;
     }
 
     public editVariable(name: string, variable: Partial<VariableConfiguration>) {
-        if (!this.config.variables.find(v => v.name === name)) {
+        if (!this.vars.has(name)) {
             throw new NotFoundError(`Variable not found: ${name}`);
         }
 
-        this.config.variables = this.config.variables.map(v => v.name === name ? { ...v, ...variable } : v);
+        this.vars.set(name, { ...this.vars.get(name)!, ...variable });
+
         return this;
     }
 
     public removeVariable(name: string) {
-        if (!this.config.variables.find(v => v.name === name)) {
-            throw new NotFoundError(`Variable not found: ${name}`);
-        }
+        this.vars.delete(name);
 
-        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);
+        return this.vars.get(name);
     }
 
     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, _] of Object.entries(parse(content))) {
+            this.addVariable({
+                name: key,
+                type: key.includes('PRIVATE') ? VariableType.Private : VariableType.Public,
+            });
         }
 
-        return config;
+        return this;
     }
 
-    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>);
+    public static getTypeDetails(type: VariableType) {
+        const VariableTypeMap = new Map<number, keyof typeof VariableType>();
+
+        for (const [key, value] of Object.entries(VariableType)) {
+            if (typeof value !== "number") continue;
+            VariableTypeMap.set(value, key as 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() {
+    public get data() {
         if (!fs.existsSync(this.path)) {
             fs.writeFileSync(this.path, '', { mode: 0o600 });
         }
-
-        this.rawContent = fs.readFileSync(this.path, "utf-8");
-        this.content = parse(this.rawContent);
-
-        return this;
+        return parse(fs.readFileSync(this.path, "utf-8"));
     }
 
-    public save() {
+    public set data(content: Record<string, string>) {
         const lines: string[] = [];
-        for (const [key, value] of Object.entries(this.content)) {
+        for (const [key, value] of Object.entries(content)) {
             lines.push(`${key}='${value}'`);
         }
-        this.rawContent = lines.join('\n');
-        fs.writeFileSync(this.path, this.rawContent);
-
-        return this;
+        fs.writeFileSync(this.path, lines.join('\n'));
     }
 
     public setVariable(name: string, value: string) {
-        this.content[name] = value;
-
+        this.data = { ...this.data, [name]: value };
         return this;
     }
 
     public removeVariable(name: string) {
-        delete this.content[name];
-
+        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).load();
-        envFile.setVariable(name, value).save();
-
+        const envFile = new EnvironmentFile(path);
+        envFile.setVariable(name, value);
         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

@@ -2,7 +2,7 @@
   "name": "@benshawmean/envedit",
   "module": "index.ts",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "license": "GPL-3.0-only",
   "bin": {
     "envedit": "index.ts"