@ix-xs/node-comfort 2.0.0 → 2.1.0

package/src/Emitter.js

@@ -15,6 +15,7 @@
  */
 
 const { TimeoutError, AbortError } = require("./errors.js");
+const { toMs, setLongTimeout } = require("./internal/shared.js");
 
 /**
  * Event names mapped to their arguments, like
@@ -22,6 +23,12 @@ const { TimeoutError, AbortError } = require("./errors.js");
  * @typedef {Record<string, any[]>} EventMap
  */
 
+/**
+ * Options for `on()` and `once()`.
+ * @typedef {object} ListenOptions
+ * @property {AbortSignal} [signal] Removes the listener when aborted. One signal can clean up many listeners at once.
+ */
+
 /**
  * Options for `waitFor()`.
  * @template {any[]} A
@@ -31,6 +38,15 @@ const { TimeoutError, AbortError } = require("./errors.js");
  * @property {(...args: A) => boolean} [filter] Only resolve for events that pass this test.
  */
 
+/**
+ * A listener as stored: `once()` wraps the function it was given and keeps
+ * it as `listener`, so `off()` can find it.
+ * @typedef {((...args: any[]) => unknown) & { listener?: Function }} _StoredListener
+ */
+
+/** @type {readonly _StoredListener[]} */
+const NONE = Object.freeze([]);
+
 /**
  * A typed event emitter. In JavaScript, give the variable a JSDoc type such
  * as `import("@ix-xs/node-comfort").Emitter<{ ready: [port: number] }>`.
@@ -38,10 +54,44 @@ const { TimeoutError, AbortError } = require("./errors.js");
  * @template {EventMap} [Events=EventMap]
  */
 class Emitter {
-  /** @type {Map<keyof Events, Set<(...args: any[]) => unknown>>} */
+  // Listener lists are replaced, never changed in place: emit() can walk one
+  // without copying it, even if a listener adds or removes others meanwhile.
+  /** @type {Map<keyof Events, readonly _StoredListener[]>} */
   #listeners = new Map();
-  /** @type {Set<(event: keyof Events, ...args: any[]) => unknown>} */
-  #any = new Set();
+  /** @type {readonly _StoredListener[]} */
+  #any = NONE;
+
+  /**
+   * @param {keyof Events} event
+   * @param {_StoredListener} stored
+   * @param {ListenOptions | undefined} options
+   * @returns {() => void}
+   */
+  #add(event, stored, options) {
+    const signal = options?.signal;
+    if (signal?.aborted) return () => {};
+    const current = this.#listeners.get(event) ?? NONE;
+    if (!current.includes(stored)) this.#listeners.set(event, [...current, stored]);
+    const off = () => {
+      signal?.removeEventListener("abort", off);
+      this.#drop(event, stored);
+    };
+    signal?.addEventListener("abort", off, { once: true });
+    return off;
+  }
+
+  /**
+   * @param {keyof Events} event
+   * @param {Function} listener The stored function, or the one given to `once()`.
+   */
+  #drop(event, listener) {
+    const current = this.#listeners.get(event);
+    if (!current) return;
+    const next = current.filter((stored) => stored !== listener && stored.listener !== listener);
+    if (next.length === current.length) return;
+    if (next.length) this.#listeners.set(event, next);
+    else this.#listeners.delete(event);
+  }
 
   /**
    * Listens to an event.
@@ -50,16 +100,19 @@ class Emitter {
    * const off = emitter.on("data", (chunk) => chunks.push(chunk));
    * off(); // stop listening
    *
+   * const controller = new AbortController();
+   * emitter.on("data", onData, { signal: controller.signal });
+   * emitter.on("end", onEnd, { signal: controller.signal });
+   * controller.abort(); // removes both
+   *
    * @template {keyof Events & string} K
    * @param {K} event
    * @param {(...args: Events[K]) => unknown} listener
+   * @param {ListenOptions} [options]
    * @returns {() => void} Removes the listener.
    */
