@adonisjs/env 7.0.0-next.1 → 7.0.0-next.3

package/build/index.js

@@ -1,471 +1,234 @@
-import {
-  EnvLoader,
-  __export,
-  debug_default
-} from "./chunk-KE5AFOK2.js";
-
-// src/env.ts
-import { schema as envSchema } from "@poppinss/validator-lite";
-
-// src/parser.ts
-import dotenv from "dotenv";
-
-// src/errors.ts
-var errors_exports = {};
-__export(errors_exports, {
-  E_IDENTIFIER_ALREADY_DEFINED: () => E_IDENTIFIER_ALREADY_DEFINED,
-  E_INVALID_ENV_VARIABLES: () => E_INVALID_ENV_VARIABLES
+import { n as debug_default, t as EnvLoader } from "./loader-KsjAiZ3e.js";
+import "node:module";
+import { parseEnv } from "node:util";
+import { readFile } from "node:fs/promises";
+import { Exception, RuntimeException, createError } from "@poppinss/utils/exception";
+import { Secret } from "@poppinss/utils";
+import { schema } from "@poppinss/validator-lite";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var errors_exports = /* @__PURE__ */ __export({
+	E_IDENTIFIER_ALREADY_DEFINED: () => E_IDENTIFIER_ALREADY_DEFINED,
+	E_INVALID_ENV_VARIABLES: () => E_INVALID_ENV_VARIABLES
 });
-import { createError, Exception } from "@poppinss/utils/exception";
-var E_INVALID_ENV_VARIABLES = class EnvValidationException extends Exception {
-  static message = "Validation failed for one or more environment variables";
-  static code = "E_INVALID_ENV_VARIABLES";
-  help = "";
+const E_INVALID_ENV_VARIABLES = class EnvValidationException extends Exception {
+	static message = "Validation failed for one or more environment variables";
+	static code = "E_INVALID_ENV_VARIABLES";
+	help = "";
 };
-var E_IDENTIFIER_ALREADY_DEFINED = createError(
-  'The identifier "%s" is already defined',
-  "E_IDENTIFIER_ALREADY_DEFINED",
-  500
-);
-
-// src/parser.ts
-import { readFile } from "fs/promises";
-import { RuntimeException } from "@poppinss/utils/exception";
-var EnvParser = class _EnvParser {
-  /**
-   * Raw environment file contents
-   */
-  #envContents;
-  /**
-   * Application root directory URL
-   */
-  #appRoot;
-  /**
-   * Whether to prefer process.env values over parsed values
-   */
-  #preferProcessEnv = true;
-  /**
-   * Static collection of registered identifiers with their callbacks
-   */
-  static #identifiers = {
-    async file(value, key, appRoot) {
-      const filePath = new URL(value, appRoot);
-      try {
-        const contents = await readFile(filePath, "utf-8");
-        return contents;
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          throw new RuntimeException(
-            `Cannot process "${key}" env variable. Unable to locate file "${filePath}"`,
-            {
-              cause: error
-            }
-          );
-        }
-        throw error;
-      }
-    }
-  };
-  /**
-   * Creates a new EnvParser instance
-   *
-   * @param envContents - Raw environment file contents
-   * @param appRoot - Application root directory URL
-   * @param options - Parser options
-   */
-  constructor(envContents, appRoot, options) {
-    if (options?.ignoreProcessEnv) {
-      this.#preferProcessEnv = false;
-    }
-    this.#envContents = envContents;
-    this.#appRoot = appRoot;
-  }
-  /**
-   * Define an identifier for any environment value. The callback is invoked
-   * when the value match the identifier to modify its interpolation.
-   *
-   * @deprecated use `EnvParser.defineIdentifier` instead
-   */
-  /**
-   * Define an identifier for any environment value. The callback is invoked
-   * when the value match the identifier to modify its interpolation.
-   *
-   * @deprecated use `EnvParser.defineIdentifier` instead
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static identifier(name, callback) {
-    _EnvParser.defineIdentifier(name, callback);
-  }
-  /**
-   * Define an identifier for any environment value. The callback is invoked
-   * when the value match the identifier to modify its interpolation.
-   *
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static defineIdentifier(name, callback) {
-    if (this.#identifiers[name]) {
-      throw new E_IDENTIFIER_ALREADY_DEFINED([name]);
-    }
-    this.#identifiers[name] = callback;
-  }
-  /**
-   * Define an identifier for any environment value, if it's not already defined.
-   * The callback is invoked when the value match the identifier to modify its
-   * interpolation.
-   *
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static defineIdentifierIfMissing(name, callback) {
-    if (typeof this.#identifiers[name] === "undefined") {
-      this.#identifiers[name] = callback;
-    }
-  }
-  /**
-   * Remove an identifier
-   *
-   * @param name - The identifier name to remove
-   */
-  static removeIdentifier(name) {
-    delete this.#identifiers[name];
-  }
-  /**
-   * Returns the value from the parsed object
-   *
-   * @param key - The environment variable key
-   * @param parsed - Parsed environment variables object
-   * @returns The resolved environment variable value
-   */
-  #getValue(key, parsed) {
-    if (this.#preferProcessEnv && process.env[key]) {
-      return process.env[key];
-    }
-    if (parsed[key]) {
-      return this.#interpolate(parsed[key], parsed);
-    }
-    return process.env[key] || "";
-  }
-  /**
-   * Interpolating the token wrapped inside the mustache braces.
-   *
-   * @param token - The token to interpolate
-   * @param parsed - Parsed environment variables object
-   * @returns Interpolated value
-   */
-  #interpolateMustache(token, parsed) {
-    const closingBrace = token.indexOf("}");
-    if (closingBrace === -1) {
-      return token;
-    }
-    const varReference = token.slice(1, closingBrace).trim();
-    return `${this.#getValue(varReference, parsed)}${token.slice(closingBrace + 1)}`;
-  }
-  /**
-   * Interpolating the variable reference starting with a
-   * `$`. We only capture numbers,letter and underscore.
-   * For other characters, one can use the mustache
-   * braces.
-   *
-   * @param token - The token to interpolate
-   * @param parsed - Parsed environment variables object
-   * @returns Interpolated value
-   */
-  #interpolateVariable(token, parsed) {
-    return token.replace(/[a-zA-Z0-9_]+/, (key) => {
-      return this.#getValue(key, parsed);
-    });
-  }
-  /**
-   * Interpolates the referenced values
-   *
-   * @param value - The value to interpolate
-   * @param parsed - Parsed environment variables object
-   * @returns Interpolated value
-   */
-  #interpolate(value, parsed) {
-    const tokens = value.split("$");
-    let newValue = "";
-    let skipNextToken = true;
-    tokens.forEach((token) => {
-      if (token === "\\") {
-        newValue += "$";
-        skipNextToken = true;
-        return;
-      }
-      if (skipNextToken) {
-        newValue += token.replace(/\\$/, "$");
-        if (token.endsWith("\\")) {
-          return;
-        }
-      } else {
-        if (token.startsWith("{")) {
-          newValue += this.#interpolateMustache(token, parsed);
-          return;
-        }
-        newValue += this.#interpolateVariable(token, parsed);
-      }
-      skipNextToken = false;
-    });
-    return newValue;
-  }
-  /**
-   * Parse the env string to an object of environment variables.
-   *
-   * @returns Promise resolving to parsed environment variables
-   */
-  async parse() {
-    const envCollection = dotenv.parse(this.#envContents.trim());
-    const identifiers = Object.keys(_EnvParser.#identifiers);
-    let result = {};
-    $keyLoop: for (const key in envCollection) {
-      const value = this.#getValue(key, envCollection);
-      if (value.includes(":")) {
-        for (const identifier of identifiers) {
-          if (value.startsWith(`${identifier}:`)) {
-            result[key] = await _EnvParser.#identifiers[identifier](
-              value.substring(identifier.length + 1),
-              key,
-              this.#appRoot
-            );
-            continue $keyLoop;
-          }
-          if (value.startsWith(`${identifier}\\:`)) {
-            result[key] = identifier + value.substring(identifier.length + 1);
-            continue $keyLoop;
-          }
-        }
-        result[key] = value;
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
+const E_IDENTIFIER_ALREADY_DEFINED = createError("The identifier \"%s\" is already defined", "E_IDENTIFIER_ALREADY_DEFINED", 500);
+var EnvParser = class EnvParser {
+	#envContents;
+	#appRoot;
+	#preferProcessEnv = true;
+	static #identifiers = { async file(value, key, appRoot) {
+		const filePath = new URL(value, appRoot);
+		try {
+			return await readFile(filePath, "utf-8");
+		} catch (error) {
+			if (error.code === "ENOENT") throw new RuntimeException(`Cannot process "${key}" env variable. Unable to locate file "${filePath}"`, { cause: error });
+			throw error;
+		}
+	} };
+	constructor(envContents, appRoot, options) {
+		if (options?.ignoreProcessEnv) this.#preferProcessEnv = false;
+		this.#envContents = envContents;
+		this.#appRoot = appRoot;
+	}
+	static identifier(name, callback) {
+		EnvParser.defineIdentifier(name, callback);
+	}
+	static defineIdentifier(name, callback) {
+		if (this.#identifiers[name]) throw new E_IDENTIFIER_ALREADY_DEFINED([name]);
+		this.#identifiers[name] = callback;
+	}
+	static defineIdentifierIfMissing(name, callback) {
+		if (typeof this.#identifiers[name] === "undefined") this.#identifiers[name] = callback;
+	}
+	static removeIdentifier(name) {
+		delete this.#identifiers[name];
+	}
+	#getValue(key, parsed) {
+		if (this.#preferProcessEnv && process.env[key]) return process.env[key];
+		if (parsed[key]) return this.#interpolate(parsed[key], parsed);
+		return process.env[key] || "";
+	}
+	#interpolateMustache(token, parsed) {
+		const closingBrace = token.indexOf("}");
+		if (closingBrace === -1) return token;
+		const varReference = token.slice(1, closingBrace).trim();
+		return `${this.#getValue(varReference, parsed)}${token.slice(closingBrace + 1)}`;
+	}
+	#interpolateVariable(token, parsed) {
+		return token.replace(/[a-zA-Z0-9_]+/, (key) => {
+			return this.#getValue(key, parsed);
+		});
+	}
+	#interpolate(value, parsed) {
+		const tokens = value.split("$");
+		let newValue = "";
+		let skipNextToken = true;
+		tokens.forEach((token) => {
+			if (token === "\\") {
+				newValue += "$";
+				skipNextToken = true;
+				return;
+			}
+			if (skipNextToken) {
+				newValue += token.replace(/\\$/, "$");
+				if (token.endsWith("\\")) return;
+			} else {
+				if (token.startsWith("{")) {
+					newValue += this.#interpolateMustache(token, parsed);
+					return;
+				}
+				newValue += this.#interpolateVariable(token, parsed);
+			}
+			skipNextToken = false;
+		});
+		return newValue;
+	}
+	async parse() {
+		const envCollection = parseEnv(this.#envContents.trim());
+		const identifiers = Object.keys(EnvParser.#identifiers);
+		let result = {};
+		$keyLoop: for (const key in envCollection) {
+			const value = this.#getValue(key, envCollection);
+			if (value.includes(":")) {
+				for (const identifier of identifiers) {
+					if (value.startsWith(`${identifier}:`)) {
+						result[key] = await EnvParser.#identifiers[identifier](value.substring(identifier.length + 1), key, this.#appRoot);
+						continue $keyLoop;
+					}
+					if (value.startsWith(`${identifier}\\:`)) {
+						result[key] = identifier + value.substring(identifier.length + 1);
+						continue $keyLoop;
+					}
+				}
+				result[key] = value;
+			} else result[key] = value;
+		}
+		return result;
+	}
 };
-
-// src/validator.ts
 var EnvValidator = class {
-  /**
-   * The validation schema for environment variables
-   */
-  #schema;
-  /**
-   * The error instance for validation failures
-   */
-  #error;
-  /**
-   * Creates a new EnvValidator instance
-   *
-   * @param schema - The validation schema object
-   */
-  constructor(schema) {
-    this.#schema = schema;
-    this.#error = new E_INVALID_ENV_VARIABLES();
-  }
-  /**
-   * Accepts an object of values to validate against the pre-defined
-   * schema.
-   *
-   * The return value is a merged copy of the original object and the
-   * values mutated by the schema validator.
-   *
-   * @param values - Object of environment variable values to validate
-   * @returns Validated and transformed environment variables
-   */
-  validate(values) {
-    const help = [];
-    const validated = Object.keys(this.#schema).reduce(
-      (result, key) => {
-        const value = process.env[key] || values[key];
-        try {
-          result[key] = this.#schema[key](key, value);
-        } catch (error) {
-          help.push(`- ${error.message}`);
-        }
-        return result;
-      },
-      { ...values }
-    );
-    if (help.length) {
-      this.#error.help = help.join("\n");
-      throw this.#error;
-    }
-    return validated;
-  }
+	#schema;
+	#error;
+	constructor(schema$2) {
+		this.#schema = schema$2;
+		this.#error = new E_INVALID_ENV_VARIABLES();
+	}
+	validate(values) {
+		const help = [];
+		const validated = Object.keys(this.#schema).reduce((result, key) => {
+			const value = process.env[key] || values[key];
+			try {
+				result[key] = this.#schema[key](key, value);
+			} catch (error) {
+				help.push(`- ${error.message}`);
+			}
+			return result;
+		}, { ...values });
+		if (help.length) {
+			this.#error.help = help.join("\n");
+			throw this.#error;
+		}
+		return validated;
+	}
 };
-
-// src/processor.ts
 var EnvProcessor = class {
-  /**
-   * App root is needed to load files
-   */
-  #appRoot;
-  /**
-   * Creates a new EnvProcessor instance
-   *
-   * @param appRoot - The application root directory URL
-   */
-  constructor(appRoot) {
-    this.#appRoot = appRoot;
-  }
-  /**
-   * Parse env variables from raw contents
-   *
-   * @param envContents - Raw environment file contents
-   * @param store - Store object to collect parsed variables
-   * @returns Updated store with parsed variables
-   */
-  async #processContents(envContents, store) {
-    if (!envContents.trim()) {
-      return store;
-    }
-    const parser = new EnvParser(envContents, this.#appRoot);
-    const values = await parser.parse();
-    Object.keys(values).forEach((key) => {
-      let value = process.env[key];
-      if (!value) {
-        value = values[key];
-        process.env[key] = values[key];
-      }
-      if (!store[key]) {
-        store[key] = value;
-      }
-    });
-    return store;
-  }
-  /**
-   * Parse env variables by loading dot files.
-   *
-   * @returns Promise resolving to collected environment variables
-   */
-  async #loadAndProcessDotFiles() {
-    const loader = new EnvLoader(this.#appRoot);
-    const envFiles = await loader.load();
-    if (debug_default.enabled) {
-      debug_default(
-        "processing .env files (priority from top to bottom) %O",
-        envFiles.map((file) => file.path)
-      );
-    }
-    const envValues = {};
-    await Promise.all(envFiles.map(({ contents }) => this.#processContents(contents, envValues)));
-    return envValues;
-  }
-  /**
-   * Process env variables
-   *
-   * @returns Promise resolving to processed environment variables
-   */
-  async process() {
-    return this.#loadAndProcessDotFiles();
-  }
+	#appRoot;
+	constructor(appRoot) {
+		this.#appRoot = appRoot;
+	}
+	async #processContents(envContents, store) {
+		if (!envContents.trim()) return store;
+		const values = await new EnvParser(envContents, this.#appRoot).parse();
+		Object.keys(values).forEach((key) => {
+			let value = process.env[key];
+			if (value === void 0) {
+				value = values[key];
+				process.env[key] = values[key];
+			}
+			if (key in store === false) store[key] = value;
+		});
+		return store;
+	}
+	async #loadAndProcessDotFiles() {
+		const envFiles = await new EnvLoader(this.#appRoot).load();
+		if (debug_default.enabled) debug_default("processing .env files (priority from top to bottom) %O", envFiles.map((file) => file.path));
+		const envValues = {};
+		await Promise.all(envFiles.map(({ contents }) => this.#processContents(contents, envValues)));
+		return envValues;
+	}
+	async process() {
+		return this.#loadAndProcessDotFiles();
+	}
+};
+function secret(options) {
+	return function validate(key, value) {
+		if (!value) throw new Error(options?.message ?? `Missing environment variable "${key}"`);
+		return new Secret(value);
+	};
+}
+secret.optional = function optionalString() {
+	return function validate(_, value) {
+		if (!value) return;
+		return new Secret(value);
+	};
+};
+secret.optionalWhen = function optionalWhenString(condition, options) {
+	return function validate(key, value) {
+		if (typeof condition === "function" ? condition(key, value) : condition) return secret.optional()(key, value);
+		return secret(options)(key, value);
+	};
 };
-
-// src/env.ts
-var Env = class _Env {
-  /**
-   * A cache of env values
-   */
-  #values;
-  /**
-   * Creates a new Env instance
-   *
-   * @param values - Validated environment values
-   */
-  constructor(values) {
-    this.#values = values;
-  }
-  /**
-   * Create an instance of the env class by validating the
-   * environment variables. Also, the `.env` files are
-   * loaded from the appRoot
-   *
-   * @param appRoot - The application root directory URL
-   * @param schema - Validation schema for environment variables
-   * @returns Promise resolving to an Env instance with validated values
-   */
-  static async create(appRoot, schema) {
-    const values = await new EnvProcessor(appRoot).process();
-    const validator = this.rules(schema);
-    return new _Env(validator.validate(values));
-  }
-  /**
-   * Define an identifier for any environment value. The callback is invoked
-   * when the value match the identifier to modify its interpolation.
-   *
-   * @deprecated use `Env.defineIdentifier` instead
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static identifier(name, callback) {
-    return EnvParser.defineIdentifier(name, callback);
-  }
-  /**
-   * Define an identifier for any environment value. The callback is invoked
-   * when the value match the identifier to modify its interpolation.
-   *
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static defineIdentifier(name, callback) {
-    EnvParser.defineIdentifier(name, callback);
-  }
-  /**
-   * Define an identifier for any environment value, if it's not already defined.
-   * The callback is invoked when the value match the identifier to modify its
-   * interpolation.
-   *
-   * @param name - The identifier name
-   * @param callback - Callback function to process the identifier value
-   */
-  static defineIdentifierIfMissing(name, callback) {
-    EnvParser.defineIdentifierIfMissing(name, callback);
-  }
-  /**
-   * Remove an identifier
-   *
-   * @param name - The identifier name to remove
-   */
-  static removeIdentifier(name) {
-    EnvParser.removeIdentifier(name);
-  }
-  /**
-   * The schema builder for defining validation rules
-   */
-  static schema = envSchema;
-  /**
-   * Define the validation rules for validating environment
-   * variables. The return value is an instance of the
-   * env validator
-   *
-   * @param schema - Validation schema object
-   * @returns EnvValidator instance
-   */
-  static rules(schema) {
-    const validator = new EnvValidator(schema);
-    return validator;
-  }
-  get(key, defaultValue) {
-    if (this.#values[key] !== void 0) {
-      return this.#values[key];
-    }
-    const envValue = process.env[key];
-    if (envValue) {
-      return envValue;
-    }
-    return defaultValue;
-  }
-  set(key, value) {
-    this.#values[key] = value;
-    process.env[key] = value;
-  }
+const schema$1 = {
+	...schema,
+	secret
 };
-export {
-  Env,
-  EnvLoader,
-  EnvParser,
-  EnvProcessor,
-  errors_exports as errors
+var Env = class Env {
+	#values;
+	constructor(values) {
+		this.#values = values;
+	}
+	static async create(appRoot, schema$2) {
+		const values = await new EnvProcessor(appRoot).process();
+		return new Env(this.rules(schema$2).validate(values));
+	}
+	static identifier(name, callback) {
+		return EnvParser.defineIdentifier(name, callback);
+	}
+	static defineIdentifier(name, callback) {
+		EnvParser.defineIdentifier(name, callback);
+	}
+	static defineIdentifierIfMissing(name, callback) {
+		EnvParser.defineIdentifierIfMissing(name, callback);
+	}
+	static removeIdentifier(name) {
+		EnvParser.removeIdentifier(name);
+	}
+	static schema = schema$1;
+	static rules(schema$2) {
+		return new EnvValidator(schema$2);
+	}
+	get(key, defaultValue) {
+		if (this.#values[key] !== void 0) return this.#values[key];
+		const envValue = process.env[key];
+		if (envValue) return envValue;
+		return defaultValue;
+	}
+	set(key, value) {
+		this.#values[key] = value;
+		process.env[key] = value;
+	}
 };
+export { Env, EnvLoader, EnvParser, EnvProcessor, errors_exports as errors };

package/build/loader-KsjAiZ3e.js

@@ -0,0 +1,74 @@
+import { debuglog } from "node:util";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { isAbsolute, join } from "node:path";
+var debug_default = debuglog("adonisjs:env");
+var EnvLoader = class {
+	#appRoot;
+	#loadExampleFile;
+	constructor(appRoot, loadExampleFile = false) {
+		this.#appRoot = typeof appRoot === "string" ? appRoot : fileURLToPath(appRoot);
+		this.#loadExampleFile = loadExampleFile;
+	}
+	async #loadFile(filePath) {
+		try {
+			return {
+				contents: await readFile(filePath, "utf-8"),
+				fileExists: true
+			};
+		} catch (error) {
+			/* c8 ignore next 3 */
+			if (error.code !== "ENOENT") throw error;
+			return {
+				contents: "",
+				fileExists: false
+			};
+		}
+	}
+	async load() {
+		const ENV_PATH = process.env.ENV_PATH;
+		const NODE_ENV = process.env.NODE_ENV;
+		const envFiles = [];
+		if (debug_default.enabled) {
+			debug_default("ENV_PATH variable is %s", ENV_PATH ? "set" : "not set");
+			debug_default("NODE_ENV variable is %s", NODE_ENV ? "set" : "not set");
+		}
+		const baseEnvPath = ENV_PATH ? isAbsolute(ENV_PATH) ? ENV_PATH : join(this.#appRoot, ENV_PATH) : this.#appRoot;
+		if (debug_default.enabled) debug_default("dot-env files base path \"%s\"", baseEnvPath);
+		if (NODE_ENV) {
+			const nodeEnvLocalFile = join(baseEnvPath, `.env.${NODE_ENV}.local`);
+			envFiles.push({
+				path: nodeEnvLocalFile,
+				...await this.#loadFile(nodeEnvLocalFile)
+			});
+		}
+		if (!NODE_ENV || !["test", "testing"].includes(NODE_ENV)) {
+			const envLocalFile = join(baseEnvPath, ".env.local");
+			envFiles.push({
+				path: envLocalFile,
+				...await this.#loadFile(envLocalFile)
+			});
+		}
+		if (NODE_ENV) {
+			const nodeEnvFile = join(baseEnvPath, `.env.${NODE_ENV}`);
+			envFiles.push({
+				path: nodeEnvFile,
+				...await this.#loadFile(nodeEnvFile)
+			});
+		}
+		const envFile = join(baseEnvPath, ".env");
+		envFiles.push({
+			path: envFile,
+			...await this.#loadFile(envFile)
+		});
+		if (this.#loadExampleFile) {
+			const envExampleFile = join(baseEnvPath, ".env.example");
+			envFiles.push({
+				path: envExampleFile,
+				...await this.#loadFile(envExampleFile)
+			});
+		}
+		return envFiles;
+	}
+};
+export { debug_default as n, EnvLoader as t };

package/build/src/debug.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/editor.js

@@ -1,103 +1,43 @@
-import {
-  EnvLoader
-} from "../chunk-KE5AFOK2.js";
-
-// src/editor.ts
+import { t as EnvLoader } from "../loader-KsjAiZ3e.js";
+import { writeFile } from "node:fs/promises";
 import splitLines from "split-lines";
 import lodash from "@poppinss/utils/lodash";
-import { writeFile } from "fs/promises";
-var EnvEditor = class _EnvEditor {
-  /**
-   * The application root directory URL
-   */
-  #appRoot;
-  /**
-   * Environment file loader instance
-   */
-  #loader;
-  /**
-   * Array of loaded environment files with their contents and paths
-   */
-  #files = [];
-  /**
-   * Creates an instance of env editor and loads .env files
-   * contents.
-   *
-   * @param appRoot - The application root directory URL
-   * @returns Promise resolving to an EnvEditor instance
-   */
-  static async create(appRoot) {
-    const editor = new _EnvEditor(appRoot);
-    await editor.load();
-    return editor;
-  }
-  /**
-   * Constructs a new EnvEditor instance
-   *
-   * @param appRoot - The application root directory URL
-   */
-  constructor(appRoot) {
-    this.#appRoot = appRoot;
-    this.#loader = new EnvLoader(this.#appRoot, true);
-  }
-  /**
-   * Loads .env files for editing. Only ".env" and ".env.example"
-   * files are picked for editing.
-   *
-   * @returns Promise that resolves when files are loaded
-   */
-  async load() {
-    const envFiles = await this.#loader.load();
-    this.#files = envFiles.filter(
-      (envFile) => envFile.fileExists && (envFile.path.endsWith(".env") || envFile.path.endsWith(".env.example"))
-    ).map((envFile) => {
-      return {
-        contents: splitLines(envFile.contents.trim()),
-        path: envFile.path
-      };
-    });
-  }
-  /**
-   * Add key-value pair to the dot-env files.
-   * If `withEmptyExampleValue` is true then the key will be added with an empty value
-   * to the `.env.example` file.
-   *
-   * @param key - The environment variable key
-   * @param value - The environment variable value
-   * @param withEmptyExampleValue - Whether to add empty value to .env.example file
-   */
-  add(key, value, withEmptyExampleValue = false) {
-    this.#files.forEach((file) => {
-      let entryIndex = file.contents.findIndex((line) => line.startsWith(`${key}=`));
-      entryIndex = entryIndex === -1 ? file.contents.length : entryIndex;
-      if (withEmptyExampleValue && file.path.endsWith(".env.example")) {
-        lodash.set(file.contents, entryIndex, `${key}=`);
-      } else {
-        lodash.set(file.contents, entryIndex, `${key}=${value}`);
-      }
-    });
-  }
-  /**
-   * Returns the loaded files as JSON
-   *
-   * @returns Array of file objects with contents and paths
-   */
-  toJSON() {
-    return this.#files;
-  }
-  /**
-   * Save changes to the disk
-   *
-   * @returns Promise that resolves when files are saved
-   */
-  async save() {
-    await Promise.all(
-      this.#files.map((file) => {
-        return writeFile(file.path, file.contents.join("\n"));
-      })
-    );
-  }
-};
-export {
-  EnvEditor
+var EnvEditor = class EnvEditor {
+	#appRoot;
+	#loader;
+	#files = [];
+	static async create(appRoot) {
+		const editor = new EnvEditor(appRoot);
+		await editor.load();
+		return editor;
+	}
+	constructor(appRoot) {
+		this.#appRoot = appRoot;
+		this.#loader = new EnvLoader(this.#appRoot, true);
+	}
+	async load() {
+		this.#files = (await this.#loader.load()).filter((envFile) => envFile.fileExists && (envFile.path.endsWith(".env") || envFile.path.endsWith(".env.example"))).map((envFile) => {
+			return {
+				contents: splitLines(envFile.contents.trim()),
+				path: envFile.path
+			};
+		});
+	}
+	add(key, value, withEmptyExampleValue = false) {
+		this.#files.forEach((file) => {
+			let entryIndex = file.contents.findIndex((line) => line.startsWith(`${key}=`));
+			entryIndex = entryIndex === -1 ? file.contents.length : entryIndex;
+			if (withEmptyExampleValue && file.path.endsWith(".env.example")) lodash.set(file.contents, entryIndex, `${key}=`);
+			else lodash.set(file.contents, entryIndex, `${key}=${value}`);
+		});
+	}
+	toJSON() {
+		return this.#files;
+	}
+	async save() {
+		await Promise.all(this.#files.map((file) => {
+			return writeFile(file.path, file.contents.join("\n"));
+		}));
+	}
 };
