@benshawmean/envedit 1.1.1 → 1.1.3

package/.gitlab-ci.yml

@@ -1,44 +1,76 @@
 stages:
   - test
-  - build
   - deploy
 
 workflow:
   rules:
     - if: $CI_COMMIT_BRANCH
+    - if: $CI_COMMIT_TAG
 
 default:
   image: oven/bun:debian
   before_script:
     - apt-get update -y > /dev/null
-    - apt-get install -qy git curl > /dev/null
-    - bun i
+    - apt-get install -qy git curl jq build-essential just > /dev/null
+    - curl -sSf https://sh.rustup.rs | bash -s -- -y -q > /dev/null
+    - . "$HOME/.cargo/env"
+    - bun install --quiet
 
-.deploy: &deploy
-  stage: deploy
-  id_tokens:
-    SIGSTORE_ID_TOKEN:
-      aud: sigstore
+variables:
+  GLAB_NPM_REG: //${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/
+  VERSION_REGEX: /^v\d+\.\d+\.\d+(-\S*)?$/
+  NO_CI_REGEX: /(no|skip)\s+(ci|pipeline)/mi
+
+test:
+  stage: test
   rules:
-    - if: $CI_COMMIT_REF_PROTECTED == 'true'
-      when: manual
+    - if: $CI_COMMIT_TAG || $CI_COMMIT_MESSAGE =~ $VERSION_REGEX
+      when: never
+    - if: $CI_COMMIT_DESCRIPTION =~ $NO_CI_REGEX
+      when: never
+    - if: $CI_COMMIT_BRANCH
+      when: always
+  allow_failure: false
+  script:
+    - bun test
+    - sed 's/amp;//' coverage/junit.xml > coverage/junit.xml.tmp # remove amp; from junit report to prevent gitlab parsing issues
+    - mv coverage/junit.xml.tmp coverage/junit.xml # make the change permanent
+    - cargo install -q lcov2xml # used to convert lcov output to cobertura-xml for gitlab code coverage parsing
+    - lcov2xml coverage/lcov.info -o coverage/cobertura-coverage.xml
+  coverage: /All files[^|]*\|[^|]*\s+([\d\.]+)/
+  artifacts:
+    reports:
+      junit: ./coverage/junit.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: ./coverage/cobertura-coverage.xml
 
-deploy npm:
-  <<: *deploy
-  # Bun seems to struggle publishing to npm on the CI job, so we'll use npm for this one
-  image: node:latest
-  before_script: [] # skip the default before_script
+deploy:
+  stage: deploy
   id_tokens:
     SIGSTORE_ID_TOKEN:
       aud: sigstore
     NPM_ID_TOKEN:
       aud: "npm:registry.npmjs.org"
+  rules:
+    - if: $CI_COMMIT_REF_PROTECTED && $CI_COMMIT_TAG && $CI_COMMIT_TAG =~ $VERSION_REGEX
+    - if: $CI_COMMIT_DESCRIPTION =~ $NO_CI_REGEX
+      when: never
   script:
-    - npm publish
+    - | # Setup environment variables for deployment
+      export PACKAGE_NAME=$(jq -r '.name' package.json)
+      export CURR_VER=$(jq -r '.version' package.json)
+      export LIVE_VER=$(bun info $PACKAGE_NAME version)
 
-deploy gitlab:
-  <<: *deploy
-  script:
-    - echo "//${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/:_authToken=${CI_JOB_TOKEN}" > .npmrc
-    - echo "@benshawmean:registry=https://${CI_SERVER_HOST}/api/v4/projects/${CI_PROJECT_ID}/packages/npm/" >> .npmrc
-    - bun publish
+    - | # Check if the current version is already published
+      if [ "$LIVE_VER" == "$CURR_VER" ]; then
+        echo "Version $CURR_VER is already published. Skipping deployment."
+        exit 9001
+      fi
+
+    - | # Publish to npm and GitLab registries
+      echo "${GLAB_NPM_REG}:_authToken=${CI_JOB_TOKEN}" > .npmrc
+      just publish
+  allow_failure:
+    exit_codes:
+      - 9001

