💅 Bug with "unused else branch" #5362

maelp · 2025-03-15T17:11:08Z

I've got this code (sorry it's a bit long, didn't want to edit it for now) which I use as a small script with a "hacky" argument parser, which expects something like `./myscript someArgs -- someCommand someArgs`

and this it stops parsing args when it spots "--", but `biome` is telling me that the "else" clause is unused, although I'm pretty sure it is used... not sure why?


#!/usr/bin/env -S pnpm tsx

import { spawn } from "node:child_process";
/**
 * Environment Variable Loader
 *
 * This module can be used in two ways:
 *
 * 1. As a preload script with -r flag:
 *    tsx -r '@workspace/config/env-loader' src/index.ts
 *    (Requires ENV_LOADER_PACKAGES env var as a comma-separated list of packages)
 *
 * 2. As a CLI tool:
 *    tsx env-loader -p package1 -p package2 -v KEY=VALUE -v ANOTHER=VALUE -- command args
 *
 * It loads environment variables from the TypeScript config
 * rather than from .env files, allowing for a single source of truth.
 *
 * The loader will always load the root ENV, then each specified package in order.
 * If a variable is defined in multiple places, it will exit with an error.
 */
import { config } from "@workspace/config";

const exitWithMessage = (message: string) => {
  console.error(`❌ env-loader: [${config.environment}] ${message}`);
  process.exit(1);
};
// Log infos to stderr to avoid interfering with stdout
const logToStderr = (message: string) => {
  console.error(`👉 env-loader: [${config.environment}] ${message}`);
};

// Parse package names and custom environment variables

let packageNames: string[] = [];
// Check if ENV_LOADER_PACKAGES is set (comma-separated list)
// eslint-disable-next-line turbo/no-undeclared-env-vars
const envPackages = process.env.ENV_LOADER_PACKAGES;
if (envPackages) {
  packageNames = envPackages
    .split(",")
    .map((p) => p.trim())
    .filter(Boolean);
}

const customEnvVars: Record<string, string> = {};
let commandString: string | undefined;

// CLI mode: parse arguments
const args = process.argv.slice(2);
let i = 0;

// Process arguments as a stream
while (i < args.length) {
  const arg = args[i];

  if (arg === "--") {
    // End of options, rest is command
    const commandArgs = args.slice(i + 1);
    if (commandArgs.length > 0) {
      commandString = commandArgs.join(" ");
    }
    break;
  } else if (arg === "-p") {
    // Package argument
    if (i + 1 >= args.length) {
      exitWithMessage("Error: -p flag requires a package name");
    }
    if (args[i + 1] === "--") {
      exitWithMessage("Error: -p flag requires a package name, got -- instead");
    }
    if (args[i + 1].startsWith("-")) {
      exitWithMessage(
        `Error: -p flag requires a package name, got ${args[i + 1]} instead`,
      );
    }
    packageNames.push(args[i + 1]);
    i += 2; // Skip next arg (package name)
  } else if (arg === "-v") {
    // Environment variable argument
    if (i + 1 >= args.length) {
      exitWithMessage("Error: -v flag requires a KEY=VALUE pair");
    }
    if (args[i + 1] === "--") {
      exitWithMessage(
        "Error: -v flag requires a KEY=VALUE pair, got -- instead",
      );
    }

    const envString = args[i + 1];
    const equalIndex = envString.indexOf("=");
    if (equalIndex <= 0) {
      exitWithMessage(
        `Error: -v flag requires a KEY=VALUE pair, got ${envString} instead`,
      );
    }

    const key = envString.substring(0, equalIndex);
    const value = envString.substring(equalIndex + 1);
    customEnvVars[key] = value;
    i += 2; // Skip next arg (env var)
  } else {
    // Unknown argument
    exitWithMessage(`Error: Unrecognized argument: ${arg}`);
  }
}

// Prepare to collect all environment variables
const allEnvVars: Record<string, string> = {};
const envSources: Record<string, string> = {};

logToStderr(`Loading environment variables`);

// Always load the root ENV first
const rootEnv = config.ENV || {};
// logToStderr(`Loading environment variables from root ENV`);
for (const [key, value] of Object.entries(rootEnv)) {
  allEnvVars[key] = value as string;
  envSources[key] = "root";
  if (config.isDevelopment) {
    logToStderr(` - ${key}=${value} (from config ENV)`);
  }
}

// Load each package's ENV section
for (const packageName of packageNames) {
  const packageConfig = config[packageName as keyof typeof config];
  if (!packageConfig) {
    exitWithMessage(`Package "${packageName}" not found in config`);
  }

  const packageEnv =
    (packageConfig as unknown as Record<string, unknown>).ENV || {};
  //   logToStderr(`Loading environment variables for package "${packageName}"`);

  for (const [key, value] of Object.entries(packageEnv)) {
    if (key in allEnvVars) {
      exitWithMessage(
        `Error: Environment variable "${key}" is defined multiple times (in ${envSources[key]} and ${packageName})`,
      );
    }
    allEnvVars[key] = value as string;
    envSources[key] = packageName;
    if (config.isDevelopment) {
      logToStderr(` - ${key}=${value} (from ${packageName} ENV)`);
    }
  }
}

// Add custom environment variables passed via command line
for (const [key, value] of Object.entries(customEnvVars)) {
  if (key in allEnvVars) {
    logToStderr(
      `Warning: Environment variable "${key}" is defined in ${envSources[key]} and also passed via command line`,
    );
  }
  allEnvVars[key] = value;
  envSources[key] = "command-line";
  if (config.isDevelopment) {
    logToStderr(` - ${key}=${value} (from command line)`);
  }
}

// Set all environment variables
for (const [key, value] of Object.entries(allEnvVars)) {
  process.env[key] = value;
}

// Validate that a command was specified
if (!commandString) {
  exitWithMessage(
    "Error: No command specified. You must provide a command to execute after the -- separator.",
  );
}

// Execute the command
// logToStderr(`Executing command: ${commandString}`);

// Spawn the command in a shell to support piping, redirection, etc.
const child = spawn("sh", ["-c", commandString as string], {
  stdio: "inherit",
  env: process.env,
});

// Handle command completion
await new Promise<void>((resolve, _reject) => {
  child.on("close", (code) => {
    if (code !== 0) {
      // Exit with the same code but without the zx stack trace
      process.exit(code || 1);
    }
    resolve();
  });

  child.on("error", (err) => {
    console.error(`Error executing command: ${err.message}`);
    process.exit(1);
  });
});

lint/style/noUselessElse

It should compile normally...

I agree to follow Biome's Code of Conduct

maelp · 2025-03-15T17:12:30Z

Using latest version of biome (1.9.4)

maelp added the S-Needs triage Status: this issue needs to be triaged label Mar 15, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

💅 Bug with "unused else branch" #5362

💅 Bug with "unused else branch" #5362

💅 Bug with "unused else branch" #5362

💅 Bug with "unused else branch" #5362

Comments

maelp commented Mar 15, 2025

Environment information

Rule name

Playground link

Expected result

Code of Conduct

maelp commented Mar 15, 2025