@adonisjs/env 3.0.9 → 4.0.0-0

package/build/adonis-typings/env.d.ts

@@ -1,127 +0,0 @@
-declare module '@ioc:Adonis/Core/Env' {
-    /**
-     * An interface meant to be extended in the user land that holds
-     * types for environment variables extracted using env.validate
-     * method.
-     */
-    export interface EnvTypes {
-    }
-    /**
-     * The shape of the validate fn
-     */
-    export type ValidateFn<T extends unknown> = (key: string, value?: string) => T;
-    /**
-     * A standard set of options accepted by the schema validation
-     * functions
-     */
-    export type SchemaFnOptions = {
-        message?: string;
-    };
-    export type StringFnUrlOptions = SchemaFnOptions & {
-        format: 'url';
-        /**
-         * Whether the URL must have a valid TLD in their domain.
-         * Defaults to `true`.
-         */
-        tld?: boolean;
-        /**
-         * Whether the URL must start with a valid protocol.
-         * Defaults to `true`.
-         */
-        protocol?: boolean;
-    };
-    /**
-     * Options accepted by the string schema function
-     */
-    export type StringFnOptions = (SchemaFnOptions & {
-        format?: 'host' | 'email';
-    }) | StringFnUrlOptions;
-    /**
-     * Shape of the number validator
-     */
-    export interface NumberType {
-        (options?: SchemaFnOptions): ValidateFn<number>;
-        optional: (options?: SchemaFnOptions) => ValidateFn<number | undefined>;
-    }
-    /**
-     * Shape of the string validator
-     */
-    export interface StringType {
-        (options?: StringFnOptions): ValidateFn<string>;
-        optional: (options?: StringFnOptions) => ValidateFn<string | undefined>;
-    }
-    /**
-     * Shape of the boolean validator
-     */
-    export interface BooleanType {
-        (options?: SchemaFnOptions): ValidateFn<boolean>;
-        optional: (options?: SchemaFnOptions) => ValidateFn<boolean | undefined>;
-    }
-    /**
-     * Shape of the enum validator
-     */
-    export interface EnumType {
-        <K extends any>(choices: readonly K[], options?: SchemaFnOptions): ValidateFn<K>;
-        optional: <K extends any>(choices: readonly K[], options?: SchemaFnOptions) => ValidateFn<K | undefined>;
-    }
-    /**
-     * Available schema functions. The end user can also define their
-     * own
-     */
-    export interface EnvSchema {
-        /**
-         * Number function to enforce value to be a strict number
-         */
-        number: NumberType;
-        /**
-         * String function to enforce value to be a string. Optionally
-         * the format can also be defined
-         */
-        string: StringType;
-        /**
-         * Boolean function to enforce value to be a boolean value.
-         */
-        boolean: BooleanType;
-        /**
-         * Boolean function to enforce value to be one of the defined values.
-         */
-        enum: EnumType;
-    }
-    /**
-     * Env contract
-     */
-    export interface EnvContract {
-        /**
-         * Get value for a given environment variable
-         */
-        get<K extends keyof EnvTypes>(key: K): EnvTypes[K];
-        get<K extends keyof EnvTypes>(key: K, defaultValue: Exclude<EnvTypes[K], undefined>): Exclude<EnvTypes[K], undefined>;
-        get(key: string, defaultValue?: any): any;
-        /**
-         * Update/set value for a given environment variable. Ideally one should
-         * avoid updating values during runtime
-         */
-        set<K extends keyof EnvTypes>(key: K, value: EnvTypes[K]): void;
-        set(key: string, value: any): void;
-        /**
-         * Validate environment variables
-         */
-        rules<T extends {
-            [key: string]: ValidateFn<unknown>;
-        }>(values: T): {
-            [K in keyof T]: ReturnType<T[K]>;
-        };
-        /**
-         * Processes environment variables and performs the registered
-         * validations
-         */
-        process(): void;
-        /**
-         * Reference to the schema object for defining validation
-         * rules
-         */
-        schema: EnvSchema;
-    }
-    const Env: EnvContract;
-    export default Env;
-}

package/build/adonis-typings/env.js

@@ -1,8 +0,0 @@
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */

package/build/src/Env/index.d.ts

