create-typed-env/dist/index.cjs

Create a type-safe proxy for accessing environment variables

'use strict';

function createTypedEnv(options) {
  const { lazy, fallback, log, env = process.env } = options ?? {};
  const logger = (message) => {
    const nodeEnv = env?.NODE_ENV;
    if (!log) return;
    if (typeof log === "boolean") {
      console.warn(message);
    } else if (typeof log === "object" && nodeEnv && nodeEnv in log && log[nodeEnv]) {
      console.warn(message);
    }
  };
  const getFallbackValue = (fallback2, key) => {
    if (fallback2 === void 0) return void 0;
    if (typeof fallback2 === "string") return fallback2;
    if (typeof fallback2 === "function") return fallback2(key);
    if (typeof fallback2 === "object" && fallback2) {
      if ("env" in fallback2 && typeof fallback2.env === "object") {
        const fallbackEnv = fallback2.env[process.env.NODE_ENV];
        return getFallbackValue(fallbackEnv, key);
      }
      if (key in fallback2) {
        const fallbackValue = fallback2[key];
        return getFallbackValue(fallbackValue, key);
      }
    }
    throw new Error(`Invalid fallback value: ${fallback2}`);
  };
  const getEnvValue = (key) => {
    if (key in env) return env[key];
    if (!fallback) {
      logger(`Environment variable ${key} not found`);
      throw new Error(`Environment variable ${key} not found`);
    }
    const fallbackValue = getFallbackValue(fallback, key);
    if (fallbackValue !== void 0) {
      logger(
        `Environment variable ${key} not found, using fallback: ${fallbackValue}`
      );
      return fallbackValue;
    }
    logger(`Environment variable ${key} not found and no fallback available`);
    throw new Error(
      `Environment variable ${key} not found and no fallback available`
    );
  };
  const setEnvValue = (key, value) => {
    env[key] = value;
  };
  return new Proxy({}, {
    get(_target, prop) {
      if (lazy) {
        return (value) => {
          if (value !== void 0) {
            setEnvValue(prop, value);
          }
          return getEnvValue(prop);
        };
      }
      return getEnvValue(prop);
    },
    set(_target, prop, value) {
      if (!lazy) {
        if (typeof value !== "string") {
          throw new Error(
            `Environment variables must be strings. Attempted to set ${prop} to non-string.`
          );
        }
        setEnvValue(prop, value);
        return true;
      }
      throw new Error(
        `Attempted to set lazy environment variable ${prop} via assignment. Use the function call env.${prop}('value') instead.`
      );
    }
  });
}

exports.createTypedEnv = createTypedEnv;