+export { EnvEditor };

package/build/src/env.d.ts

@@ -1,6 +1,6 @@
-import { schema as envSchema } from '@poppinss/validator-lite';
 import type { ValidateFn } from '@poppinss/validator-lite/types';
 import { EnvValidator } from './validator.ts';
+import { schema as envSchema } from './schema.ts';
 /**
  * A wrapper over "process.env" with types information.
  *

package/build/src/parser.d.ts

@@ -1,9 +1,8 @@
-import { type DotenvParseOutput } from 'dotenv';
 /**
  * Env parser parses the environment variables from a string formatted
  * as a key-value pair seperated using an `=`. For example:
  *
- * ```dotenv
+ * ```
  * PORT=3333
  * HOST=127.0.0.1
  * ```
@@ -11,7 +10,7 @@ import { type DotenvParseOutput } from 'dotenv';
  * The variables can reference other environment variables as well using `$`.
  * For example:
  *
- * ```dotenv
+ * ```
  * PORT=3333
  * REDIS_PORT=$PORT
  * ```
@@ -19,14 +18,14 @@ import { type DotenvParseOutput } from 'dotenv';
  * The variables using characters other than letters can wrap variable
  * named inside a curly brace.
  *
- * ```dotenv
+ * ```
  * APP-PORT=3333
  * REDIS_PORT=${APP-PORT}
  * ```
  *
  * You can escape the `$` sign with a backtick.
  *
- * ```dotenv
+ * ```
  * REDIS_PASSWORD=foo\$123
  * ```
  *
@@ -94,5 +93,5 @@ export declare class EnvParser {
      *
      * @returns Promise resolving to parsed environment variables
      */