package/cmd/environment/add.ts

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+
+import { confirm, input, password, select } 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: 'add',
+    describe: 'Add a new environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await input({
+            message: "Enter the environment name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Environment name cannot be empty";
+                }
+                if (config.getEnvironment(input)) {
+                    return "Environment name already exists";
+                }
+                return true;
+            },
+        });
+
+        const prefix = await input({
+            message: "Enter the environment prefix:",
+        });
+
+        const file = await input({
+            message: "Enter the environment file path:",
+            default: `.env.${prefix}`,
+        });
+
+        const isActive = await confirm({
+            message: "Is this environment active?",
+        });
+
+        logger
+            .debug(`Adding new environment "${name}" with prefix "${prefix}" and file: "${file}"`);
+
+        config
+            .addEnvironment({ name, prefix, file, isActive })
+            .saveConfigurationFile();
+
+        const envFile = new EnvironmentFile(file).load();
+
+        const valuesToSet: Array<[string, string]> = []
+
+        if (!fs.existsSync(file)) {
+            logger.debug(`Environment file not found: ${file}`);
+
+            const shouldClone = await confirm({
+                message: "Do you want to clone a pre-existing environment into the new file?",
+            });
+
+            if (shouldClone) {
+                logger.debug(`Cloning a pre-existing environment into the new file: ${file}`);
+
+                const clonedEnv = await select({
+                    message: "Select the environment to clone from:",
+                    choices: config.configuration.environments.map(env => ({
+                        name: env.name,
+                        value: env.name,
+                    })),
+                });
+
+                const selectedEnv = config.getEnvironment(clonedEnv);
+
+                if (!selectedEnv) {
+                    throw new NotFoundError(`Environment not found: ${clonedEnv}`);
+                }
+
+                const selectedEnvFile = new EnvironmentFile(selectedEnv.file).load();
+
+                for (const [key, value] of Object.entries(selectedEnvFile.content)) {
+                    valuesToSet.push([key, value]);
+                }
+            } else {
+                for (const variable of config.configuration.variables) {
+                    const request = {
+                        message: `Enter the value for ${variable.name} in environment ${name}:`,
+                        mask: variable.type === VariableType.Private ? "*" : undefined,
+                    };
+
+                    const value = variable.type === VariableType.Private
+                        ? await password(request)
+                        : await input(request);
+
+                    logger
+                        .debug(`Setting variable "${variable.name}" with value "${value}" in environment "${name}"`);
+
+                    valuesToSet.push([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();
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment/edit.ts

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+
+import { confirm, input, select, checkbox } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'edit',
+    describe: 'Edit an environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await select({
+            message: "Select the environment to edit:",
+            choices: config.configuration.environments.map(env => ({
+                name: env.name,
+                value: env.name,
+            })),
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        const itemsToEdit = await checkbox({
+            message: "Select the items to edit:",
+            choices: [
+                { name: "Name", value: "name" },
+                { name: "Prefix", value: "prefix" },
+                { name: "File", value: "file" },
+            ],
+        });
+
+        const updatedEnv = { ...selectedEnv };
+
+        if (itemsToEdit.includes("name")) {
+            logger.debug(`Editing environment name from "${selectedEnv.name}" to "${updatedEnv.name}"`);
+            updatedEnv.name = await input({
+                message: "Enter the new environment name:",
+                default: selectedEnv.name,
+            });
+        }
+
+        if (itemsToEdit.includes("prefix")) {
+            logger.debug(`Editing environment prefix from "${selectedEnv.prefix}" to "${updatedEnv.prefix}"`);
+            updatedEnv.prefix = await input({
+                message: "Enter the new environment prefix:",
+                default: selectedEnv.prefix,
+            });
+        }
+
+        if (itemsToEdit.includes("file")) {
+            logger.debug(`Editing environment file from "${selectedEnv.file}" to "${updatedEnv.file}"`);
+            updatedEnv.file = await input({
+                message: "Enter the new environment file path:",
+                default: selectedEnv.file,
+            });
+        }
+
+        config
+            .editEnvironment(name, updatedEnv)
+            .saveConfigurationFile();
+
+        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);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment/list.ts

@@ -0,0 +1,19 @@
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'list',
+    describe: 'List all environments',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        logger.debug(`Listing all environments`);
+
+        console.log(
+            JSON.stringify(config.configuration.environments, null, 2)
+        )
+    }
+} satisfies CommandModule;

package/cmd/environment/remove.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+
+import { confirm, select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+export default {
+    command: 'remove',
+    describe: 'Remove an environment',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await select({
+            message: "Select the environment to remove:",
+            choices: config.configuration.environments.map(env => ({
+                name: env.name,
+                value: env.name,
+            })),
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        logger
+            .debug(`Removing environment "${name}" with file: "${selectedEnv.file}"`);
+
+        config
+            .removeEnvironment(name)
+            .saveConfigurationFile();
+
+        if (fs.existsSync(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);
+            }
+        }
+    }
+} satisfies CommandModule;

package/cmd/environment.ts

@@ -0,0 +1,21 @@
+import type { CommandModule } from "yargs";
+
+import Add from "./environment/add";
+import Edit from "./environment/edit";
+import List from "./environment/list";
+import Remove from "./environment/remove";
+
+const data = {
+    command: 'environment',
+    describe: 'Manage environments',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit environment <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;

package/cmd/setup.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+
+import { confirm } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { logger } from "#lib/logger";
+
+const data = {
+    command: 'setup',
+    describe: 'Setup the project for use with envedit',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit setup'),
+    handler: async (_args) => {
+        new Configuration().loadConfigurationFile();
+
+        if (fs.existsSync('.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}`);
+
+                const toCreate = await confirm({
+                    message: `Git Repository without a git ignore file not found: ${gitignorePath}. Do you want to create it?`
+                });
+
+                if (toCreate) {
+                    console.error(`Git Repository without a git ignore file not found: ${gitignorePath}`);
+                    process.exit(1);
+                }
+
+                fs.writeFileSync(gitignorePath, "");
+            }
+
+            const expectedItems = ['.env', '.env.*', 'env.config.yaml'];
+
+            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)) {
+                    logger.debug(`Item not found in git ignore file: ${item}`);
+
+                    const toAdd = await confirm({
+                        message: `The item ${item} is not in the git ignore file. Do you want to add it?`
+                    });
+
+                    if (!toAdd) {
+                        console.error(`The item ${item} is not in the git ignore file.`);
+                        process.exit(1);
+                    }
+
+                    fs.appendFileSync(gitignorePath, `\n${item}`);
+                }
+            }
+        }
+    }
+} satisfies CommandModule;
+
+export const command = data.command;
+export const describe = data.describe;
+export const builder = data.builder;
+export const handler = data.handler;

package/cmd/use.ts

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+
+import { select } from "@inquirer/prompts";
+import type { CommandModule } from "yargs";
+
+import { Configuration } from "#lib/config";
+import { NotFoundError } from "#lib/error";
+import { logger } from "#lib/logger";
+
+const data = {
+    command: 'use',
+    describe: 'Set the current environment to use',
+    builder: (yargs) => yargs
+        .usage('Usage: envedit use'),
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        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,
+            })),
+            default: config.getActiveEnvironment()?.name,
+        });
+
+        const selectedEnv = config.getEnvironment(name);
+
+        if (!selectedEnv) {
+            throw new NotFoundError(`Environment not found: ${name}`);
+        }
+
+        logger.debug(`Setting current environment to "${name}" with file: "${selectedEnv.file}"`);
+
+        if (!selectedEnv.isActive) {
+            logger.debug(`Updating active environment in configuration file to "${name}"`);
+
+            for (const env of config.configuration.environments) {
+                env.isActive = env.name === name;
+            }
+
+            config.saveConfigurationFile();
+        }
+
+        logger.debug(`Creating symlink to environment file: ${selectedEnv.file}`);
+
+        const envFilePath = selectedEnv.file;
+
+        if (fs.existsSync('.env')) {
+            logger.debug(`Removing existing symlink or file: .env`);
+
+            fs.unlinkSync('.env');
+        }
+
+        fs.symlinkSync(envFilePath, '.env', 'file');
+    }
+} satisfies CommandModule;
+
+export const command = data.command;
+export const describe = data.describe;
+export const builder = data.builder;
+export const handler = data.handler;

