@adonisjs/env 4.2.0-5 → 4.2.0-7

package/README.md

@@ -110,7 +110,7 @@ env.get('NODE_ENV') // is unknown, hence a string or undefined
 The Env editor can be used to edit dot-env files and persist changes on disk. Only the `.env` and `.env.example` files are updated (if exists).
 
 ```ts
-import { EnvEditor } from '@adonisjs/env'
+import { EnvEditor } from '@adonisjs/env/editor'
 
 const editor = await EnvEditor.create(new URL('./', import.meta.url))
 editor.add('PORT', 3000)

package/build/chunk-H6UKLEIO.js

@@ -0,0 +1,96 @@
+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 "node:url";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+
+// src/debug.ts
+import { debuglog } from "node:util";
+var debug_default = debuglog("adonisjs:env");
+
+// src/loader.ts
+var EnvLoader = class {
+  #appRoot;
+  #loadExampleFile;
+  constructor(appRoot, loadExampleFile = false) {
+    this.#appRoot = typeof appRoot === "string" ? appRoot : fileURLToPath(appRoot);
+    this.#loadExampleFile = loadExampleFile;
+  }
+  /**
+   * Optionally read a file from the disk
+   */
+  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
+   */
+  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
+};
+//# sourceMappingURL=chunk-H6UKLEIO.js.map

package/build/chunk-H6UKLEIO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/loader.ts","../src/debug.ts"],"sourcesContent":["/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { fileURLToPath } from 'node:url'\nimport { readFile } from 'node:fs/promises'\nimport { isAbsolute, join } from 'node:path'\n\nimport debug from './debug.js'\n\n/**\n * Read the contents of one or more dot-env files. Following is how the files\n * are read.\n *\n * - Load file from the \"ENV_PATH\" environment file.\n *    (Raise error if file is missing)\n *\n * - If \"ENV_PATH\" is not defined, then find \".env\" file in the app root.\n *    (Ignore if file is missing)\n *\n * - Find \".env.[NODE_ENV]\" file in the app root.\n *    (Ignore if file is missing)\n *\n * ```ts\n * const loader = new EnvLoader(new URL('./', import.meta.url))\n *\n * const { envContents, currentEnvContents } = await loader.load()\n *\n * // envContents: Contents of .env or file specified via ENV_PATH\n * // currentEnvContents: Contents of .env.[NODE_ENV] file\n * ```\n */\nexport class EnvLoader {\n  #appRoot: string\n  #loadExampleFile: boolean\n\n  constructor(appRoot: string | URL, loadExampleFile: boolean = false) {\n    this.#appRoot = typeof appRoot === 'string' ? appRoot : fileURLToPath(appRoot)\n    this.#loadExampleFile = loadExampleFile\n  }\n\n  /**\n   * Optionally read a file from the disk\n   */\n  async #loadFile(filePath: string | URL): Promise<{ fileExists: boolean; contents: string }> {\n    try {\n      const contents = await readFile(filePath, 'utf-8')\n      return { contents, fileExists: true }\n    } catch (error) {\n      /* c8 ignore next 3 */\n      if (error.code !== 'ENOENT') {\n        throw error\n      }\n\n      return { contents: '', fileExists: false }\n    }\n  }\n\n  /**\n   * Load contents of the main dot-env file and the current\n   * environment dot-env file\n   */\n  async load(): Promise<{ contents: string; path: string; fileExists: boolean }[]> {\n    const ENV_PATH = process.env.ENV_PATH\n    const NODE_ENV = process.env.NODE_ENV\n    const envFiles: { path: string; contents: string; fileExists: boolean }[] = []\n\n    if (debug.enabled) {\n      debug('ENV_PATH variable is %s', ENV_PATH ? 'set' : 'not set')\n      debug('NODE_ENV variable is %s', NODE_ENV ? 'set' : 'not set')\n    }\n\n    /**\n     * Base path to load .env files from\n     */\n    const baseEnvPath = ENV_PATH\n      ? isAbsolute(ENV_PATH)\n        ? ENV_PATH\n        : join(this.#appRoot, ENV_PATH)\n      : this.#appRoot\n\n    if (debug.enabled) {\n      debug('dot-env files base path \"%s\"', baseEnvPath)\n    }\n\n    /**\n     * 1st\n     * The top most priority is given to the \".env.[NODE_ENV].local\" file\n     */\n    if (NODE_ENV) {\n      const nodeEnvLocalFile = join(baseEnvPath, `.env.${NODE_ENV}.local`)\n      envFiles.push({\n        path: nodeEnvLocalFile,\n        ...(await this.#loadFile(nodeEnvLocalFile)),\n      })\n    }\n\n    /**\n     * 2nd\n     * Next, we give priority to the \".env.local\" file\n     */\n    if (!NODE_ENV || !['test', 'testing'].includes(NODE_ENV)) {\n      const envLocalFile = join(baseEnvPath, '.env.local')\n      envFiles.push({\n        path: envLocalFile,\n        ...(await this.#loadFile(envLocalFile)),\n      })\n    }\n\n    /**\n     * 3rd\n     * Next, we give priority to the \".env.[NODE_ENV]\" file\n     */\n    if (NODE_ENV) {\n      const nodeEnvFile = join(baseEnvPath, `.env.${NODE_ENV}`)\n      envFiles.push({\n        path: nodeEnvFile,\n        ...(await this.#loadFile(nodeEnvFile)),\n      })\n    }\n\n    /**\n     * Finally, we push the contents of the \".env\" file.\n     */\n    const envFile = join(baseEnvPath, '.env')\n    envFiles.push({\n      path: envFile,\n      ...(await this.#loadFile(envFile)),\n    })\n\n    /**\n     * Load example file\n     */\n    if (this.#loadExampleFile) {\n      const envExampleFile = join(baseEnvPath, '.env.example')\n      envFiles.push({\n        path: envExampleFile,\n        ...(await this.#loadFile(envExampleFile)),\n      })\n    }\n\n    return envFiles\n  }\n}\n","/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { debuglog } from 'node:util'\nexport default debuglog('adonisjs:env')\n"],"mappings":";;;;;;;AASA,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB;AACzB,SAAS,YAAY,YAAY;;;ACFjC,SAAS,gBAAgB;AACzB,IAAO,gBAAQ,SAAS,cAAc;;;AD2B/B,IAAM,YAAN,MAAgB;AAAA,EACrB;AAAA,EACA;AAAA,EAEA,YAAY,SAAuB,kBAA2B,OAAO;AACnE,SAAK,WAAW,OAAO,YAAY,WAAW,UAAU,cAAc,OAAO;AAC7E,SAAK,mBAAmB;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,UAAU,UAA4E;AAC1F,QAAI;AACF,YAAM,WAAW,MAAM,SAAS,UAAU,OAAO;AACjD,aAAO,EAAE,UAAU,YAAY,KAAK;AAAA,IACtC,SAAS,OAAO;AAEd,UAAI,MAAM,SAAS,UAAU;AAC3B,cAAM;AAAA,MACR;AAEA,aAAO,EAAE,UAAU,IAAI,YAAY,MAAM;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,OAA2E;AAC/E,UAAM,WAAW,QAAQ,IAAI;AAC7B,UAAM,WAAW,QAAQ,IAAI;AAC7B,UAAM,WAAsE,CAAC;AAE7E,QAAI,cAAM,SAAS;AACjB,oBAAM,2BAA2B,WAAW,QAAQ,SAAS;AAC7D,oBAAM,2BAA2B,WAAW,QAAQ,SAAS;AAAA,IAC/D;AAKA,UAAM,cAAc,WAChB,WAAW,QAAQ,IACjB,WACA,KAAK,KAAK,UAAU,QAAQ,IAC9B,KAAK;AAET,QAAI,cAAM,SAAS;AACjB,oBAAM,gCAAgC,WAAW;AAAA,IACnD;AAMA,QAAI,UAAU;AACZ,YAAM,mBAAmB,KAAK,aAAa,QAAQ,QAAQ,QAAQ;AACnE,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,GAAI,MAAM,KAAK,UAAU,gBAAgB;AAAA,MAC3C,CAAC;AAAA,IACH;AAMA,QAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,SAAS,EAAE,SAAS,QAAQ,GAAG;AACxD,YAAM,eAAe,KAAK,aAAa,YAAY;AACnD,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,GAAI,MAAM,KAAK,UAAU,YAAY;AAAA,MACvC,CAAC;AAAA,IACH;AAMA,QAAI,UAAU;AACZ,YAAM,cAAc,KAAK,aAAa,QAAQ,QAAQ,EAAE;AACxD,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,GAAI,MAAM,KAAK,UAAU,WAAW;AAAA,MACtC,CAAC;AAAA,IACH;AAKA,UAAM,UAAU,KAAK,aAAa,MAAM;AACxC,aAAS,KAAK;AAAA,MACZ,MAAM;AAAA,MACN,GAAI,MAAM,KAAK,UAAU,OAAO;AAAA,IAClC,CAAC;AAKD,QAAI,KAAK,kBAAkB;AACzB,YAAM,iBAAiB,KAAK,aAAa,cAAc;AACvD,eAAS,KAAK;AAAA,QACZ,MAAM;AAAA,QACN,GAAI,MAAM,KAAK,UAAU,cAAc;AAAA,MACzC,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AACF;","names":[]}