-    parse(): Promise<DotenvParseOutput>;
+    parse(): Promise<NodeJS.Dict<string>>;
 }

package/build/src/schema.d.ts

@@ -0,0 +1,13 @@
+import { Secret } from '@poppinss/utils';
+import { type Prettify } from '@poppinss/utils/types';
+import { schema as envSchema } from '@poppinss/validator-lite';
+import { type SchemaFnOptions } from '@poppinss/validator-lite/types';
+declare function secret(options?: SchemaFnOptions): (key: string, value?: string) => Secret<string>;
+declare namespace secret {
+    var optional: () => (_: string, value?: string) => Secret<string> | undefined;
+    var optionalWhen: (condition: boolean | ((key: string, value?: string) => boolean), options?: SchemaFnOptions) => (key: string, value?: string) => Secret<string> | undefined;
+}
+export declare const schema: Prettify<typeof envSchema & {
+    secret: typeof secret;
+}>;
+export {};

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/env",
-  "version": "7.0.0-next.1",
+  "version": "7.0.0-next.3",
   "description": "Environment variable manager for Node.js",
   "main": "build/index.js",
   "type": "module",
@@ -26,7 +26,7 @@
     "typecheck": "tsc --noEmit",
     "precompile": "npm run lint && npm run clean",
     "clean": "del-cli build",
