@adonisjs/env 4.2.0-4 → 4.2.0-6

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.d.ts

@@ -1,12 +0,0 @@
-/// <reference types="@types/node" resolution-mode="require"/>
-/**
- * Env processors loads, parses and process environment variables.
- */
-export declare class EnvProcessor {
-    #private;
-    constructor(appRoot: URL);
-    /**
-     * Process env variables
-     */
-    process(): Promise<Record<string, any>>;
-}

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.d.ts

@@ -1,25 +0,0 @@
-import { ValidateFn } from '@poppinss/validator-lite';
-/**
- * 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 declare class EnvValidator<Schema extends {
-    [key: string]: ValidateFn<unknown>;
-}> {
-    #private;
-    constructor(schema: Schema);
-    /**
-     * 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: {
-        [K: string]: string | undefined;
-    }): {
-        [K in keyof Schema]: ReturnType<Schema[K]>;
-    };
-}

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;
-    }
-}