package/build/index.d.ts

@@ -1,5 +1,5 @@
 export { Env } from './src/env.js';
 export { EnvParser } from './src/parser.js';
 export { EnvLoader } from './src/loader.js';
-export * as errors from './src/exceptions.js';
+export * as errors from './src/errors.js';
 export { EnvProcessor } from './src/processor.js';

package/build/index.js

@@ -1,13 +1,252 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export { Env } from './src/env.js';
-export { EnvParser } from './src/parser.js';
-export { EnvLoader } from './src/loader.js';
-export * as errors from './src/exceptions.js';
-export { EnvProcessor } from './src/processor.js';
+import {
+  EnvLoader,
+  __export,
+  debug_default
+} from "./chunk-H6UKLEIO.js";
+
+// src/env.ts
+import { schema as envSchema } from "@poppinss/validator-lite";
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  E_INVALID_ENV_VARIABLES: () => E_INVALID_ENV_VARIABLES
+});
+import { Exception } from "@poppinss/utils";
+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 = "";
+};
+
+// src/validator.ts
+var EnvValidator = class {
+  #schema;
+  #error;
+  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.
+   */
+  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/parser.ts
+import dotenv from "dotenv";
+var EnvParser = class {
+  #envContents;
+  #preferProcessEnv = true;
+  constructor(envContents, options) {
+    if (options?.ignoreProcessEnv) {
+      this.#preferProcessEnv = false;
+    }
+    this.#envContents = envContents;
+  }
+  /**
+   * Returns the value from the parsed object
+   */
+  #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.
+   */
+  #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.
+   */
+  #interpolateVariable(token, parsed) {
+    return token.replace(/[a-zA-Z0-9_]+/, (key) => {
+      return this.#getValue(key, parsed);
+    });
+  }
+  /**
+   * Interpolates the referenced values
+   */
+  #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.
+   */
+  parse() {
+    const envCollection = dotenv.parse(this.#envContents.trim());
+    return Object.keys(envCollection).reduce((result, key) => {
+      result[key] = this.#getValue(key, envCollection);
+      return result;
+    }, {});
+  }
+};
+
+// src/processor.ts
+var EnvProcessor = class {
+  /**
+   * App root is needed to load files
+   */
+  #appRoot;
+  constructor(appRoot) {
+    this.#appRoot = appRoot;
+  }
+  /**
+   * Parse env variables from raw contents
+   */
+  #processContents(envContents, store) {
+    if (!envContents.trim()) {
+      return store;
+    }
+    const values = new EnvParser(envContents).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.
+   */
+  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 = {};
+    envFiles.forEach(({ contents }) => this.#processContents(contents, envValues));
+    return envValues;
+  }
+  /**
+   * Process env variables
+   */
+  async process() {
+    return this.#loadAndProcessDotFiles();
+  }
+};
+
+// src/env.ts
+var Env = class _Env {
+  /**
+   * A cache of env values
+   */
+  #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
+   */
+  static async create(appRoot, schema) {
+    const values = await new EnvProcessor(appRoot).process();
+    const validator = this.rules(schema);
+    return new _Env(validator.validate(values));
+  }
+  /**
+   * 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
+   */
+  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;
+  }
+};
+export {
+  Env,
+  EnvLoader,
+  EnvParser,
+  EnvProcessor,
+  errors_exports as errors
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/env.ts","../src/errors.ts","../src/validator.ts","../src/parser.ts","../src/processor.ts"],"sourcesContent":["/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { schema as envSchema, type ValidateFn } from '@poppinss/validator-lite'\nimport { EnvValidator } from './validator.js'\nimport { EnvProcessor } from './processor.js'\n\n/**\n * A wrapper over \"process.env\" with types information.\n *\n * ```ts\n * const validate = Env.rules({\n *   PORT: Env.schema.number()\n * })\n *\n * const validatedEnvVars = validate(process.env)\n *\n * const env = new EnvValues(validatedEnvVars)\n * env.get('PORT') // type === number\n * ```\n */\nexport class Env<EnvValues extends Record<string, any>> {\n  /**\n   * A cache of env values\n   */\n  #values: EnvValues\n\n  constructor(values: EnvValues) {\n    this.#values = values\n  }\n\n  /**\n   * Create an instance of the env class by validating the\n   * environment variables. Also, the `.env` files are\n   * loaded from the appRoot\n   */\n  static async create<Schema extends { [key: string]: ValidateFn<unknown> }>(\n    appRoot: URL,\n    schema: Schema\n  ): Promise<\n    Env<{\n      [K in keyof Schema]: ReturnType<Schema[K]>\n    }>\n  > {\n    const values = await new EnvProcessor(appRoot).process()\n    const validator = this.rules(schema)\n    return new Env(validator.validate(values))\n  }\n\n  /**\n   * The schema builder for defining validation rules\n   */\n  static schema = envSchema\n\n  /**\n   * Define the validation rules for validating environment\n   * variables. The return value is an instance of the\n   * env validator\n   */\n  static rules<T extends { [key: string]: ValidateFn<unknown> }>(schema: T): EnvValidator<T> {\n    const validator = new EnvValidator<T>(schema)\n    return validator\n  }\n\n  /**\n   * Get the value of an environment variable by key. The values are\n   * lookedup inside the validated environment and \"process.env\"\n   * is used as a fallback.\n   *\n   * The second param is the default value, which is returned when\n   * the environment variable does not exist.\n   *\n   * ```ts\n   * Env.get('PORT')\n   *\n   * // With default value\n   * Env.get('PORT', 3000)\n   * ```\n   */\n  get<K extends keyof EnvValues>(key: K): EnvValues[K]\n  get<K extends keyof EnvValues>(\n    key: K,\n    defaultValue: Exclude<EnvValues[K], undefined>\n  ): Exclude<EnvValues[K], undefined>\n  get(key: string): string | undefined\n  get(key: string, defaultValue: string): string\n  get(key: string, defaultValue?: any): any {\n    /**\n     * Return cached value\n     */\n    if (this.#values[key] !== undefined) {\n      return this.#values[key]\n    }\n\n    /**\n     * Get value from \"process.env\" and update the cache\n     */\n    const envValue = process.env[key]\n    if (envValue) {\n      return envValue\n    }\n\n    /**\n     * Return default value when unable to lookup any other value\n     */\n    return defaultValue\n  }\n\n  /**\n   * Update/set value of an environment variable.\n   *\n   * The value is not casted/validated using the validator, so make sure\n   * to set the correct data type.\n   *\n   * ```ts\n   * Env.set('PORT', 3000)\n   *\n   * Env.get('PORT') === 3000 // true\n   * process.env.PORT === '3000' // true\n   * ```\n   */\n  set<K extends keyof EnvValues>(key: K, value: EnvValues[K]): void\n  set(key: string, value: string): void\n  set(key: string | keyof EnvValues, value: any): void {\n    this.#values[key] = value\n    process.env[key as string] = value\n  }\n}\n","/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { Exception } from '@poppinss/utils'\n\n/**\n * Exception raised when one or more env variables\n * are invalid\n */\nexport const E_INVALID_ENV_VARIABLES = class EnvValidationException extends Exception {\n  static message = 'Validation failed for one or more environment variables'\n  static code = 'E_INVALID_ENV_VARIABLES'\n  help: string = ''\n}\n","/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport type { Exception } from '@poppinss/utils'\nimport { ValidateFn } from '@poppinss/validator-lite'\n\nimport { E_INVALID_ENV_VARIABLES } from './errors.js'\n\n/**\n * Exposes the API to validate environment variables against a\n * pre-defined schema.\n *\n * The class is not exported in the main API and used internally.\n */\nexport class EnvValidator<Schema extends { [key: string]: ValidateFn<unknown> }> {\n  #schema: Schema\n  #error: Exception\n\n  constructor(schema: Schema) {\n    this.#schema = schema\n    this.#error = new E_INVALID_ENV_VARIABLES()\n  }\n\n  /**\n   * Accepts an object of values to validate against the pre-defined\n   * schema.\n   *\n   * The return value is a merged copy of the original object and the\n   * values mutated by the schema validator.\n   */\n  validate(values: { [K: string]: string | undefined }): {\n    [K in keyof Schema]: ReturnType<Schema[K]>\n  } {\n    const help: string[] = []\n\n    const validated = Object.keys(this.#schema).reduce(\n      (result, key) => {\n        const value = process.env[key] || values[key]\n\n        try {\n          result[key] = this.#schema[key](key, value) as any\n        } catch (error) {\n          help.push(`- ${error.message}`)\n        }\n        return result\n      },\n      { ...values }\n    ) as { [K in keyof Schema]: ReturnType<Schema[K]> }\n\n    if (help.length) {\n      this.#error.help = help.join('\\n')\n      throw this.#error\n    }\n\n    return validated\n  }\n}\n","/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport dotenv, { DotenvParseOutput } from 'dotenv'\n\n/**\n * Env parser parses the environment variables from a string formatted\n * as a key-value pair seperated using an `=`. For example:\n *\n * ```dotenv\n * PORT=3333\n * HOST=127.0.0.1\n * ```\n *\n * The variables can reference other environment variables as well using `$`.\n * For example:\n *\n * ```dotenv\n * PORT=3333\n * REDIS_PORT=$PORT\n * ```\n *\n * The variables using characters other than letters can wrap variable\n * named inside a curly brace.\n *\n * ```dotenv\n * APP-PORT=3333\n * REDIS_PORT=${APP-PORT}\n * ```\n *\n * You can escape the `$` sign with a backtick.\n *\n * ```dotenv\n * REDIS_PASSWORD=foo\\$123\n * ```\n *\n * ## Usage\n *\n * ```ts\n * const parser = new EnvParser(envContents)\n * const output = parser.parse()\n *\n * // The output is a key-value pair\n * ```\n */\nexport class EnvParser {\n  #envContents: string\n  #preferProcessEnv: boolean = true\n\n  constructor(envContents: string, options?: { ignoreProcessEnv: boolean }) {\n    if (options?.ignoreProcessEnv) {\n      this.#preferProcessEnv = false\n    }\n\n    this.#envContents = envContents\n  }\n\n  /**\n   * Returns the value from the parsed object\n   */\n  #getValue(key: string, parsed: DotenvParseOutput): string {\n    if (this.#preferProcessEnv && process.env[key]) {\n      return process.env[key]!\n    }\n\n    if (parsed[key]) {\n      return this.#interpolate(parsed[key], parsed)\n    }\n\n    return process.env[key] || ''\n  }\n\n  /**\n   * Interpolating the token wrapped inside the mustache braces.\n   */\n  #interpolateMustache(token: string, parsed: DotenvParseOutput) {\n    /**\n     * Finding the closing brace. If closing brace is missing, we\n     * consider the block as a normal string\n     */\n    const closingBrace = token.indexOf('}')\n    if (closingBrace === -1) {\n      return token\n    }\n\n    /**\n     * Then we pull everything until the closing brace, except\n     * the opening brace and trim off all white spaces.\n     */\n    const varReference = token.slice(1, closingBrace).trim()\n\n    /**\n     * Getting the value of the reference inside the braces\n     */\n    return `${this.#getValue(varReference, parsed)}${token.slice(closingBrace + 1)}`\n  }\n\n  /**\n   * Interpolating the variable reference starting with a\n   * `$`. We only capture numbers,letter and underscore.\n   * For other characters, one can use the mustache\n   * braces.\n   */\n  #interpolateVariable(token: string, parsed: any) {\n    return token.replace(/[a-zA-Z0-9_]+/, (key) => {\n      return this.#getValue(key, parsed)\n    })\n  }\n\n  /**\n   * Interpolates the referenced values\n   */\n  #interpolate(value: string, parsed: DotenvParseOutput): string {\n    const tokens = value.split('$')\n\n    let newValue = ''\n    let skipNextToken = true\n\n    tokens.forEach((token) => {\n      /**\n       * If the value is an escaped sequence, then we replace it\n       * with a `$` and then skip the next token.\n       */\n      if (token === '\\\\') {\n        newValue += '$'\n        skipNextToken = true\n        return\n      }\n\n      /**\n       * Use the value as it is when \"skipNextToken\" is set to true.\n       */\n      if (skipNextToken) {\n        /**\n         * Replace the ending escape sequence with a $\n         */\n        newValue += token.replace(/\\\\$/, '$')\n        /**\n         *  and then skip the next token if it ends with escape sequence\n         */\n        if (token.endsWith('\\\\')) {\n          return\n        }\n      } else {\n        /**\n         * Handle mustache block\n         */\n        if (token.startsWith('{')) {\n          newValue += this.#interpolateMustache(token, parsed)\n          return\n        }\n\n        /**\n         * Process all words as variable\n         */\n        newValue += this.#interpolateVariable(token, parsed)\n      }\n\n      /**\n       * Process next token\n       */\n      skipNextToken = false\n    })\n\n    return newValue\n  }\n\n  /**\n   * Parse the env string to an object of environment variables.\n   */\n  parse(): DotenvParseOutput {\n    const envCollection = dotenv.parse(this.#envContents.trim())\n\n    return Object.keys(envCollection).reduce<DotenvParseOutput>((result, key) => {\n      result[key] = this.#getValue(key, envCollection)\n      return result\n    }, {})\n  }\n}\n","/*\n * @adonisjs/application\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport debug from './debug.js'\nimport { EnvParser } from './parser.js'\nimport { EnvLoader } from './loader.js'\n\n/**\n * Env processors loads, parses and process environment variables.\n */\nexport class EnvProcessor {\n  /**\n   * App root is needed to load files\n   */\n  #appRoot: URL\n\n  constructor(appRoot: URL) {\n    this.#appRoot = appRoot\n  }\n\n  /**\n   * Parse env variables from raw contents\n   */\n  #processContents(envContents: string, store: Record<string, any>) {\n    /**\n     * Collected env variables\n     */\n    if (!envContents.trim()) {\n      return store\n    }\n\n    const values = new EnvParser(envContents).parse()\n    Object.keys(values).forEach((key) => {\n      let value = process.env[key]\n\n      if (!value) {\n        value = values[key]\n        process.env[key] = values[key]\n      }\n\n      if (!store[key]) {\n        store[key] = value\n      }\n    })\n\n    return store\n  }\n\n  /**\n   * Parse env variables by loading dot files.\n   */\n  async #loadAndProcessDotFiles() {\n    const loader = new EnvLoader(this.#appRoot)\n    const envFiles = await loader.load()\n\n    if (debug.enabled) {\n      debug(\n        'processing .env files (priority from top to bottom) %O',\n        envFiles.map((file) => file.path)\n      )\n    }\n\n    /**\n     * Collected env variables\n     */\n    const envValues: Record<string, any> = {}\n    envFiles.forEach(({ contents }) => this.#processContents(contents, envValues))\n    return envValues\n  }\n\n  /**\n   * Process env variables\n   */\n  async process() {\n    return this.#loadAndProcessDotFiles()\n  }\n}\n"],"mappings":"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","names":[]}

package/build/src/editor.js

@@ -1,67 +1,68 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import splitLines from 'split-lines';
-import lodash from '@poppinss/utils/lodash';
-import { writeFile } from 'node:fs/promises';
-import { EnvLoader } from './loader.js';
-export class EnvEditor {
-    #appRoot;
-    #loader;
-    #files = [];
-    /**
-     * Creates an instance of env editor and loads .env files
-     * contents.
-     */
-    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);
-    }
-    /**
-     * Loads .env files for editing. Only ".env" and ".env.example"
-     * files are picked for editing.
-     */
-    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.
-     */
-    add(key, value) {
-        this.#files.forEach((file) => {
-            let entryIndex = file.contents.findIndex((line) => line.startsWith(`${key}=`));
-            entryIndex = entryIndex === -1 ? file.contents.length : entryIndex;
-            lodash.set(file.contents, entryIndex, `${key}=${String(value)}`);
-        });
-    }
-    toJSON() {
-        return this.#files;
-    }
-    /**
-     * Save changes to the disk
-     */
-    async save() {
-        await Promise.all(this.#files.map((file) => {
-            return writeFile(file.path, file.contents.join('\n'));
-        }));
-    }
-}
+import {
+  EnvLoader
+} from "../chunk-H6UKLEIO.js";
+
+// src/editor.ts
+import splitLines from "split-lines";
+import lodash from "@poppinss/utils/lodash";
+import { writeFile } from "node:fs/promises";
+var EnvEditor = class _EnvEditor {
+  #appRoot;
+  #loader;
+  #files = [];
+  /**
+   * Creates an instance of env editor and loads .env files
+   * contents.
+   */
+  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);
+  }
+  /**
+   * Loads .env files for editing. Only ".env" and ".env.example"
+   * files are picked for editing.
+   */
+  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.
+   */
+  add(key, value) {
+    this.#files.forEach((file) => {
+      let entryIndex = file.contents.findIndex((line) => line.startsWith(`${key}=`));
+      entryIndex = entryIndex === -1 ? file.contents.length : entryIndex;
+      lodash.set(file.contents, entryIndex, `${key}=${String(value)}`);
+    });
+  }
+  toJSON() {
+    return this.#files;
+  }
+  /**
+   * Save changes to the disk
+   */
+  async save() {
+    await Promise.all(
+      this.#files.map((file) => {
+        return writeFile(file.path, file.contents.join("\n"));
+      })
+    );
+  }
+};
+export {
+  EnvEditor
+};
+//# sourceMappingURL=editor.js.map