-    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
+    "compile": "tsdown && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
     "release": "release-it",
     "version": "npm run build",
@@ -34,29 +34,29 @@
     "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
   },
   "devDependencies": {
-    "@adonisjs/eslint-config": "^3.0.0-next.1",
+    "@adonisjs/eslint-config": "^3.0.0-next.5",
     "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/tsconfig": "^2.0.0-next.0",
-    "@japa/assert": "^4.1.1",
-    "@japa/expect-type": "^2.0.3",
-    "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.4.0",
+    "@adonisjs/tsconfig": "^2.0.0-next.3",
+    "@japa/assert": "^4.2.0",
+    "@japa/expect-type": "^2.0.4",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.0.0",
     "@poppinss/ts-exec": "^1.4.1",
-    "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.3.0",
+    "@release-it/conventional-changelog": "^10.0.3",
+    "@types/node": "^25.0.2",
     "c8": "^10.1.3",
-    "cross-env": "^10.0.0",
-    "del-cli": "^6.0.0",
-    "eslint": "^9.34.0",
-    "prettier": "^3.6.2",
-    "release-it": "^19.0.4",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "cross-env": "^10.1.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "release-it": "^19.1.0",
+    "tsdown": "^0.17.4",
+    "typedoc": "^0.28.15",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@poppinss/utils": "^7.0.0-next.3",
+    "@poppinss/utils": "^7.0.0-next.4",
     "@poppinss/validator-lite": "^2.1.2",
-    "dotenv": "^17.2.1",
     "split-lines": "^3.0.0"
   },
   "homepage": "https://github.com/adonisjs/env#readme",
