@e-n-v/env 0.0.1 → 0.0.4

package/dist/src-BBwjK5SK.js

@@ -0,0 +1,127 @@
+import { r as resolvePreprocessor } from "./src-CLTURaoo.js";
+import { i as resolveSchemas, n as EnvModel } from "./src-CVdUqK3q.js";
+
+//#region ../parse/src/errors/EnvParseError.ts
+/**
+* Error thrown when parsing environment variables fails.
+* Collects all issues so callers can inspect them without relying on subclasses.
+*/
+var EnvParseError = class EnvParseError extends Error {
+	issues;
+	partial;
+	constructor(params) {
+		const { issues, partial } = params;
+		super(EnvParseError.formatMessage(issues));
+		this.name = "EnvParseError";
+		this.issues = Object.freeze([...issues]);
+		this.partial = partial ?? {};
+	}
+	/** Number of issues encountered while parsing. */
+	get issueCount() {
+		return this.issues.length;
+	}
+	/** Keys that were missing but required. */
+	get missing() {
+		return this.issues.filter((issue) => issue.type === "missing").map((issue) => issue.key);
+	}
+	/** Keys that were present but invalid. */
+	get invalid() {
+		return this.issues.filter((issue) => issue.type === "invalid").map((issue) => issue.key);
+	}
+	/**
+	* Get all issue messages as a numbered list for easy logging.
+	*/
+	formatIssues() {
+		return this.issues.map((issue, index) => `${index + 1}. ${issue.message}`).join("\n");
+	}
+	static formatMessage(issues) {
+		if (issues.length === 0) return "Environment validation failed with no details.";
+		return [`Environment validation failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}:`, ...issues.map((issue) => {
+			if (issue.type === "missing") return `- ${issue.key}: ${issue.message}`;
+			return `- ${issue.key}: ${issue.message}`;
+		})].join("\n");
+	}
+};
+
+//#endregion
+//#region ../parse/src/parse.ts
+/**
+* Parse and validate environment variables from a source object
+* Does NOT mutate process.env
+*/
+function parse(source, modelOrOptions) {
+	let resolvedSchemas;
+	let preprocessConfig;
+	if (modelOrOptions instanceof EnvModel) {
+		const model = modelOrOptions;
+		resolvedSchemas = model.schemas;
+		preprocessConfig = model.preprocess;
+	} else {
+		const options = modelOrOptions;
+		resolvedSchemas = resolveSchemas(options.schemas);
+		const config = options.preprocess;
+		if (config === false) preprocessConfig = {
+			string: false,
+			number: false,
+			boolean: false,
+			enum: false
+		};
+		else if (config === true || config === void 0) preprocessConfig = {};
+		else preprocessConfig = { ...config };
+	}
+	const result = {};
+	const issues = [];
+	for (const [key, schema$1] of Object.entries(resolvedSchemas)) {
+		const rawValue = source[key];
+		if (rawValue === void 0 || rawValue.trim() === "") {
+			if (schema$1.default !== void 0) {
+				result[key] = schema$1.default;
+				continue;
+			}
+			if (schema$1.required) {
+				issues.push({
+					type: "missing",
+					key,
+					message: `Required environment variable "${key}" is missing`
+				});
+				result[key] = void 0;
+				continue;
+			}
+			result[key] = void 0;
+			continue;
+		}
+		const preprocessor = resolvePreprocessor(schema$1.type, preprocessConfig);
+		const preprocessedValue = preprocessor ? preprocessor(rawValue) : rawValue;
+		const stringValue = typeof preprocessedValue === "string" ? preprocessedValue : String(preprocessedValue);
+		try {
+			const processedValue = schema$1.process(stringValue);
+			if (processedValue === void 0) if (schema$1.default !== void 0) result[key] = schema$1.default;
+			else if (schema$1.required) {
+				issues.push({
+					type: "missing",
+					key,
+					message: `Required environment variable "${key}" is missing`
+				});
+				result[key] = void 0;
+			} else result[key] = void 0;
+			else result[key] = processedValue;
+		} catch (error) {
+			const message = `Environment variable "${key}" validation failed: ${error instanceof Error ? error.message : String(error)}`;
+			issues.push({
+				type: "invalid",
+				key,
+				value: rawValue,
+				message
+			});
+			result[key] = void 0;
+		}
+	}
+	if (issues.length > 0) throw new EnvParseError({
+		issues,
+		partial: { ...result }
+	});
+	return result;
+}
+
+//#endregion
+export { EnvParseError as n, parse as t };