package/build/src/editor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/editor.ts"],"sourcesContent":["/*\n * @adonisjs/env\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport splitLines from 'split-lines'\nimport lodash from '@poppinss/utils/lodash'\nimport { writeFile } from 'node:fs/promises'\n\nimport { EnvLoader } from './loader.js'\n\nexport class EnvEditor {\n  #appRoot: URL\n  #loader: EnvLoader\n  #files: { contents: string[]; path: string }[] = []\n\n  /**\n   * Creates an instance of env editor and loads .env files\n   * contents.\n   */\n  static async create(appRoot: URL) {\n    const editor = new EnvEditor(appRoot)\n    await editor.load()\n\n    return editor\n  }\n\n  constructor(appRoot: URL) {\n    this.#appRoot = appRoot\n    this.#loader = new EnvLoader(this.#appRoot, true)\n  }\n\n  /**\n   * Loads .env files for editing. Only \".env\" and \".env.example\"\n   * files are picked for editing.\n   */\n  async load() {\n    const envFiles = await this.#loader.load()\n\n    this.#files = envFiles\n      .filter(\n        (envFile) =>\n          envFile.fileExists &&\n          (envFile.path.endsWith('.env') || envFile.path.endsWith('.env.example'))\n      )\n      .map((envFile) => {\n        return {\n          contents: splitLines(envFile.contents.trim()),\n          path: envFile.path,\n        }\n      })\n  }\n\n  /**\n   * Add key-value pair to the dot-env files.\n   */\n  add(key: string, value: string | number | boolean) {\n    this.#files.forEach((file) => {\n      let entryIndex = file.contents.findIndex((line) => line.startsWith(`${key}=`))\n\n      entryIndex = entryIndex === -1 ? file.contents.length : entryIndex\n      lodash.set(file.contents, entryIndex, `${key}=${String(value)}`)\n    })\n  }\n\n  toJSON() {\n    return this.#files\n  }\n\n  /**\n   * Save changes to the disk\n   */\n  async save() {\n    await Promise.all(\n      this.#files.map((file) => {\n        return writeFile(file.path, file.contents.join('\\n'))\n      })\n    )\n  }\n}\n"],"mappings":";;;;;AASA,OAAO,gBAAgB;AACvB,OAAO,YAAY;AACnB,SAAS,iBAAiB;AAInB,IAAM,YAAN,MAAM,WAAU;AAAA,EACrB;AAAA,EACA;AAAA,EACA,SAAiD,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMlD,aAAa,OAAO,SAAc;AAChC,UAAM,SAAS,IAAI,WAAU,OAAO;AACpC,UAAM,OAAO,KAAK;AAElB,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,SAAc;AACxB,SAAK,WAAW;AAChB,SAAK,UAAU,IAAI,UAAU,KAAK,UAAU,IAAI;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,OAAO;AACX,UAAM,WAAW,MAAM,KAAK,QAAQ,KAAK;AAEzC,SAAK,SAAS,SACX;AAAA,MACC,CAAC,YACC,QAAQ,eACP,QAAQ,KAAK,SAAS,MAAM,KAAK,QAAQ,KAAK,SAAS,cAAc;AAAA,IAC1E,EACC,IAAI,CAAC,YAAY;AAChB,aAAO;AAAA,QACL,UAAU,WAAW,QAAQ,SAAS,KAAK,CAAC;AAAA,QAC5C,MAAM,QAAQ;AAAA,MAChB;AAAA,IACF,CAAC;AAAA,EACL;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,KAAa,OAAkC;AACjD,SAAK,OAAO,QAAQ,CAAC,SAAS;AAC5B,UAAI,aAAa,KAAK,SAAS,UAAU,CAAC,SAAS,KAAK,WAAW,GAAG,GAAG,GAAG,CAAC;AAE7E,mBAAa,eAAe,KAAK,KAAK,SAAS,SAAS;AACxD,aAAO,IAAI,KAAK,UAAU,YAAY,GAAG,GAAG,IAAI,OAAO,KAAK,CAAC,EAAE;AAAA,IACjE,CAAC;AAAA,EACH;AAAA,EAEA,SAAS;AACP,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OAAO;AACX,UAAM,QAAQ;AAAA,MACZ,KAAK,OAAO,IAAI,CAAC,SAAS;AACxB,eAAO,UAAU,KAAK,MAAM,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,MACtD,CAAC;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@adonisjs/env",
-  "version": "4.2.0-5",
+  "version": "4.2.0-7",
   "description": "Environment variable manager for Node.js",
   "main": "build/index.js",
   "type": "module",
   "files": [
-    "build/src",
-    "build/index.d.ts",
-    "build/index.js"
+    "build",
+    "!build/bin",
+    "!build/examples",
+    "!build/tests"
   ],
   "exports": {
     ".": "./build/index.js",
@@ -21,7 +22,8 @@
     "test": "cross-env NODE_DEBUG=adonisjs:env c8 npm run quick:test",
     "clean": "del-cli build",
     "typecheck": "tsc --noEmit",
-    "compile": "npm run lint && npm run clean && tsc",
+    "precompile": "npm run lint && npm run clean",
+    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
     "release": "np",
     "version": "npm run build",
@@ -38,30 +40,31 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/eslint-config": "^1.1.8",
-    "@adonisjs/prettier-config": "^1.1.8",
-    "@adonisjs/tsconfig": "^1.1.8",
-    "@commitlint/cli": "^17.7.1",
-    "@commitlint/config-conventional": "^17.7.0",
-    "@japa/assert": "^2.0.0-1",
-    "@japa/expect-type": "^2.0.0-0",
-    "@japa/file-system": "^2.0.0-1",
-    "@japa/runner": "^3.0.0-3",
-    "@swc/core": "^1.3.78",
-    "@types/node": "^20.5.3",
+    "@adonisjs/eslint-config": "^1.1.9",
+    "@adonisjs/prettier-config": "^1.1.9",
+    "@adonisjs/tsconfig": "^1.1.9",
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3",
+    "@japa/assert": "^2.0.1",
+    "@japa/expect-type": "^2.0.0",
+    "@japa/file-system": "^2.0.1",
+    "@japa/runner": "^3.1.0",
+    "@swc/core": "^1.3.99",
+    "@types/node": "^20.9.4",
     "c8": "^8.0.1",
     "cross-env": "^7.0.3",
-    "del-cli": "^5.0.0",
-    "eslint": "^8.47.0",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.54.0",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
     "np": "^8.0.4",
-    "prettier": "^3.0.2",
+    "prettier": "^3.1.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.1.6"
+    "tsup": "^8.0.1",
+    "typescript": "5.2.2"
   },
   "dependencies": {
-    "@poppinss/utils": "^6.5.0-5",
+    "@poppinss/utils": "^6.5.1",
     "@poppinss/validator-lite": "^1.0.3",
     "dotenv": "^16.3.1",
     "split-lines": "^3.0.0"
@@ -101,5 +104,17 @@
   "eslintConfig": {
     "extends": "@adonisjs/eslint-config/package"
   },
-  "prettier": "@adonisjs/prettier-config"
+  "prettier": "@adonisjs/prettier-config",
+  "tsup": {
+    "entry": [
+      "./index.ts",
+      "./src/editor.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": false,
+    "sourcemap": true,
+    "target": "esnext"
+  }
 }

package/build/src/debug.js

@@ -1,10 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { debuglog } from 'node:util';
-export default debuglog('adonisjs:env');

package/build/src/env.js

@@ -1,80 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { schema as envSchema } from '@poppinss/validator-lite';
-import { EnvValidator } from './validator.js';
-import { EnvProcessor } from './processor.js';
-/**
- * A wrapper over "process.env" with types information.
- *
- * ```ts
- * const validate = Env.rules({
- *   PORT: Env.schema.number()
- * })
- *
- * const validatedEnvVars = validate(process.env)
- *
- * const env = new EnvValues(validatedEnvVars)
- * env.get('PORT') // type === number
- * ```
- */
-export class Env {
-    /**
-     * A cache of env values
-     */
-    #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
-     */
-    static async create(appRoot, schema) {
-        const values = await new EnvProcessor(appRoot).process();
-        const validator = this.rules(schema);
-        return new Env(validator.validate(values));
-    }
-    /**
-     * 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
-     */
-    static rules(schema) {
-        const validator = new EnvValidator(schema);
-        return validator;
-    }
-    get(key, defaultValue) {
-        /**
-         * Return cached value
-         */
-        if (this.#values[key] !== undefined) {
-            return this.#values[key];
-        }
-        /**
-         * Get value from "process.env" and update the cache
-         */
-        const envValue = process.env[key];
-        if (envValue) {
-            return envValue;
-        }
-        /**
-         * Return default value when unable to lookup any other value
-         */
-        return defaultValue;
-    }
-    set(key, value) {
-        this.#values[key] = value;
-        process.env[key] = value;
-    }
-}

package/build/src/exceptions.js

@@ -1,18 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { Exception } from '@poppinss/utils';
-/**
- * Exception raised when one or more env variables
- * are invalid
- */
-export 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 = '';
-};

package/build/src/loader.js

@@ -1,134 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { fileURLToPath } from 'node:url';
-import { readFile } from 'node:fs/promises';
-import { isAbsolute, join } from 'node:path';
-import debug from './debug.js';
-/**
- * Read the contents of one or more dot-env files. Following is how the files
- * are read.
- *
- * - Load file from the "ENV_PATH" environment file.
- *    (Raise error if file is missing)
- *
- * - If "ENV_PATH" is not defined, then find ".env" file in the app root.
- *    (Ignore if file is missing)
- *
- * - Find ".env.[NODE_ENV]" file in the app root.
- *    (Ignore if file is missing)
- *
- * ```ts
- * const loader = new EnvLoader(new URL('./', import.meta.url))
- *
- * const { envContents, currentEnvContents } = await loader.load()
- *
- * // envContents: Contents of .env or file specified via ENV_PATH
- * // currentEnvContents: Contents of .env.[NODE_ENV] file
- * ```
- */
-export class EnvLoader {
-    #appRoot;
-    #loadExampleFile;
-    constructor(appRoot, loadExampleFile = false) {
-        this.#appRoot = typeof appRoot === 'string' ? appRoot : fileURLToPath(appRoot);
-        this.#loadExampleFile = loadExampleFile;
-    }
-    /**
-     * Optionally read a file from the disk
-     */
-    async #loadFile(filePath) {
-        try {
-            const contents = await readFile(filePath, 'utf-8');
-            return { contents, fileExists: true };
-        }
-        catch (error) {
-            /* c8 ignore next 3 */
-            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
-     */
-    async load() {
-        const ENV_PATH = process.env.ENV_PATH;
-        const NODE_ENV = process.env.NODE_ENV;
-        const envFiles = [];
-        if (debug.enabled) {
-            debug('ENV_PATH variable is %s', ENV_PATH ? 'set' : 'not set');
-            debug('NODE_ENV variable is %s', NODE_ENV ? 'set' : 'not set');
-        }
-        /**
-         * Base path to load .env files from
-         */
-        const baseEnvPath = ENV_PATH
-            ? isAbsolute(ENV_PATH)
-                ? ENV_PATH
-                : join(this.#appRoot, ENV_PATH)
-            : this.#appRoot;
-        if (debug.enabled) {
-            debug('dot-env files base path "%s"', baseEnvPath);
-        }
-        /**
-         * 1st
-         * The top most priority is given to the ".env.[NODE_ENV].local" file
-         */
-        if (NODE_ENV) {
-            const nodeEnvLocalFile = join(baseEnvPath, `.env.${NODE_ENV}.local`);
-            envFiles.push({
-                path: nodeEnvLocalFile,
-                ...(await this.#loadFile(nodeEnvLocalFile)),
-            });
-        }
-        /**
-         * 2nd
-         * Next, we give priority to the ".env.local" file
-         */
-        if (!NODE_ENV || !['test', 'testing'].includes(NODE_ENV)) {
-            const envLocalFile = join(baseEnvPath, '.env.local');
-            envFiles.push({
-                path: envLocalFile,
-                ...(await this.#loadFile(envLocalFile)),
-            });
-        }
-        /**
-         * 3rd
-         * Next, we give priority to the ".env.[NODE_ENV]" file
-         */
-        if (NODE_ENV) {
-            const nodeEnvFile = join(baseEnvPath, `.env.${NODE_ENV}`);
-            envFiles.push({
-                path: nodeEnvFile,
-                ...(await this.#loadFile(nodeEnvFile)),
-            });
-        }
-        /**
-         * Finally, we push the contents of the ".env" file.
-         */
-        const envFile = join(baseEnvPath, '.env');
-        envFiles.push({
-            path: envFile,
-            ...(await this.#loadFile(envFile)),
-        });
-        /**
-         * Load example file
-         */
-        if (this.#loadExampleFile) {
-            const envExampleFile = join(baseEnvPath, '.env.example');
-            envFiles.push({
-                path: envExampleFile,
-                ...(await this.#loadFile(envExampleFile)),
-            });
-        }
-        return envFiles;
-    }
-}

package/build/src/parser.js

@@ -1,166 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import dotenv 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
- * ```
- *
- * The variables can reference other environment variables as well using `$`.
- * For example:
- *
- * ```dotenv
- * PORT=3333
- * REDIS_PORT=$PORT
- * ```
- *
- * 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
- * ```
- *
- * ## Usage
- *
- * ```ts
- * const parser = new EnvParser(envContents)
- * const output = parser.parse()
- *
- * // The output is a key-value pair
- * ```
- */
-export class EnvParser {
-    #envContents;
-    #preferProcessEnv = true;
-    constructor(envContents, options) {
-        if (options?.ignoreProcessEnv) {
-            this.#preferProcessEnv = false;
-        }
-        this.#envContents = envContents;
-    }
-    /**
-     * Returns the value from the parsed object
-     */
-    #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.
-     */
-    #interpolateMustache(token, parsed) {
-        /**
-         * Finding the closing brace. If closing brace is missing, we
-         * consider the block as a normal string
-         */
-        const closingBrace = token.indexOf('}');
-        if (closingBrace === -1) {
-            return token;
-        }
-        /**
-         * Then we pull everything until the closing brace, except
-         * the opening brace and trim off all white spaces.
-         */
-        const varReference = token.slice(1, closingBrace).trim();
-        /**
-         * Getting the value of the reference inside the braces
-         */
-        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.
-     */
-    #interpolateVariable(token, parsed) {
-        return token.replace(/[a-zA-Z0-9_]+/, (key) => {
-            return this.#getValue(key, parsed);
-        });
-    }
-    /**
-     * Interpolates the referenced values
-     */
-    #interpolate(value, parsed) {
-        const tokens = value.split('$');
-        let newValue = '';
-        let skipNextToken = true;
-        tokens.forEach((token) => {
-            /**
-             * If the value is an escaped sequence, then we replace it
-             * with a `$` and then skip the next token.
-             */
-            if (token === '\\') {
-                newValue += '$';
-                skipNextToken = true;
-                return;
-            }
-            /**
-             * Use the value as it is when "skipNextToken" is set to true.
-             */
-            if (skipNextToken) {
-                /**
-                 * Replace the ending escape sequence with a $
-                 */
-                newValue += token.replace(/\\$/, '$');
-                /**
-                 *  and then skip the next token if it ends with escape sequence
-                 */
-                if (token.endsWith('\\')) {
-                    return;
-                }
-            }
-            else {
-                /**
-                 * Handle mustache block
-                 */
-                if (token.startsWith('{')) {
-                    newValue += this.#interpolateMustache(token, parsed);
-                    return;
-                }
-                /**
-                 * Process all words as variable
-                 */
-                newValue += this.#interpolateVariable(token, parsed);
-            }
-            /**
-             * Process next token
-             */
-            skipNextToken = false;
-        });
-        return newValue;
-    }
-    /**
-     * Parse the env string to an object of environment variables.
-     */
-    parse() {
-        const envCollection = dotenv.parse(this.#envContents.trim());
-        return Object.keys(envCollection).reduce((result, key) => {
-            result[key] = this.#getValue(key, envCollection);
-            return result;
-        }, {});
-    }
-}

package/build/src/processor.js

@@ -1,68 +0,0 @@
-/*
- * @adonisjs/application
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import debug from './debug.js';
-import { EnvParser } from './parser.js';
-import { EnvLoader } from './loader.js';
-/**
- * Env processors loads, parses and process environment variables.
- */
-export class EnvProcessor {
-    /**
-     * App root is needed to load files
-     */
-    #appRoot;
-    constructor(appRoot) {
-        this.#appRoot = appRoot;
-    }
-    /**
-     * Parse env variables from raw contents
-     */
-    #processContents(envContents, store) {
-        /**
-         * Collected env variables
-         */
-        if (!envContents.trim()) {
-            return store;
-        }
-        const values = new EnvParser(envContents).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.
-     */
-    async #loadAndProcessDotFiles() {
-        const loader = new EnvLoader(this.#appRoot);
-        const envFiles = await loader.load();
-        if (debug.enabled) {
-            debug('processing .env files (priority from top to bottom) %O', envFiles.map((file) => file.path));
-        }
-        /**
-         * Collected env variables
-         */
-        const envValues = {};
-        envFiles.forEach(({ contents }) => this.#processContents(contents, envValues));
-        return envValues;
-    }
-    /**
-     * Process env variables
-     */
-    async process() {
-        return this.#loadAndProcessDotFiles();
-    }
-}

package/build/src/validator.js

@@ -1,48 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { E_INVALID_ENV_VARIABLES } from './exceptions.js';
-/**
- * Exposes the API to validate environment variables against a
- * pre-defined schema.
- *
- * The class is not exported in the main API and used internally.
- */
-export class EnvValidator {
-    #schema;
-    #error;
-    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.
-     */
-    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;
-    }
-}