deno.land / std@0.177.1 / dotenv / mod.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license./** * Load environment variables from `.env` files. * Inspired by the node module [`dotenv`](https://github.com/motdotla/dotenv) and * [`dotenv-expand`](https://github.com/motdotla/dotenv-expand). * * ```sh * # .env * GREETING=hello world * ``` * * Then import the configuration using the `load` function. * * ```ts * // app.ts * import { load } from "https://deno.land/std@$STD_VERSION/dotenv/mod.ts"; * * console.log(await load()); * ``` * * Then run your app. * * ```sh * > deno run --allow-env --allow-read app.ts * { GREETING: "hello world" } * ``` * * ## Auto loading * * `load.ts` automatically loads the local `.env` file on import and exports it to * the process environment: * * ```sh * # .env * GREETING=hello world * ``` * * ```ts * // app.ts * import "https://deno.land/std@$STD_VERSION/dotenv/load.ts"; * * console.log(Deno.env.get("GREETING")); * ``` * * ```sh * > deno run --allow-env --allow-read app.ts * hello world * ``` * * ## Parsing Rules * * The parsing engine currently supports the following rules: * * - Variables that already exist in the environment are not overridden with * `export: true` * - `BASIC=basic` becomes `{ BASIC: "basic" }` * - empty lines are skipped * - lines beginning with `#` are treated as comments * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`) * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes * `{ SINGLE_QUOTE: "quoted" }`) * - new lines are expanded in double quoted values (`MULTILINE="new\nline"` * becomes * * ``` * { MULTILINE: "new\nline" } * ``` * * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes * `{ JSON: "{\"foo\": \"bar\"}" }`) * - whitespace is removed from both ends of unquoted values (see more on * [`trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)) * (`FOO= some value` becomes `{ FOO: "some value" }`) * - whitespace is preserved on both ends of quoted values (`FOO=" some value "` * becomes `{ FOO: " some value " }`) * - dollar sign with an environment key in or without curly braces in unquoted * values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes * `{ KEY: "<KEY_VALUE_FROM_ENV>" }`) * - escaped dollar sign with an environment key in unquoted values will escape the * environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`) * - colon and a minus sign with a default value(which can also be another expand * value) in expanding construction in unquoted values will first attempt to * expand the environment key. If it’s not found, then it will return the default * value (`KEY=${KEY:-default}` If KEY exists it becomes * `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes * `{ KEY: "default" }`. Also there is possible to do this case * `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes * `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`) * * @module */
import { filterValues } from "../collections/filter_values.ts";import { withoutAll } from "../collections/without_all.ts";
type StrictDotenvConfig<T extends ReadonlyArray<string>> = & { [key in T[number]]: string; } & Record<string, string>;
type StrictEnvVarList<T extends string> = | Array<Extract<T, string>> | ReadonlyArray<Extract<T, string>>;
type StringList = Array<string> | ReadonlyArray<string> | undefined;
export interface LoadOptions { /** Optional path to `.env` file. * * @default {"./.env"} */ envPath?: string; /** * Set to `true` to export all `.env` variables to the current processes * environment. Variables are then accessable via `Deno.env.get(<key>)`. * * @default {false} */ export?: boolean; /** Optional path to `.env.example` file. * * @default {"./.env.example"} */ examplePath?: string; /** * Set to `true` to allow required env variables to be empty. Otherwise, it * will throw an error if any variable is empty. * * @default {false} */ allowEmptyValues?: boolean; /** * Path to `.env.defaults` file which is used to define default values. * * ```sh * # .env.defaults * # Will not be set if GREETING is set in base .env file * GREETING="a secret to everybody" * ``` * * @default {"./.env.defaults"} */ defaultsPath?: string; /** * List of Env variables to read from process. By default, the complete Env is * looked up. This allows to permit access to only specific Env variables with * `--allow-env=ENV_VAR_NAME`. */ restrictEnvAccessTo?: StringList;}type LineParseResult = { key: string; unquoted: string; interpolated: string; notInterpolated: string;};
type CharactersMap = { [key: string]: string };
const RE_KeyValue = /^\s*(?:export\s+)?(?<key>[a-zA-Z_]+[a-zA-Z0-9_]*?)\s*=[\ \t]*('\n?(?<notInterpolated>(.|\n)*?)\n?'|"\n?(?<interpolated>(.|\n)*?)\n?"|(?<unquoted>[^\n#]*)) *#*.*$/gm;
const RE_ExpandValue = /(\${(?<inBrackets>.+?)(\:-(?<inBracketsDefault>.+))?}|(?<!\\)\$(?<notInBrackets>\w+)(\:-(?<notInBracketsDefault>.+))?)/g;
export function parse( rawDotenv: string, restrictEnvAccessTo: StringList = [],): Record<string, string> { const env: Record<string, string> = {};
let match; const keysForExpandCheck = [];
while ((match = RE_KeyValue.exec(rawDotenv)) != null) { const { key, interpolated, notInterpolated, unquoted } = match ?.groups as LineParseResult;
if (unquoted) { keysForExpandCheck.push(key); }
env[key] = typeof notInterpolated === "string" ? notInterpolated : typeof interpolated === "string" ? expandCharacters(interpolated) : unquoted.trim(); }
//https://github.com/motdotla/dotenv-expand/blob/ed5fea5bf517a09fd743ce2c63150e88c8a5f6d1/lib/main.js#L23 const variablesMap = { ...env, ...readEnv(restrictEnvAccessTo) }; keysForExpandCheck.forEach((key) => { env[key] = expand(env[key], variablesMap); });
return env;}
export function loadSync( options?: Omit<LoadOptions, "restrictEnvAccessTo">,): Record<string, string>;export function loadSync<TEnvVar extends string>( options: Omit<LoadOptions, "restrictEnvAccessTo"> & { restrictEnvAccessTo: StrictEnvVarList<TEnvVar>; },): StrictDotenvConfig<StrictEnvVarList<TEnvVar>>;export function loadSync( { envPath = ".env", examplePath = ".env.example", defaultsPath = ".env.defaults", export: _export = false, allowEmptyValues = false, restrictEnvAccessTo = [], }: LoadOptions = {},): Record<string, string> { const conf = parseFileSync(envPath, restrictEnvAccessTo);
if (defaultsPath) { const confDefaults = parseFileSync(defaultsPath, restrictEnvAccessTo); for (const key in confDefaults) { if (!(key in conf)) { conf[key] = confDefaults[key]; } } }
if (examplePath) { const confExample = parseFileSync(examplePath, restrictEnvAccessTo); assertSafe(conf, confExample, allowEmptyValues, restrictEnvAccessTo); }
if (_export) { for (const key in conf) { if (Deno.env.get(key) !== undefined) continue; Deno.env.set(key, conf[key]); } }
return conf;}
export function load( options?: Omit<LoadOptions, "restrictEnvAccessTo">,): Promise<Record<string, string>>;export function load<TEnvVar extends string>( options: Omit<LoadOptions, "restrictEnvAccessTo"> & { restrictEnvAccessTo: StrictEnvVarList<TEnvVar>; },): Promise<StrictDotenvConfig<StrictEnvVarList<TEnvVar>>>;export async function load( { envPath = ".env", examplePath = ".env.example", defaultsPath = ".env.defaults", export: _export = false, allowEmptyValues = false, restrictEnvAccessTo = [], }: LoadOptions = {},): Promise<Record<string, string>> { const conf = await parseFile(envPath, restrictEnvAccessTo);
if (defaultsPath) { const confDefaults = await parseFile( defaultsPath, restrictEnvAccessTo, ); for (const key in confDefaults) { if (!(key in conf)) { conf[key] = confDefaults[key]; } } }
if (examplePath) { const confExample = await parseFile( examplePath, restrictEnvAccessTo, ); assertSafe(conf, confExample, allowEmptyValues, restrictEnvAccessTo); }
if (_export) { for (const key in conf) { if (Deno.env.get(key) !== undefined) continue; Deno.env.set(key, conf[key]); } }
return conf;}
function parseFileSync( filepath: string, restrictEnvAccessTo: StringList = [],): Record<string, string> { try { return parse(Deno.readTextFileSync(filepath), restrictEnvAccessTo); } catch (e) { if (e instanceof Deno.errors.NotFound) return {}; throw e; }}
async function parseFile( filepath: string, restrictEnvAccessTo: StringList = [],): Promise<Record<string, string>> { try { return parse(await Deno.readTextFile(filepath), restrictEnvAccessTo); } catch (e) { if (e instanceof Deno.errors.NotFound) return {}; throw e; }}
function expandCharacters(str: string): string { const charactersMap: CharactersMap = { "\\n": "\n", "\\r": "\r", "\\t": "\t", };
return str.replace( /\\([nrt])/g, ($1: keyof CharactersMap): string => charactersMap[$1], );}
function assertSafe( conf: Record<string, string>, confExample: Record<string, string>, allowEmptyValues: boolean, restrictEnvAccessTo: StringList = [],) { const currentEnv = readEnv(restrictEnvAccessTo);
// Not all the variables have to be defined in .env, they can be supplied externally const confWithEnv = Object.assign({}, currentEnv, conf);
const missing = withoutAll( Object.keys(confExample), // If allowEmptyValues is false, filter out empty values from configuration Object.keys( allowEmptyValues ? confWithEnv : filterValues(confWithEnv, Boolean), ), );
if (missing.length > 0) { const errorMessages = [ `The following variables were defined in the example file but are not present in the environment:\n ${ missing.join( ", ", ) }`, `Make sure to add them to your env file.`, !allowEmptyValues && `If you expect any of these variables to be empty, you can set the allowEmptyValues option to true.`, ];
throw new MissingEnvVarsError( errorMessages.filter(Boolean).join("\n\n"), missing, ); }}
// a guarded env access, that reads only a subset from the Deno.env object,// if `restrictEnvAccessTo` property is passed.function readEnv(restrictEnvAccessTo: StringList) { if ( restrictEnvAccessTo && Array.isArray(restrictEnvAccessTo) && restrictEnvAccessTo.length > 0 ) { return restrictEnvAccessTo.reduce( ( accessedEnvVars: Record<string, string>, envVarName: string, ): Record<string, string> => { if (Deno.env.get(envVarName)) { accessedEnvVars[envVarName] = Deno.env.get(envVarName) as string; } return accessedEnvVars; }, {}, ); }
return Deno.env.toObject();}
export class MissingEnvVarsError extends Error { missing: string[]; constructor(message: string, missing: string[]) { super(message); this.name = "MissingEnvVarsError"; this.missing = missing; Object.setPrototypeOf(this, new.target.prototype); }}
function expand(str: string, variablesMap: { [key: string]: string }): string { if (RE_ExpandValue.test(str)) { return expand( str.replace(RE_ExpandValue, function (...params) { const { inBrackets, inBracketsDefault, notInBrackets, notInBracketsDefault, } = params[params.length - 1]; const expandValue = inBrackets || notInBrackets; const defaultValue = inBracketsDefault || notInBracketsDefault;
return variablesMap[expandValue] || expand(defaultValue, variablesMap); }), variablesMap, ); } else { return str; }}
/** * @example * ```ts * import { stringify } from "https://deno.land/std@$STD_VERSION/dotenv/mod.ts"; * * const object = { GREETING: "hello world" }; * const string = stringify(object); // GREETING='hello world' * ``` * * @param object object to be stringified * @returns string of object */export function stringify(object: Record<string, string>) { const lines: string[] = []; for (const [key, value] of Object.entries(object)) { let quote;
let escapedValue = value ?? ""; if (key.startsWith("#")) { console.warn( `key starts with a '#' indicates a comment and is ignored: '${key}'`, ); continue; } else if (escapedValue.includes("\n")) { // escape inner new lines escapedValue = escapedValue.replaceAll("\n", "\\n"); quote = `"`; } else if (escapedValue.match(/\W/)) { quote = "'"; }
if (quote) { // escape inner quotes escapedValue = escapedValue.replaceAll(quote, `\\${quote}`); escapedValue = `${quote}${escapedValue}${quote}`; } const line = `${key}=${escapedValue}`; lines.push(line); } return lines.join("\n");}
std
Version Info
11 months ago