package/dist/src-CLTURaoo.js

@@ -0,0 +1,311 @@
+//#region ../core/src/schemas/EnvVarSchemaBase.ts
+var EnvVarSchemaBase = class {
+	required;
+	default;
+	description;
+	process;
+	constructor(input) {
+		this.required = input?.required ?? true;
+		this.default = input?.default;
+		this.description = input?.description;
+		this.process = input.process;
+	}
+};
+
+//#endregion
+//#region ../core/src/processing/helpers/toList.ts
+/**
+* Convert array of items to natural language list.
+* Examples:
+* - [] => ""
+* - ["one"] => "one"
+* - ["one", "two"] => "one and two"
+* - ["one", "two", "three"] => "one, two, and three"
+*/
+function toList(items) {
+	if (items.length === 0) return "";
+	if (items.length === 1) return items[0];
+	if (items.length === 2) return `${items[0]} and ${items[1]}`;
+	return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+//#endregion
+//#region ../core/src/processing/helpers/validate.ts
+/**
+* Run checks and aggregate errors.
+* Throws an error with all validation requirements if any check fails.
+*/
+function validate(value, checks) {
+	const allRequirements = checks.map((check) => check(value)).flat();
+	if (allRequirements.length > 0) {
+		const message = toList(allRequirements);
+		throw new Error(`Must be ${message}`);
+	}
+	return value;
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/string.ts
+/**
+* String processor with optional validation checks.
+* This is the primary string processor - the base stringProcessor() calls this with no checks.
+*/
+function string$1(...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		if (input === "") return;
+		if (checks.length > 0) return validate(input, checks);
+		return input;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/number.ts
+/**
+* Number processor with optional validation checks.
+* This is the primary number processor - the base numberProcessor() calls this with no checks.
+*/
+function number$1(...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim();
+		if (trimmed === "") return;
+		const parsed = parseFloat(trimmed);
+		if (isNaN(parsed)) throw new Error(`"${input}" is not a valid number`);
+		if (checks.length > 0) return validate(parsed, checks);
+		return parsed;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/constants/FALSE_STRINGS.ts
+const FALSE_STRINGS = [
+	"false",
+	"0",
+	"no",
+	"off"
+];
+
+//#endregion
+//#region ../core/src/processing/constants/TRUE_STRINGS.ts
+const TRUE_STRINGS = [
+	"true",
+	"1",
+	"yes",
+	"on"
+];
+
+//#endregion
+//#region ../core/src/processing/processors/typed/boolean.ts
+/**
+* Boolean processor.
+* This is the primary boolean processor - the base booleanProcessor() calls this.
+*/
+function boolean$1() {
+	const trueValues = new Set(TRUE_STRINGS);
+	const falseValues = new Set(FALSE_STRINGS);
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim().toLowerCase();
+		if (trimmed === "") return;
+		if (trueValues.has(trimmed)) return true;
+		if (falseValues.has(trimmed)) return false;
+		const trueList = [...TRUE_STRINGS].join("/");
+		const falseList = [...FALSE_STRINGS].join("/");
+		throw new Error(`"${input}" is not a valid boolean. Use: ${trueList} or ${falseList}`);
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/typed/enumeration.ts
+/**
+* Enum processor with optional validation checks.
+* This is the primary enum processor - the base enumProcessor() calls this with no checks.
+*/
+function enumeration$1(allowedValues, ...checks) {
+	return (input) => {
+		if (typeof input !== "string") throw new Error("Value must be a string");
+		const trimmed = input.trim();
+		if (trimmed === "") return;
+		if (!allowedValues.includes(trimmed)) throw new Error(`"${input}" is not a valid option. Must be one of: ${allowedValues.join(", ")}`);
+		if (checks.length > 0) return validate(trimmed, checks);
+		return trimmed;
+	};
+}
+
+//#endregion
+//#region ../core/src/processing/processors/processors.ts
+/**
+* Default processors for environment variable types.
+* Each processor factory returns a function that takes a value and returns T | undefined.
+* Returns undefined for empty/null values, throws descriptive errors for invalid values.
+*/
+const processors = {
+	boolean: boolean$1,
+	enum: enumeration$1,
+	number: number$1,
+	string: string$1
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/BooleanEnvVarSchema.ts
+var BooleanEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "boolean";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.boolean()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/EnumEnvVarSchema.ts
+var EnumEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "enum";
+	values;
+	constructor(input) {
+		super({
+			...input,
+			process: input.process ?? processors.enum(input.values)
+		});
+		this.values = input.values;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/NumberEnvVarSchema.ts
+var NumberEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "number";
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.number()
+		});
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/typed/StringEnvVarSchema.ts
+var StringEnvVarSchema = class extends EnvVarSchemaBase {
+	type = "string";
+	secret;
+	constructor(input = {}) {
+		super({
+			...input,
+			process: input.process ?? processors.string()
+		});
+		this.secret = input.secret;
+	}
+};
+
+//#endregion
+//#region ../core/src/schemas/EnvVarSchema.ts
+/**
+* Type guard to check if a value is a EnvVarSchema instance
+*/
+function isEnvVarSchema(value) {
+	return value instanceof StringEnvVarSchema || value instanceof NumberEnvVarSchema || value instanceof BooleanEnvVarSchema || value instanceof EnumEnvVarSchema;
+}
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/number.ts
+/**
+* Create a number preprocessor that strips commas and whitespace
+*/
+const number = () => (value) => {
+	try {
+		const cleaned = value.replace(/,/g, "").trim();
+		if (/^-?\d*\.?\d+$/.test(cleaned)) return cleaned;
+	} catch {}
+	return value;
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/boolean.ts
+const boolean = (options = {
+	true: TRUE_STRINGS,
+	false: FALSE_STRINGS
+}) => {
+	const normalize = (candidate) => candidate.toLowerCase().trim();
+	const trueValues = new Set(options.true.map(normalize));
+	const falseValues = new Set(options.false.map(normalize));
+	for (const candidate of trueValues) if (falseValues.has(candidate)) throw new Error(`Boolean preprocessor option value "${candidate}" cannot map to both true and false`);
+	return (value) => {
+		try {
+			const cleaned = normalize(value);
+			if (trueValues.has(cleaned)) return true;
+			if (falseValues.has(cleaned)) return false;
+		} catch {}
+		return value;
+	};
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/enumeration.ts
+/**
+* Create an enum preprocessor - pass through unchanged
+*/
+const enumeration = () => (value) => value;
+
+//#endregion
+//#region ../core/src/processing/preprocessors/typed/string.ts
+/**
+* Create a string preprocessor - pass through unchanged
+*/
+const string = () => (value) => value;
+
+//#endregion
+//#region ../core/src/processing/preprocessors/preprocessors.ts
+/**
+* Default preprocessors map for each environment variable type
+*/
+const preprocessors = {
+	boolean,
+	enum: enumeration,
+	number,
+	string
+};
+
+//#endregion
+//#region ../core/src/processing/preprocessors/resolvePreprocessor.ts
+const defaultFactories = {
+	number: preprocessors.number,
+	boolean: preprocessors.boolean,
+	string: void 0,
+	enum: void 0
+};
+const explicitFactories = {
+	number: preprocessors.number,
+	boolean: preprocessors.boolean,
+	string: preprocessors.string,
+	enum: preprocessors.enum
+};
+/**
+* Resolve the effective preprocessor for a given environment variable type.
+* Respects custom overrides and falls back to built-in defaults (number, boolean).
+*/
+function resolvePreprocessor(envVarType, preprocessorOptions) {
+	const override = preprocessorOptions?.[envVarType];
+	if (override === void 0) {
+		const factory = defaultFactories[envVarType];
+		return factory ? factory() : void 0;
+	}
+	if (override === false) return;
+	if (override === true) return explicitFactories[envVarType]();
+	if (typeof override === "function") return override;
+	return preprocessors.boolean(override);
+}
+
+//#endregion
+//#region ../core/src/schemas/schema.ts
+const schema = {
+	string: (input = {}) => new StringEnvVarSchema(input),
+	number: (input = {}) => new NumberEnvVarSchema(input),
+	boolean: (input = {}) => new BooleanEnvVarSchema(input),
+	enum: (input) => new EnumEnvVarSchema(input)
+};
+const s = schema;
+
+//#endregion
+export { EnvVarSchemaBase as _, isEnvVarSchema as a, EnumEnvVarSchema as c, enumeration$1 as d, boolean$1 as f, toList as g, validate as h, preprocessors as i, BooleanEnvVarSchema as l, string$1 as m, schema as n, StringEnvVarSchema as o, number$1 as p, resolvePreprocessor as r, NumberEnvVarSchema as s, s as t, processors as u };