-  on(event, listener) {
-    let set = this.#listeners.get(event);
-    if (!set) this.#listeners.set(event, (set = new Set()));
-    set.add(listener);
-    return () => this.off(event, listener);
+  on(event, listener, options) {
+    return this.#add(event, listener, options);
   }
 
   /**
@@ -68,15 +121,17 @@ class Emitter {
    * @template {keyof Events & string} K
    * @param {K} event
    * @param {(...args: Events[K]) => unknown} listener
+   * @param {ListenOptions} [options]
    * @returns {() => void} Removes the listener if it hasn't run yet.
    */
-  once(event, listener) {
-    /** @type {(...args: Events[K]) => unknown} */
+  once(event, listener, options) {
+    /** @type {_StoredListener} */
     const wrapper = (...args) => {
       off();
-      return listener(...args);
+      return listener(.../** @type {Events[K]} */ (args));
     };
-    const off = this.on(event, wrapper);
+    wrapper.listener = listener;
+    const off = this.#add(event, wrapper, options);
     return off;
   }
 
@@ -91,8 +146,10 @@ class Emitter {
    * @returns {() => void} Removes the listener.
    */
   onAny(listener) {
-    this.#any.add(/** @type {any} */ (listener));
-    return () => void this.#any.delete(/** @type {any} */ (listener));
+    if (!this.#any.includes(listener)) this.#any = [...this.#any, listener];
+    return () => {
+      this.#any = this.#any.filter((stored) => stored !== listener);
+    };
   }
 
   /**
@@ -100,16 +157,12 @@ class Emitter {
    *
    * @template {keyof Events & string} K
    * @param {K} event
-   * @param {(...args: Events[K]) => unknown} [listener]
+   * @param {(...args: Events[K]) => unknown} [listener] The function given to `on()` or `once()`.
    * @returns {this}
    */
   off(event, listener) {
     if (!listener) this.#listeners.delete(event);
-    else {
-      const set = this.#listeners.get(event);
-      set?.delete(listener);
-      if (set && !set.size) this.#listeners.delete(event);
-    }
+    else this.#drop(event, listener);
     return this;
   }
 
@@ -126,10 +179,11 @@ class Emitter {
    * @returns {boolean} `true` if anyone was listening.
    */
   emit(event, ...args) {
-    const listeners = [...(this.#listeners.get(event) ?? [])];
-    for (const listener of listeners) listener(...args);
-    for (const listener of [...this.#any]) listener(event, ...args);
-    return listeners.length > 0 || this.#any.size > 0;
+    const listeners = this.#listeners.get(event);
+    const any = this.#any;
+    if (listeners !== undefined) for (let i = 0; i < listeners.length; i++) listeners[i](...args);
+    for (let i = 0; i < any.length; i++) any[i](event, ...args);
+    return listeners !== undefined || any.length > 0;
   }
 
   /**
@@ -146,8 +200,9 @@ class Emitter {
    */
   async emitAsync(event, ...args) {
     const results = [];
-    for (const listener of [...(this.#listeners.get(event) ?? [])]) results.push(await listener(...args));
-    for (const listener of [...this.#any]) await listener(event, ...args);
+    const any = this.#any;
+    for (const listener of this.#listeners.get(event) ?? NONE) results.push(await listener(...args));
+    for (const listener of any) await listener(event, ...args);
     return results;
   }
 
@@ -167,10 +222,11 @@ class Emitter {
    */
   waitFor(event, options = {}) {
     return new Promise((resolve, reject) => {
-      /** @type {NodeJS.Timeout | undefined} */
-      let timer;
+      const limit = options.timeout === undefined ? undefined : toMs(options.timeout, "timeout");
+      /** @type {() => void} */
+      let cancelTimer = () => {};
       const cleanup = () => {
-        clearTimeout(timer);
+        cancelTimer();
         off();
         options.signal?.removeEventListener("abort", onAbort);
       };
@@ -185,12 +241,11 @@ class Emitter {
       }));
       if (options.signal?.aborted) return onAbort();
       options.signal?.addEventListener("abort", onAbort, { once: true });
-      if (options.timeout !== undefined) {
-        const ms = typeof options.timeout === "number" ? options.timeout : require("./Time.js").parseDuration(options.timeout) ?? 0;
-        timer = setTimeout(() => {
+      if (limit !== undefined) {
+        cancelTimer = setLongTimeout(() => {
           cleanup();
-          reject(new TimeoutError(`Timed out waiting for "${event}" after ${ms}ms`, { timeout: ms }));
-        }, ms);
+          reject(new TimeoutError(`Timed out waiting for "${event}" after ${limit}ms`, { timeout: limit }));
+        }, limit);
       }
     });
   }
@@ -255,12 +310,24 @@ class Emitter {
    * @returns {number}
    */
   listenerCount(event) {
-    if (event !== undefined) return this.#listeners.get(event)?.size ?? 0;
+    if (event !== undefined) return this.#listeners.get(event)?.length ?? 0;
     let total = 0;
-    for (const set of this.#listeners.values()) total += set.size;
+    for (const list of this.#listeners.values()) total += list.length;
     return total;
   }
 
+  /**
+   * The listeners of an event, in the order they run. For `once()`, you get
+   * the function you passed, not its wrapper.
+   *
+   * @template {keyof Events & string} K
+   * @param {K} event
+   * @returns {Array<(...args: Events[K]) => unknown>}
+   */
+  listeners(event) {
+    return (this.#listeners.get(event) ?? NONE).map((stored) => /** @type {any} */ (stored.listener ?? stored));
+  }
+
   /**
    * The events that have listeners.
    *
@@ -280,7 +347,7 @@ class Emitter {
     if (event !== undefined) this.#listeners.delete(event);
     else {
       this.#listeners.clear();
-      this.#any.clear();
+      this.#any = NONE;
     }
     return this;
   }

package/src/Env.js

@@ -7,7 +7,8 @@
  *
  * The `.env` file in the working directory is loaded when the package is
  * required; variables that are already set are never overwritten. Set
- * `NODE_COMFORT_DOTENV=false` to turn that off.
+ * `NODE_COMFORT_DOTENV=false` to turn that off. What it loaded has the
+ * lowest priority: a file you load yourself afterwards wins over it.
  *
  * @example
  * const config = env.validate({
@@ -21,6 +22,7 @@
 const fs = require("node:fs");
 const nodePath = require("node:path");
 const { ValidationError } = require("./errors.js");
+const { parseDuration } = require("./internal/shared.js");
 
 /**
  * Options for `load()`.
@@ -28,6 +30,7 @@ const { ValidationError } = require("./errors.js");
  * @property {boolean} [override] Overwrite variables that are already set.
  * @property {boolean} [expand] Replace `${OTHER}` references. Defaults to `true`.
  * @property {boolean} [required] Throw if a file is missing.
+ * @property {boolean | string} [cascade] Also load the files that go with each one: `.env.production.local`, `.env.local`, `.env.production`, then `.env`. `true` takes the mode from `NODE_ENV`; a string names it. `.env.local` is skipped in test mode, so tests run the same for everyone.
  * @property {NodeJS.ProcessEnv} [target] Where to put the variables. Defaults to `process.env`.
  */
 
@@ -77,6 +80,18 @@ const { ValidationError } = require("./errors.js");
  * @typedef {{ -readonly [K in keyof T]: T[K] extends { optional: true } ? EnvVarValue<T[K]> | undefined : EnvVarValue<T[K]> }} EnvConfig
  */
 
+const _TRUE = ["true", "1", "yes", "y", "on"];
+const _FALSE = ["false", "0", "no", "n", "off", ""];
+
+/**
+ * Reads a variable, ignoring what objects inherit: without this,
+ * `TOSTRING` is fine but `toString` would come back as a function.
+ * @param {Record<string, string | undefined>} source
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+const _raw = (source, name) => (Object.hasOwn(source, name) ? source[name] : undefined);
+
 /**
  * @param {string} name
  * @param {string} code
@@ -116,8 +131,8 @@ const _convert = (name, raw, spec) => {
     }
     case "boolean": {
       const lower = value.toLowerCase();
-      if (["true", "1", "yes", "y", "on"].includes(lower)) return true;
-      if (["false", "0", "no", "n", "off", ""].includes(lower)) return false;
+      if (_TRUE.includes(lower)) return true;
+      if (_FALSE.includes(lower)) return false;
       return _fail(name, "invalid_type", `must be a boolean (true/false, 1/0, yes/no, on/off), got "${raw}"`);
     }
     case "url": {
@@ -138,7 +153,6 @@ const _convert = (name, raw, spec) => {
       return value;
     }
     case "duration": {
-      const { parseDuration } = require("./Time.js");
       const ms = parseDuration(value);
       if (ms === null) _fail(name, "invalid_type", `must be a duration such as "30s", "5m" or "1h", got "${raw}"`);
       return ms;
@@ -166,17 +180,23 @@ const _convert = (name, raw, spec) => {
  * @returns {unknown}
  */
 const _read = (name, spec, source) => {
-  const raw = source[name];
+  const raw = _raw(source, name);
   if (raw === undefined || raw.trim() === "") {
     if ("default" in spec && spec.default !== undefined) {
       return spec.type === "duration" && typeof spec.default === "string" ? _convert(name, spec.default, spec) : spec.default;
     }
     if (spec.optional) return undefined;
-    return _fail(name, "required", "is required but is not set");
+    return _fail(name, "required", `is required but is not set${spec.description ? ` (${spec.description})` : ""}`);
   }
   return _convert(name, raw, spec);
 };
 
+const _LINE = /^[ \t]*(?:export[ \t]+)?([\w.-]+)[ \t]*[=:][ \t]*(?:("(?:\\.|[^"\\])*"|'[^']*'|`[^`]*`)[ \t]*(?:#[^\n]*)?|([^\n]*))$/gm;
+const _ESCAPE = /\\([nrt"\\$])/g;
+const _REFERENCE = /\\\$|\$\{([\w.]+)(?::?-([^}]*))?\}|\$([A-Za-z_]\w*)/g;
+/** @type {Record<string, string>} */
+const _ESCAPED = { n: "\n", r: "\r", t: "\t" };
+
 /**
  * Parses the text of a `.env` file: quotes, multi-line values, `export`,
  * comments, escapes, and `${VAR}` expansion (except in single quotes).
@@ -190,61 +210,97 @@ const _read = (name, spec, source) => {
  * @returns {Record<string, string>}
  */
 function parse(content, options = {}) {
-  /** @type {Record<string, string>} */
-  const out = {};
+  return _parse(content, options);
+}
+
+/**
+ * @param {string} content
+ * @param {EnvParseOptions} options
+ * @param {(name: string) => string | undefined} [wins] Values that a reference takes before the file's own: what the variable will really be once loaded.
+ * @returns {Record<string, string>}
+ */
+function _parse(content, options, wins) {
+  // A Map, so that a variable called __proto__ or toString is a variable like any other.
+  /** @type {Map<string, string>} */
+  const out = new Map();
   /** @type {Set<string>} */
   const literal = new Set();
   const text = String(content).replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
-  const regex = /^[ \t]*(?:export[ \t]+)?([\w.-]+)[ \t]*[=:][ \t]*(?:("(?:\\.|[^"\\])*"|'[^']*'|`[^`]*`)[ \t]*(?:#[^\n]*)?|([^\n]*))$/gm;
-  let match;
-  while ((match = regex.exec(text)) !== null) {
-    const [, key, quoted, bare] = match;
+  for (const [, key, quoted, bare] of text.matchAll(_LINE)) {
     let value;
     if (quoted !== undefined) {
       const quote = quoted[0];
       value = quoted.slice(1, -1);
-      if (quote === '"') value = value.replace(/\\([nrt"\\$])/g, (_, c) => ({ n: "\n", r: "\r", t: "\t" })[/** @type {"n"} */ (c)] ?? c);
+      if (quote === '"') value = value.replace(_ESCAPE, (_, char) => _ESCAPED[char] ?? char);
       if (quote === "'") literal.add(key);
+      else literal.delete(key);
     } else {
       value = (bare ?? "").replace(/(?:^|[ \t]+)#.*$/, "").trim();
+      literal.delete(key);
     }
-    out[key] = value;
+    out.set(key, value);
   }
   if (options.expand !== false) {
     const base = options.env ?? process.env;
-    const resolve = (/** @type {string} */ name, /** @type {Set<string>} */ seen) => {
-      if (seen.has(name)) return "";
-      if (name in out) return expandValue(out[name], new Set([...seen, name]), name);
-      return base[name] ?? "";
+    /**
+     * @param {string} name
+     * @param {string[]} seen The variables being expanded, to stop at a loop.
+     * @returns {string}
+     */
+    const resolve = (name, seen) => {
+      if (seen.includes(name)) return "";
+      const winner = wins?.(name);
+      if (winner !== undefined) return winner;
+      const own = out.get(name);
+      return own !== undefined ? expand(own, [...seen, name], name) : _raw(base, name) ?? "";
     };
     /**
      * @param {string} value
-     * @param {Set<string>} seen
+     * @param {string[]} seen
      * @param {string} key
      * @returns {string}
      */
-    const expandValue = (value, seen, key) => {
-      if (literal.has(key)) return value;
-      return value.replace(/\\\$|\$\{([\w.]+)(?::?-([^}]*))?\}|\$([A-Za-z_]\w*)/g, (m, braced, fallback, bare) => {
-        if (m === "\\$") return "$";
-        const resolved = resolve(braced ?? bare, seen);
+    const expand = (value, seen, key) => {
+      if (literal.has(key) || !value.includes("$")) return value;
+      return value.replace(_REFERENCE, (match, braced, fallback, plain) => {
+        if (match === "\\$") return "$";
+        const resolved = resolve(braced ?? plain, seen);
         return resolved === "" && fallback !== undefined ? fallback : resolved;
       });
     };
-    for (const key of Object.keys(out)) out[key] = expandValue(out[key], new Set([key]), key);
+    for (const [key, value] of out) out.set(key, expand(value, [key], key));
   }
-  return out;
+  return Object.fromEntries(out);
 }
 
+/**
+ * What the automatic load of `.env` put in `process.env`. A later `load()`
+ * may replace these values, as long as nobody changed them in between: they
+ * came from a file, not from the real environment.
+ * @type {Map<string, string>}
+ */
+const _automatic = new Map();
+let _loadingAutomatically = false;
+
+/**
+ * The files that go with a `.env` file, most specific first.
+ * @param {string} file
+ * @param {string} mode
+ * @returns {string[]}
+ */
+const _cascade = (file, mode) => [`${file}.${mode}.local`, ...(mode === "test" ? [] : [`${file}.local`]), `${file}.${mode}`, file];
+
 /**
  * Loads `.env` files into `process.env`. The first file to set a variable
  * wins, and variables that are already set are kept, unless you pass
- * `override`.
+ * `override`. The `.env` loaded by itself at startup doesn't count as
+ * already set: `.env.local` wins over it, as you'd expect.
  *
  * @example
  * env.load();                                // ./.env
  * env.load([".env.local", ".env"]);          // local values win
  * env.load(".env.test", { override: true });
+ * env.load(".env", { cascade: true });       // .env.production.local, .env.local, .env.production, .env
  *
  * @param {string | string[]} [files=".env"] Relative to the working directory.
  * @param {EnvLoadOptions} [options]
@@ -253,21 +309,49 @@ function parse(content, options = {}) {
  */
 function load(files = ".env", options = {}) {
   const target = options.target ?? process.env;
-  /** @type {Record<string, string>} */
-  const loaded = {};
-  for (const file of Array.isArray(files) ? files : [files]) {
-    const full = nodePath.resolve(process.cwd(), file);
-    if (!fs.existsSync(full)) {
-      if (options.required) throw new Error(`Environment file not found: ${full}`);
-      continue;
-    }
-    const values = parse(fs.readFileSync(full, "utf8"), { expand: options.expand, env: { ...target, ...loaded } });
-    for (const [key, value] of Object.entries(values)) {
-      if (!(key in loaded)) loaded[key] = value;
-      if (options.override || target[key] === undefined) target[key] = value;
+  const given = Array.isArray(files) ? files : [files];
+  const cascade = options.cascade === true ? mode() : options.cascade;
+  const own = target === process.env;
+  /** @type {Map<string, string>} */
+  const loaded = new Map();
+  /**
+   * The value a variable already has and keeps, whatever the files say.
+   * @param {string} key
+   * @returns {string | undefined}
+   */
+  const kept = (key) => {
+    if (options.override) return undefined;
+    const current = _raw(target, key);
+    return current !== undefined && !(own && _automatic.get(key) === current) ? current : undefined;
+  };
+  // A reference such as ${HOST} takes the value HOST ends up with, not the
+  // one of a file that lost.
+  const wins = (/** @type {string} */ key) => loaded.get(key) ?? kept(key);
+  for (const name of given) {
+    for (const file of cascade ? _cascade(name, cascade) : [name]) {
+      const full = nodePath.resolve(process.cwd(), file);
+      let content;
+      try {
+        content = fs.readFileSync(full, "utf8");
+      } catch (error) {
+        // Only the file you named has to exist, not the ones that go with it.
+        if (options.required && file === name) throw new Error(`Environment file not found: ${full}`, { cause: error });
+        continue;
+      }
+      const values = _parse(content, { expand: options.expand, env: target }, wins);
+      for (const [key, value] of Object.entries(values)) {
+        if (!loaded.has(key)) loaded.set(key, value);
+      }
     }
   }
-  return loaded;
+  for (const [key, value] of loaded) {
+    if (kept(key) !== undefined) continue;
+    target[key] = value;
+    if (!own) continue;
+    if (_loadingAutomatically) _automatic.set(key, value);
+    else _automatic.delete(key);
+  }
+  return Object.fromEntries(loaded);
 }
 
 /**
@@ -281,7 +365,7 @@ function load(files = ".env", options = {}) {
  * @returns {string | undefined}
  */
 function get(name, fallback) {
-  return process.env[name] ?? fallback;
+  return _raw(process.env, name) ?? fallback;
 }
 
 /**
@@ -291,7 +375,7 @@ function get(name, fallback) {
  * @returns {boolean}
  */
 function has(name) {
-  return process.env[name] !== undefined;
+  return _raw(process.env, name) !== undefined;
 }
 
 /**
@@ -489,6 +573,53 @@ function validate(spec, options = {}) {
   return /** @type {any} */ (Object.freeze(out));
 }
 
+/**
+ * Quotes a value when spaces, `#` or `$` would otherwise change its meaning.
+ * @param {string} text
+ */
+const _quote = (text) => {
+  if (!/[\s#"'`$\\]/.test(text)) return text;
+  if (!text.includes("'") && !text.includes("\n")) return `'${text}'`;
+  return `"${text.replace(/[\\"$]/g, "\\$&").replace(/\n/g, "\\n")}"`;
+};
+
+/**
+ * Writes the `.env.example` that goes with a `validate()` spec: one entry
+ * per variable, with its description, type and default. Keep the file in
+ * the repository so nobody has to read the code to know what to set.
+ *
+ * @example
+ * const spec = {
+ *   PORT: { type: "port", default: 3000, description: "Port to listen on" },
+ *   DATABASE_URL: { type: "url", description: "Postgres connection string" },
+ * };
+ * fs.writeFileSync(".env.example", env.example(spec));
+ * // # Port to listen on
+ * // # port, default: 3000
+ * // PORT=3000
+ * //
+ * // # Postgres connection string
+ * // # url, required
+ * // DATABASE_URL=
+ *
+ * @param {Record<string, EnvVarSpec>} spec
+ * @returns {string}
+ */
+function example(spec) {
+  const blocks = [];
+  for (const [name, entry] of Object.entries(spec)) {
+    const fallback = "default" in entry && entry.default !== undefined ? entry.default : undefined;
+    const text = fallback === undefined ? "" : Array.isArray(fallback) ? fallback.join(entry.type === "list" ? entry.separator ?? "," : ",") : typeof fallback === "object" ? JSON.stringify(fallback) : String(fallback);
+    const kind = entry.type === "enum" ? entry.values.join(" | ") : entry.type;
+    const lines = [];
+    if (entry.description) lines.push(...entry.description.split(/\r?\n/).map((line) => `# ${line}`));
+    lines.push(`# ${kind}, ${fallback !== undefined ? `default: ${text}` : entry.optional ? "optional" : "required"}`);
+    lines.push(`${name}=${_quote(text)}`);
+    blocks.push(lines.join("\n"));
+  }
+  return `${blocks.join("\n\n")}\n`;
+}
+
 /**
  * `NODE_ENV`, or `"development"` when it's not set.
  *
@@ -524,11 +655,13 @@ function isTest() {
 }
 
 if (String(process.env.NODE_COMFORT_DOTENV).toLowerCase() !== "false") {
+  _loadingAutomatically = true;
   try {
     load(".env");
   } catch {
     // A broken .env file must never prevent the application from starting.
   }
+  _loadingAutomatically = false;
 }
 
 module.exports = {
@@ -548,6 +681,7 @@ module.exports = {
   json,
   oneOf,
   validate,
+  example,
   mode,
   isProduction,
   isDevelopment,