@@ -81,7 +81,7 @@
     "access": "public",
     "provenance": true
   },
-  "tsup": {
+  "tsdown": {
     "entry": [
       "./index.ts",
       "./src/types.ts",
@@ -90,8 +90,11 @@
     "outDir": "./build",
     "clean": true,
     "format": "esm",
+    "minify": "dce-only",
+    "fixedExtension": false,
     "dts": false,
-    "sourcemap": false,
+    "treeshake": false,
+    "sourcemaps": false,
     "target": "esnext"
   },
   "release-it": {

package/build/chunk-KE5AFOK2.js

@@ -1,112 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/loader.ts
-import { fileURLToPath } from "url";
-import { readFile } from "fs/promises";
-import { isAbsolute, join } from "path";
-
-// src/debug.ts
-import { debuglog } from "util";
-var debug_default = debuglog("adonisjs:env");
-
-// src/loader.ts
-var EnvLoader = class {
-  /**
-   * The application root directory path
-   */
-  #appRoot;
-  /**
-   * Whether to load the .env.example file
-   */
-  #loadExampleFile;
-  /**
-   * Creates a new EnvLoader instance
-   *
-   * @param appRoot - The application root directory as string or URL
-   * @param loadExampleFile - Whether to load .env.example file
-   */
-  constructor(appRoot, loadExampleFile = false) {
-    this.#appRoot = typeof appRoot === "string" ? appRoot : fileURLToPath(appRoot);
-    this.#loadExampleFile = loadExampleFile;
-  }
-  /**
-   * Optionally read a file from the disk
-   *
-   * @param filePath - Path to the file to read
-   * @returns Promise resolving to file existence status and contents
-   */
-  async #loadFile(filePath) {
-    try {
-      const contents = await readFile(filePath, "utf-8");
-      return { contents, fileExists: true };
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      return { contents: "", fileExists: false };
-    }
-  }
-  /**
-   * Load contents of the main dot-env file and the current
-   * environment dot-env file
-   *
-   * @returns Promise resolving to array of loaded environment files
-   */
-  async load() {
-    const ENV_PATH = process.env.ENV_PATH;
-    const NODE_ENV = process.env.NODE_ENV;
-    const envFiles = [];
-    if (debug_default.enabled) {
-      debug_default("ENV_PATH variable is %s", ENV_PATH ? "set" : "not set");
-      debug_default("NODE_ENV variable is %s", NODE_ENV ? "set" : "not set");
-    }
-    const baseEnvPath = ENV_PATH ? isAbsolute(ENV_PATH) ? ENV_PATH : join(this.#appRoot, ENV_PATH) : this.#appRoot;
-    if (debug_default.enabled) {
-      debug_default('dot-env files base path "%s"', baseEnvPath);
-    }
-    if (NODE_ENV) {
-      const nodeEnvLocalFile = join(baseEnvPath, `.env.${NODE_ENV}.local`);
-      envFiles.push({
-        path: nodeEnvLocalFile,
-        ...await this.#loadFile(nodeEnvLocalFile)
-      });
-    }
-    if (!NODE_ENV || !["test", "testing"].includes(NODE_ENV)) {
-      const envLocalFile = join(baseEnvPath, ".env.local");
-      envFiles.push({
-        path: envLocalFile,
-        ...await this.#loadFile(envLocalFile)
-      });
-    }
-    if (NODE_ENV) {
-      const nodeEnvFile = join(baseEnvPath, `.env.${NODE_ENV}`);
-      envFiles.push({
-        path: nodeEnvFile,
-        ...await this.#loadFile(nodeEnvFile)
-      });
-    }
-    const envFile = join(baseEnvPath, ".env");
-    envFiles.push({
-      path: envFile,
-      ...await this.#loadFile(envFile)
-    });
-    if (this.#loadExampleFile) {
-      const envExampleFile = join(baseEnvPath, ".env.example");
-      envFiles.push({
-        path: envExampleFile,
-        ...await this.#loadFile(envExampleFile)
-      });
-    }
-    return envFiles;
-  }
-};
-
-export {
-  __export,
-  debug_default,
-  EnvLoader
-};