package/cmd/variable/add.ts

@@ -0,0 +1,94 @@
+import { confirm, input, password, select } 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: 'add',
+    describe: 'Add a new environment variable',
+    builder: (yargs) => yargs,
+    handler: async (_args) => {
+        const config = new Configuration().loadConfigurationFile();
+
+        const name = await input({
+            message: "Enter the variable name:",
+            validate: (input) => {
+                if (!input) {
+                    return "Variable name cannot be empty";
+                }
+                if (config.getVariable(input)) {
+                    return "Variable name already exists";
+                }
+                return true;
+            },
+        });
+
+        const type = await select({
+            message: "Select the variable type:",
+            choices: [
+                { name: "Public", value: VariableType.Public },
+                { name: "Private", value: VariableType.Private },
+            ],
+        });
+
+        logger
+            .debug(`Adding new variable "${name}" with type "${type}"`);
+
+        config
+            .addVariable({ name, type })
+            .saveConfigurationFile();
+
+        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 => ({
+            envName: env.name,
+            value: '',
+        }));
+
+        if (shouldGloballySet) {
+            const request = {
+                message: `Enter the global value for ${name}:`,
+                mask: type === VariableType.Private ? "*" : undefined,
+            };
+
+            const globalValue = type === VariableType.Private
+                ? await password(request)
+                : await input(request);
+
+            logger
+                .debug(`Setting variable "${name}" with global value "${globalValue}" for all environments`);
+
+            valuesToSet.forEach((envValue) => { envValue.value = globalValue });
+        } else {
+            for (const envValue of valuesToSet) {
+                const request = {
+                    message: `Enter the value for ${name} in environment ${envValue.envName}:`,
+                    mask: type === VariableType.Private ? "*" : undefined,
+                };
+
+                envValue.value = type === VariableType.Private
+                    ? await password(request)
+                    : await input(request);
+
+                logger
+                    .debug(`Setting variable "${name}" with value "${envValue.value}" for environment "${envValue.envName}"`);
+            }
+        }
+
+        for (const envValue of valuesToSet) {
+            const env = config.getEnvironment(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);
+        }
+    }
+} satisfies CommandModule;