env-validated 1.0.0

package/dist/index.cjs

@@ -0,0 +1,737 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  EnvSafeError: () => EnvSafeError,
+  createEnv: () => createEnv,
+  registerAdapter: () => registerAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/built-in/types.ts
+var BUILT_IN_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "url",
+  "port",
+  "enum",
+  "json"
+]);
+function isBuiltInField(field) {
+  return field != null && typeof field === "object" && "type" in field && typeof field.type === "string" && BUILT_IN_TYPES.has(field.type);
+}
+
+// src/built-in/validators.ts
+function parseBuiltIn(field, raw, _key) {
+  if (raw === void 0 || raw === "") {
+    if ("default" in field && field.default !== void 0) {
+      return field.default;
+    }
+    if (field.required === false) {
+      return void 0;
+    }
+    throw new Error("required, was not set");
+  }
+  switch (field.type) {
+    case "string":
+      return parseString(raw, field);
+    case "number":
+      return parseNumber(raw, field);
+    case "boolean":
+      return parseBoolean(raw);
+    case "url":
+      return parseUrl(raw);
+    case "port":
+      return parsePort(raw);
+    case "enum":
+      return parseEnum(raw, field);
+    case "json":
+      return parseJson(raw);
+  }
+}
+function parseString(raw, field) {
+  if (field.minLength !== void 0 && raw.length < field.minLength) {
+    throw new Error(
+      `must be at least ${field.minLength} characters (got ${raw.length})`
+    );
+  }
+  if (field.maxLength !== void 0 && raw.length > field.maxLength) {
+    throw new Error(
+      `must be at most ${field.maxLength} characters (got ${raw.length})`
+    );
+  }
+  if (field.pattern !== void 0 && !field.pattern.test(raw)) {
+    throw new Error(`must match pattern ${field.pattern}`);
+  }
+  return raw;
+}
+function parseNumber(raw, field) {
+  const num = Number(raw);
+  if (Number.isNaN(num)) {
+    throw new Error(`must be a number (got "${raw}")`);
+  }
+  if (field.min !== void 0 && num < field.min) {
+    throw new Error(`must be >= ${field.min} (got ${num})`);
+  }
+  if (field.max !== void 0 && num > field.max) {
+    throw new Error(`must be <= ${field.max} (got ${num})`);
+  }
+  return num;
+}
+function parseBoolean(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "true" || lower === "1" || lower === "yes") {
+    return true;
+  }
+  if (lower === "false" || lower === "0" || lower === "no") {
+    return false;
+  }
+  throw new Error(`must be a boolean (true/false/1/0/yes/no) (got "${raw}")`);
+}
+function parseUrl(raw) {
+  try {
+    new URL(raw);
+    return raw;
+  } catch {
+    throw new Error(`must be a valid URL (got "${raw}")`);
+  }
+}
+function parsePort(raw) {
+  const num = Number.parseInt(raw, 10);
+  if (Number.isNaN(num) || num < 1 || num > 65535) {
+    throw new Error(`must be a valid port (1-65535) (got "${raw}")`);
+  }
+  return num;
+}
+function parseEnum(raw, field) {
+  if (!field.values.includes(raw)) {
+    throw new Error(
+      `must be one of: ${field.values.join(", ")} (got "${raw}")`
+    );
+  }
+  return raw;
+}
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`must be valid JSON (got "${raw}")`);
+  }
+}
+
+// src/error.ts
+var SENSITIVE_PATTERN = /_KEY$|_SECRET$|_TOKEN$|_PASSWORD$|_PASS$/i;
+function isSensitiveKey(key) {
+  return SENSITIVE_PATTERN.test(key);
+}
+function redactValue(key, value) {
+  if (value === void 0) return "(not set)";
+  if (isSensitiveKey(key)) return "*****";
+  return `"${value}"`;
+}
+
+// src/adapters/detect.ts
+var adapters = [];
+function registerAdapter(adapter) {
+  if (!adapters.some((a) => a.name === adapter.name)) {
+    adapters.push(adapter);
+  }
+}
+function isZodSchema(field) {
+  return field != null && typeof field === "object" && ("_zod" in field || "_def" in field);
+}
+function isJoiSchema(field) {
+  return field != null && typeof field === "object" && "$_root" in field;
+}
+function isYupSchema(field) {
+  return field != null && typeof field === "object" && "spec" in field && "tests" in field && "transforms" in field;
+}
+function isValibotSchema(field) {
+  return field != null && typeof field === "object" && "kind" in field && field.kind === "schema" && "~run" in field;
+}
+function isTypeboxSchema(field) {
+  return field != null && typeof field === "object" && /* @__PURE__ */ Symbol.for("TypeBox.Kind") in field;
+}
+function isArkTypeSchema(field) {
+  return typeof field === "function" && "traverse" in field && "expression" in field;
+}
+function isSuperstructSchema(field) {
+  return field != null && typeof field === "object" && "refiner" in field && "coercer" in field && "validator" in field;
+}
+function isRuntypesSchema(field) {
+  return field != null && typeof field === "object" && "check" in field && "guard" in field && "tag" in field;
+}
+function isEffectSchema(field) {
+  return field != null && (typeof field === "object" || typeof field === "function") && "ast" in field && "annotations" in field && "pipe" in field;
+}
+function isCustomValidateField(field) {
+  return field != null && typeof field === "object" && "validate" in field && typeof field.validate === "function";
+}
+function parseZod(field, raw, key) {
+  const schema = field;
+  try {
+    const result = schema.safeParse(raw);
+    if (result.success) {
+      return { success: true, value: result.data };
+    }
+    const msg = result.error?.issues?.[0]?.message ?? `invalid value (got ${redactValue(key, raw)})`;
+    return { success: false, error: msg };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseJoi(field, raw, _key) {
+  const schema = field;
+  const result = schema.validate(raw);
+  if (result.error) {
+    return { success: false, error: result.error.message };
+  }
+  return { success: true, value: result.value };
+}
+function parseYup(field, raw, _key) {
+  const schema = field;
+  try {
+    let input = raw;
+    if (raw !== void 0) {
+      if (schema.type === "number") {
+        input = Number(raw);
+      } else if (schema.type === "boolean") {
+        const lower = raw.toLowerCase();
+        if (lower === "true" || lower === "1") input = true;
+        else if (lower === "false" || lower === "0") input = false;
+      }
+    }
+    const value = schema.validateSync(input);
+    return { success: true, value };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseValibot(field, raw, _key) {
+  const schema = field;
+  try {
+    const result = schema["~run"]({
+      value: raw,
+      typed: false,
+      issues: void 0
+    });
+    if (result.issues && result.issues.length > 0) {
+      const firstIssue = result.issues[0];
+      return {
+        success: false,
+        error: firstIssue?.message ?? "validation failed"
+      };
+    }
+    return { success: true, value: result.value };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseTypebox(field, raw, key) {
+  try {
+    let Value;
+    try {
+      Value = require("@sinclair/typebox/value").Value;
+    } catch {
+      return {
+        success: false,
+        error: "TypeBox adapter requires @sinclair/typebox to be installed"
+      };
+    }
+    const converted = Value.Convert(field, raw);
+    if (Value.Check(field, converted)) {
+      return { success: true, value: Value.Decode(field, converted) };
+    }
+    return {
+      success: false,
+      error: `invalid value (got ${redactValue(key, raw)})`
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseArkType(field, raw, key) {
+  const t = field;
+  const result = t(raw);
+  if (result instanceof Error || result != null && typeof result === "object" && "summary" in result) {
+    const msg = result instanceof Error ? result.message : typeof result.summary === "string" ? result.summary : `invalid value (got ${redactValue(key, raw)})`;
+    return { success: false, error: msg };
+  }
+  return { success: true, value: result };
+}
+function parseSuperstruct(field, raw, _key) {
+  const struct = field;
+  try {
+    const coerced = struct.coercer(raw, null);
+    for (const failure of struct.validator(coerced, null)) {
+      return { success: false, error: failure.message };
+    }
+    for (const failure of struct.refiner(coerced, null)) {
+      return { success: false, error: failure.message };
+    }
+    return { success: true, value: coerced };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseRuntypes(field, raw, _key) {
+  const rt = field;
+  try {
+    const value = rt.check(raw);
+    return { success: true, value };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function parseEffect(field, raw, _key) {
+  try {
+    let SchemaModule;
+    try {
+      const effect = require("effect");
+      SchemaModule = effect.Schema;
+    } catch {
+      try {
+        SchemaModule = require("@effect/schema/Schema");
+      } catch {
+        return {
+          success: false,
+          error: "Effect adapter requires effect or @effect/schema to be installed"
+        };
+      }
+    }
+    const value = SchemaModule.decodeUnknownSync(field)(raw);
+    return { success: true, value };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function isObjectSchema(schema) {
+  if (isZodSchema(schema)) {
+    const s = schema;
+    if (typeof s.shape === "object" && s.shape !== null) return true;
+    const def = s._def;
+    if (def && typeof def.shape === "object") return true;
+  }
+  if (isJoiSchema(schema)) {
+    return schema.type === "object";
+  }
+  if (isYupSchema(schema)) {
+    return "fields" in schema;
+  }
+  if (isValibotSchema(schema)) {
+    return schema.type === "object";
+  }
+  if (isTypeboxSchema(schema)) {
+    return schema[/* @__PURE__ */ Symbol.for("TypeBox.Kind")] === "Object" && "properties" in schema;
+  }
+  if (isArkTypeSchema(schema)) {
+    const expr = schema.expression ?? "";
+    return expr.includes("{") && expr.includes("}");
+  }
+  if (isSuperstructSchema(schema)) {
+    return "schema" in schema && typeof schema.schema === "object" && schema.schema !== null;
+  }
+  if (isRuntypesSchema(schema)) {
+    return schema.tag === "object" && "fields" in schema;
+  }
+  if (isEffectSchema(schema)) {
+    return "fields" in schema;
+  }
+  return false;
+}
+function resolveObjectSchema(schema) {
+  if (!isObjectSchema(schema)) return null;
+  if (isZodSchema(schema)) {
+    return {
+      adapter: "zod",
+      validate: (source) => {
+        const s = schema;
+        const result = s.safeParse(source);
+        if (result.success) {
+          return {
+            success: true,
+            value: result.data
+          };
+        }
+        const issues = result.error?.issues ?? [];
+        const msg = issues.map((i) => {
+          const path = Array.isArray(i.path) ? i.path.join(".") : "?";
+          return `${path}: ${i.message}`;
+        }).join("; ");
+        return { success: false, error: msg };
+      }
+    };
+  }
+  if (isJoiSchema(schema)) {
+    return {
+      adapter: "joi",
+      validate: (source) => {
+        const s = schema;
+        const result = s.validate(source);
+        if (result.error) {
+          return { success: false, error: result.error.message };
+        }
+        return {
+          success: true,
+          value: result.value
+        };
+      }
+    };
+  }
+  if (isYupSchema(schema)) {
+    return {
+      adapter: "yup",
+      validate: (source) => {
+        const s = schema;
+        try {
+          const value = s.validateSync(source);
+          return { success: true, value };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  if (isValibotSchema(schema)) {
+    return {
+      adapter: "valibot",
+      validate: (source) => {
+        const s = schema;
+        try {
+          const result = s["~run"]({
+            value: source,
+            typed: false,
+            issues: void 0
+          });
+          if (result.issues && result.issues.length > 0) {
+            const firstIssue = result.issues[0];
+            return {
+              success: false,
+              error: firstIssue?.message ?? "validation failed"
+            };
+          }
+          return {
+            success: true,
+            value: result.value
+          };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  if (isTypeboxSchema(schema)) {
+    return {
+      adapter: "typebox",
+      validate: (source) => {
+        try {
+          let Value;
+          try {
+            Value = require("@sinclair/typebox/value").Value;
+          } catch {
+            return {
+              success: false,
+              error: "TypeBox adapter requires @sinclair/typebox to be installed"
+            };
+          }
+          const converted = Value.Convert(schema, source);
+          if (Value.Check(schema, converted)) {
+            return {
+              success: true,
+              value: Value.Decode(schema, converted)
+            };
+          }
+          return {
+            success: false,
+            error: "TypeBox object schema validation failed"
+          };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  if (isArkTypeSchema(schema)) {
+    return {
+      adapter: "arktype",
+      validate: (source) => {
+        const t = schema;
+        const result = t(source);
+        if (result instanceof Error || result != null && typeof result === "object" && "summary" in result) {
+          const msg = result instanceof Error ? result.message : typeof result.summary === "string" ? result.summary : "ArkType object schema validation failed";
+          return { success: false, error: msg };
+        }
+        return { success: true, value: result };
+      }
+    };
+  }
+  if (isSuperstructSchema(schema)) {
+    return {
+      adapter: "superstruct",
+      validate: (source) => {
+        try {
+          let ssModule;
+          try {
+            ssModule = require("superstruct");
+          } catch {
+            return {
+              success: false,
+              error: "Superstruct adapter requires superstruct to be installed"
+            };
+          }
+          const [error, value] = ssModule.validate(source, schema);
+          if (error) {
+            return { success: false, error: error.message };
+          }
+          return { success: true, value };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  if (isRuntypesSchema(schema)) {
+    return {
+      adapter: "runtypes",
+      validate: (source) => {
+        const rt = schema;
+        try {
+          const value = rt.check(source);
+          return { success: true, value };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  if (isEffectSchema(schema)) {
+    return {
+      adapter: "effect",
+      validate: (source) => {
+        try {
+          let SchemaModule;
+          try {
+            const effect = require("effect");
+            SchemaModule = effect.Schema;
+          } catch {
+            try {
+              SchemaModule = require("@effect/schema/Schema");
+            } catch {
+              return {
+                success: false,
+                error: "Effect adapter requires effect or @effect/schema to be installed"
+              };
+            }
+          }
+          const value = SchemaModule.decodeUnknownSync(schema)(source);
+          return { success: true, value };
+        } catch (e) {
+          return {
+            success: false,
+            error: e instanceof Error ? e.message : String(e)
+          };
+        }
+      }
+    };
+  }
+  return null;
+}
+function resolveField(field, raw, key) {
+  for (const adapter of adapters) {
+    if (adapter.detect(field)) {
+      return adapter.validate(field, raw, key);
+    }
+  }
+  if (isZodSchema(field)) return parseZod(field, raw, key);
+  if (isJoiSchema(field)) return parseJoi(field, raw, key);
+  if (isYupSchema(field)) return parseYup(field, raw, key);
+  if (isValibotSchema(field)) return parseValibot(field, raw, key);
+  if (isTypeboxSchema(field)) return parseTypebox(field, raw, key);
+  if (isArkTypeSchema(field)) return parseArkType(field, raw, key);
+  if (isSuperstructSchema(field)) return parseSuperstruct(field, raw, key);
+  if (isRuntypesSchema(field)) return parseRuntypes(field, raw, key);
+  if (isEffectSchema(field)) return parseEffect(field, raw, key);
+  if (isCustomValidateField(field)) {
+    return field.validate(raw);
+  }
+  if (isBuiltInField(field)) {
+    try {
+      const value = parseBuiltIn(field, raw, key);
+      return { success: true, value };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  return {
+    success: false,
+    error: `No adapter found for field "${key}". The schema object shape was not recognized.`
+  };
+}
+
+// src/types.ts
+var EnvSafeError = class extends Error {
+  errors;
+  constructor(errors) {
+    const header = `[env-validated] Missing or invalid environment variables:
+`;
+    const lines = errors.map((e) => `  \u2716 ${e.key} \u2014 ${e.message}`).join("\n");
+    const footer = "\n\nFix these before starting the app.";
+    super(`${header}${lines}${footer}`);
+    this.name = "EnvSafeError";
+    this.errors = errors;
+  }
+};
+
+// src/index.ts
+var import_meta = {};
+function resolveSource(options) {
+  if (options?.source) {
+    return options.source;
+  }
+  if (options?.dotenv) {
+    try {
+      const { createRequire } = require("module");
+      const req = createRequire(import_meta.url);
+      const dotenv = req("dotenv");
+      const path = typeof options.dotenv === "string" ? options.dotenv : void 0;
+      dotenv.config(path ? { path } : void 0);
+    } catch {
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+function handleError(error, onError) {
+  if (onError === "warn") {
+    console.warn(error.message);
+    return;
+  }
+  if (typeof onError === "function") {
+    onError(error);
+    return;
+  }
+  throw error;
+}
+function createEnv(config, options) {
+  const source = resolveSource(options);
+  const prefix = options?.prefix ?? "";
+  const errors = [];
+  if (isObjectSchema(config.schema)) {
+    const objectSchemaInfo = resolveObjectSchema(config.schema);
+    if (objectSchemaInfo) {
+      let effectiveSource = source;
+      if (prefix) {
+        effectiveSource = {};
+        for (const fullKey of Object.keys(source)) {
+          if (fullKey.startsWith(prefix)) {
+            effectiveSource[fullKey.slice(prefix.length)] = source[fullKey];
+          }
+        }
+      }
+      const validation = objectSchemaInfo.validate(effectiveSource);
+      if (validation.success) {
+        return Object.freeze(validation.value);
+      }
+      const envError = new EnvSafeError([
+        {
+          key: `[${objectSchemaInfo.adapter} schema]`,
+          message: validation.error
+        }
+      ]);
+      handleError(envError, options?.onError);
+      return Object.freeze({});
+    }
+  }
+  const schema = config.schema;
+  const result = {};
+  for (const key of Object.keys(schema)) {
+    const envKey = prefix ? `${prefix}${key}` : key;
+    const raw = source[envKey];
+    const field = schema[key];
+    const validation = resolveField(field, raw, envKey);
+    if (validation.success) {
+      result[key] = validation.value;
+    } else {
+      let errorMsg = validation.error;
+      if (isSensitiveKey(envKey) && raw !== void 0 && !errorMsg.includes("*****")) {
+        errorMsg = errorMsg.replace(
+          new RegExp(raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+          "*****"
+        );
+      }
+      errors.push({ key: envKey, message: errorMsg });
+    }
+  }
+  if (errors.length > 0) {
+    const envError = new EnvSafeError(errors);
+    handleError(envError, options?.onError);
+  }
+  return Object.freeze(result);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnvSafeError,
+  createEnv,
+  registerAdapter
+});
+//# sourceMappingURL=index.cjs.map