@@ -1,59 +0,0 @@
-/// <reference path="../../adonis-typings/env.d.ts" />
-import { DotenvParseOutput } from 'dotenv';
-import { EnvContract, ValidateFn } from '@ioc:Adonis/Core/Env';
-/**
- * The ENV module enables the use of environment variables by parsing dotfiles syntax
- * and updates the `process.env` object in Node.js.
- *
- * AdonisJs automatically reads and passes the contents of `.env` file to this class.
- */
-export declare class Env implements EnvContract {
-    private valuesToProcess;
-    /**
-     * A boolean to know if the values have been processed or
-     * not
-     */
-    private hasProcessedValues;
-    /**
-     * A cache of env values
-     */
-    private envCache;
-    /**
-     * The schema to be used for validating and casting environment
-     * variables
-     */
-    private validationSchema;
-    constructor(valuesToProcess: {
-        values: DotenvParseOutput;
-        overwriteExisting: boolean;
-    }[]);
-    /**
-     * Reference to the underlying schema
-     */
-    schema: import("@ioc:Adonis/Core/Env").EnvSchema;
-    /**
-     * Process parsed env variables. The values will be validated
-     * against the validation schema
-     */
-    process(): void;
-    /**
-     * Register the validation schema
-     */
-    rules(schema: {
-        [key: string]: ValidateFn<unknown>;
-    }): any;
-    /**
-     * Returns the environment variable value. First the cached
-     * values are preferred. When missing, the value from
-     * "process.env" is used
-     */
-    get(key: string, defaultValue?: any): any;
-    /**
-     * Set key-value pair. The value will be validated using
-     * the validation rule if exists.
-     *
-     * The original value is also updated on the `process.env`
-     * object
-     */
-    set(key: string, value: any): void;
-}

package/build/src/Env/index.js

@@ -1,140 +0,0 @@
-"use strict";
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Env = void 0;
-const Schema_1 = require("../Schema");
-/**
- * The ENV module enables the use of environment variables by parsing dotfiles syntax
- * and updates the `process.env` object in Node.js.
- *
- * AdonisJs automatically reads and passes the contents of `.env` file to this class.
- */
-class Env {
-    constructor(valuesToProcess) {
-        this.valuesToProcess = valuesToProcess;
-        /**
-         * A boolean to know if the values have been processed or
-         * not
-         */
-        this.hasProcessedValues = false;
-        /**
-         * A cache of env values
-         */
-        this.envCache = {};
-        /**
-         * The schema to be used for validating and casting environment
-         * variables
-         */
-        this.validationSchema = {};
-        /**
-         * Reference to the underlying schema
-         */
-        this.schema = Schema_1.schema;
-    }
-    /**
-     * Process parsed env variables. The values will be validated
-     * against the validation schema
-     */
-    process() {
-        /**
-         * Avoid re-processing the same values over and over
-         * again
-         */
-        if (this.hasProcessedValues) {
-            return;
-        }
-        this.hasProcessedValues = true;
-        /**
-         * Loop over the parsed object and set the value
-         * on the process.env and the local cache.
-         *
-         * At this stage we process the values like a regular env parser with
-         * no validation taking place
-         */
-        this.valuesToProcess.forEach(({ values, overwriteExisting }) => {
-            Object.keys(values).forEach((key) => {
-                /**
-                 * Use existing value when it already exists in process.env object
-                 * and [this.overwriteExisting] is set to false
-                 */
-                const existingValue = process.env[key];
-                if (existingValue && !overwriteExisting) {
-                    this.envCache[key] = existingValue;
-                    return;
-                }
-                /**
-                 * Otherwise set the value on "process.env"
-                 */
-                this.envCache[key] = values[key];
-                process.env[key] = values[key];
-            });
-        });
-        /**
-         * Release parsed values, since we don't need it anymore
-         */
-        this.valuesToProcess = [];
-        /**
-         * Perform validations by reading the environment variables
-         */
-        Object.keys(this.validationSchema).forEach((key) => {
-            this.envCache[key] = this.validationSchema[key](key, this.get(key));
-        });
-    }
-    /**
-     * Register the validation schema
-     */
-    rules(schema) {
-        this.validationSchema = schema;
-        return {};
-    }
-    /**
-     * Returns the environment variable value. First the cached
-     * values are preferred. When missing, the value from
-     * "process.env" is used
-     */
-    get(key, defaultValue) {
-        /**
-         * Return cached value
-         */
-        if (this.envCache[key] !== undefined) {
-            return this.envCache[key];
-        }
-        /**
-         * Get value from process.env and update the cache
-         */
-        const envValue = process.env[key];
-        if (envValue) {
-            this.envCache[key] = envValue;
-            return envValue;
-        }
-        /**
-         * Return default value when unable to lookup any other value
-         */
-        return defaultValue;
-    }
-    /**
-     * Set key-value pair. The value will be validated using
-     * the validation rule if exists.
-     *
-     * The original value is also updated on the `process.env`
-     * object
-     */
-    set(key, value) {
-        const validationFn = this.validationSchema[key];
-        if (validationFn) {
-            this.envCache[key] = validationFn(key, value);
-        }
-        else {
-            this.envCache[key] = value;
-        }
-        process.env[key] = value;
-    }
-}
-exports.Env = Env;

package/build/src/Parser/index.d.ts

@@ -1,54 +0,0 @@
-/**
- * Env parser parses the environment variables from a string formatted
- * as a key-value pair seperated using an `=`. For example:
- *
- * ```
- * PORT=3333
- * HOST=127.0.0.1
- * ```
- *
- * The variables can reference other environment variables as well using `$`.
- * For example:
- *
- * ```
- * PORT=3333
- * REDIS_PORT=$PORT
- * ```
- *
- * The variables using characters other than letters can use wrap variables inside
- * a curly brace.
- *
- * ```
- * APP-PORT=3333
- * REDIS_PORT=${APP-PORT}
- * ```
- */
-export declare class EnvParser {
-    private preferExistingEnvVariables;
-    constructor(preferExistingEnvVariables?: boolean);
-    /**
-     * Returns value for a given key from the environment variables. Also
-     * the current parsed object is used to pull the reference.
-     */
-    private getValue;
-    /**
-     * Interpolating the token wrapped inside the mustache
-     * braces.
-     */
-    private interpolateMustache;
-    /**
-     * Interpolating the variable reference starting with a
-     * `$`. We only capture numbers,letter and underscore.
-     * For other characters, one can use the mustache
-     * braces.
-     */
-    private interpolateVariable;
-    /**
-     * Interpolates the referenced values
-     */
-    private interpolate;
-    /**
-     * Parse the env string to an object of environment variables.
-     */
-    parse(envString: string): {};
-}

package/build/src/Parser/index.js

@@ -1,172 +0,0 @@
-"use strict";
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvParser = void 0;
-const dotenv_1 = __importDefault(require("dotenv"));
-/**
- * Env parser parses the environment variables from a string formatted
- * as a key-value pair seperated using an `=`. For example:
- *
- * ```
- * PORT=3333
- * HOST=127.0.0.1
- * ```
- *
- * The variables can reference other environment variables as well using `$`.
- * For example:
- *
- * ```
- * PORT=3333
- * REDIS_PORT=$PORT
- * ```
- *
- * The variables using characters other than letters can use wrap variables inside
- * a curly brace.
- *
- * ```
- * APP-PORT=3333
- * REDIS_PORT=${APP-PORT}
- * ```
- */
-class EnvParser {
-    constructor(preferExistingEnvVariables = true) {
-        this.preferExistingEnvVariables = preferExistingEnvVariables;
-    }
-    /**
-     * Returns value for a given key from the environment variables. Also
-     * the current parsed object is used to pull the reference.
-     */
-    getValue(key, parsed) {
-        /**
-         * When existing env variables are preferred, then we lookup the
-         * value inside `process.env` first.
-         */
-        if (this.preferExistingEnvVariables) {
-            if (process.env[key]) {
-                return process.env[key];
-            }
-            if (parsed[key]) {
-                return this.interpolate(parsed[key], parsed);
-            }
-            return '';
-        }
-        /**
-         * Otherwise we lookup the value inside the parsed object
-         * first
-         */
-        if (parsed[key]) {
-            return this.interpolate(parsed[key], parsed);
-        }
-        if (process.env[key]) {
-            return process.env[key];
-        }
-        return '';
-    }
-    /**
-     * 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(envString) {
-        const envCollection = dotenv_1.default.parse(envString.trim());
-        return Object.keys(envCollection).reduce((result, key) => {
-            result[key] = this.interpolate(envCollection[key], envCollection);
-            return result;
-        }, {});
-    }
-}
-exports.EnvParser = EnvParser;

package/build/src/Schema/boolean.d.ts

@@ -1,10 +0,0 @@
-import { SchemaFnOptions } from '@ioc:Adonis/Core/Env';
-/**
- * Enforces the value to be of type boolean. Also casts
- * string representation of a boolean to a boolean
- * type
- */
-export declare function boolean(options?: SchemaFnOptions): (key: string, value?: string | undefined) => boolean;
-export declare namespace boolean {
-    var optional: (options?: SchemaFnOptions | undefined) => (key: string, value?: string | undefined) => boolean | undefined;
-}

package/build/src/Schema/boolean.js

@@ -1,49 +0,0 @@
-"use strict";
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.boolean = void 0;
-const utils_1 = require("@poppinss/utils");
-const helpers_1 = require("./helpers");
-/**
- * Casts a string value to a boolean
- */
-function castToBoolean(key, value, message) {
-    if (helpers_1.BOOLEAN_POSITIVES.includes(value)) {
-        return true;
-    }
-    if (helpers_1.BOOLEAN_NEGATIVES.includes(value)) {
-        return false;
-    }
-    throw new utils_1.Exception(message ||
-        `Value for environment variable "${key}" must be a boolean, instead received "${value}"`, 500, 'E_INVALID_ENV_VALUE');
-}
-/**
- * Enforces the value to be of type boolean. Also casts
- * string representation of a boolean to a boolean
- * type
- */
-function boolean(options) {
-    return function validate(key, value) {
-        (0, helpers_1.ensureValue)(key, value, options?.message);
-        return castToBoolean(key, value, options?.message);
-    };
-}
-exports.boolean = boolean;
-/**
- * Same as boolean, but allows undefined values as well.
- */
-boolean.optional = function optionalBoolean(options) {
-    return function validate(key, value) {
-        if (!value) {
-            return undefined;
-        }
-        return castToBoolean(key, value, options?.message);
-    };
-};

package/build/src/Schema/helpers.d.ts

@@ -1,12 +0,0 @@
-/**
- * Following values are considered as "true"
- */
-export declare const BOOLEAN_POSITIVES: (string | number | boolean)[];
-/**
- * Following values are considered as "false"
- */
-export declare const BOOLEAN_NEGATIVES: (string | number | boolean)[];
-/**
- * Ensures the value to exist
- */
-export declare function ensureValue(key: string, value?: string, message?: string): asserts value is string;

package/build/src/Schema/helpers.js

@@ -1,29 +0,0 @@
-"use strict";
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureValue = exports.BOOLEAN_NEGATIVES = exports.BOOLEAN_POSITIVES = void 0;
-const utils_1 = require("@poppinss/utils");
-/**
- * Following values are considered as "true"
- */
-exports.BOOLEAN_POSITIVES = ['1', 1, 'true', true];
-/**
- * Following values are considered as "false"
- */
-exports.BOOLEAN_NEGATIVES = ['0', 0, 'false', false];
-/**
- * Ensures the value to exist
- */
-function ensureValue(key, value, message) {
-    if (!value) {
-        throw new utils_1.Exception(message || `Missing environment variable "${key}"`, 500, 'E_MISSING_ENV_VALUE');
-    }
-}
-exports.ensureValue = ensureValue;

package/build/src/Schema/index.d.ts

@@ -1,2 +0,0 @@
-import { EnvSchema } from '@ioc:Adonis/Core/Env';
-export declare const schema: EnvSchema;

package/build/src/Schema/index.js

@@ -1,21 +0,0 @@
-"use strict";
-/*
- * @adonisjs/env
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = void 0;
-const number_1 = require("./number");
-const string_1 = require("./string");
-const boolean_1 = require("./boolean");
-const oneOf_1 = require("./oneOf");
-exports.schema = {
-    number: number_1.number,
-    string: string_1.string,
-    boolean: boolean_1.boolean,
-    enum: oneOf_1.oneOf,
-};